CMakeLists.txt

cmake_minimum_required(VERSION 3.20)

# ====================================================================
# Vix.cpp — Umbrella CMake Configuration
# ====================================================================
# Purpose:
#   - Build Vix modules (json, utils, core, websocket, orm, cli).
#   - Provide a single umbrella target: vix::vix
#   - Install/export a CMake package: find_package(Vix CONFIG REQUIRED)
#
# Quick start:
#   cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DVIX_BUILD_EXAMPLES=ON
#   cmake --build build -j
# ====================================================================

# Policies for newer CMake versions
if (POLICY CMP0126)
  cmake_policy(SET CMP0126 NEW)
endif()

if (POLICY CMP0167)
  cmake_policy(SET CMP0167 NEW)
endif()

# Resolve umbrella version from git (preferred)
set(_VIX_VERSION_FALLBACK "0.0.0")

find_package(Git QUIET)
set(_VIX_GIT_DESCRIBE "")
if(Git_FOUND)
  execute_process(
    COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
    OUTPUT_VARIABLE _VIX_GIT_DESCRIBE
    OUTPUT_STRIP_TRAILING_WHITESPACE
    ERROR_QUIET
  )
endif()

# Compute PROJECT_VERSION (must be numeric for CMake packaging)
# If describe returns: v1.20.1-4-gXXXX -> numeric is 1.20.1
set(_VIX_PROJECT_VERSION "${_VIX_VERSION_FALLBACK}")
if(_VIX_GIT_DESCRIBE MATCHES "^v([0-9]+\\.[0-9]+\\.[0-9]+)")
  set(_VIX_PROJECT_VERSION "${CMAKE_MATCH_1}")
endif()

project(vix VERSION ${_VIX_PROJECT_VERSION} LANGUAGES CXX)

set(VIX_SDK_PROFILE "" CACHE STRING "SDK profile to build (empty/legacy/default/web/data/desktop/p2p/game/agent/all)")
set_property(CACHE VIX_SDK_PROFILE PROPERTY STRINGS
  "" legacy default web data desktop p2p game agent all
)

set(_VIX_SDK_PROFILE_EFFECTIVE "${VIX_SDK_PROFILE}")
if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "")
  set(_VIX_SDK_PROFILE_EFFECTIVE "legacy")
endif()
string(TOLOWER "${_VIX_SDK_PROFILE_EFFECTIVE}" _VIX_SDK_PROFILE_EFFECTIVE)

set(_VIX_SDK_PROFILE_NAMES legacy default web data desktop p2p game agent all)
if (NOT _VIX_SDK_PROFILE_EFFECTIVE IN_LIST _VIX_SDK_PROFILE_NAMES)
  message(FATAL_ERROR
    "Unknown VIX_SDK_PROFILE=${VIX_SDK_PROFILE}. "
    "Expected one of: legacy, default, web, data, desktop, p2p, game, agent, all."
  )
endif()

set(_VIX_SDK_PROFILE_OPTION_VARS
  VIX_ENABLE_ORM
  VIX_ENABLE_WEBSOCKET
  VIX_ENABLE_CLI
  VIX_ENABLE_MIDDLEWARE
  VIX_ENABLE_HTTP_COMPRESSION
  VIX_ENABLE_DB
  VIX_DB_USE_MYSQL
  VIX_DB_USE_SQLITE
  VIX_DB_USE_POSTGRES
  VIX_DB_USE_REDIS
  VIX_ENABLE_P2P
  VIX_ENABLE_P2P_HTTP
  VIX_ENABLE_CACHE
  VIX_ENABLE_ASYNC
  VIX_ENABLE_VALIDATION
  VIX_ENABLE_CRYPTO
  VIX_ENABLE_WEBRPC
  VIX_ENABLE_REQUESTS
  VIX_ENABLE_REALTIME
  VIX_ENABLE_TIME
  VIX_ENABLE_TESTS_MODULE
  VIX_ENABLE_TEMPLATE
  VIX_ENABLE_UI
  VIX_UI_ENABLE_LINUX_WEBVIEW
  VIX_CLI_ENABLE_DESKTOP
  VIX_ENABLE_NOTE
  VIX_ENABLE_PROCESS
  VIX_ENABLE_ENGINE
  VIX_ENABLE_THREADPOOL
  VIX_ENABLE_KV
  VIX_ENABLE_AGENT
  VIX_ENABLE_GAME
  VIX_GAME_ENABLE_SDL
  VIX_GAME_ENABLE_SDL_OPENGL
)

set(_VIX_SDK_PROFILE_USER_CACHE_VARS)
foreach(_vix_sdk_profile_var IN LISTS _VIX_SDK_PROFILE_OPTION_VARS)
  if (DEFINED CACHE{${_vix_sdk_profile_var}})
    get_property(_vix_sdk_profile_cache_help CACHE ${_vix_sdk_profile_var} PROPERTY HELPSTRING)
    if (NOT _vix_sdk_profile_cache_help MATCHES "^Set by VIX_SDK_PROFILE=")
      list(APPEND _VIX_SDK_PROFILE_USER_CACHE_VARS "${_vix_sdk_profile_var}")
    endif()
  endif()
endforeach()

if (WIN32)
  add_compile_definitions(
    _WIN32_WINNT=0x0A00
    WIN32_LEAN_AND_MEAN
    NOMINMAX
  )
endif()

# Human-friendly version string (can include -N-gHASH[-dirty])
if(_VIX_GIT_DESCRIBE STREQUAL "")
  set(VIX_UMBRELLA_VERSION "v${PROJECT_VERSION}")
else()
  set(VIX_UMBRELLA_VERSION "${_VIX_GIT_DESCRIBE}")
endif()
set(VIX_UMBRELLA_VERSION "${VIX_UMBRELLA_VERSION}" CACHE STRING "Umbrella version" FORCE)

set(VIX_UMBRELLA_BUILD ON CACHE BOOL "Building Vix from umbrella" FORCE)

# Make find_package honor *_ROOT hints (e.g. MYSQLCPPCONN_ROOT)
if (POLICY CMP0144)
  cmake_policy(SET CMP0144 NEW)
endif()

include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
include(FetchContent)

# Resolve to a real target (not an ALIAS) so we can mutate properties safely.
function(vix_resolve_real_target out name)
  set(_real "")
  if (TARGET "${name}")
    get_target_property(_aliased "${name}" ALIASED_TARGET)
    if (_aliased)
      set(_real "${_aliased}")
    else()
      set(_real "${name}")
    endif()
  endif()
  set(${out} "${_real}" PARENT_SCOPE)
endfunction()

# Apply sanitizer flags to a real local target only.
function(vix_enable_sanitizers target)
  if (NOT VIX_ENABLE_SANITIZERS)
    return()
  endif()

  if (NOT TARGET "${target}")
    return()
  endif()

  get_target_property(_target_type "${target}" TYPE)
  if (NOT _target_type)
    return()
  endif()

  # INTERFACE libraries do not compile or link anything themselves.
  # Sanitizer flags must not be applied to them.
  if (_target_type STREQUAL "INTERFACE_LIBRARY")
    message(STATUS "Sanitizers: skipping interface target '${target}'")
    return()
  endif()

  if (MSVC)
    message(FATAL_ERROR "Sanitizers are not supported on MSVC. Use Clang or GCC.")
  endif()

  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
    target_compile_options(${target} PRIVATE
      -O1
      -g
      -fno-omit-frame-pointer
      -fsanitize=address,undefined
    )
    target_link_options(${target} PRIVATE
      -fsanitize=address,undefined
    )
  endif()
endfunction()

# Resolve the first existing target name among candidates, then apply sanitizers.
function(vix_enable_sanitizers_first)
  foreach(_candidate IN LISTS ARGN)
    if (TARGET "${_candidate}")
      get_target_property(_aliased "${_candidate}" ALIASED_TARGET)
      if (_aliased)
        vix_enable_sanitizers("${_aliased}")
      else()
        vix_enable_sanitizers("${_candidate}")
      endif()
      return()
    endif()
  endforeach()
endfunction()

# RPATH to easily run after installation
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)
if (APPLE)
  set(CMAKE_MACOSX_RPATH ON)
endif()

# ----------------------------------------------------
# Global build settings
# ----------------------------------------------------
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Copy compile_commands.json to repo root (tooling QoL)
# Disabled on Windows because Visual Studio generators do not reliably
# generate compile_commands.json and this must never fail a build.
if (NOT WIN32)
  if (CMAKE_EXPORT_COMPILE_COMMANDS)
    add_custom_target(copy-compile-commands ALL
      COMMAND ${CMAKE_COMMAND} -E copy_if_different
              "${CMAKE_BINARY_DIR}/compile_commands.json"
              "${CMAKE_SOURCE_DIR}/compile_commands.json"
      BYPRODUCTS "${CMAKE_SOURCE_DIR}/compile_commands.json"
      COMMENT "Copy compile_commands.json to project root"
      VERBATIM
    )
  endif()
else()
  message(STATUS "compile_commands.json copy disabled on Windows.")
endif()

# ----------------------------------------------------
# Options
# ----------------------------------------------------
option(VIX_ENABLE_WARNINGS         "Enable extra warnings"                                        ON)
option(VIX_ENABLE_INSTALL          "Enable install/export rules for packaging"                    ON)
option(VIX_ENABLE_LTO              "Enable IPO/LTO (Release only)"                                OFF)
option(VIX_MSVC_STATIC_RUNTIME     "Link MSVC runtime statically (/MT)"                           OFF)
option(VIX_ENABLE_CLANG_TIDY       "Enable clang-tidy if available"                               OFF)
option(VIX_ENABLE_CPPCHECK         "Enable cppcheck if available"                                 OFF)
option(VIX_ENABLE_COVERAGE         "Enable coverage flags (Debug only)"                           OFF)
option(VIX_ENABLE_SANITIZERS       "Enable ASan+UBSan (GCC/Clang only)"                           OFF)
option(VIX_BUILD_EXAMPLES          "Build umbrella examples in ./examples"                        ON)
option(VIX_BUILD_TESTS             "Build unit tests (GoogleTest)"                                OFF)
option(VIX_ENABLE_ORM              "Build Vix ORM module"                                         ON)
option(VIX_ENABLE_WEBSOCKET        "Build Vix WebSocket module"                                   ON)
option(VIX_ENABLE_CLI              "Build Vix CLI module"                                         ON)
option(VIX_FORCE_FETCH_JSON        "Fetch JSON backend if modules/json missing"                   ON)
option(VIX_BENCH_MODE              "Disable heavy security/logging checks for benchmarks"         OFF)
option(VIX_ENABLE_MIDDLEWARE       "Build Vix middleware module"                                  ON)
option(VIX_ENABLE_HTTP_COMPRESSION "Enable HTTP compression middleware deps (zlib/brotli)"        ON)
option(VIX_ENABLE_DB               "Build Vix DB module (core anti-ORM)"                          ON)
option(VIX_DB_USE_MYSQL            "Enable MySQL backend in vix_db"                               ON)
option(VIX_DB_USE_SQLITE           "Enable SQLite backend in vix_db"                              OFF)
option(VIX_DB_USE_POSTGRES         "Enable PostgreSQL backend in vix_db"                          OFF)
option(VIX_DB_USE_REDIS            "Enable Redis backend in vix_db"                               OFF)
option(VIX_ENABLE_P2P              "Build Vix P2P module"                                         ON)
option(VIX_ENABLE_P2P_HTTP         "Build Vix P2P HTTP adapter module"                            ON)
option(VIX_ENABLE_CACHE            "Build Vix Cache module"                                       ON)
option(VIX_FETCH_DEPS              "Allow fetching missing deps from the internet"                OFF)
option(VIX_ENABLE_ASYNC            "Build Vix Async module"                                       ON)
option(VIX_ENABLE_VALIDATION       "Build Vix Validation module"                                  ON)
option(VIX_ENABLE_CRYPTO           "Build Vix Crypto module"                                      ON)
option(VIX_ENABLE_WEBRPC           "Build Vix WebRPC module"                                      ON)
option(VIX_ENABLE_REQUESTS         "Build Vix Requests module"                                    ON)
option(VIX_ENABLE_REALTIME         "Build Vix Realtime module"                                    ON)
option(VIX_REALTIME_BUILD_TESTS    "Build vix::realtime tests"                                    ${VIX_BUILD_TESTS})
option(VIX_REALTIME_BUILD_EXAMPLES "Build vix::realtime examples"                                 OFF)
option(VIX_REALTIME_WITH_WEBSOCKET "Build vix::realtime WebSocket transport adapter"              ${VIX_ENABLE_WEBSOCKET})
option(VIX_REALTIME_WITH_POSTGRES  "Build vix::realtime PostgreSQL stores"                        OFF)
option(VIX_REQUESTS_BUILD_TESTS     "Build vix::requests tests"                                     ${VIX_BUILD_TESTS})
option(VIX_REQUESTS_BUILD_EXAMPLES  "Build vix::requests examples"                                  OFF)
option(VIX_ENABLE_TIME             "Build Vix Time module"                                        ON)
option(VIX_TIME_BUILD_TESTS        "Build vix::time tests"                                        ${VIX_BUILD_TESTS})
option(VIX_TIME_BUILD_BENCH        "Build vix::time benchmarks"                                   OFF)

option(VIX_ENABLE_TESTS_MODULE     "Build Vix Tests module"                                       ON)

option(VIX_ENABLE_TEMPLATE         "Build Vix Template module"                                    ON)
option(VIX_TEMPLATE_BUILD_TESTS    "Build vix::template tests"                                    ${VIX_BUILD_TESTS})
option(VIX_TEMPLATE_BUILD_EXAMPLES "Build vix::template examples"                                 OFF)
option(VIX_TEMPLATE_BUILD_BENCH    "Build vix::template benchmarks"                               OFF)

option(VIX_ENABLE_UI               "Build Vix UI module"                                          ON)
option(VIX_UI_BUILD_TESTS          "Build vix::ui tests"                                          ${VIX_BUILD_TESTS})
option(VIX_UI_BUILD_EXAMPLES       "Build vix::ui examples"                                       OFF)
option(VIX_UI_BUILD_BENCHMARKS     "Build vix::ui benchmarks"                                     OFF)
option(VIX_UI_ENABLE_LINUX_WEBVIEW "Enable Linux desktop WebView backend for vix::ui"              OFF)
option(VIX_CLI_ENABLE_DESKTOP       "Build vix desktop CLI support through vix::ui"                 ${VIX_ENABLE_UI})

option(VIX_ENABLE_NOTE             "Build Vix Note module"                                        ON)
option(VIX_NOTE_BUILD_TESTS        "Build vix::note tests"                                        ${VIX_BUILD_TESTS})
option(VIX_NOTE_BUILD_EXAMPLES     "Build vix::note examples"                                     OFF)

option(VIX_ENABLE_PROCESS          "Build Vix Process module"                                     ON)
option(VIX_ENABLE_ENGINE           "Build Vix Engine module"                                      ON)

option(VIX_ENABLE_THREADPOOL       "Build Vix ThreadPool module"                                  ON)
option(VIX_THREADPOOL_BUILD_EXAMPLES   "Build vix::threadpool examples"                           OFF)
option(VIX_THREADPOOL_BUILD_TESTS      "Build vix::threadpool tests"                              ${VIX_BUILD_TESTS})
option(VIX_THREADPOOL_BUILD_BENCHMARKS "Build vix::threadpool benchmarks"                         OFF)

option(VIX_ENABLE_KV               "Build Vix KV module"                                          ON)
option(VIX_KV_BUILD_EXAMPLES       "Build vix::kv examples"                                       OFF)
option(VIX_KV_BUILD_TESTS          "Build vix::kv tests"                                          ${VIX_BUILD_TESTS})
option(VIX_KV_BUILD_BENCHMARKS     "Build vix::kv benchmarks"                                     OFF)

option(VIX_ENABLE_AGENT            "Build Vix AI Agent module"                                    ON)
option(VIX_AGENT_BUILD_TESTS       "Build vix::ai_agent tests"                                    ${VIX_BUILD_TESTS})
option(VIX_AGENT_BUILD_EXAMPLES    "Build vix::ai_agent examples"                                 OFF)

option(VIX_ENABLE_GAME             "Build Vix Game module"                                        ON)
option(VIX_GAME_BUILD_TESTS        "Build vix::game tests"                                        ${VIX_BUILD_TESTS})
option(VIX_GAME_BUILD_EXAMPLES     "Build vix::game examples"                                     OFF)
option(VIX_GAME_ENABLE_SDL         "Enable SDL backend for vix::game"                             OFF)
option(VIX_GAME_ENABLE_SDL_OPENGL  "Enable SDL OpenGL renderer backend for vix::game"             OFF)

option(VIX_ORM_BUILD_EXAMPLES      "Build vix::orm examples"                                      OFF)
option(VIX_ORM_BUILD_TESTS         "Build vix::orm tests"                                         ${VIX_BUILD_TESTS})

function(vix_sdk_profile_default option_name option_value)
  list(FIND _VIX_SDK_PROFILE_USER_CACHE_VARS "${option_name}" _vix_sdk_profile_user_index)
  if (_vix_sdk_profile_user_index EQUAL -1)
    set(${option_name} ${option_value} CACHE BOOL "Set by VIX_SDK_PROFILE=${_VIX_SDK_PROFILE_EFFECTIVE}" FORCE)
  endif()
endfunction()

function(vix_sdk_profile_common)
  vix_sdk_profile_default(VIX_ENABLE_ORM OFF)
  vix_sdk_profile_default(VIX_ENABLE_WEBSOCKET OFF)
  vix_sdk_profile_default(VIX_ENABLE_CLI ON)
  vix_sdk_profile_default(VIX_ENABLE_MIDDLEWARE OFF)
  vix_sdk_profile_default(VIX_ENABLE_DB OFF)
  vix_sdk_profile_default(VIX_DB_USE_MYSQL OFF)
  vix_sdk_profile_default(VIX_DB_USE_SQLITE OFF)
  vix_sdk_profile_default(VIX_DB_USE_POSTGRES OFF)
  vix_sdk_profile_default(VIX_DB_USE_REDIS OFF)
  vix_sdk_profile_default(VIX_ENABLE_P2P OFF)
  vix_sdk_profile_default(VIX_ENABLE_P2P_HTTP OFF)
  vix_sdk_profile_default(VIX_ENABLE_CACHE OFF)
  vix_sdk_profile_default(VIX_ENABLE_ASYNC ON)
  vix_sdk_profile_default(VIX_ENABLE_VALIDATION OFF)
  vix_sdk_profile_default(VIX_ENABLE_CRYPTO OFF)
  vix_sdk_profile_default(VIX_ENABLE_WEBRPC OFF)
  vix_sdk_profile_default(VIX_ENABLE_REQUESTS OFF)
  vix_sdk_profile_default(VIX_ENABLE_REALTIME OFF)
  vix_sdk_profile_default(VIX_ENABLE_TIME ON)
  vix_sdk_profile_default(VIX_ENABLE_TESTS_MODULE OFF)
  vix_sdk_profile_default(VIX_ENABLE_TEMPLATE ON)
  vix_sdk_profile_default(VIX_ENABLE_UI ON)
  vix_sdk_profile_default(VIX_UI_ENABLE_LINUX_WEBVIEW OFF)
  vix_sdk_profile_default(VIX_CLI_ENABLE_DESKTOP OFF)
  vix_sdk_profile_default(VIX_ENABLE_NOTE ON)
  vix_sdk_profile_default(VIX_ENABLE_PROCESS ON)
  vix_sdk_profile_default(VIX_ENABLE_ENGINE ON)
  vix_sdk_profile_default(VIX_ENABLE_THREADPOOL ON)
  vix_sdk_profile_default(VIX_ENABLE_KV OFF)
  vix_sdk_profile_default(VIX_ENABLE_AGENT OFF)
  vix_sdk_profile_default(VIX_ENABLE_GAME OFF)
  vix_sdk_profile_default(VIX_GAME_ENABLE_SDL OFF)
  vix_sdk_profile_default(VIX_GAME_ENABLE_SDL_OPENGL OFF)
endfunction()

if (NOT _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "legacy")
  vix_sdk_profile_common()

  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "web")
    vix_sdk_profile_default(VIX_ENABLE_WEBSOCKET ON)
    vix_sdk_profile_default(VIX_ENABLE_MIDDLEWARE ON)
    vix_sdk_profile_default(VIX_ENABLE_VALIDATION ON)
    vix_sdk_profile_default(VIX_ENABLE_CRYPTO ON)
    vix_sdk_profile_default(VIX_ENABLE_WEBRPC ON)
    vix_sdk_profile_default(VIX_ENABLE_REQUESTS ON)
    vix_sdk_profile_default(VIX_ENABLE_REALTIME ON)
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "data")
    vix_sdk_profile_default(VIX_ENABLE_DB ON)
    vix_sdk_profile_default(VIX_ENABLE_ORM ON)
    vix_sdk_profile_default(VIX_ENABLE_KV ON)
    vix_sdk_profile_default(VIX_ENABLE_CACHE ON)
    vix_sdk_profile_default(VIX_DB_USE_SQLITE ON)
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "desktop")
    vix_sdk_profile_default(VIX_CLI_ENABLE_DESKTOP ON)
    if (UNIX AND NOT APPLE)
      vix_sdk_profile_default(VIX_UI_ENABLE_LINUX_WEBVIEW ON)
    endif()
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "p2p")
    vix_sdk_profile_default(VIX_ENABLE_P2P ON)
    vix_sdk_profile_default(VIX_ENABLE_P2P_HTTP ON)
    vix_sdk_profile_default(VIX_ENABLE_CRYPTO ON)
    vix_sdk_profile_default(VIX_ENABLE_CACHE ON)
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "game")
    vix_sdk_profile_default(VIX_ENABLE_GAME ON)
    vix_sdk_profile_default(VIX_GAME_ENABLE_SDL ON)
    vix_sdk_profile_default(VIX_GAME_ENABLE_SDL_OPENGL ON)
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "agent")
    vix_sdk_profile_default(VIX_ENABLE_AGENT ON)
    vix_sdk_profile_default(VIX_ENABLE_CACHE ON)
  elseif (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all")
    vix_sdk_profile_default(VIX_ENABLE_ORM ON)
    vix_sdk_profile_default(VIX_ENABLE_WEBSOCKET ON)
    vix_sdk_profile_default(VIX_ENABLE_MIDDLEWARE ON)
    vix_sdk_profile_default(VIX_ENABLE_DB ON)
    vix_sdk_profile_default(VIX_DB_USE_MYSQL ON)
    vix_sdk_profile_default(VIX_ENABLE_P2P ON)
    vix_sdk_profile_default(VIX_ENABLE_P2P_HTTP ON)
    vix_sdk_profile_default(VIX_ENABLE_CACHE ON)
    vix_sdk_profile_default(VIX_ENABLE_VALIDATION ON)
    vix_sdk_profile_default(VIX_ENABLE_CRYPTO ON)
    vix_sdk_profile_default(VIX_ENABLE_WEBRPC ON)
    vix_sdk_profile_default(VIX_ENABLE_REQUESTS ON)
    vix_sdk_profile_default(VIX_ENABLE_REALTIME ON)
    vix_sdk_profile_default(VIX_ENABLE_KV ON)
    vix_sdk_profile_default(VIX_ENABLE_AGENT ON)
    vix_sdk_profile_default(VIX_ENABLE_GAME ON)
    vix_sdk_profile_default(VIX_CLI_ENABLE_DESKTOP ON)
    if (UNIX AND NOT APPLE)
      vix_sdk_profile_default(VIX_UI_ENABLE_LINUX_WEBVIEW ON)
    endif()
    vix_sdk_profile_default(VIX_GAME_ENABLE_SDL ON)
    vix_sdk_profile_default(VIX_GAME_ENABLE_SDL_OPENGL ON)
  endif()

  if (VIX_ENABLE_CLI)
    vix_sdk_profile_default(VIX_ENABLE_CRYPTO ON)
    vix_sdk_profile_default(VIX_ENABLE_CACHE ON)
    vix_sdk_profile_default(VIX_ENABLE_P2P ON)
    vix_sdk_profile_default(VIX_ENABLE_AGENT ON)
    vix_sdk_profile_default(VIX_ENABLE_REQUESTS ON)
  endif()
endif()

function(vix_sdk_profile_user_set out_var option_name)
  list(FIND _VIX_SDK_PROFILE_USER_CACHE_VARS "${option_name}" _vix_sdk_profile_user_index)
  if (_vix_sdk_profile_user_index EQUAL -1)
    set(${out_var} OFF PARENT_SCOPE)
  else()
    set(${out_var} ON PARENT_SCOPE)
  endif()
endfunction()

set(_VIX_SDK_PACKAGE_DB ON)
set(_VIX_SDK_PACKAGE_ORM ON)
set(_VIX_SDK_PACKAGE_WEBSOCKET ON)
set(_VIX_SDK_PACKAGE_P2P ON)
set(_VIX_SDK_PACKAGE_P2P_HTTP ON)
set(_VIX_SDK_PACKAGE_AGENT ON)
set(_VIX_SDK_PACKAGE_GAME ON)
set(_VIX_SDK_PACKAGE_REALTIME ON)

if (NOT _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "legacy")
  vix_sdk_profile_user_set(_VIX_SDK_USER_DB VIX_ENABLE_DB)
  vix_sdk_profile_user_set(_VIX_SDK_USER_ORM VIX_ENABLE_ORM)
  vix_sdk_profile_user_set(_VIX_SDK_USER_WEBSOCKET VIX_ENABLE_WEBSOCKET)
  vix_sdk_profile_user_set(_VIX_SDK_USER_P2P VIX_ENABLE_P2P)
  vix_sdk_profile_user_set(_VIX_SDK_USER_P2P_HTTP VIX_ENABLE_P2P_HTTP)
  vix_sdk_profile_user_set(_VIX_SDK_USER_AGENT VIX_ENABLE_AGENT)
  vix_sdk_profile_user_set(_VIX_SDK_USER_GAME VIX_ENABLE_GAME)
  vix_sdk_profile_user_set(_VIX_SDK_USER_REALTIME VIX_ENABLE_REALTIME)

  set(_VIX_SDK_PACKAGE_DB OFF)
  set(_VIX_SDK_PACKAGE_ORM OFF)
  set(_VIX_SDK_PACKAGE_WEBSOCKET OFF)
  set(_VIX_SDK_PACKAGE_P2P OFF)
  set(_VIX_SDK_PACKAGE_P2P_HTTP OFF)
  set(_VIX_SDK_PACKAGE_AGENT OFF)
  set(_VIX_SDK_PACKAGE_GAME OFF)
  set(_VIX_SDK_PACKAGE_REALTIME OFF)

  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "data" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_DB AND VIX_ENABLE_DB))
    set(_VIX_SDK_PACKAGE_DB ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "data" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_ORM AND VIX_ENABLE_ORM))
    set(_VIX_SDK_PACKAGE_ORM ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "web" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_WEBSOCKET AND VIX_ENABLE_WEBSOCKET))
    set(_VIX_SDK_PACKAGE_WEBSOCKET ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "p2p" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_P2P AND VIX_ENABLE_P2P))
    set(_VIX_SDK_PACKAGE_P2P ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "p2p" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_P2P_HTTP AND VIX_ENABLE_P2P_HTTP))
    set(_VIX_SDK_PACKAGE_P2P_HTTP ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "agent" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_AGENT AND VIX_ENABLE_AGENT))
    set(_VIX_SDK_PACKAGE_AGENT ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "game" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_GAME AND VIX_ENABLE_GAME))
    set(_VIX_SDK_PACKAGE_GAME ON)
  endif()
  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "web" OR _VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" OR (_VIX_SDK_USER_REALTIME AND VIX_ENABLE_REALTIME))
    set(_VIX_SDK_PACKAGE_REALTIME ON)
  endif()
endif()
# ----------------------------------------------------
# Module test defaults
# ----------------------------------------------------
# The root tests/ directory may be empty. In umbrella builds, tests live
# inside modules/*, so VIX_BUILD_TESTS must propagate to module options.
set(VIX_ERROR_BUILD_TESTS      ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::error tests")
set(VIX_PATH_BUILD_TESTS       ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::path tests")
set(VIX_FS_BUILD_TESTS         ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::fs tests")
set(VIX_IO_BUILD_TESTS         ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::io tests")
set(VIX_ENV_BUILD_TESTS        ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::env tests")
set(VIX_OS_BUILD_TESTS         ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::os tests")
set(VIX_LOG_BUILD_TESTS        ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::log tests")
set(VIX_UTILS_BUILD_TESTS      ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::utils tests")
set(VIX_JSON_BUILD_TESTS       ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::json tests")
set(VIX_CORE_BUILD_TESTS       ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::core tests")
set(VIX_ASYNC_BUILD_TESTS      ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::async tests")
set(VIX_CRYPTO_BUILD_TESTS     ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::crypto tests")
set(VIX_CONVERSION_BUILD_TESTS ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::conversion tests")
set(VIX_VALIDATION_BUILD_TESTS ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::validation tests")
set(VIX_WEBRPC_BUILD_TESTS     ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::webrpc tests")
set(VIX_REQUESTS_BUILD_TESTS   ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::requests tests")
set(VIX_REALTIME_BUILD_TESTS   ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::realtime tests")
set(VIX_NET_BUILD_TESTS        ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::net tests")
set(VIX_SYNC_BUILD_TESTS       ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::sync tests")
set(VIX_CACHE_BUILD_TESTS      ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::cache tests")
set(VIX_P2P_BUILD_TESTS        ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::p2p tests")
set(VIX_P2P_HTTP_BUILD_TESTS   ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::p2p_http tests")
set(VIX_DB_BUILD_TESTS         ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::db tests")
set(VIX_MIDDLEWARE_BUILD_TESTS ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::middleware tests")
set(VIX_CLI_BUILD_TESTS        ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::cli tests")
set(VIX_CLI_ENABLE_DESKTOP     ${VIX_CLI_ENABLE_DESKTOP} CACHE BOOL "Build vix desktop CLI support through vix::ui")
set(VIX_WEBSOCKET_BUILD_TESTS  ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::websocket tests")
set(VIX_UI_BUILD_TESTS         ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::ui tests")
set(VIX_NOTE_BUILD_TESTS       ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::note tests")
set(VIX_ENGINE_BUILD_TESTS     ${VIX_BUILD_TESTS} CACHE BOOL "Build vix::engine tests")

# Some modules use their own public option names.
set(TEMPLATE_BUILD_TESTS       ${VIX_TEMPLATE_BUILD_TESTS} CACHE BOOL "Build template tests")
set(UI_BUILD_TESTS             ${VIX_UI_BUILD_TESTS} CACHE BOOL "Build ui tests")
set(UI_BUILD_EXAMPLES          ${VIX_UI_BUILD_EXAMPLES} CACHE BOOL "Build ui examples")
set(UI_BUILD_BENCHMARKS        ${VIX_UI_BUILD_BENCHMARKS} CACHE BOOL "Build ui benchmarks")
set(VIX_AI_AGENT_BUILD_TESTS   ${VIX_AGENT_BUILD_TESTS} CACHE BOOL "Build vix ai agent tests")
set(VIX_UI_ENABLE_LINUX_WEBVIEW ${VIX_UI_ENABLE_LINUX_WEBVIEW}
    CACHE BOOL "Enable Linux desktop WebView backend for vix::ui")

# ----------------------------------------------------
# Testing bootstrap
# ----------------------------------------------------
# Must happen before add_subdirectory(modules/*), otherwise module tests may
# be built but not registered correctly in the umbrella CTest tree.
if (VIX_BUILD_TESTS)
  include(CTest)
  enable_testing()

  find_package(GTest QUIET)
  if (NOT GTest_FOUND)
    message(STATUS "GTest not found, fetching googletest...")
    fetchcontent_declare(
      googletest
      GIT_REPOSITORY https://github.com/google/googletest.git
      GIT_TAG        v1.14.0
    )
    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
    fetchcontent_makeavailable(googletest)
  endif()
endif()

# ----------------------------------------------------
# Tooling / Static analysis
# ----------------------------------------------------
if (VIX_ENABLE_CLANG_TIDY)
  find_program(CLANG_TIDY_EXE NAMES clang-tidy)
  if (CLANG_TIDY_EXE)
    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}")
    message(STATUS "clang-tidy enabled: ${CLANG_TIDY_EXE}")
  else()
    message(WARNING "clang-tidy requested but not found")
  endif()
endif()

if (VIX_ENABLE_CPPCHECK)
  find_program(CPPCHECK_EXE NAMES cppcheck)
  if (CPPCHECK_EXE)
    set(CMAKE_CXX_CPPCHECK
      ${CPPCHECK_EXE}
      --enable=warning,style,performance,portability
      --std=c++20 --inline-suppr
      --suppress=unusedFunction
    )
    message(STATUS "cppcheck enabled: ${CPPCHECK_EXE}")
  else()
    message(WARNING "cppcheck requested but not found")
  endif()
endif()

# ----------------------------------------------------
# Warnings (opt-in reusable interface target)
# ----------------------------------------------------
if (VIX_ENABLE_WARNINGS)
  add_library(vix_warnings INTERFACE)
  if (MSVC)
    target_compile_options(vix_warnings INTERFACE /W4 /permissive-)
  else()
    target_compile_options(vix_warnings INTERFACE
      -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion
    )
    # Silence some false positives on GCC 13+ (fmt/spdlog inlines)
    target_compile_options(vix_warnings INTERFACE
      $<$<CXX_COMPILER_ID:GNU>:-Wno-array-bounds>
    )
  endif()
endif()

# ----------------------------------------------------
# Coverage (Debug only)
# ----------------------------------------------------
if (VIX_ENABLE_COVERAGE AND CMAKE_BUILD_TYPE MATCHES "Debug")
  if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    add_library(vix_coverage INTERFACE)
    target_compile_options(vix_coverage INTERFACE --coverage -O0 -g)
    target_link_options(vix_coverage INTERFACE --coverage)
    message(STATUS "Coverage flags enabled")
  else()
    message(WARNING "Coverage only supported on GCC/Clang")
  endif()
endif()

# ----------------------------------------------------
# Sanitizers (opt-in, GCC/Clang) — internal flags only
# ----------------------------------------------------
if (VIX_ENABLE_SANITIZERS)
  message(STATUS "Sanitizers enabled via internal target flags.")
endif()

# ----------------------------------------------------
# LTO (Release only)
# ----------------------------------------------------
if (VIX_ENABLE_LTO AND CMAKE_BUILD_TYPE MATCHES "Release")
  include(CheckIPOSupported)
  check_ipo_supported(RESULT ipo_ok OUTPUT ipo_err)
  if (ipo_ok)
    message(STATUS "IPO/LTO enabled")
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON)
  else()
    message(WARNING "IPO/LTO not supported: ${ipo_err}")
  endif()
endif()

# ----------------------------------------------------
# MSVC static runtime (/MT)
# ----------------------------------------------------
if (MSVC AND VIX_MSVC_STATIC_RUNTIME)
  foreach(flag_var
    CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS_DEBUG
    CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_DEBUG
  )
    if (DEFINED ${flag_var})
      string(REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
    endif()
  endforeach()
endif()

# ----------------------------------------------------
# Umbrella INTERFACE target (created early)
# ----------------------------------------------------
add_library(vix INTERFACE)

if (WIN32)
  target_compile_definitions(vix INTERFACE _WIN32_WINNT=0x0A00 WIN32_LEAN_AND_MEAN NOMINMAX)
endif()

# ----------------------------------------------------
# Third-party: Asio (standalone, header-only)
# Exposes: vix::thirdparty_asio
# ----------------------------------------------------
add_library(vix_thirdparty_asio INTERFACE)
add_library(vix::thirdparty_asio ALIAS vix_thirdparty_asio)
target_compile_definitions(vix_thirdparty_asio INTERFACE ASIO_STANDALONE=1)

if (WIN32)
  target_compile_definitions(vix_thirdparty_asio INTERFACE
    _WIN32_WINNT=0x0A00
    WIN32_LEAN_AND_MEAN
    NOMINMAX
  )
endif()

set(VIX_THIRDPARTY_ASIO_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/asio-src/asio/include")

# Prefer vendored Asio (submodule)
if (EXISTS "${VIX_THIRDPARTY_ASIO_DIR}/asio.hpp")
  message(STATUS "Asio: using vendored Asio at ${VIX_THIRDPARTY_ASIO_DIR}")

  target_include_directories(vix_thirdparty_asio SYSTEM INTERFACE
    $<BUILD_INTERFACE:${VIX_THIRDPARTY_ASIO_DIR}>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/vix/third_party/asio>
  )

else()
  message(STATUS "Asio submodule missing, fetching Asio automatically...")

  include(FetchContent)

  fetchcontent_declare(
    asio
    GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
    GIT_TAG        asio-1-30-2
  )

  fetchcontent_makeavailable(asio)

  target_include_directories(vix_thirdparty_asio SYSTEM INTERFACE
    $<BUILD_INTERFACE:${asio_SOURCE_DIR}/asio/include>
  )
endif()

target_compile_options(vix_thirdparty_asio INTERFACE
  $<$<CXX_COMPILER_ID:GNU>:-Wno-null-dereference>
)

target_link_libraries(vix INTERFACE vix::thirdparty_asio)

add_library(vix::vix ALIAS vix)

# ----------------------------------------------------
# Optional deps: HTTP compression (zlib + brotli)
# Propagate defs/libs to all consumers through vix::vix
# ----------------------------------------------------
if (VIX_ENABLE_HTTP_COMPRESSION)
  # ---- zlib (gzip) ----
  find_package(ZLIB QUIET)
  if (ZLIB_FOUND)
    message(STATUS "Compression: zlib found -> gzip enabled")
    target_compile_definitions(vix INTERFACE VIX_HAS_ZLIB=1)

    if (TARGET ZLIB::ZLIB)
      target_link_libraries(vix INTERFACE ZLIB::ZLIB)
    else()
      add_library(ZLIB::ZLIB INTERFACE IMPORTED)
      target_include_directories(ZLIB::ZLIB INTERFACE "${ZLIB_INCLUDE_DIRS}")
      target_link_libraries(ZLIB::ZLIB INTERFACE "${ZLIB_LIBRARIES}")
      target_link_libraries(vix INTERFACE ZLIB::ZLIB)
    endif()
  else()
    message(STATUS "Compression: zlib not found -> gzip disabled")
  endif()

  # ---- brotli (br) ----
  find_library(BROTLI_ENC NAMES brotlienc)
  find_library(BROTLI_COMMON NAMES brotlicommon)

  if (BROTLI_ENC AND BROTLI_COMMON)
    message(STATUS "Compression: brotli found -> br enabled")
    target_compile_definitions(vix INTERFACE VIX_HAS_BROTLI=1)
    target_link_libraries(vix INTERFACE ${BROTLI_ENC} ${BROTLI_COMMON})
  else()
    message(STATUS "Compression: brotli not found -> br disabled")
  endif()
endif()

# Attach warnings/coverage only for local builds.
# Do not export them through the installed package.
if (TARGET vix_warnings)
  target_link_libraries(vix INTERFACE
    $<BUILD_INTERFACE:vix_warnings>
  )
endif()

if (TARGET vix_coverage)
  target_link_libraries(vix INTERFACE
    $<BUILD_INTERFACE:vix_coverage>
  )
endif()

# Install include interface root
target_include_directories(vix INTERFACE
  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)

# ----------------------------------------------------
# Add submodules
# ----------------------------------------------------
set(_VIX_JSON_BACKEND "none")
set(JSON_TARGET "")

# --- Error ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/error/CMakeLists.txt")
  message(STATUS "Adding 'modules/error'...")
  add_subdirectory(modules/error error_build)
else()
  message(FATAL_ERROR "Missing 'modules/error'. Run: git submodule update --init --recursive")
endif()

# --- Path ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/path/CMakeLists.txt")
  message(STATUS "Adding 'modules/path'...")
  add_subdirectory(modules/path path_build)
else()
  message(FATAL_ERROR "Missing 'modules/path'. Run: git submodule update --init --recursive")
endif()

# --- FS ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/fs/CMakeLists.txt")
  message(STATUS "Adding 'modules/fs'...")
  add_subdirectory(modules/fs fs_build)
else()
  message(FATAL_ERROR "Missing 'modules/fs'. Run: git submodule update --init --recursive")
endif()

# --- Utils ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/utils/CMakeLists.txt")
  message(STATUS "Adding 'modules/utils'...")
  add_subdirectory(modules/utils utils_build)
else()
  message(FATAL_ERROR "Missing 'modules/utils'. Run: git submodule update --init --recursive")
endif()

# --- Log ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/log/CMakeLists.txt")
  message(STATUS "Adding 'modules/log'...")
  add_subdirectory(modules/log log_build)
else()
  message(FATAL_ERROR "Missing 'modules/log'. Run: git submodule update --init --recursive")
endif()

# --- IO ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/io/CMakeLists.txt")
  message(STATUS "Adding 'modules/io'...")
  add_subdirectory(modules/io io_build)
else()
  message(FATAL_ERROR "Missing 'modules/io'. Run: git submodule update --init --recursive")
endif()

# --- Env ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/env/CMakeLists.txt")
  message(STATUS "Adding 'modules/env'...")
  add_subdirectory(modules/env env_build)
else()
  message(FATAL_ERROR "Missing 'modules/env'. Run: git submodule update --init --recursive")
endif()

# --- OS ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/os/CMakeLists.txt")
  message(STATUS "Adding 'modules/os'...")
  add_subdirectory(modules/os os_build)
else()
  message(FATAL_ERROR "Missing 'modules/os'. Run: git submodule update --init --recursive")
endif()

# --- JSON ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/json/CMakeLists.txt")
  message(STATUS "Adding 'modules/json'...")
  add_subdirectory(modules/json json_build)
  set(_VIX_JSON_BACKEND "submodule")
elseif (VIX_FORCE_FETCH_JSON)
  message(WARNING "modules/json missing — fetching nlohmann/json fallback")
  fetchcontent_declare(
    nlohmann_json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG        v3.11.3
  )
  fetchcontent_makeavailable(nlohmann_json)

  add_library(vix_json INTERFACE)
  target_link_libraries(vix_json INTERFACE nlohmann_json::nlohmann_json)

  if (NOT TARGET vix::json)
    add_library(vix::json ALIAS vix_json)
  endif()

  set(_VIX_JSON_BACKEND "nlohmann_json")
else()
  message(FATAL_ERROR "Missing 'modules/json'. Run: git submodule update --init --recursive")
endif()

# Resolve JSON target name
if (TARGET vix::json)
  set(JSON_TARGET vix::json)
elseif (TARGET vix_json)
  set(JSON_TARGET vix_json)
else()
  message(FATAL_ERROR "JSON backend target not found (expected vix::json or vix_json).")
endif()

# --- WebRPC (optional) ---
set(VIX_HAS_WEBRPC OFF)

if (VIX_ENABLE_WEBRPC AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/webrpc/CMakeLists.txt")
  message(STATUS "Adding 'modules/webrpc'...")
  add_subdirectory(modules/webrpc webrpc_build)

  # Normalise: expose vix::webrpc
  if (TARGET vix::webrpc OR TARGET vix_webrpc)
    set(VIX_HAS_WEBRPC ON)
    if (TARGET vix_webrpc AND NOT TARGET vix::webrpc)
      add_library(vix::webrpc ALIAS vix_webrpc)
    endif()
  else()
    message(WARNING "WebRPC module added but no vix::webrpc target was exported.")
  endif()
else()
  message(STATUS "WebRPC: disabled or not present.")
endif()


# --- Requests (optional, async transport) ---
set(VIX_HAS_REQUESTS OFF)

if (VIX_ENABLE_REQUESTS AND NOT VIX_ENABLE_ASYNC)
  message(FATAL_ERROR "Requests requires vix::async. Enable VIX_ENABLE_ASYNC or disable VIX_ENABLE_REQUESTS.")
endif()

if (VIX_ENABLE_REQUESTS AND VIX_ENABLE_ASYNC AND NOT TARGET vix::async AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/async/CMakeLists.txt")
  message(STATUS "Adding 'modules/async' for requests...")
  add_subdirectory(modules/async async_build)

  if (TARGET vix::async OR TARGET vix_async)
    set(VIX_HAS_ASYNC ON)
    if (TARGET vix_async AND NOT TARGET vix::async)
      add_library(vix::async ALIAS vix_async)
    endif()
  else()
    message(FATAL_ERROR "Requests requires vix::async, but the async module did not export it.")
  endif()
endif()

if (VIX_ENABLE_REQUESTS AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/requests/CMakeLists.txt")
  message(STATUS "Adding 'modules/requests'...")

  set(VIX_REQUESTS_BUILD_TESTS ${VIX_REQUESTS_BUILD_TESTS} CACHE BOOL "Build vix::requests tests" FORCE)
  set(VIX_REQUESTS_BUILD_EXAMPLES ${VIX_REQUESTS_BUILD_EXAMPLES} CACHE BOOL "Build vix::requests examples" FORCE)
  set(VIX_REQUESTS_INSTALL OFF CACHE BOOL "Enable standalone install/package rules" FORCE)

  add_subdirectory(modules/requests requests_build)

  if (TARGET vix::requests OR TARGET vix_requests)
    set(VIX_HAS_REQUESTS ON)
    if (TARGET vix_requests AND NOT TARGET vix::requests)
      add_library(vix::requests ALIAS vix_requests)
    endif()
  else()
    message(WARNING "Requests module added but no vix::requests target was exported.")
  endif()
else()
  message(STATUS "Requests: disabled or not present.")
endif()

# --- Tests (optional) ---
set(VIX_HAS_TESTS OFF)

if (VIX_ENABLE_TESTS_MODULE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/tests/CMakeLists.txt")
  message(STATUS "Adding 'modules/tests'...")
  add_subdirectory(modules/tests tests_build)

  if (TARGET vix::tests OR TARGET vix_tests)
    set(VIX_HAS_TESTS ON)
    if (TARGET vix_tests AND NOT TARGET vix::tests)
      add_library(vix::tests ALIAS vix_tests)
    endif()
  else()
    message(WARNING "Tests module added but no vix::tests target was exported.")
  endif()
else()
  message(STATUS "Tests module: disabled or not present.")
endif()

# --- Time (foundation module) ---
set(VIX_HAS_TIME OFF)

if (VIX_ENABLE_TIME AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/time/CMakeLists.txt")
  message(STATUS "Adding 'modules/time'...")

  set(VIX_TIME_BUILD_TESTS ${VIX_TIME_BUILD_TESTS} CACHE BOOL "" FORCE)
  set(VIX_TIME_BUILD_BENCH ${VIX_TIME_BUILD_BENCH} CACHE BOOL "" FORCE)

  add_subdirectory(modules/time time_build)

  if (TARGET vix::time OR TARGET vix_time)
    set(VIX_HAS_TIME ON)

    if (TARGET vix_time AND NOT TARGET vix::time)
      add_library(vix::time ALIAS vix_time)
    endif()
  else()
    message(WARNING "Time module added but no vix::time target was exported.")
  endif()
else()
  message(STATUS "Time: disabled or not present.")
endif()

# --- Crypto (optional) ---
set(VIX_HAS_CRYPTO OFF)

if (VIX_ENABLE_CRYPTO AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/crypto/CMakeLists.txt")
  message(STATUS "Adding 'modules/crypto'...")

  # Important: en umbrella, crypto ne fait pas find_package(OpenSSL),
  # il attend que OpenSSL::Crypto existe deja.
  find_package(OpenSSL QUIET)
  if (OpenSSL_FOUND AND TARGET OpenSSL::Crypto)
    message(STATUS "Crypto: OpenSSL found -> provider available")
  else()
    message(STATUS "Crypto: OpenSSL not found -> provider will be disabled")
  endif()

  add_subdirectory(modules/crypto crypto_build)

  if (TARGET vix::crypto OR TARGET vix_crypto)
    set(VIX_HAS_CRYPTO ON)
    if (TARGET vix_crypto AND NOT TARGET vix::crypto)
      add_library(vix::crypto ALIAS vix_crypto)
    endif()
  else()
    message(WARNING "Crypto module added but no vix::crypto target was exported.")
  endif()
else()
  message(STATUS "Crypto: disabled or not present.")
endif()

# Resolve real utils target (dereference ALIAS if needed)
set(_VIX_UTILS_REAL "")

vix_resolve_real_target(_VIX_UTILS_REAL vix_utils)
if (NOT _VIX_UTILS_REAL)
  vix_resolve_real_target(_VIX_UTILS_REAL vix-utils)
endif()
if (NOT _VIX_UTILS_REAL)
  vix_resolve_real_target(_VIX_UTILS_REAL utils)
endif()

# Propagate transitive include dirs from deps (avoid warnings from 3rd-party headers)
if (_VIX_UTILS_REAL AND NOT _VIX_UTILS_REAL STREQUAL "")
  if (TARGET spdlog::spdlog)
    get_target_property(_spdlog_inc spdlog::spdlog INTERFACE_INCLUDE_DIRECTORIES)
    if (_spdlog_inc)
      target_include_directories(${_VIX_UTILS_REAL} SYSTEM INTERFACE ${_spdlog_inc})
    endif()
  endif()

  if (TARGET fmt::fmt)
    get_target_property(_fmt_inc fmt::fmt INTERFACE_INCLUDE_DIRECTORIES)
    if (_fmt_inc)
      target_include_directories(${_VIX_UTILS_REAL} SYSTEM INTERFACE ${_fmt_inc})
    endif()
  endif()
else()
  message(WARNING "Could not resolve real utils target (tried: vix_utils, vix-utils, utils).")
endif()

# --- Async (optional) ---
if (NOT DEFINED VIX_HAS_ASYNC)
  set(VIX_HAS_ASYNC OFF)
endif()

if (TARGET vix::async)
  set(VIX_HAS_ASYNC ON)
elseif (VIX_ENABLE_ASYNC AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/async/CMakeLists.txt")
  message(STATUS "Adding 'modules/async'...")
  add_subdirectory(modules/async async_build)

  if (TARGET vix::async OR TARGET vix_async)
    set(VIX_HAS_ASYNC ON)
    if (TARGET vix_async AND NOT TARGET vix::async)
      add_library(vix::async ALIAS vix_async)
    endif()
  else()
    message(WARNING "Async module added but no vix::async target was exported.")
  endif()
else()
  message(STATUS "Async: disabled or not present.")
endif()

# --- Process (optional) ---
set(VIX_HAS_PROCESS OFF)
if (VIX_ENABLE_PROCESS AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/process/CMakeLists.txt")
  message(STATUS "Adding 'modules/process'...")
  add_subdirectory(modules/process process_build)

  if (TARGET vix::process OR TARGET vix_process)
    set(VIX_HAS_PROCESS ON)
    if (TARGET vix_process AND NOT TARGET vix::process)
      add_library(vix::process ALIAS vix_process)
    endif()
  else()
    message(WARNING "Process module added but no vix::process target was exported.")
  endif()
else()
  message(STATUS "Process: disabled or not present.")
endif()

# --- ThreadPool (optional) ---
set(VIX_HAS_THREADPOOL OFF)

if (VIX_ENABLE_THREADPOOL AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/threadpool/CMakeLists.txt")
  message(STATUS "Adding 'modules/threadpool'...")

  set(VIX_THREADPOOL_BUILD_EXAMPLES ${VIX_THREADPOOL_BUILD_EXAMPLES} CACHE BOOL "Build vix::threadpool examples" FORCE)
  set(VIX_THREADPOOL_BUILD_TESTS ${VIX_THREADPOOL_BUILD_TESTS} CACHE BOOL "Build vix::threadpool tests" FORCE)
  set(VIX_THREADPOOL_BUILD_BENCHMARKS ${VIX_THREADPOOL_BUILD_BENCHMARKS} CACHE BOOL "Build vix::threadpool benchmarks" FORCE)

  add_subdirectory(modules/threadpool threadpool_build)

  if (TARGET vix::threadpool OR TARGET vix_threadpool)
    set(VIX_HAS_THREADPOOL ON)

    if (TARGET vix_threadpool AND NOT TARGET vix::threadpool)
      add_library(vix::threadpool ALIAS vix_threadpool)
    endif()
  else()
    message(WARNING "ThreadPool module added but no vix::threadpool target was exported.")
  endif()
else()
  message(STATUS "ThreadPool: disabled or not present.")
endif()

# --- KV (optional) ---
set(VIX_HAS_KV OFF)

if (VIX_ENABLE_KV AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/kv/CMakeLists.txt")
  message(STATUS "Adding 'modules/kv'...")

  set(VIX_KV_BUILD_EXAMPLES ${VIX_KV_BUILD_EXAMPLES} CACHE BOOL "Build vix::kv examples" FORCE)
  set(VIX_KV_BUILD_TESTS ${VIX_KV_BUILD_TESTS} CACHE BOOL "Build vix::kv tests" FORCE)
  set(VIX_KV_BUILD_BENCHMARKS ${VIX_KV_BUILD_BENCHMARKS} CACHE BOOL "Build vix::kv benchmarks" FORCE)

  add_subdirectory(modules/kv kv_build)

  if (TARGET vix::kv OR TARGET vix_kv)
    set(VIX_HAS_KV ON)

    if (TARGET vix_kv AND NOT TARGET vix::kv)
      add_library(vix::kv ALIAS vix_kv)
    endif()
  else()
    message(WARNING "KV module added but no vix::kv target was exported.")
  endif()
else()
  message(STATUS "KV: disabled or not present.")
endif()

# --- Template (optional) ---
set(VIX_HAS_TEMPLATE OFF)

if (VIX_ENABLE_TEMPLATE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/template/CMakeLists.txt")
  message(STATUS "Adding 'modules/template'...")

  set(TEMPLATE_BUILD_TESTS ${VIX_TEMPLATE_BUILD_TESTS} CACHE BOOL "" FORCE)
  set(TEMPLATE_BUILD_EXAMPLES ${VIX_TEMPLATE_BUILD_EXAMPLES} CACHE BOOL "" FORCE)
  set(TEMPLATE_BUILD_BENCHMARKS ${VIX_TEMPLATE_BUILD_BENCH} CACHE BOOL "" FORCE)
  set(TEMPLATE_INSTALL OFF CACHE BOOL "" FORCE)

  add_subdirectory(modules/template template_build)

  if (TARGET vix::template)
    set(VIX_HAS_TEMPLATE ON)
  elseif (TARGET template)
    set(VIX_HAS_TEMPLATE ON)
  else()
    message(WARNING "Template module added but no template target was exported.")
  endif()
else()
  message(STATUS "Template: disabled or not present.")
endif()

# --- UI (optional) ---
set(VIX_HAS_UI OFF)

if (VIX_ENABLE_UI AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/ui/CMakeLists.txt")
  if (NOT TARGET vix::template AND NOT TARGET template)
    message(FATAL_ERROR "UI requires vix::template. Ensure template is added before ui.")
  endif()

  message(STATUS "Adding 'modules/ui'...")

  set(UI_BUILD_TESTS ${VIX_UI_BUILD_TESTS} CACHE BOOL "Build ui tests" FORCE)
  set(UI_BUILD_EXAMPLES ${VIX_UI_BUILD_EXAMPLES} CACHE BOOL "Build ui examples" FORCE)
  set(UI_BUILD_BENCHMARKS ${VIX_UI_BUILD_BENCHMARKS} CACHE BOOL "Build ui benchmarks" FORCE)
  set(UI_INSTALL OFF CACHE BOOL "Enable standalone install/package rules" FORCE)

  set(VIX_UI_ENABLE_LINUX_WEBVIEW ${VIX_UI_ENABLE_LINUX_WEBVIEW}
    CACHE BOOL "Enable Linux desktop WebView backend for vix::ui" FORCE)

  add_subdirectory(modules/ui ui_build)

  if (TARGET vix::ui OR TARGET ui)
    set(VIX_HAS_UI ON)

    if (TARGET ui AND NOT TARGET vix::ui)
      add_library(vix::ui ALIAS ui)
    endif()
  else()
    message(WARNING "UI module added but no vix::ui target was exported.")
  endif()
else()
  message(STATUS "UI: disabled or not present.")
endif()

# --- Note (optional) ---
set(VIX_HAS_NOTE OFF)

if (VIX_ENABLE_NOTE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/note/CMakeLists.txt")
  message(STATUS "Adding 'modules/note'...")

  set(VIX_NOTE_BUILD_TESTS ${VIX_NOTE_BUILD_TESTS} CACHE BOOL "Build vix::note tests" FORCE)
  set(VIX_NOTE_BUILD_EXAMPLES ${VIX_NOTE_BUILD_EXAMPLES} CACHE BOOL "Build vix::note examples" FORCE)
  set(VIX_NOTE_INSTALL OFF CACHE BOOL "Enable standalone install/package rules" FORCE)

  add_subdirectory(modules/note note_build)

  if (TARGET vix::note OR TARGET vix_note)
    set(VIX_HAS_NOTE ON)

    if (TARGET vix_note AND NOT TARGET vix::note)
      add_library(vix::note ALIAS vix_note)
    endif()
  else()
    message(WARNING "Note module added but no vix::note target was exported.")
  endif()
else()
  message(STATUS "Note: disabled or not present.")
endif()

# --- Core ---
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/core/CMakeLists.txt")
  message(STATUS "Adding 'modules/core'...")
  add_subdirectory(modules/core core_build)
else()
  message(FATAL_ERROR "Missing 'modules/core'. Run: git submodule update --init --recursive")
endif()

# --- Game (optional) ---
set(VIX_HAS_GAME OFF)

if (VIX_ENABLE_GAME AND _VIX_SDK_PACKAGE_GAME AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/game/CMakeLists.txt")
  if (NOT TARGET vix::error)
    message(FATAL_ERROR "Game requires vix::error. Ensure error is added before game.")
  endif()

  if (NOT TARGET vix::time)
    message(FATAL_ERROR "Game requires vix::time. Ensure time is added before game.")
  endif()

  if (NOT TARGET vix::fs)
    message(FATAL_ERROR "Game requires vix::fs. Ensure fs is added before game.")
  endif()

  if (NOT TARGET vix::path)
    message(FATAL_ERROR "Game requires vix::path. Ensure path is added before game.")
  endif()

  if (NOT TARGET vix::json)
    message(FATAL_ERROR "Game requires vix::json. Ensure json is added before game.")
  endif()

  if (NOT TARGET vix::log)
    message(FATAL_ERROR "Game requires vix::log. Ensure log is added before game.")
  endif()

  if (NOT TARGET vix::threadpool)
    message(FATAL_ERROR "Game requires vix::threadpool. Ensure threadpool is added before game.")
  endif()

  if (NOT TARGET vix::async)
    message(FATAL_ERROR "Game requires vix::async. Ensure async is added before game.")
  endif()

  if (VIX_GAME_BUILD_EXAMPLES AND NOT TARGET vix::core)
    message(FATAL_ERROR "Game examples require vix::core because they use vix::print.")
  endif()

  message(STATUS "Adding 'modules/game'...")

  set(VIX_GAME_BUILD_TESTS ${VIX_GAME_BUILD_TESTS} CACHE BOOL "Build vix::game tests" FORCE)
  set(VIX_GAME_BUILD_EXAMPLES ${VIX_GAME_BUILD_EXAMPLES} CACHE BOOL "Build vix::game examples" FORCE)
  set(VIX_GAME_ENABLE_SDL ${VIX_GAME_ENABLE_SDL} CACHE BOOL "Enable SDL backend for vix::game" FORCE)
  set(VIX_GAME_ENABLE_SDL_OPENGL ${VIX_GAME_ENABLE_SDL_OPENGL} CACHE BOOL "Enable SDL OpenGL renderer backend for vix::game" FORCE)

  add_subdirectory(modules/game game_build)

  if (TARGET vix::game OR TARGET vix_game)
    set(VIX_HAS_GAME ON)

    if (TARGET vix_game AND NOT TARGET vix::game)
      add_library(vix::game ALIAS vix_game)
    endif()
  else()
    message(WARNING "Game module added but no vix::game target was exported.")
  endif()
else()
  message(STATUS "Game: disabled or not present.")
endif()

# --- Conversion (required by Validation) ---
set(VIX_HAS_CONVERSION OFF)

if (TARGET vix::conversion)
  set(VIX_HAS_CONVERSION ON)
else()
  # If you have it as a module, add it here (umbrella must not fetch)
  if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/conversion/CMakeLists.txt")
    message(STATUS "Adding 'modules/conversion'...")
    add_subdirectory(modules/conversion conversion_build)

    if (TARGET vix::conversion OR TARGET vix_conversion)
      set(VIX_HAS_CONVERSION ON)
      if (TARGET vix_conversion AND NOT TARGET vix::conversion)
        add_library(vix::conversion ALIAS vix_conversion)
      endif()
    else()
      message(FATAL_ERROR "Conversion module added but no vix::conversion target was exported.")
    endif()
  else()
    message(STATUS "Conversion: not present as module. Expecting it to be provided by core or another module.")
  endif()
endif()

# --- Validation (optional) ---
set(VIX_HAS_VALIDATION OFF)

if (VIX_ENABLE_VALIDATION AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/validation/CMakeLists.txt")
  if (NOT TARGET vix::conversion)
    message(FATAL_ERROR "Validation requires vix::conversion. Ensure conversion is added before validation in the umbrella.")
  endif()

  message(STATUS "Adding 'modules/validation'...")
  add_subdirectory(modules/validation validation_build)

  if (TARGET vix::validation OR TARGET vix_validation)
    set(VIX_HAS_VALIDATION ON)
    if (TARGET vix_validation AND NOT TARGET vix::validation)
      add_library(vix::validation ALIAS vix_validation)
    endif()
  else()
    message(WARNING "Validation module added but no vix::validation target was exported.")
  endif()
else()
  message(STATUS "Validation: disabled or not present.")
endif()

# --- Net (required by P2P) ---
set(VIX_HAS_NET OFF)
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/net/CMakeLists.txt")
  message(STATUS "Adding 'modules/net'...")
  add_subdirectory(modules/net net_build)

  if (TARGET vix::net OR TARGET vix_net)
    set(VIX_HAS_NET ON)
    if (TARGET vix_net AND NOT TARGET vix::net)
      add_library(vix::net ALIAS vix_net)
    endif()
  else()
    message(WARNING "Net module added but no vix::net target was exported.")
  endif()
else()
  message(STATUS "Net: not present (P2P will be disabled or will fetch standalone).")
endif()

# --- Cache (optional, used by P2P) ---
set(VIX_HAS_CACHE OFF)
if (VIX_ENABLE_CACHE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/cache/CMakeLists.txt")
  message(STATUS "Adding 'modules/cache'...")
  add_subdirectory(modules/cache cache_build)

  if (TARGET vix::cache OR TARGET vix_cache)
    set(VIX_HAS_CACHE ON)
    if (TARGET vix_cache AND NOT TARGET vix::cache)
      add_library(vix::cache ALIAS vix_cache)
    endif()
  else()
    message(WARNING "Cache module added but no vix::cache target was exported.")
  endif()
else()
  message(STATUS "Cache: disabled or not present.")
endif()

# --- AI Agent (optional) ---
set(VIX_HAS_AGENT OFF)

if (VIX_ENABLE_AGENT AND _VIX_SDK_PACKAGE_AGENT AND NOT VIX_HAS_CACHE)
  message(WARNING "AI Agent requested but Cache module is missing -> disabling AI Agent in umbrella")
  set(VIX_ENABLE_AGENT OFF CACHE BOOL "Build Vix AI Agent module" FORCE)
endif()

if (VIX_ENABLE_AGENT AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/agent/CMakeLists.txt")
  message(STATUS "Adding 'modules/agent'...")

  set(VIX_AI_AGENT_BUILD_TESTS ${VIX_AGENT_BUILD_TESTS} CACHE BOOL "Build vix ai agent tests" FORCE)
  set(VIX_AI_AGENT_BUILD_EXAMPLES ${VIX_AGENT_BUILD_EXAMPLES} CACHE BOOL "Build vix ai agent examples" FORCE)

  set(VIX_AI_AGENT_ENABLE_INSTALL ${_VIX_SDK_PACKAGE_AGENT} CACHE BOOL "Enable install/export rules for vix ai agent" FORCE)

  add_subdirectory(modules/agent agent_build)

  if (TARGET vix::ai_agent OR TARGET vix_ai_agent)
    set(VIX_HAS_AGENT ON)

    if (TARGET vix_ai_agent AND NOT TARGET vix::ai_agent)
      add_library(vix::ai_agent ALIAS vix_ai_agent)
    endif()
  else()
    message(WARNING "AI Agent module added but no vix::ai_agent target was exported.")
  endif()
else()
  message(STATUS "AI Agent: disabled or not present.")
endif()

# --- Sync (optional, used by P2P) ---
set(VIX_HAS_SYNC OFF)
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/sync/CMakeLists.txt")
  message(STATUS "Adding 'modules/sync'...")
  add_subdirectory(modules/sync sync_build)

  if (TARGET vix::sync OR TARGET vix_sync)
    set(VIX_HAS_SYNC ON)
    if (TARGET vix_sync AND NOT TARGET vix::sync)
      add_library(vix::sync ALIAS vix_sync)
    endif()
  endif()
else()
  message(STATUS "Sync: not present.")
endif()

# If net is missing, P2P must be disabled in umbrella (no auto-fetch here)
if (VIX_ENABLE_P2P AND NOT VIX_HAS_NET)
  message(WARNING "P2P requested but Net module is missing -> disabling P2P in umbrella")
  set(VIX_ENABLE_P2P OFF CACHE BOOL "Build Vix P2P module" FORCE)
endif()

# --- P2P (optional) ---
set(VIX_HAS_P2P OFF)
if (VIX_ENABLE_P2P AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/p2p/CMakeLists.txt")
  message(STATUS "Adding 'modules/p2p'...")
  set(VIX_P2P_ENABLE_INSTALL ${_VIX_SDK_PACKAGE_P2P} CACHE BOOL "Enable install/export rules for vix::p2p" FORCE)
  add_subdirectory(modules/p2p p2p_build)

  # Normalise: expose vix::p2p
  if (TARGET vix::p2p OR TARGET vix_p2p)
    set(VIX_HAS_P2P ON)
    if (TARGET vix_p2p AND NOT TARGET vix::p2p)
      add_library(vix::p2p ALIAS vix_p2p)
    endif()
  else()
    message(WARNING "P2P module added but no vix::p2p target was exported.")
  endif()
else()
  message(STATUS "P2P: disabled or not present.")
endif()

# --- Middleware (optional) ---
set(VIX_HAS_MIDDLEWARE OFF)
if (VIX_ENABLE_MIDDLEWARE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/middleware/CMakeLists.txt")
  message(STATUS "Adding 'modules/middleware'...")
  add_subdirectory(modules/middleware middleware_build)

  # Normalise: expose vix::middleware
  if (TARGET vix::middleware OR TARGET vix_middleware)
    set(VIX_HAS_MIDDLEWARE ON)
    if (TARGET vix_middleware AND NOT TARGET vix::middleware)
      add_library(vix::middleware ALIAS vix_middleware)
    endif()
  else()
    message(WARNING "Middleware module added but no vix::middleware target was exported.")
  endif()
else()
  message(STATUS "Middleware: disabled or not present.")
endif()

# --- P2P HTTP Adapter (optional) ---
set(VIX_HAS_P2P_HTTP OFF)

# Guard: p2p_http requires both core + p2p
if (VIX_ENABLE_P2P_HTTP AND _VIX_SDK_PACKAGE_P2P_HTTP AND VIX_HAS_P2P AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/p2p_http/CMakeLists.txt")
  message(STATUS "Adding 'modules/p2p_http'...")
  add_subdirectory(modules/p2p_http p2p_http_build)

  if (TARGET vix::p2p_http OR TARGET vix_p2p_http)
    set(VIX_HAS_P2P_HTTP ON)
    if (TARGET vix_p2p_http AND NOT TARGET vix::p2p_http)
      add_library(vix::p2p_http ALIAS vix_p2p_http)
    endif()
  else()
    message(WARNING "p2p_http module added but no vix::p2p_http target was exported.")
  endif()
else()
  message(STATUS "P2P HTTP: disabled, missing, or P2P not built.")
endif()

# Bench mode (compile-time flags)
if (VIX_BENCH_MODE)
  message(STATUS "Bench mode enabled: defining VIX_BENCH_MODE")

  # Resolve the real core target (vix::core is an ALIAS in your tree)
  set(_VIX_CORE_REAL "")

  set(_VIX_CORE_REAL "")
  vix_resolve_real_target(_VIX_CORE_REAL vix_core)
  if (NOT _VIX_CORE_REAL)
    vix_resolve_real_target(_VIX_CORE_REAL vix-core)
  endif()
  if (NOT _VIX_CORE_REAL)
    vix_resolve_real_target(_VIX_CORE_REAL core)
  endif()

  if (_VIX_CORE_REAL)
    target_compile_definitions(${_VIX_CORE_REAL} PUBLIC VIX_BENCH_MODE=1)
  else()
    message(WARNING "Bench mode requested but could not find real core target (tried: vix_core, vix-core, core).")
  endif()
endif()

# --- DB (optional, required by ORM) ---
set(VIX_HAS_DB OFF)
if (VIX_ENABLE_DB AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/db/CMakeLists.txt")
  message(STATUS "Adding 'modules/db'...")
  add_subdirectory(modules/db db_build)

  if (TARGET vix::db OR TARGET vix_db)
    if (TARGET vix_db AND NOT TARGET vix::db)
      add_library(vix::db ALIAS vix_db)
    endif()
    set(VIX_HAS_DB ON)
  else()
    message(WARNING "DB module added but no vix::db target was exported.")
  endif()
else()
  message(STATUS "DB: disabled or not present.")
endif()

# --- WebSocket (optional) ---
set(VIX_HAS_WEBSOCKET OFF)
if (VIX_ENABLE_WEBSOCKET AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/websocket/CMakeLists.txt")
  message(STATUS "Adding 'modules/websocket'...")
  set(VIX_WEBSOCKET_WITH_JSON "AUTO" CACHE STRING "Link JSON backend (AUTO|ON|OFF)")
  add_subdirectory(modules/websocket websocket_build)
  if (TARGET vix::websocket OR TARGET vix_websocket)
    set(VIX_HAS_WEBSOCKET ON)
  endif()
else()
  message(STATUS "WebSocket: disabled or not present.")
endif()

# --- Realtime (optional) ---
set(VIX_HAS_REALTIME OFF)
if (VIX_ENABLE_REALTIME AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/realtime/CMakeLists.txt")
  if (NOT VIX_HAS_ASYNC)
    message(FATAL_ERROR "Realtime requires Async module. Enable it with -DVIX_ENABLE_ASYNC=ON.")
  endif()
  if (NOT VIX_HAS_TIME)
    message(FATAL_ERROR "Realtime requires Time module. Enable it with -DVIX_ENABLE_TIME=ON.")
  endif()
  if (NOT VIX_HAS_SYNC)
    message(FATAL_ERROR "Realtime requires Sync module. Ensure modules/sync exists and configures successfully.")
  endif()

  message(STATUS "Adding 'modules/realtime'...")

  if (VIX_REALTIME_WITH_WEBSOCKET AND NOT VIX_HAS_WEBSOCKET)
    message(WARNING "Realtime WebSocket adapter requested but WebSocket module is missing -> disabling adapter")
    set(VIX_REALTIME_WITH_WEBSOCKET OFF CACHE BOOL "Build vix::realtime WebSocket transport adapter" FORCE)
  endif()

  if (VIX_REALTIME_WITH_POSTGRES AND NOT VIX_HAS_DB)
    message(FATAL_ERROR "Realtime PostgreSQL stores require DB module. Enable VIX_ENABLE_DB=ON or disable VIX_REALTIME_WITH_POSTGRES.")
  endif()

  set(VIX_REALTIME_FETCH_DEPENDENCIES ${VIX_FETCH_DEPS} CACHE BOOL "Fetch missing Vix dependencies" FORCE)
  set(VIX_REALTIME_BUILD_TESTS ${VIX_REALTIME_BUILD_TESTS} CACHE BOOL "Build realtime module tests" FORCE)
  set(VIX_REALTIME_BUILD_EXAMPLES ${VIX_REALTIME_BUILD_EXAMPLES} CACHE BOOL "Build realtime module examples" FORCE)
  set(VIX_REALTIME_WITH_WEBSOCKET ${VIX_REALTIME_WITH_WEBSOCKET} CACHE BOOL "Build the Vix WebSocket transport adapter" FORCE)
  set(VIX_REALTIME_WITH_POSTGRES ${VIX_REALTIME_WITH_POSTGRES} CACHE BOOL "Build PostgreSQL event and snapshot stores" FORCE)
  set(VIX_REALTIME_ENABLE_INSTALL ${_VIX_SDK_PACKAGE_REALTIME} CACHE BOOL "Generate install rules for the realtime package" FORCE)

  add_subdirectory(modules/realtime realtime_build)

  if (TARGET vix::realtime OR TARGET vix_realtime)
    set(VIX_HAS_REALTIME ON)
    if (TARGET vix_realtime AND NOT TARGET vix::realtime)
      add_library(vix::realtime ALIAS vix_realtime)
    endif()
  else()
    message(WARNING "Realtime module added but no vix::realtime target was exported.")
  endif()
else()
  message(STATUS "Realtime: disabled or not present.")
endif()

# --- Engine (optional, before CLI) ---
if (VIX_ENABLE_ENGINE AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/engine/CMakeLists.txt")
  message(STATUS "Adding 'modules/engine'...")
  add_subdirectory(modules/engine engine_build)
else()
  message(STATUS "Engine: disabled or not present.")
endif()

# --- CLI (optional) ---
if (VIX_ENABLE_CLI AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/cli/CMakeLists.txt")
  message(STATUS "Adding 'modules/cli'...")
  set(VIX_CLI_ENABLE_DESKTOP ${VIX_CLI_ENABLE_DESKTOP}
      CACHE BOOL "Build vix desktop CLI support through vix::ui" FORCE)
  add_subdirectory(modules/cli cli_build)
  if (VIX_BUILD_TESTS
      AND TARGET vix_cli
      AND TARGET vix_engine_model_tests
      AND TARGET vix_engine_parser_tests
      AND TARGET vix_engine_ninja_tests
      AND TARGET vix_engine_graph_tests
      AND TARGET vix_engine_scheduler_tests
      AND TARGET vix_engine_process_tests
      AND TARGET vix_engine_object_cache_tests
      AND TARGET vix_engine_graph_executor_tests
      AND TARGET vix_engine_artifact_cache_tests
      AND TARGET vix_engine_execution_plan_tests
      AND TARGET vix_cli_build_context_compat_tests
      AND TARGET vix_cli_build_task_process_executor_tests)
    add_dependencies(vix_cli
      vix_engine_model_tests
      vix_engine_parser_tests
      vix_engine_ninja_tests
      vix_engine_graph_tests
      vix_engine_scheduler_tests
      vix_engine_process_tests
      vix_engine_object_cache_tests
      vix_engine_graph_executor_tests
      vix_engine_artifact_cache_tests
      vix_engine_execution_plan_tests
      vix_cli_build_context_compat_tests
      vix_cli_build_task_process_executor_tests
    )
  endif()
else()
  message(STATUS "CLI: disabled or not present.")
endif()

# --- ORM (optional) ---
set(VIX_HAS_ORM OFF)
if (VIX_ENABLE_ORM AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/orm/CMakeLists.txt")

  if (NOT VIX_HAS_DB)
    message(FATAL_ERROR "ORM requires DB module. Enable it with -DVIX_ENABLE_DB=ON and ensure modules/db exists.")
  endif()

  message(STATUS "Adding 'modules/orm'...")
  set(VIX_ORM_BUILD_EXAMPLES ${VIX_ORM_BUILD_EXAMPLES} CACHE BOOL "Build vix::orm examples" FORCE)
  set(VIX_ORM_BUILD_TESTS ${VIX_ORM_BUILD_TESTS} CACHE BOOL "Build vix::orm tests" FORCE)

  add_subdirectory(modules/orm orm_build)

  if (TARGET vix::orm OR TARGET vix_orm)
    if (TARGET vix_orm AND NOT TARGET vix::orm)
      add_library(vix::orm ALIAS vix_orm)
    endif()
    set(VIX_HAS_ORM ON)
  else()
    message(WARNING "ORM module added but no vix::orm target was exported.")
  endif()
else()
  message(STATUS "ORM: disabled or not present.")
endif()

# ----------------------------------------------------
# Sanitizers
# Apply sanitizer flags only to final executables/tests/examples.
# Do not apply them to library/module targets.
# ----------------------------------------------------


if (TARGET vix_cli)
  if (TARGET vix::ai_agent)
    target_link_libraries(vix_cli PRIVATE vix::ai_agent)
  endif()
  if (TARGET vix::p2p)
    target_link_libraries(vix_cli PRIVATE vix::p2p)
  endif()
endif()

# ----------------------------------------------------
# Link umbrella to required module targets
# ----------------------------------------------------
target_link_libraries(vix INTERFACE
  vix::error
  vix::path
  vix::fs
  vix::io
  vix::env
  vix::os
  vix::utils
  vix::log
  vix::core
  ${JSON_TARGET}
)

if (TARGET vix::tests)
  target_link_libraries(vix INTERFACE vix::tests)
endif()

if (TARGET vix::time)
  target_link_libraries(vix INTERFACE vix::time)
endif()

if (TARGET vix::conversion)
  target_link_libraries(vix INTERFACE vix::conversion)
endif()

if (TARGET vix::validation)
  target_link_libraries(vix INTERFACE vix::validation)
endif()

if (TARGET vix::crypto)
  target_link_libraries(vix INTERFACE vix::crypto)
endif()

if (TARGET vix::net)
  target_link_libraries(vix INTERFACE vix::net)
endif()

if (TARGET vix::cache)
  target_link_libraries(vix INTERFACE vix::cache)
endif()

if (TARGET vix::sync)
  target_link_libraries(vix INTERFACE vix::sync)
endif()

if (TARGET vix::async)
  target_link_libraries(vix INTERFACE vix::async)
endif()

if (TARGET vix::process)
  target_link_libraries(vix INTERFACE vix::process)
endif()

if (TARGET vix::engine)
  target_link_libraries(vix INTERFACE vix::engine)
endif()

if (TARGET vix::threadpool)
  target_link_libraries(vix INTERFACE vix::threadpool)
endif()

if (TARGET vix::game)
  target_link_libraries(vix INTERFACE vix::game)
endif()

if (TARGET vix::kv)
  target_link_libraries(vix INTERFACE vix::kv)
endif()

if (TARGET vix::ai_agent AND _VIX_SDK_PACKAGE_AGENT)
  target_link_libraries(vix INTERFACE vix::ai_agent)
endif()

if (TARGET vix::p2p AND _VIX_SDK_PACKAGE_P2P)
  target_link_libraries(vix INTERFACE vix::p2p)
endif()

if (TARGET vix::p2p_http AND _VIX_SDK_PACKAGE_P2P_HTTP)
  target_link_libraries(vix INTERFACE vix::p2p_http)
endif()

if (TARGET vix::db)
  target_link_libraries(vix INTERFACE vix::db)
endif()

if (TARGET vix::webrpc)
  target_link_libraries(vix INTERFACE vix::webrpc)
endif()

if (TARGET vix::requests)
  target_link_libraries(vix INTERFACE vix::requests)
endif()

if (TARGET vix::realtime AND _VIX_SDK_PACKAGE_REALTIME)
  target_link_libraries(vix INTERFACE vix::realtime)
endif()

# Link websocket only if it exists
if (TARGET vix::websocket)
  target_link_libraries(vix INTERFACE vix::websocket)
elseif (TARGET vix_websocket)
  add_library(vix::websocket ALIAS vix_websocket)
  target_link_libraries(vix INTERFACE vix::websocket)
endif()

# Link middleware only if it exists
if (TARGET vix::middleware)
  target_link_libraries(vix INTERFACE vix::middleware)
  target_compile_definitions(vix INTERFACE VIX_HAS_MIDDLEWARE=1)
elseif (TARGET vix_middleware)
  add_library(vix::middleware ALIAS vix_middleware)
  target_link_libraries(vix INTERFACE vix::middleware)
  target_compile_definitions(vix INTERFACE VIX_HAS_MIDDLEWARE=1)
endif()

if (TARGET vix::template)
  target_link_libraries(vix INTERFACE vix::template)
elseif (TARGET template)
  target_link_libraries(vix INTERFACE template)
endif()

if (TARGET vix::ui)
  target_link_libraries(vix INTERFACE vix::ui)
elseif (TARGET ui)
  target_link_libraries(vix INTERFACE ui)
endif()

if (TARGET vix::note)
  target_link_libraries(vix INTERFACE vix::note)
elseif (TARGET vix_note)
  target_link_libraries(vix INTERFACE vix_note)
endif()

# ----------------------------------------------------
# Examples filtering
# ----------------------------------------------------
# Examples that require ORM at all
set(_ORM_EXAMPLES
  demo_with_orm
  error_handling
  batch_insert_tx
  users_crud
  repository_crud_full
  migrate_init
  tx_unit_of_work
  querybuilder_update
)

# Subset of ORM examples that require MySQL backend
set(_ORM_MYSQL_EXAMPLES
  demo_with_orm
  error_handling
  batch_insert_tx
  users_crud
  repository_crud_full
  migrate_init
  tx_unit_of_work
  querybuilder_update
)

# ----------------------------------------------------
# Examples (flat: examples/*.cpp and examples/orm/*.cpp)
# ----------------------------------------------------
if (VIX_BUILD_EXAMPLES)
  file(GLOB VIX_UMBRELLA_EXAMPLES
       CONFIGURE_DEPENDS
       "${CMAKE_CURRENT_SOURCE_DIR}/examples/*.cpp"
       "${CMAKE_CURRENT_SOURCE_DIR}/examples/orm/*.cpp")

  # 1) If ORM is OFF → remove all ORM examples
  if (NOT VIX_HAS_ORM)
    foreach(_ex IN LISTS _ORM_EXAMPLES)
      list(FILTER VIX_UMBRELLA_EXAMPLES EXCLUDE REGEX ".*/${_ex}\\.cpp$")
      list(FILTER VIX_UMBRELLA_EXAMPLES EXCLUDE REGEX ".*\\\\${_ex}\\.cpp$")
    endforeach()
    message(STATUS "Examples: ORM OFF → filtered ORM examples: ${_ORM_EXAMPLES}")
  endif()

  # 2) If ORM is ON but MySQL backend is OFF → remove MySQL-based ORM examples
  if (VIX_HAS_ORM AND NOT VIX_DB_USE_MYSQL)
    foreach(_ex IN LISTS _ORM_MYSQL_EXAMPLES)
      list(FILTER VIX_UMBRELLA_EXAMPLES EXCLUDE REGEX ".*/${_ex}\\.cpp$")
      list(FILTER VIX_UMBRELLA_EXAMPLES EXCLUDE REGEX ".*\\\\${_ex}\\.cpp$")
    endforeach()
    message(STATUS "Examples: MySQL OFF → filtered MySQL ORM examples: ${_ORM_MYSQL_EXAMPLES}")
  endif()

  if (VIX_UMBRELLA_EXAMPLES)
    foreach(EXAMPLE_SRC IN LISTS VIX_UMBRELLA_EXAMPLES)
      get_filename_component(_raw_name "${EXAMPLE_SRC}" NAME_WE)

      if (_raw_name MATCHES "_common$" OR _raw_name MATCHES "_disabled$" OR _raw_name MATCHES "_internal$")
        message(STATUS "Skipping helper/internal example: ${_raw_name}")
        continue()
      endif()

      set(EXAMPLE_NAME "${_raw_name}")
      if (TARGET "${EXAMPLE_NAME}")
        set(EXAMPLE_NAME "ex_${_raw_name}")
        message(WARNING "Target '${_raw_name}' already exists. Using '${EXAMPLE_NAME}'.")
      endif()

      add_executable("${EXAMPLE_NAME}" "${EXAMPLE_SRC}")
      target_link_libraries("${EXAMPLE_NAME}" PRIVATE vix::vix)

      if (VIX_HAS_ORM AND TARGET vix::orm AND EXAMPLE_SRC MATCHES "examples[/\\\\]orm[/\\\\]")
        target_link_libraries("${EXAMPLE_NAME}" PRIVATE vix::orm)
      endif()

      if (TARGET vix_warnings)
        target_link_libraries("${EXAMPLE_NAME}" PRIVATE vix_warnings)
      endif()

      vix_enable_sanitizers("${EXAMPLE_NAME}")

      if (TARGET vix_coverage)
        target_link_libraries("${EXAMPLE_NAME}" PRIVATE vix_coverage)
      endif()

      set_target_properties("${EXAMPLE_NAME}" PROPERTIES
        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
      )

      message(STATUS "Example added: ${EXAMPLE_NAME}  [${EXAMPLE_SRC}]")
    endforeach()
  else()
    message(STATUS "No example sources found under examples/.")
  endif()
endif()

# ----------------------------------------------------
# Grouped examples (subdirectories) — optional
# ----------------------------------------------------
if (VIX_BUILD_EXAMPLES AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt")
  message(STATUS "Examples: enabling grouped examples via examples/CMakeLists.txt")
  add_subdirectory(examples)
endif()

# ----------------------------------------------------
# Root umbrella tests
# ----------------------------------------------------
# Module tests are registered by modules/* when VIX_BUILD_TESTS and the
# matching module test option are ON. This block is only for optional
# root-level tests under ./tests.
if (VIX_BUILD_TESTS)
  file(GLOB_RECURSE VIX_TEST_SOURCES CONFIGURE_DEPENDS
       "${CMAKE_CURRENT_SOURCE_DIR}/tests/*_test.cpp")

  if (VIX_TEST_SOURCES)
    add_executable(vix_umbrella_tests ${VIX_TEST_SOURCES})
    target_link_libraries(vix_umbrella_tests PRIVATE
      vix::vix
      GTest::gtest
      GTest::gtest_main
    )

    if (TARGET vix_warnings)
      target_link_libraries(vix_umbrella_tests PRIVATE vix_warnings)
    endif()

    vix_enable_sanitizers(vix_umbrella_tests)

    if (TARGET vix_coverage)
      target_link_libraries(vix_umbrella_tests PRIVATE vix_coverage)
    endif()

    include(GoogleTest)
    gtest_discover_tests(vix_umbrella_tests
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
      DISCOVERY_MODE PRE_TEST
    )
  else()
    message(STATUS "No root *_test.cpp found under tests/ — module tests only.")
  endif()
endif()

# ----------------------------------------------------
# Runtime config copy (optional)
# ----------------------------------------------------
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/config/config.json")
  file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/config/config.json"
       DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
endif()

# ----------------------------------------------------
# Install/export (find_package(Vix CONFIG))
# ----------------------------------------------------
# Compute feature flags as real ON/OFF at configure-time (NO generator expressions)
set(VIX_WITH_JSON     ON)
set(VIX_WITH_OPENSSL  OFF)
find_package(OpenSSL QUIET)
if (OpenSSL_FOUND AND TARGET OpenSSL::Crypto)
  set(VIX_WITH_OPENSSL ON)
endif()
set(VIX_WITH_MYSQL    OFF)
set(VIX_WITH_SQLITE   OFF)
set(VIX_WITH_BOOST_FS OFF)

set(VIX_WITH_ZLIB OFF)
if (VIX_ENABLE_HTTP_COMPRESSION AND ZLIB_FOUND)
  set(VIX_WITH_ZLIB ON)
endif()

set(VIX_WITH_MYSQL OFF)
if (VIX_HAS_DB AND VIX_DB_USE_MYSQL)
  set(VIX_WITH_MYSQL ON)
endif()

set(VIX_WITH_CACHE OFF)
if (VIX_HAS_CACHE)
  set(VIX_WITH_CACHE ON)
endif()

set(VIX_WITH_P2P OFF)
if (VIX_HAS_P2P AND _VIX_SDK_PACKAGE_P2P)
  set(VIX_WITH_P2P ON)
endif()

set(VIX_WITH_P2P_HTTP OFF)
if (VIX_HAS_P2P_HTTP AND _VIX_SDK_PACKAGE_P2P_HTTP)
  set(VIX_WITH_P2P_HTTP ON)
endif()

set(VIX_WITH_REQUESTS OFF)
if (VIX_HAS_REQUESTS)
  set(VIX_WITH_REQUESTS ON)
endif()

set(VIX_WITH_REALTIME OFF)
if (VIX_HAS_REALTIME AND _VIX_SDK_PACKAGE_REALTIME)
  set(VIX_WITH_REALTIME ON)
endif()

if ((VIX_HAS_DB AND VIX_DB_USE_SQLITE) OR VIX_HAS_WEBSOCKET)
  set(VIX_WITH_SQLITE ON)
endif()

if (VIX_ENABLE_INSTALL)

  if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "legacy")
    set(_VIX_INSTALL_MODULES error path fs io env os log tests core utils json websocket webrpc requests realtime crypto time conversion validation async process threadpool kv agent game net cache sync p2p p2p_http middleware db orm template ui note)
  else()
    set(_VIX_INSTALL_MODULES error path fs io env os log core utils json time conversion async process threadpool template ui note net sync crypto)
    if (VIX_HAS_WEBRPC)
      list(APPEND _VIX_INSTALL_MODULES webrpc)
    endif()
    if (VIX_HAS_REQUESTS)
      list(APPEND _VIX_INSTALL_MODULES requests)
    endif()
    if (VIX_HAS_REALTIME AND _VIX_SDK_PACKAGE_REALTIME)
      list(APPEND _VIX_INSTALL_MODULES realtime)
    endif()
    if (VIX_HAS_VALIDATION)
      list(APPEND _VIX_INSTALL_MODULES validation)
    endif()
    if (VIX_HAS_MIDDLEWARE)
      list(APPEND _VIX_INSTALL_MODULES middleware)
    endif()
    if (VIX_HAS_CACHE)
      list(APPEND _VIX_INSTALL_MODULES cache)
    endif()
    if (VIX_HAS_KV)
      list(APPEND _VIX_INSTALL_MODULES kv)
    endif()
    if (VIX_HAS_DB AND _VIX_SDK_PACKAGE_DB)
      list(APPEND _VIX_INSTALL_MODULES db)
    endif()
    if (VIX_HAS_ORM AND _VIX_SDK_PACKAGE_ORM)
      list(APPEND _VIX_INSTALL_MODULES orm)
    endif()
    if (VIX_HAS_WEBSOCKET AND _VIX_SDK_PACKAGE_WEBSOCKET)
      list(APPEND _VIX_INSTALL_MODULES websocket)
    endif()
    if (VIX_HAS_P2P AND _VIX_SDK_PACKAGE_P2P)
      list(APPEND _VIX_INSTALL_MODULES p2p)
    endif()
    if (VIX_HAS_P2P_HTTP AND _VIX_SDK_PACKAGE_P2P_HTTP)
      list(APPEND _VIX_INSTALL_MODULES p2p_http)
    endif()
    if (VIX_HAS_AGENT AND _VIX_SDK_PACKAGE_AGENT)
      list(APPEND _VIX_INSTALL_MODULES agent)
    endif()
    if (VIX_HAS_GAME AND _VIX_SDK_PACKAGE_GAME)
      list(APPEND _VIX_INSTALL_MODULES game)
    endif()
    list(REMOVE_DUPLICATES _VIX_INSTALL_MODULES)
  endif()

  foreach(_m IN LISTS _VIX_INSTALL_MODULES)
    if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/modules/${_m}/include")
      install(DIRECTORY "modules/${_m}/include/"
        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
        FILES_MATCHING
          PATTERN "*.hpp"
          PATTERN "*.h"
          PATTERN "*.inc"
      )
    endif()
  endforeach()

  # ----------------------------------------------------
  # Install root umbrella header
  # ----------------------------------------------------
  if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vix.hpp")
    install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/vix.hpp"
      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
    )
  endif()

  # ----------------------------------------------------
  # Install umbrella public headers (vix/*.hpp)
  # ----------------------------------------------------
  if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vix")
    if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "legacy")
      install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/vix/"
        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vix"
        FILES_MATCHING
          PATTERN "*.hpp"
          PATTERN "*.h"
      )
    else()
      foreach(_m IN LISTS _VIX_INSTALL_MODULES)
        if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vix/${_m}.hpp")
          install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/vix/${_m}.hpp"
            DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vix"
          )
        endif()
      endforeach()
      if (_VIX_SDK_PROFILE_EFFECTIVE STREQUAL "all" AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/vix/all.hpp")
        install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/vix/all.hpp"
          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vix"
        )
      endif()
    endif()
  endif()

  # ---- Install Asio (submodule) ----
  set(_VIX_ASIO_INSTALL_SRC "${CMAKE_CURRENT_SOURCE_DIR}/third_party/asio-src/asio/include")

  if (NOT EXISTS "${_VIX_ASIO_INSTALL_SRC}/asio.hpp")
    message(FATAL_ERROR "Asio submodule missing: third_party/asio-src. Run: git submodule update --init --recursive")
  endif()

  file(GLOB_RECURSE _VIX_ASIO_HEADERS
    CONFIGURE_DEPENDS
    "${_VIX_ASIO_INSTALL_SRC}/*.hpp"
    "${_VIX_ASIO_INSTALL_SRC}/*.h"
  )

  install(FILES ${_VIX_ASIO_HEADERS}
    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vix/third_party/asio"
  )

  install(TARGETS vix EXPORT VixTargets)

  if (TARGET vix_thirdparty_asio)
    install(TARGETS vix_thirdparty_asio EXPORT VixTargets)
  endif()

  # ---- Config files ----
  set(VIX_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/Vix")

  write_basic_package_version_file(
    "${CMAKE_CURRENT_BINARY_DIR}/VixConfigVersion.cmake"
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion
  )

  set(VIX_HAS_ORM ${VIX_HAS_ORM})

  set(VIX_DB_WITH_MYSQL OFF)
  if (VIX_HAS_DB AND VIX_DB_USE_MYSQL)
    set(VIX_DB_WITH_MYSQL ON)
  endif()

  set(VIX_WITH_MYSQL ${VIX_DB_WITH_MYSQL})

  set(VIX_HAS_CACHE  ${VIX_HAS_CACHE})
  set(VIX_HAS_P2P    ${VIX_WITH_P2P})
  set(VIX_WITH_CACHE ${VIX_WITH_CACHE})
  set(VIX_WITH_P2P   ${VIX_WITH_P2P})
  set(VIX_HAS_P2P_HTTP  ${VIX_WITH_P2P_HTTP})
  set(VIX_WITH_P2P_HTTP ${VIX_WITH_P2P_HTTP})
  set(VIX_HAS_TIME ${VIX_HAS_TIME})
  set(VIX_HAS_TEMPLATE ${VIX_HAS_TEMPLATE})
  set(VIX_HAS_UI ${VIX_HAS_UI})

  set(VIX_WITH_THREADPOOL OFF)
  if (VIX_HAS_THREADPOOL)
    set(VIX_WITH_THREADPOOL ON)
  endif()

  set(VIX_WITH_ASYNC OFF)
  if (VIX_HAS_ASYNC)
    set(VIX_WITH_ASYNC ON)
  endif()

  set(VIX_HAS_ASYNC ${VIX_HAS_ASYNC})
  set(VIX_WITH_ASYNC ${VIX_WITH_ASYNC})

  set(VIX_WITH_KV OFF)
  if (VIX_HAS_KV)
    set(VIX_WITH_KV ON)
  endif()

  set(VIX_HAS_KV  ${VIX_HAS_KV})
  set(VIX_WITH_KV ${VIX_WITH_KV})

  set(VIX_WITH_CONVERSION OFF)
  if (VIX_HAS_CONVERSION)
    set(VIX_WITH_CONVERSION ON)
  endif()

  set(VIX_WITH_CRYPTO OFF)
  if (VIX_HAS_CRYPTO)
    set(VIX_WITH_CRYPTO ON)
  endif()

  set(VIX_HAS_CRYPTO  ${VIX_HAS_CRYPTO})
  set(VIX_WITH_CRYPTO ${VIX_WITH_CRYPTO})

  set(VIX_WITH_WEBRPC OFF)
  if (VIX_HAS_WEBRPC)
    set(VIX_WITH_WEBRPC ON)
  endif()

  set(VIX_WITH_REQUESTS OFF)
  if (VIX_HAS_REQUESTS)
    set(VIX_WITH_REQUESTS ON)
  endif()

  set(VIX_WITH_VALIDATION OFF)
  if (VIX_HAS_VALIDATION)
    set(VIX_WITH_VALIDATION ON)
  endif()

  set(VIX_WITH_TEMPLATE OFF)
  if (VIX_HAS_TEMPLATE)
    set(VIX_WITH_TEMPLATE ON)
  endif()

  set(VIX_WITH_UI OFF)
  if (VIX_HAS_UI)
    set(VIX_WITH_UI ON)
  endif()

  set(VIX_WITH_UI_LINUX_WEBVIEW OFF)
  if (VIX_HAS_UI AND VIX_UI_ENABLE_LINUX_WEBVIEW)
    set(VIX_WITH_UI_LINUX_WEBVIEW ON)
  endif()

  set(VIX_HAS_UI ${VIX_HAS_UI})
  set(VIX_WITH_UI ${VIX_WITH_UI})
  set(VIX_WITH_UI_LINUX_WEBVIEW ${VIX_WITH_UI_LINUX_WEBVIEW})

  set(VIX_WITH_NOTE OFF)
  if (VIX_HAS_NOTE)
    set(VIX_WITH_NOTE ON)
  endif()

  set(VIX_HAS_NOTE ${VIX_HAS_NOTE})
  set(VIX_WITH_NOTE ${VIX_WITH_NOTE})

  set(VIX_HAS_REQUESTS ${VIX_HAS_REQUESTS})
  set(VIX_WITH_REQUESTS ${VIX_WITH_REQUESTS})

  set(VIX_HAS_REALTIME ${VIX_WITH_REALTIME})
  set(VIX_WITH_REALTIME ${VIX_WITH_REALTIME})

  set(VIX_WITH_AGENT OFF)
  if (VIX_HAS_AGENT AND _VIX_SDK_PACKAGE_AGENT)
    set(VIX_WITH_AGENT ON)
  endif()

  set(VIX_HAS_AGENT ${VIX_WITH_AGENT})
  set(VIX_WITH_AGENT ${VIX_WITH_AGENT})

  set(VIX_WITH_GAME OFF)
  if (VIX_HAS_GAME AND _VIX_SDK_PACKAGE_GAME)
    set(VIX_WITH_GAME ON)
  endif()

  set(VIX_HAS_GAME ${VIX_WITH_GAME})
  set(VIX_WITH_GAME ${VIX_WITH_GAME})

  set(VIX_WITH_GAME_SDL OFF)
  if (VIX_HAS_GAME AND _VIX_SDK_PACKAGE_GAME AND VIX_GAME_ENABLE_SDL)
    set(VIX_WITH_GAME_SDL ON)
  endif()

  set(VIX_WITH_GAME_SDL ${VIX_WITH_GAME_SDL})

  set(VIX_WITH_GAME_SDL_OPENGL OFF)
  if (VIX_HAS_GAME AND _VIX_SDK_PACKAGE_GAME AND VIX_GAME_ENABLE_SDL_OPENGL)
    set(VIX_WITH_GAME_SDL_OPENGL ON)
  endif()

  set(VIX_WITH_GAME_SDL_OPENGL ${VIX_WITH_GAME_SDL_OPENGL})

  set(VIX_HAS_VALIDATION  ${VIX_HAS_VALIDATION})
  set(VIX_WITH_VALIDATION ${VIX_WITH_VALIDATION})

  set(VIX_HAS_TESTS ${VIX_HAS_TESTS})

  set(VIX_WITH_TESTS OFF)
  if (VIX_HAS_TESTS)
    set(VIX_WITH_TESTS ON)
  endif()

  configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/VixConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/VixConfig.cmake"
    INSTALL_DESTINATION "${VIX_INSTALL_CMAKEDIR}"
  )

  install(EXPORT VixTargets
          NAMESPACE vix::
          DESTINATION "${VIX_INSTALL_CMAKEDIR}")

  install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/VixConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/VixConfigVersion.cmake"
    DESTINATION "${VIX_INSTALL_CMAKEDIR}"
  )

  # ---- Install CLI executable (not exported) ----
  if (TARGET vix_cli)
    install(
      TARGETS vix_cli
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      COMPONENT Runtime
    )
    message(STATUS "CLI install: installing target 'vix_cli' as 'vix'")
  else()
    message(STATUS "CLI install: no 'vix_cli' target detected, CLI not installed")
  endif()

endif()

# ----------------------------------------------------
# Summary
# ----------------------------------------------------
message(STATUS "------------------------------------------------------")
message(STATUS "Vix umbrella configured")
message(STATUS "Project version   : ${PROJECT_VERSION}")
message(STATUS "Tests module      : ${VIX_HAS_TESTS}")
message(STATUS "JSON backend      : ${_VIX_JSON_BACKEND}")
message(STATUS "Time module       : ${VIX_HAS_TIME}")
message(STATUS "WebRPC built      : ${VIX_HAS_WEBRPC}")
message(STATUS "Requests built    : ${VIX_HAS_REQUESTS}")
message(STATUS "Realtime built    : ${VIX_HAS_REALTIME}")
message(STATUS "WebSocket built   : ${VIX_HAS_WEBSOCKET}")
message(STATUS "Process built     : ${VIX_HAS_PROCESS}")
message(STATUS "ThreadPool built  : ${VIX_HAS_THREADPOOL}")
message(STATUS "KV built          : ${VIX_HAS_KV}")
message(STATUS "AI Agent built    : ${VIX_HAS_AGENT}")
message(STATUS "ORM packaged      : ${VIX_HAS_ORM}")
message(STATUS "DB built          : ${VIX_HAS_DB}")
message(STATUS "P2P built         : ${VIX_HAS_P2P}")
message(STATUS "Conversion built  : ${VIX_HAS_CONVERSION}")
message(STATUS "Game built        : ${VIX_HAS_GAME}")
message(STATUS "Game SDL          : ${VIX_GAME_ENABLE_SDL}")
message(STATUS "Game SDL OpenGL   : ${VIX_GAME_ENABLE_SDL_OPENGL}")
message(STATUS "Validation built  : ${VIX_HAS_VALIDATION}")
message(STATUS "Middleware built  : ${VIX_HAS_MIDDLEWARE}")
message(STATUS "Template built    : ${VIX_HAS_TEMPLATE}")
message(STATUS "UI built          : ${VIX_HAS_UI}")
message(STATUS "Note built        : ${VIX_HAS_NOTE}")
message(STATUS "Examples          : ${VIX_BUILD_EXAMPLES}")
message(STATUS "Tests             : ${VIX_BUILD_TESTS}")
message(STATUS "Sanitizers        : ${VIX_ENABLE_SANITIZERS}")
message(STATUS "Coverage          : ${VIX_ENABLE_COVERAGE}")
message(STATUS "LTO               : ${VIX_ENABLE_LTO}")
message(STATUS "Install/Export    : ${VIX_ENABLE_INSTALL}")
message(STATUS "Flags exported    : JSON=${VIX_WITH_JSON} CONVERSION=${VIX_WITH_CONVERSION} VALIDATION=${VIX_WITH_VALIDATION} WEBRPC=${VIX_WITH_WEBRPC} REQUESTS=${VIX_WITH_REQUESTS} REALTIME=${VIX_WITH_REALTIME} CRYPTO=${VIX_WITH_CRYPTO} BOOST_FS=${VIX_WITH_BOOST_FS} OPENSSL=${VIX_WITH_OPENSSL} SQLITE=${VIX_WITH_SQLITE} MYSQL=${VIX_WITH_MYSQL} HAS_ORM=${VIX_HAS_ORM} CACHE=${VIX_WITH_CACHE} P2P=${VIX_WITH_P2P} TEMPLATE=${VIX_WITH_TEMPLATE} UI=${VIX_WITH_UI} UI_WEBVIEW=${VIX_WITH_UI_LINUX_WEBVIEW} NOTE=${VIX_WITH_NOTE} THREADPOOL=${VIX_WITH_THREADPOOL} KV=${VIX_WITH_KV} AGENT=${VIX_WITH_AGENT} GAME=${VIX_WITH_GAME} GAME_SDL=${VIX_WITH_GAME_SDL} GAME_SDL_OPENGL=${VIX_WITH_GAME_SDL_OPENGL}")
message(STATUS "------------------------------------------------------")