backend-infra-engineer: Release v0.3.3 snapshot

2025-11-21 21:35:50 -05:00
parent 3d71417f62
commit 476dd1cd1c
818 changed files with 65706 additions and 35514 deletions
--- a/cmake/CPM.cmake
+++ b/cmake/CPM.cmake
@@ -0,0 +1,49 @@
+# CPM.cmake - C++ Package Manager
+# https://github.com/cpm-cmake/CPM.cmake
+
+set(CPM_DOWNLOAD_VERSION 0.38.7)
+
+if(CPM_SOURCE_CACHE)
+  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+elseif(DEFINED ENV{CPM_SOURCE_CACHE})
+  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+else()
+  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+endif()
+
+# Expand relative path. This is important if the provided path contains a tilde (~)
+get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
+
+function(download_cpm)
+  message(STATUS "Downloading CPM.cmake to ${CPM_DOWNLOAD_LOCATION}")
+  file(DOWNLOAD
+       https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+       ${CPM_DOWNLOAD_LOCATION}
+  )
+endfunction()
+
+if(NOT (EXISTS ${CPM_DOWNLOAD_LOCATION}))
+  download_cpm()
+else()
+  # resume download if it previously failed
+  file(READ ${CPM_DOWNLOAD_LOCATION} check)
+  if("${check}" STREQUAL "")
+    download_cpm()
+  endif()
+endif()
+
+include(${CPM_DOWNLOAD_LOCATION})
+
+# Set CPM options for better caching and performance
+set(CPM_USE_LOCAL_PACKAGES ON)
+set(CPM_LOCAL_PACKAGES_ONLY OFF)
+set(CPM_DONT_CREATE_PACKAGE_LOCK ON)
+set(CPM_DONT_UPDATE_MODULE_PATH ON)
+set(CPM_DONT_PREPEND_TO_MODULE_PATH ON)
+
+# Set cache directory for CI builds
+if(DEFINED ENV{GITHUB_ACTIONS})
+  set(CPM_SOURCE_CACHE "$ENV{HOME}/.cpm-cache")
+  message(STATUS "CPM cache directory: ${CPM_SOURCE_CACHE}")
+endif()
+
--- a/cmake/absl.cmake
+++ b/cmake/absl.cmake
@@ -38,6 +38,9 @@ if(_yaze_use_fetched_absl)
    set(ABSL_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(absl)
    message(STATUS "Fetched Abseil ${YAZE_ABSL_GIT_TAG}")
+
+    # NEW: Export source directory for Windows builds that need explicit include paths
+    set(YAZE_ABSL_SOURCE_DIR "${absl_SOURCE_DIR}" CACHE INTERNAL "Abseil source directory")
  endif()
 endif()

--- a/cmake/asar.cmake
+++ b/cmake/asar.cmake
@@ -14,7 +14,7 @@ if(MSVC)
 endif()

 # Set Asar source directory
-set(ASAR_SRC_DIR "${CMAKE_SOURCE_DIR}/src/lib/asar/src")
+set(ASAR_SRC_DIR "${CMAKE_SOURCE_DIR}/ext/asar/src")

 # Add Asar as subdirectory
 add_subdirectory(${ASAR_SRC_DIR} EXCLUDE_FROM_ALL)
--- a/cmake/dependencies.cmake
+++ b/cmake/dependencies.cmake
@@ -1,155 +1,95 @@
-# This file centralizes the management of all third-party dependencies.
-# It provides functions to find or fetch dependencies and creates alias targets
-# for consistent usage throughout the project.
+# YAZE Dependencies Management
+# Centralized dependency management using CPM.cmake

-include(FetchContent)
+# Include CPM and options
+include(cmake/CPM.cmake)
+include(cmake/options.cmake)
+include(cmake/dependencies.lock)

-# ============================================================================
-# Helper function to add a dependency
-# ============================================================================
-function(yaze_add_dependency name)
-  set(options)
-  set(oneValueArgs GIT_REPOSITORY GIT_TAG URL)
-  set(multiValueArgs)
-  cmake_parse_arguments(DEP "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+message(STATUS "=== Setting up YAZE dependencies with CPM.cmake ===")

-  if(TARGET yaze::${name})
-    return()
-  endif()
+# Clear any previous dependency targets
+set(YAZE_ALL_DEPENDENCIES "")
+set(YAZE_SDL2_TARGETS "")
+set(YAZE_YAML_TARGETS "")
+set(YAZE_IMGUI_TARGETS "")
+set(YAZE_JSON_TARGETS "")
+set(YAZE_GRPC_TARGETS "")
+set(YAZE_FTXUI_TARGETS "")
+set(YAZE_TESTING_TARGETS "")

-  # Try to find the package via find_package first
-  find_package(${name} QUIET)
+# Core dependencies (always required)
+include(cmake/dependencies/sdl2.cmake)
+# Debug: message(STATUS "After SDL2 setup, YAZE_SDL2_TARGETS = '${YAZE_SDL2_TARGETS}'")
+list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_SDL2_TARGETS})

-  if(${name}_FOUND)
-    message(STATUS "Found ${name} via find_package")
-    if(TARGET ${name}::${name})
-        add_library(yaze::${name} ALIAS ${name}::${name})
-    else()
-        # Handle cases where find_package doesn't create an imported target
-        # This is a simplified approach; more logic may be needed for specific packages
-        add_library(yaze::${name} INTERFACE IMPORTED)
-        target_include_directories(yaze::${name} INTERFACE ${${name}_INCLUDE_DIRS})
-        target_link_libraries(yaze::${name} INTERFACE ${${name}_LIBRARIES})
-    endif()
-    return()
-  endif()
+include(cmake/dependencies/yaml.cmake)
+list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_YAML_TARGETS})

-  # If not found, use FetchContent
-  message(STATUS "Could not find ${name}, fetching from source.")
-  FetchContent_Declare(
-    ${name}
-    GIT_REPOSITORY ${DEP_GIT_REPOSITORY}
-    GIT_TAG ${DEP_GIT_TAG}
-  )
+include(cmake/dependencies/imgui.cmake)
+# Debug: message(STATUS "After ImGui setup, YAZE_IMGUI_TARGETS = '${YAZE_IMGUI_TARGETS}'")
+list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_IMGUI_TARGETS})

-  FetchContent_GetProperties(${name})
-  if(NOT ${name}_POPULATED)
-    FetchContent_Populate(${name})
-    add_subdirectory(${${name}_SOURCE_DIR} ${${name}_BINARY_DIR})
-  endif()
-
-  if(TARGET ${name})
-    add_library(yaze::${name} ALIAS ${name})
-  elseif(TARGET ${name}::${name})
-    add_library(yaze::${name} ALIAS ${name}::${name})
-  else()
-    message(FATAL_ERROR "Failed to create target for ${name}")
-  endif()
-endfunction()
-
-# ============================================================================
-# Dependency Declarations
-# ============================================================================
-
-# gRPC (must come before Abseil - provides its own compatible Abseil)
-if(YAZE_WITH_GRPC)
-  include(cmake/grpc.cmake)
-  # Verify ABSL_TARGETS was populated by gRPC
-  list(LENGTH ABSL_TARGETS _absl_count)
-  if(_absl_count EQUAL 0)
-    message(FATAL_ERROR "ABSL_TARGETS is empty after including grpc.cmake!")
-  else()
-    message(STATUS "gRPC provides ${_absl_count} Abseil targets for linking")
-  endif()
-endif()
-
-# Abseil (only if gRPC didn't provide it)
-if(NOT YAZE_WITH_GRPC)
+# Abseil is required for failure_signal_handler, status, and other utilities
+# Only include standalone Abseil when gRPC is disabled - when gRPC is enabled,
+# it provides its own bundled Abseil via CPM
+if(NOT YAZE_ENABLE_GRPC)
  include(cmake/absl.cmake)
-  # Verify ABSL_TARGETS was populated
-  list(LENGTH ABSL_TARGETS _absl_count)
-  if(_absl_count EQUAL 0)
-    message(FATAL_ERROR "ABSL_TARGETS is empty after including absl.cmake!")
-  else()
-    message(STATUS "Abseil provides ${_absl_count} targets for linking")
-  endif()
 endif()

-set(YAZE_PROTOBUF_TARGETS)
-
-if(TARGET protobuf::libprotobuf)
-  list(APPEND YAZE_PROTOBUF_TARGETS protobuf::libprotobuf)
-else()
-  if(TARGET libprotobuf)
-    list(APPEND YAZE_PROTOBUF_TARGETS libprotobuf)
-  endif()
+# Optional dependencies based on feature flags
+if(YAZE_ENABLE_JSON)
+  include(cmake/dependencies/json.cmake)
+  list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_JSON_TARGETS})
 endif()

-set(YAZE_PROTOBUF_WHOLEARCHIVE_TARGETS ${YAZE_PROTOBUF_TARGETS})
-
-if(YAZE_PROTOBUF_TARGETS)
-  list(GET YAZE_PROTOBUF_TARGETS 0 YAZE_PROTOBUF_TARGET)
-else()
-  set(YAZE_PROTOBUF_TARGET "")
+# CRITICAL: Load testing dependencies BEFORE gRPC when both are enabled
+# This ensures gmock is available before Abseil (bundled with gRPC) tries to export test_allocator
+# which depends on gmock. This prevents CMake export errors.
+if(YAZE_BUILD_TESTS AND YAZE_ENABLE_GRPC)
+  include(cmake/dependencies/testing.cmake)
+  list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_TESTING_TARGETS})
 endif()

-# SDL2
-include(cmake/sdl2.cmake)
+if(YAZE_ENABLE_GRPC)
+  include(cmake/dependencies/grpc.cmake)
+  list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_GRPC_TARGETS})
+endif()

-# Asar
-include(cmake/asar.cmake)
+if(YAZE_BUILD_CLI)
+  include(cmake/dependencies/ftxui.cmake)
+  list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_FTXUI_TARGETS})
+endif()

-# Google Test
+# Load testing dependencies after gRPC if tests are enabled but gRPC is not
+if(YAZE_BUILD_TESTS AND NOT YAZE_ENABLE_GRPC)
+  include(cmake/dependencies/testing.cmake)
+  list(APPEND YAZE_ALL_DEPENDENCIES ${YAZE_TESTING_TARGETS})
+endif()
+
+# ASAR dependency (for ROM assembly) - temporarily disabled
+# TODO: Add CMakeLists.txt to bundled ASAR or find working repository
+message(STATUS "ASAR dependency temporarily disabled - will be added later")
+
+# Print dependency summary
+message(STATUS "=== YAZE Dependencies Summary ===")
+message(STATUS "Total dependencies: ${YAZE_ALL_DEPENDENCIES}")
+message(STATUS "SDL2: ${YAZE_SDL2_TARGETS}")
+message(STATUS "YAML: ${YAZE_YAML_TARGETS}")
+message(STATUS "ImGui: ${YAZE_IMGUI_TARGETS}")
+if(YAZE_ENABLE_JSON)
+  message(STATUS "JSON: ${YAZE_JSON_TARGETS}")
+endif()
+if(YAZE_ENABLE_GRPC)
+  message(STATUS "gRPC: ${YAZE_GRPC_TARGETS}")
+endif()
+if(YAZE_BUILD_CLI)
+  message(STATUS "FTXUI: ${YAZE_FTXUI_TARGETS}")
+endif()
 if(YAZE_BUILD_TESTS)
-  include(cmake/gtest.cmake)
+  message(STATUS "Testing: ${YAZE_TESTING_TARGETS}")
 endif()
+message(STATUS "=================================")

-# ImGui
-include(cmake/imgui.cmake)
-
-# FTXUI (for z3ed)
-if(YAZE_BUILD_Z3ED)
-    FetchContent_Declare(ftxui
-        GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
-        GIT_TAG v5.0.0
-    )
-    FetchContent_MakeAvailable(ftxui)
-endif()
-
-# yaml-cpp (always available for configuration files)
-set(YAML_CPP_BUILD_TESTS OFF CACHE BOOL "Disable yaml-cpp tests" FORCE)
-set(YAML_CPP_BUILD_CONTRIB OFF CACHE BOOL "Disable yaml-cpp contrib" FORCE)
-set(YAML_CPP_BUILD_TOOLS OFF CACHE BOOL "Disable yaml-cpp tools" FORCE)
-set(YAML_CPP_INSTALL OFF CACHE BOOL "Disable yaml-cpp install" FORCE)
-set(YAML_CPP_FORMAT_SOURCE OFF CACHE BOOL "Disable yaml-cpp format target" FORCE)
-
-# yaml-cpp (uses CMAKE_POLICY_VERSION_MINIMUM set in root CMakeLists.txt)
-FetchContent_Declare(yaml-cpp
-    GIT_REPOSITORY https://github.com/jbeder/yaml-cpp.git
-    GIT_TAG 0.8.0
-)
-FetchContent_MakeAvailable(yaml-cpp)
-
-# Fix MSVC exception handling warning for yaml-cpp
-if(MSVC AND TARGET yaml-cpp)
-  target_compile_options(yaml-cpp PRIVATE /EHsc)
-endif()
-
-# nlohmann_json (header only)
-if(YAZE_WITH_JSON)
-    set(JSON_BuildTests OFF CACHE INTERNAL "Disable nlohmann_json tests")
-    add_subdirectory(${CMAKE_SOURCE_DIR}/third_party/json ${CMAKE_BINARY_DIR}/third_party/json EXCLUDE_FROM_ALL)
-endif()
-
-# httplib (header only)
-# No action needed here as it's included directly.
+# Export all dependency targets for use in other CMake files
+set(YAZE_ALL_DEPENDENCIES ${YAZE_ALL_DEPENDENCIES})
--- a/cmake/dependencies.lock
+++ b/cmake/dependencies.lock
@@ -0,0 +1,29 @@
+# CPM Dependencies Lock File
+# This file pins exact versions to ensure reproducible builds
+# Update versions here when upgrading dependencies
+
+# Core dependencies
+set(SDL2_VERSION "2.30.0" CACHE STRING "SDL2 version")
+set(YAML_CPP_VERSION "0.8.0" CACHE STRING "yaml-cpp version")
+
+# gRPC and related
+# Using v1.67.1 for MSVC compatibility (v1.75.1 has UPB compilation errors on Windows)
+set(GRPC_VERSION "1.67.1" CACHE STRING "gRPC version - MSVC compatible")
+set(PROTOBUF_VERSION "3.25.1" CACHE STRING "Protobuf version")
+set(ABSEIL_VERSION "20240116.0" CACHE STRING "Abseil version")
+# Cache revision: increment to force CPM cache invalidation (current: 2)
+
+# Testing
+set(GTEST_VERSION "1.14.0" CACHE STRING "Google Test version")
+set(BENCHMARK_VERSION "1.8.3" CACHE STRING "Google Benchmark version")
+
+# CLI tools
+set(FTXUI_VERSION "5.0.0" CACHE STRING "FTXUI version")
+
+# ImGui
+set(IMGUI_VERSION "1.90.4" CACHE STRING "Dear ImGui version")
+# Cache revision: increment to force rebuild (current: 2)
+
+# ASAR
+set(ASAR_VERSION "main" CACHE STRING "ASAR version")
+
--- a/cmake/dependencies/ftxui.cmake
+++ b/cmake/dependencies/ftxui.cmake
@@ -0,0 +1,35 @@
+# FTXUI dependency management for CLI tools
+# Uses CPM.cmake for consistent cross-platform builds
+
+if(NOT YAZE_BUILD_CLI)
+  return()
+endif()
+
+include(cmake/CPM.cmake)
+include(cmake/dependencies.lock)
+
+message(STATUS "Setting up FTXUI ${FTXUI_VERSION} with CPM.cmake")
+
+# Use CPM to fetch FTXUI
+CPMAddPackage(
+  NAME ftxui
+  VERSION ${FTXUI_VERSION}
+  GITHUB_REPOSITORY ArthurSonzogni/ftxui
+  GIT_TAG v${FTXUI_VERSION}
+  OPTIONS
+    "FTXUI_BUILD_EXAMPLES OFF"
+    "FTXUI_BUILD_TESTS OFF"
+    "FTXUI_ENABLE_INSTALL OFF"
+)
+
+# FTXUI targets are created during the build phase
+# We'll create our own interface target and link when available
+add_library(yaze_ftxui INTERFACE)
+
+# Note: FTXUI targets will be available after the build phase
+# For now, we'll create a placeholder that can be linked later
+
+# Export FTXUI targets for use in other CMake files
+set(YAZE_FTXUI_TARGETS yaze_ftxui)
+
+message(STATUS "FTXUI setup complete")
--- a/cmake/dependencies/grpc.cmake
+++ b/cmake/dependencies/grpc.cmake
@@ -0,0 +1,433 @@
+# gRPC and Protobuf dependency management
+# Uses CPM.cmake for consistent cross-platform builds
+
+if(NOT YAZE_ENABLE_GRPC)
+  return()
+endif()
+
+# Include CPM and dependencies lock
+include(cmake/CPM.cmake)
+include(cmake/dependencies.lock)
+
+message(STATUS "Setting up gRPC ${GRPC_VERSION} with CPM.cmake")
+
+# Try to use system packages first if requested
+if(YAZE_USE_SYSTEM_DEPS)
+  find_package(PkgConfig QUIET)
+  if(PkgConfig_FOUND)
+    pkg_check_modules(GRPC_PC grpc++)
+    if(GRPC_PC_FOUND)
+      message(STATUS "Using system gRPC via pkg-config")
+      add_library(grpc::grpc++ INTERFACE IMPORTED)
+      target_include_directories(grpc::grpc++ INTERFACE ${GRPC_PC_INCLUDE_DIRS})
+      target_link_libraries(grpc::grpc++ INTERFACE ${GRPC_PC_LIBRARIES})
+      target_compile_options(grpc::grpc++ INTERFACE ${GRPC_PC_CFLAGS_OTHER})
+      return()
+    endif()
+  endif()
+endif()
+
+#-----------------------------------------------------------------------
+# Guard CMake's package lookup so CPM always downloads a consistent gRPC
+# toolchain instead of picking up partially-installed Homebrew/apt copies.
+#-----------------------------------------------------------------------
+if(DEFINED CPM_USE_LOCAL_PACKAGES)
+  set(_YAZE_GRPC_SAVED_CPM_USE_LOCAL_PACKAGES "${CPM_USE_LOCAL_PACKAGES}")
+else()
+  set(_YAZE_GRPC_SAVED_CPM_USE_LOCAL_PACKAGES "__YAZE_UNSET__")
+endif()
+set(CPM_USE_LOCAL_PACKAGES OFF)
+
+foreach(_yaze_pkg IN ITEMS gRPC Protobuf absl)
+  string(TOUPPER "CMAKE_DISABLE_FIND_PACKAGE_${_yaze_pkg}" _yaze_disable_var)
+  if(DEFINED ${_yaze_disable_var})
+    set("_YAZE_GRPC_SAVE_${_yaze_disable_var}" "${${_yaze_disable_var}}")
+  else()
+    set("_YAZE_GRPC_SAVE_${_yaze_disable_var}" "__YAZE_UNSET__")
+  endif()
+  set(${_yaze_disable_var} TRUE)
+endforeach()
+
+if(DEFINED PKG_CONFIG_USE_CMAKE_PREFIX_PATH)
+  set(_YAZE_GRPC_SAVED_PKG_CONFIG_USE_CMAKE_PREFIX_PATH "${PKG_CONFIG_USE_CMAKE_PREFIX_PATH}")
+else()
+  set(_YAZE_GRPC_SAVED_PKG_CONFIG_USE_CMAKE_PREFIX_PATH "__YAZE_UNSET__")
+endif()
+set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH FALSE)
+
+set(_YAZE_GRPC_SAVED_PREFIX_PATH "${CMAKE_PREFIX_PATH}")
+set(CMAKE_PREFIX_PATH "")
+
+if(DEFINED CMAKE_CROSSCOMPILING)
+  set(_YAZE_GRPC_SAVED_CROSSCOMPILING "${CMAKE_CROSSCOMPILING}")
+else()
+  set(_YAZE_GRPC_SAVED_CROSSCOMPILING "__YAZE_UNSET__")
+endif()
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL CMAKE_SYSTEM_NAME
+   AND CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_CROSSCOMPILING FALSE)
+endif()
+
+if(DEFINED CMAKE_CXX_STANDARD)
+  set(_YAZE_GRPC_SAVED_CXX_STANDARD "${CMAKE_CXX_STANDARD}")
+else()
+  set(_YAZE_GRPC_SAVED_CXX_STANDARD "__YAZE_UNSET__")
+endif()
+set(CMAKE_CXX_STANDARD 17)
+
+# Set gRPC options before adding package
+set(gRPC_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_CODEGEN ON CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_CPP_PLUGIN ON CACHE BOOL "" FORCE)
+set(gRPC_BUILD_CSHARP_EXT OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_CSHARP_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_NODE_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_OBJECTIVE_C_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_PHP_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_PYTHON_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_RUBY_PLUGIN OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_CPP_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPCPP_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BENCHMARK_PROVIDER "none" CACHE STRING "" FORCE)
+set(gRPC_ZLIB_PROVIDER "module" CACHE STRING "" FORCE)
+set(gRPC_PROTOBUF_PROVIDER "module" CACHE STRING "" FORCE)
+set(gRPC_ABSL_PROVIDER "module" CACHE STRING "" FORCE)
+set(protobuf_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(protobuf_BUILD_CONFORMANCE OFF CACHE BOOL "" FORCE)
+set(protobuf_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(protobuf_BUILD_PROTOC_BINARIES ON CACHE BOOL "" FORCE)
+set(protobuf_WITH_ZLIB ON CACHE BOOL "" FORCE)
+set(protobuf_INSTALL OFF CACHE BOOL "" FORCE)
+set(protobuf_MSVC_STATIC_RUNTIME OFF CACHE BOOL "" FORCE)
+set(ABSL_PROPAGATE_CXX_STD ON CACHE BOOL "" FORCE)
+set(ABSL_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
+set(ABSL_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+set(utf8_range_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(utf8_range_INSTALL OFF CACHE BOOL "" FORCE)
+set(utf8_range_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
+
+# Force consistent MSVC runtime library across all gRPC components (Windows only)
+# This ensures gRPC, protobuf, and Abseil all use the same CRT linking mode
+if(WIN32 AND MSVC)
+  # Use dynamic CRT (/MD for Release, /MDd for Debug) to avoid undefined math symbols
+  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL" CACHE STRING "" FORCE)
+  # Also ensure protobuf doesn't try to use static runtime
+  set(protobuf_MSVC_STATIC_RUNTIME OFF CACHE BOOL "" FORCE)
+  message(STATUS "Forcing dynamic MSVC runtime for gRPC dependencies: ${CMAKE_MSVC_RUNTIME_LIBRARY}")
+endif()
+
+# Temporarily disable installation to prevent utf8_range export errors
+# This is a workaround for gRPC 1.67.1 where utf8_range tries to install targets
+# that depend on Abseil, but we have ABSL_ENABLE_INSTALL=OFF
+set(CMAKE_SKIP_INSTALL_RULES TRUE)
+
+# Use CPM to fetch gRPC with bundled dependencies
+# GIT_SUBMODULES "" disables submodule recursion since gRPC handles its own deps via CMake
+
+if(WIN32)
+  set(GRPC_VERSION_TO_USE "1.67.1")
+else()
+  set(GRPC_VERSION_TO_USE "1.76.0")
+endif()
+
+message(STATUS "Selected gRPC version ${GRPC_VERSION_TO_USE} for platform ${CMAKE_SYSTEM_NAME}")
+
+CPMAddPackage(
+  NAME grpc
+  VERSION ${GRPC_VERSION_TO_USE}
+  GITHUB_REPOSITORY grpc/grpc
+  GIT_TAG v${GRPC_VERSION_TO_USE}
+  GIT_SUBMODULES ""
+  GIT_SHALLOW TRUE
+)
+
+# Re-enable installation rules after gRPC is loaded
+set(CMAKE_SKIP_INSTALL_RULES FALSE)
+
+# Restore CPM lookup behaviour and toolchain detection environment early so
+# subsequent dependency configuration isn't polluted even if we hit errors.
+if("${_YAZE_GRPC_SAVED_CPM_USE_LOCAL_PACKAGES}" STREQUAL "__YAZE_UNSET__")
+  unset(CPM_USE_LOCAL_PACKAGES)
+else()
+  set(CPM_USE_LOCAL_PACKAGES "${_YAZE_GRPC_SAVED_CPM_USE_LOCAL_PACKAGES}")
+endif()
+
+foreach(_yaze_pkg IN ITEMS gRPC Protobuf absl)
+  string(TOUPPER "CMAKE_DISABLE_FIND_PACKAGE_${_yaze_pkg}" _yaze_disable_var)
+  string(TOUPPER "_YAZE_GRPC_SAVE_${_yaze_disable_var}" _yaze_saved_key)
+  if(NOT DEFINED ${_yaze_saved_key})
+    continue()
+  endif()
+  if("${${_yaze_saved_key}}" STREQUAL "__YAZE_UNSET__")
+    unset(${_yaze_disable_var})
+  else()
+    set(${_yaze_disable_var} "${${_yaze_saved_key}}")
+  endif()
+  unset(${_yaze_saved_key})
+endforeach()
+
+if("${_YAZE_GRPC_SAVED_PKG_CONFIG_USE_CMAKE_PREFIX_PATH}" STREQUAL "__YAZE_UNSET__")
+  unset(PKG_CONFIG_USE_CMAKE_PREFIX_PATH)
+else()
+  set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH "${_YAZE_GRPC_SAVED_PKG_CONFIG_USE_CMAKE_PREFIX_PATH}")
+endif()
+unset(_YAZE_GRPC_SAVED_PKG_CONFIG_USE_CMAKE_PREFIX_PATH)
+
+set(CMAKE_PREFIX_PATH "${_YAZE_GRPC_SAVED_PREFIX_PATH}")
+unset(_YAZE_GRPC_SAVED_PREFIX_PATH)
+
+if("${_YAZE_GRPC_SAVED_CROSSCOMPILING}" STREQUAL "__YAZE_UNSET__")
+  unset(CMAKE_CROSSCOMPILING)
+else()
+  set(CMAKE_CROSSCOMPILING "${_YAZE_GRPC_SAVED_CROSSCOMPILING}")
+endif()
+unset(_YAZE_GRPC_SAVED_CROSSCOMPILING)
+
+if("${_YAZE_GRPC_SAVED_CXX_STANDARD}" STREQUAL "__YAZE_UNSET__")
+  unset(CMAKE_CXX_STANDARD)
+else()
+  set(CMAKE_CXX_STANDARD "${_YAZE_GRPC_SAVED_CXX_STANDARD}")
+endif()
+unset(_YAZE_GRPC_SAVED_CXX_STANDARD)
+
+# Check which target naming convention is used
+if(TARGET grpc++)
+  message(STATUS "Found non-namespaced gRPC target grpc++")
+  if(NOT TARGET grpc::grpc++)
+    add_library(grpc::grpc++ ALIAS grpc++)
+  endif()
+  if(NOT TARGET grpc::grpc++_reflection AND TARGET grpc++_reflection)
+    add_library(grpc::grpc++_reflection ALIAS grpc++_reflection)
+  endif()
+endif()
+
+set(_YAZE_GRPC_ERRORS "")
+
+if(NOT TARGET grpc++ AND NOT TARGET grpc::grpc++)
+  list(APPEND _YAZE_GRPC_ERRORS "gRPC target not found after CPM fetch")
+endif()
+
+if(NOT TARGET protoc)
+  list(APPEND _YAZE_GRPC_ERRORS "protoc target not found after gRPC setup")
+endif()
+
+if(NOT TARGET grpc_cpp_plugin)
+  list(APPEND _YAZE_GRPC_ERRORS "grpc_cpp_plugin target not found after gRPC setup")
+endif()
+
+if(_YAZE_GRPC_ERRORS)
+  list(JOIN _YAZE_GRPC_ERRORS "\n" _YAZE_GRPC_ERROR_MESSAGE)
+  message(FATAL_ERROR "${_YAZE_GRPC_ERROR_MESSAGE}")
+endif()
+
+# Create convenience interface for basic gRPC linking (renamed to avoid conflict with yaze_grpc_support STATIC library)
+add_library(yaze_grpc_deps INTERFACE)
+target_link_libraries(yaze_grpc_deps INTERFACE
+  grpc::grpc++
+  grpc::grpc++_reflection
+  protobuf::libprotobuf
+)
+
+# Define Windows macro guards once so protobuf-generated headers stay clean
+if(WIN32)
+  add_compile_definitions(
+    WIN32_LEAN_AND_MEAN
+    NOMINMAX
+    NOGDI
+  )
+endif()
+
+# Export Abseil targets from gRPC's bundled Abseil
+# When gRPC_ABSL_PROVIDER is "module", gRPC fetches and builds Abseil
+# All Abseil targets are available, we just need to list them
+# Note: All targets are available even if not listed here, but listing ensures consistency
+set(ABSL_TARGETS
+  absl::base
+  absl::config
+  absl::core_headers
+  absl::utility
+  absl::memory
+  absl::container_memory
+  absl::strings
+  absl::strings_internal
+  absl::str_format
+  absl::str_format_internal
+  absl::cord
+  absl::hash
+  absl::time
+  absl::time_zone
+  absl::status
+  absl::statusor
+  absl::flags
+  absl::flags_parse
+  absl::flags_usage
+  absl::flags_commandlineflag
+  absl::flags_marshalling
+  absl::flags_private_handle_accessor
+  absl::flags_program_name
+  absl::flags_config
+  absl::flags_reflection
+  absl::examine_stack
+  absl::stacktrace
+  absl::failure_signal_handler
+  absl::flat_hash_map
+  absl::synchronization
+  absl::symbolize
+  absl::strerror
+)
+
+# Only expose absl::int128 when it's supported without warnings
+if(NOT WIN32)
+  list(APPEND ABSL_TARGETS absl::int128)
+endif()
+
+# Export gRPC targets for use in other CMake files
+set(YAZE_GRPC_TARGETS
+  grpc::grpc++
+  grpc::grpc++_reflection
+  protobuf::libprotobuf
+  protoc
+  grpc_cpp_plugin
+)
+
+message(STATUS "gRPC setup complete - targets available: ${YAZE_GRPC_TARGETS}")
+
+# Setup protobuf generation directory (use CACHE so it's available in functions)
+set(_gRPC_PROTO_GENS_DIR ${CMAKE_BINARY_DIR}/gens CACHE INTERNAL "Protobuf generated files directory")
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/gens)
+
+# Get protobuf include directories (extract from generator expression or direct path)
+if(TARGET libprotobuf)
+  get_target_property(_PROTOBUF_INCLUDE_DIRS libprotobuf INTERFACE_INCLUDE_DIRECTORIES)
+  # Handle generator expressions
+  string(REGEX REPLACE "\\$<BUILD_INTERFACE:([^>]+)>" "\\1" _PROTOBUF_INCLUDE_DIR_CLEAN "${_PROTOBUF_INCLUDE_DIRS}")
+  list(GET _PROTOBUF_INCLUDE_DIR_CLEAN 0 _gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR)
+  set(_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR ${_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR} CACHE INTERNAL "Protobuf include directory")
+elseif(TARGET protobuf::libprotobuf)
+  get_target_property(_PROTOBUF_INCLUDE_DIRS protobuf::libprotobuf INTERFACE_INCLUDE_DIRECTORIES)
+  string(REGEX REPLACE "\\$<BUILD_INTERFACE:([^>]+)>" "\\1" _PROTOBUF_INCLUDE_DIR_CLEAN "${_PROTOBUF_INCLUDE_DIRS}")
+  list(GET _PROTOBUF_INCLUDE_DIR_CLEAN 0 _gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR)
+  set(_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR ${_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR} CACHE INTERNAL "Protobuf include directory")
+endif()
+
+# Remove x86-only Abseil compile flags when building on ARM64 macOS runners
+set(_YAZE_PATCH_ABSL_FOR_APPLE FALSE)
+if(APPLE)
+  if(CMAKE_OSX_ARCHITECTURES)
+    string(TOLOWER "${CMAKE_OSX_ARCHITECTURES}" _yaze_osx_archs)
+    if(_yaze_osx_archs MATCHES "arm64")
+      set(_YAZE_PATCH_ABSL_FOR_APPLE TRUE)
+    endif()
+  else()
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _yaze_proc)
+    if(_yaze_proc MATCHES "arm64" OR _yaze_proc MATCHES "aarch64")
+      set(_YAZE_PATCH_ABSL_FOR_APPLE TRUE)
+    endif()
+  endif()
+endif()
+
+if(_YAZE_PATCH_ABSL_FOR_APPLE)
+  set(_YAZE_ABSL_X86_TARGETS
+    absl_random_internal_randen_hwaes
+    absl_random_internal_randen_hwaes_impl
+    absl_crc_internal_cpu_detect
+  )
+
+  foreach(_yaze_absl_target IN LISTS _YAZE_ABSL_X86_TARGETS)
+    if(TARGET ${_yaze_absl_target})
+      get_target_property(_yaze_absl_opts ${_yaze_absl_target} COMPILE_OPTIONS)
+      if(_yaze_absl_opts AND NOT _yaze_absl_opts STREQUAL "NOTFOUND")
+        set(_yaze_filtered_opts)
+        foreach(_yaze_opt IN LISTS _yaze_absl_opts)
+          if(_yaze_opt STREQUAL "-Xarch_x86_64")
+            continue()
+          endif()
+          if(_yaze_opt MATCHES "^-m(sse|avx)")
+            continue()
+          endif()
+          if(_yaze_opt STREQUAL "-maes")
+            continue()
+          endif()
+          list(APPEND _yaze_filtered_opts "${_yaze_opt}")
+        endforeach()
+        set_property(TARGET ${_yaze_absl_target} PROPERTY COMPILE_OPTIONS ${_yaze_filtered_opts})
+        message(STATUS "Patched ${_yaze_absl_target} compile options for ARM64 macOS")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+unset(_YAZE_GRPC_SAVED_CPM_USE_LOCAL_PACKAGES)
+unset(_YAZE_GRPC_ERRORS)
+unset(_YAZE_GRPC_ERROR_MESSAGE)
+
+message(STATUS "Protobuf gens dir: ${_gRPC_PROTO_GENS_DIR}")
+message(STATUS "Protobuf include dir: ${_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR}")
+
+# Export protobuf targets
+set(YAZE_PROTOBUF_TARGETS
+  protobuf::libprotobuf
+)
+
+# Function to add protobuf/gRPC code generation to a target
+function(target_add_protobuf target)
+    if(NOT TARGET ${target})
+        message(FATAL_ERROR "Target ${target} doesn't exist")
+    endif()
+    if(NOT ARGN)
+        message(SEND_ERROR "Error: target_add_protobuf() called without any proto files")
+        return()
+    endif()
+
+    set(_protobuf_include_path -I ${CMAKE_SOURCE_DIR}/src -I ${_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR})
+    foreach(FIL ${ARGN})
+        get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
+        get_filename_component(FIL_WE ${FIL} NAME_WE)
+        file(RELATIVE_PATH REL_FIL ${CMAKE_SOURCE_DIR}/src ${ABS_FIL})
+        get_filename_component(REL_DIR ${REL_FIL} DIRECTORY)
+        if(NOT REL_DIR OR REL_DIR STREQUAL ".")
+            set(RELFIL_WE "${FIL_WE}")
+        else()
+            set(RELFIL_WE "${REL_DIR}/${FIL_WE}")
+        endif()
+        
+        message(STATUS "  Proto file: ${FIL_WE}")
+        message(STATUS "    ABS_FIL = ${ABS_FIL}")
+        message(STATUS "    REL_FIL = ${REL_FIL}")
+        message(STATUS "    REL_DIR = ${REL_DIR}")
+        message(STATUS "    RELFIL_WE = ${RELFIL_WE}")
+        message(STATUS "    Output = ${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h")
+
+        add_custom_command(
+        OUTPUT  "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.cc"
+                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.h"
+                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}_mock.grpc.pb.h"
+                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.cc"
+                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h"
+        COMMAND $<TARGET_FILE:protoc>
+        ARGS --grpc_out=generate_mock_code=true:${_gRPC_PROTO_GENS_DIR}
+            --cpp_out=${_gRPC_PROTO_GENS_DIR}
+            --plugin=protoc-gen-grpc=$<TARGET_FILE:grpc_cpp_plugin>
+            ${_protobuf_include_path}
+            ${ABS_FIL}
+        DEPENDS ${ABS_FIL} protoc grpc_cpp_plugin
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/src
+        COMMENT "Running gRPC C++ protocol buffer compiler on ${FIL}"
+        VERBATIM)
+
+        target_sources(${target} PRIVATE
+            "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.cc"
+            "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.grpc.pb.h"
+            "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}_mock.grpc.pb.h"
+            "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.cc"
+            "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h"
+        )
+        target_include_directories(${target} PUBLIC
+            $<BUILD_INTERFACE:${_gRPC_PROTO_GENS_DIR}>
+            $<BUILD_INTERFACE:${_gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR}>
+        )
+    endforeach()
+endfunction()
+
--- a/cmake/dependencies/imgui.cmake
+++ b/cmake/dependencies/imgui.cmake
@@ -0,0 +1,72 @@
+# Dear ImGui dependency management
+# Uses the bundled ImGui in ext/imgui
+
+message(STATUS "Setting up Dear ImGui from bundled sources")
+
+# Use the bundled ImGui from ext/imgui
+set(IMGUI_DIR ${CMAKE_SOURCE_DIR}/ext/imgui)
+
+# Create ImGui library with core files from bundled source
+add_library(ImGui STATIC
+  ${IMGUI_DIR}/imgui.cpp
+  ${IMGUI_DIR}/imgui_demo.cpp
+  ${IMGUI_DIR}/imgui_draw.cpp
+  ${IMGUI_DIR}/imgui_tables.cpp
+  ${IMGUI_DIR}/imgui_widgets.cpp
+  # SDL2 backend
+  ${IMGUI_DIR}/backends/imgui_impl_sdl2.cpp
+  ${IMGUI_DIR}/backends/imgui_impl_sdlrenderer2.cpp
+  # C++ stdlib helpers (for std::string support)
+  ${IMGUI_DIR}/misc/cpp/imgui_stdlib.cpp
+)
+
+target_include_directories(ImGui PUBLIC
+  ${IMGUI_DIR}
+  ${IMGUI_DIR}/backends
+)
+
+# Set C++ standard requirement (ImGui 1.90+ requires C++11, we use C++17 for consistency)
+target_compile_features(ImGui PUBLIC cxx_std_17)
+
+# Link to SDL2
+target_link_libraries(ImGui PUBLIC ${YAZE_SDL2_TARGETS})
+
+message(STATUS "Created ImGui target from bundled source at ${IMGUI_DIR}")
+
+# Create ImGui Test Engine for test automation (if tests are enabled)
+if(YAZE_BUILD_TESTS)
+  set(IMGUI_TEST_ENGINE_DIR ${CMAKE_SOURCE_DIR}/ext/imgui_test_engine/imgui_test_engine)
+  
+  if(EXISTS ${IMGUI_TEST_ENGINE_DIR})
+    set(IMGUI_TEST_ENGINE_SOURCES
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_context.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_coroutine.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_engine.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_exporters.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_perftool.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_ui.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_te_utils.cpp
+      ${IMGUI_TEST_ENGINE_DIR}/imgui_capture_tool.cpp
+    )
+    
+    add_library(ImGuiTestEngine STATIC ${IMGUI_TEST_ENGINE_SOURCES})
+    target_include_directories(ImGuiTestEngine PUBLIC 
+      ${IMGUI_DIR}
+      ${IMGUI_TEST_ENGINE_DIR}
+      ${CMAKE_SOURCE_DIR}/ext
+    )
+    target_compile_features(ImGuiTestEngine PUBLIC cxx_std_17)
+    target_link_libraries(ImGuiTestEngine PUBLIC ImGui ${YAZE_SDL2_TARGETS})
+    target_compile_definitions(ImGuiTestEngine PUBLIC
+      IMGUI_ENABLE_TEST_ENGINE=1
+      IMGUI_TEST_ENGINE_ENABLE_COROUTINE_STDTHREAD_IMPL=1
+    )
+    
+    message(STATUS "Created ImGuiTestEngine target for test automation")
+  endif()
+endif()
+
+# Export ImGui targets for use in other CMake files  
+set(YAZE_IMGUI_TARGETS ImGui)
+
+message(STATUS "Dear ImGui setup complete - YAZE_IMGUI_TARGETS = ${YAZE_IMGUI_TARGETS}")
--- a/cmake/dependencies/json.cmake
+++ b/cmake/dependencies/json.cmake
@@ -0,0 +1,31 @@
+# nlohmann_json dependency management
+
+if(NOT YAZE_ENABLE_JSON)
+  return()
+endif()
+
+message(STATUS "Setting up nlohmann_json with local ext directory")
+
+# Use the bundled nlohmann_json from ext/json
+set(JSON_BuildTests OFF CACHE BOOL "" FORCE)
+set(JSON_Install OFF CACHE BOOL "" FORCE)
+set(JSON_MultipleHeaders OFF CACHE BOOL "" FORCE)
+
+add_subdirectory(${CMAKE_SOURCE_DIR}/ext/json EXCLUDE_FROM_ALL)
+
+# Verify target is available
+if(TARGET nlohmann_json::nlohmann_json)
+  message(STATUS "nlohmann_json target found")
+elseif(TARGET nlohmann_json)
+  # Create alias if only non-namespaced target exists
+  add_library(nlohmann_json::nlohmann_json ALIAS nlohmann_json)
+  message(STATUS "Created nlohmann_json::nlohmann_json alias")
+else()
+  message(FATAL_ERROR "nlohmann_json target not found after add_subdirectory")
+endif()
+
+# Export for use in other CMake files
+set(YAZE_JSON_TARGETS nlohmann_json::nlohmann_json CACHE INTERNAL "nlohmann_json targets")
+
+message(STATUS "nlohmann_json setup complete")
+
--- a/cmake/dependencies/sdl2.cmake
+++ b/cmake/dependencies/sdl2.cmake
@@ -0,0 +1,101 @@
+# SDL2 dependency management
+# Uses CPM.cmake for consistent cross-platform builds
+
+include(cmake/CPM.cmake)
+include(cmake/dependencies.lock)
+
+message(STATUS "Setting up SDL2 ${SDL2_VERSION} with CPM.cmake")
+
+# Try to use system packages first if requested
+if(YAZE_USE_SYSTEM_DEPS)
+  find_package(SDL2 QUIET)
+  if(SDL2_FOUND)
+    message(STATUS "Using system SDL2")
+    if(NOT TARGET yaze_sdl2)
+      add_library(yaze_sdl2 INTERFACE)
+      target_link_libraries(yaze_sdl2 INTERFACE SDL2::SDL2)
+      if(TARGET SDL2::SDL2main)
+        target_link_libraries(yaze_sdl2 INTERFACE SDL2::SDL2main)
+      endif()
+    endif()
+    set(YAZE_SDL2_TARGETS yaze_sdl2 CACHE INTERNAL "")
+    return()
+  endif()
+endif()
+
+# Use CPM to fetch SDL2
+CPMAddPackage(
+  NAME SDL2
+  VERSION ${SDL2_VERSION}
+  GITHUB_REPOSITORY libsdl-org/SDL
+  GIT_TAG release-${SDL2_VERSION}
+  OPTIONS
+    "SDL_SHARED OFF"
+    "SDL_STATIC ON"
+    "SDL_TEST OFF"
+    "SDL_INSTALL OFF"
+    "SDL_CMAKE_DEBUG_POSTFIX d"
+)
+
+# Verify SDL2 targets are available  
+if(NOT TARGET SDL2-static AND NOT TARGET SDL2::SDL2-static AND NOT TARGET SDL2::SDL2)
+  message(FATAL_ERROR "SDL2 target not found after CPM fetch")
+endif()
+
+# Create convenience targets for the rest of the project
+if(NOT TARGET yaze_sdl2)
+  add_library(yaze_sdl2 INTERFACE)
+  # SDL2 from CPM might use SDL2-static or SDL2::SDL2-static
+  if(TARGET SDL2-static)
+    message(STATUS "Using SDL2-static target")
+    target_link_libraries(yaze_sdl2 INTERFACE SDL2-static)
+    # Also explicitly add include directories if they exist
+    if(SDL2_SOURCE_DIR)
+      target_include_directories(yaze_sdl2 INTERFACE ${SDL2_SOURCE_DIR}/include)
+      message(STATUS "Added SDL2 include: ${SDL2_SOURCE_DIR}/include")
+    endif()
+  elseif(TARGET SDL2::SDL2-static)
+    message(STATUS "Using SDL2::SDL2-static target")
+    target_link_libraries(yaze_sdl2 INTERFACE SDL2::SDL2-static)
+    # For local Homebrew SDL2, also add include path explicitly
+    # SDL headers are in the SDL2 subdirectory
+    if(APPLE AND EXISTS "/opt/homebrew/opt/sdl2/include/SDL2")
+      target_include_directories(yaze_sdl2 INTERFACE /opt/homebrew/opt/sdl2/include/SDL2)
+      message(STATUS "Added Homebrew SDL2 include path: /opt/homebrew/opt/sdl2/include/SDL2")
+    endif()
+  else()
+    message(STATUS "Using SDL2::SDL2 target")
+    target_link_libraries(yaze_sdl2 INTERFACE SDL2::SDL2)
+  endif()
+endif()
+
+# Add platform-specific libraries
+if(WIN32)
+  target_link_libraries(yaze_sdl2 INTERFACE
+    winmm
+    imm32
+    version
+    setupapi
+    wbemuuid
+  )
+  target_compile_definitions(yaze_sdl2 INTERFACE SDL_MAIN_HANDLED)
+elseif(APPLE)
+  target_link_libraries(yaze_sdl2 INTERFACE
+    "-framework Cocoa"
+    "-framework IOKit"
+    "-framework CoreVideo"
+    "-framework ForceFeedback"
+  )
+  target_compile_definitions(yaze_sdl2 INTERFACE SDL_MAIN_HANDLED)
+elseif(UNIX)
+  find_package(PkgConfig REQUIRED)
+  pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
+  target_link_libraries(yaze_sdl2 INTERFACE ${GTK3_LIBRARIES})
+  target_include_directories(yaze_sdl2 INTERFACE ${GTK3_INCLUDE_DIRS})
+  target_compile_options(yaze_sdl2 INTERFACE ${GTK3_CFLAGS_OTHER})
+endif()
+
+# Export SDL2 targets for use in other CMake files
+set(YAZE_SDL2_TARGETS yaze_sdl2)
+
+message(STATUS "SDL2 setup complete - YAZE_SDL2_TARGETS = ${YAZE_SDL2_TARGETS}")
--- a/cmake/dependencies/testing.cmake
+++ b/cmake/dependencies/testing.cmake
@@ -0,0 +1,138 @@
+# Testing dependencies (GTest, Benchmark)
+# Uses CPM.cmake for consistent cross-platform builds
+
+if(NOT YAZE_BUILD_TESTS)
+  return()
+endif()
+
+include(cmake/CPM.cmake)
+include(cmake/dependencies.lock)
+
+message(STATUS "Setting up testing dependencies with CPM.cmake")
+
+set(_YAZE_USE_SYSTEM_GTEST ${YAZE_USE_SYSTEM_DEPS})
+
+# Detect Homebrew installation automatically (helps offline builds)
+if(APPLE AND NOT _YAZE_USE_SYSTEM_GTEST)
+  set(_YAZE_GTEST_PREFIX_CANDIDATES
+    /opt/homebrew/opt/googletest
+    /usr/local/opt/googletest)
+
+  foreach(_prefix IN LISTS _YAZE_GTEST_PREFIX_CANDIDATES)
+    if(EXISTS "${_prefix}")
+      list(APPEND CMAKE_PREFIX_PATH "${_prefix}")
+      message(STATUS "Added Homebrew googletest prefix: ${_prefix}")
+      set(_YAZE_USE_SYSTEM_GTEST ON)
+      break()
+    endif()
+  endforeach()
+
+  if(NOT _YAZE_USE_SYSTEM_GTEST)
+    find_program(HOMEBREW_EXECUTABLE brew)
+    if(HOMEBREW_EXECUTABLE)
+      execute_process(
+        COMMAND "${HOMEBREW_EXECUTABLE}" --prefix googletest
+        OUTPUT_VARIABLE HOMEBREW_GTEST_PREFIX
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE HOMEBREW_GTEST_RESULT
+        ERROR_QUIET)
+      if(HOMEBREW_GTEST_RESULT EQUAL 0 AND EXISTS "${HOMEBREW_GTEST_PREFIX}")
+        list(APPEND CMAKE_PREFIX_PATH "${HOMEBREW_GTEST_PREFIX}")
+        message(STATUS "Added Homebrew googletest prefix: ${HOMEBREW_GTEST_PREFIX}")
+        set(_YAZE_USE_SYSTEM_GTEST ON)
+      endif()
+    endif()
+  endif()
+endif()
+
+# Try to use system packages first
+if(_YAZE_USE_SYSTEM_GTEST)
+  find_package(GTest QUIET)
+  if(GTest_FOUND)
+    message(STATUS "Using system googletest")
+    # GTest found, targets should already be available
+    # Verify targets exist
+    if(NOT TARGET GTest::gtest)
+      message(WARNING "GTest::gtest target not found despite GTest_FOUND=TRUE; falling back to CPM download")
+      set(_YAZE_USE_SYSTEM_GTEST OFF)
+    else()
+      # Create aliases to match CPM target names
+      if(NOT TARGET gtest)
+        add_library(gtest ALIAS GTest::gtest)
+      endif()
+      if(NOT TARGET gtest_main)
+        add_library(gtest_main ALIAS GTest::gtest_main)
+      endif()
+      if(TARGET GTest::gmock AND NOT TARGET gmock)
+        add_library(gmock ALIAS GTest::gmock)
+      endif()
+      if(TARGET GTest::gmock_main AND NOT TARGET gmock_main)
+        add_library(gmock_main ALIAS GTest::gmock_main)
+      endif()
+      # Skip CPM fetch
+      set(_YAZE_GTEST_SYSTEM_USED ON)
+    endif()
+  elseif(YAZE_USE_SYSTEM_DEPS)
+    message(WARNING "System googletest not found despite YAZE_USE_SYSTEM_DEPS=ON; falling back to CPM download")
+  endif()
+endif()
+
+# Use CPM to fetch googletest if not using system version
+if(NOT _YAZE_GTEST_SYSTEM_USED)
+  CPMAddPackage(
+    NAME googletest
+    VERSION ${GTEST_VERSION}
+    GITHUB_REPOSITORY google/googletest
+    GIT_TAG v${GTEST_VERSION}
+    OPTIONS
+      "BUILD_GMOCK ON"
+      "INSTALL_GTEST OFF"
+      "gtest_force_shared_crt ON"
+  )
+endif()
+
+# Verify GTest and GMock targets are available
+if(NOT TARGET gtest)
+  message(FATAL_ERROR "GTest target not found after CPM fetch")
+endif()
+
+if(NOT TARGET gmock)
+  message(FATAL_ERROR "GMock target not found after CPM fetch")
+endif()
+
+# Google Benchmark (optional, for performance tests)
+if(YAZE_ENABLE_COVERAGE OR DEFINED ENV{YAZE_ENABLE_BENCHMARKS})
+  CPMAddPackage(
+    NAME benchmark
+    VERSION ${BENCHMARK_VERSION}
+    GITHUB_REPOSITORY google/benchmark
+    GIT_TAG v${BENCHMARK_VERSION}
+    OPTIONS
+      "BENCHMARK_ENABLE_TESTING OFF"
+      "BENCHMARK_ENABLE_INSTALL OFF"
+  )
+  
+  if(NOT TARGET benchmark::benchmark)
+    message(FATAL_ERROR "Benchmark target not found after CPM fetch")
+  endif()
+  
+  set(YAZE_BENCHMARK_TARGETS benchmark::benchmark)
+endif()
+
+# Create convenience targets for the rest of the project
+add_library(yaze_testing INTERFACE)
+target_link_libraries(yaze_testing INTERFACE 
+  gtest 
+  gtest_main
+  gmock
+  gmock_main
+)
+
+if(TARGET benchmark::benchmark)
+  target_link_libraries(yaze_testing INTERFACE benchmark::benchmark)
+endif()
+
+# Export testing targets for use in other CMake files
+set(YAZE_TESTING_TARGETS yaze_testing)
+
+message(STATUS "Testing dependencies setup complete - GTest + GMock available")
--- a/cmake/dependencies/yaml.cmake
+++ b/cmake/dependencies/yaml.cmake
@@ -0,0 +1,89 @@
+# yaml-cpp dependency management
+# Uses CPM.cmake for consistent cross-platform builds
+
+include(cmake/CPM.cmake)
+include(cmake/dependencies.lock)
+
+if(NOT YAZE_ENABLE_AI AND NOT YAZE_ENABLE_AI_RUNTIME)
+  message(STATUS "Skipping yaml-cpp (AI runtime and CLI agent features disabled)")
+  set(YAZE_YAML_TARGETS "")
+  return()
+endif()
+
+message(STATUS "Setting up yaml-cpp ${YAML_CPP_VERSION} with CPM.cmake")
+
+set(_YAZE_USE_SYSTEM_YAML ${YAZE_USE_SYSTEM_DEPS})
+
+# Detect Homebrew installation automatically (helps offline builds)
+if(APPLE AND NOT _YAZE_USE_SYSTEM_YAML)
+  set(_YAZE_YAML_PREFIX_CANDIDATES
+    /opt/homebrew/opt/yaml-cpp
+    /usr/local/opt/yaml-cpp)
+
+  foreach(_prefix IN LISTS _YAZE_YAML_PREFIX_CANDIDATES)
+    if(EXISTS "${_prefix}")
+      list(APPEND CMAKE_PREFIX_PATH "${_prefix}")
+      message(STATUS "Added Homebrew yaml-cpp prefix: ${_prefix}")
+      set(_YAZE_USE_SYSTEM_YAML ON)
+      break()
+    endif()
+  endforeach()
+
+  if(NOT _YAZE_USE_SYSTEM_YAML)
+    find_program(HOMEBREW_EXECUTABLE brew)
+    if(HOMEBREW_EXECUTABLE)
+      execute_process(
+        COMMAND "${HOMEBREW_EXECUTABLE}" --prefix yaml-cpp
+        OUTPUT_VARIABLE HOMEBREW_YAML_PREFIX
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE HOMEBREW_YAML_RESULT
+        ERROR_QUIET)
+      if(HOMEBREW_YAML_RESULT EQUAL 0 AND EXISTS "${HOMEBREW_YAML_PREFIX}")
+        list(APPEND CMAKE_PREFIX_PATH "${HOMEBREW_YAML_PREFIX}")
+        message(STATUS "Added Homebrew yaml-cpp prefix: ${HOMEBREW_YAML_PREFIX}")
+        set(_YAZE_USE_SYSTEM_YAML ON)
+      endif()
+    endif()
+  endif()
+endif()
+
+# Try to use system packages first
+if(_YAZE_USE_SYSTEM_YAML)
+  find_package(yaml-cpp QUIET)
+  if(yaml-cpp_FOUND)
+    message(STATUS "Using system yaml-cpp")
+    add_library(yaze_yaml INTERFACE IMPORTED)
+    target_link_libraries(yaze_yaml INTERFACE yaml-cpp)
+    set(YAZE_YAML_TARGETS yaze_yaml)
+    return()
+  elseif(YAZE_USE_SYSTEM_DEPS)
+    message(WARNING "System yaml-cpp not found despite YAZE_USE_SYSTEM_DEPS=ON; falling back to CPM download")
+  endif()
+endif()
+
+# Use CPM to fetch yaml-cpp
+CPMAddPackage(
+  NAME yaml-cpp
+  VERSION ${YAML_CPP_VERSION}
+  GITHUB_REPOSITORY jbeder/yaml-cpp
+  GIT_TAG 0.8.0
+  OPTIONS
+    "YAML_CPP_BUILD_TESTS OFF"
+    "YAML_CPP_BUILD_CONTRIB OFF"
+    "YAML_CPP_BUILD_TOOLS OFF"
+    "YAML_CPP_INSTALL OFF"
+)
+
+# Verify yaml-cpp targets are available
+if(NOT TARGET yaml-cpp)
+  message(FATAL_ERROR "yaml-cpp target not found after CPM fetch")
+endif()
+
+# Create convenience targets for the rest of the project
+add_library(yaze_yaml INTERFACE)
+target_link_libraries(yaze_yaml INTERFACE yaml-cpp)
+
+# Export yaml-cpp targets for use in other CMake files
+set(YAZE_YAML_TARGETS yaze_yaml)
+
+message(STATUS "yaml-cpp setup complete")
--- a/cmake/grpc.cmake
+++ b/cmake/grpc.cmake
@@ -5,25 +5,6 @@ set(CMAKE_POLICY_DEFAULT_CMP0074 NEW)
 # Include FetchContent module
 include(FetchContent)

-# Try Windows-optimized path first
-if(WIN32)
-  include(${CMAKE_CURRENT_LIST_DIR}/grpc_windows.cmake)
-  if(YAZE_GRPC_CONFIGURED)
-    # Validate that grpc_windows.cmake properly exported required targets/variables
-    if(NOT COMMAND target_add_protobuf)
-      message(FATAL_ERROR "grpc_windows.cmake did not define target_add_protobuf function")
-    endif()
-    if(NOT DEFINED ABSL_TARGETS OR NOT ABSL_TARGETS)
-      message(FATAL_ERROR "grpc_windows.cmake did not export ABSL_TARGETS")
-    endif()
-    if(NOT DEFINED YAZE_PROTOBUF_TARGETS OR NOT YAZE_PROTOBUF_TARGETS)
-      message(FATAL_ERROR "grpc_windows.cmake did not export YAZE_PROTOBUF_TARGETS")
-    endif()
-    message(STATUS "✓ Windows vcpkg gRPC configuration validated")
-    return()
-  endif()
-endif()
-
 # Set minimum CMake version for subprojects (fixes c-ares compatibility)
 set(CMAKE_POLICY_VERSION_MINIMUM 3.5)

@@ -32,44 +13,19 @@ set(FETCHCONTENT_QUIET OFF)
 # CRITICAL: Prevent CMake from finding system-installed protobuf/abseil
 # This ensures gRPC uses its own bundled versions
 set(CMAKE_DISABLE_FIND_PACKAGE_Protobuf TRUE)
-set(CMAKE_DISABLE_FIND_PACKAGE_gRPC TRUE)
 set(CMAKE_DISABLE_FIND_PACKAGE_absl TRUE)
+set(CMAKE_DISABLE_FIND_PACKAGE_gRPC TRUE)

 # Also prevent pkg-config from finding system packages
 set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH FALSE)

-# Add compiler flags for modern compiler compatibility
-# These flags are scoped to gRPC and its dependencies only
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    # Clang 15+ compatibility for gRPC
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=missing-template-arg-list-after-template-kw")
-    add_compile_definitions(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
-elseif(MSVC)
-    # MSVC/Visual Studio compatibility for gRPC templates
-    # v1.67.1 fixes most issues, but these flags help with large template instantiations
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")  # Large object files
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /permissive-")  # Standards conformance
-    
-    # Suppress common gRPC warnings on MSVC (don't use add_compile_options to avoid affecting user code)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4267 /wd4244")
-    
-    # Increase template instantiation depth for complex promise chains (MSVC 2019+)
-    if(MSVC_VERSION GREATER_EQUAL 1920)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /constexpr:depth2048")
-    endif()
-    
-    # Prevent Windows macro pollution in protobuf-generated headers
-    add_compile_definitions(
-        WIN32_LEAN_AND_MEAN  # Exclude rarely-used Windows headers
-        NOMINMAX             # Don't define min/max macros
-        NOGDI                # Exclude GDI (prevents DWORD and other macro conflicts)
-    )
-endif()
-
 # Save YAZE's C++ standard and temporarily set to C++17 for gRPC
 set(_SAVED_CMAKE_CXX_STANDARD ${CMAKE_CXX_STANDARD})
 set(CMAKE_CXX_STANDARD 17)

+# ZLIB is provided by gRPC module (gRPC_ZLIB_PROVIDER="module")
+# find_package(ZLIB REQUIRED) not needed - gRPC bundles its own ZLIB
+
 # Configure gRPC build options before fetching
 set(gRPC_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(gRPC_BUILD_CODEGEN ON CACHE BOOL "" FORCE)
@@ -81,16 +37,15 @@ set(gRPC_BUILD_GRPC_OBJECTIVE_C_PLUGIN OFF CACHE BOOL "" FORCE)
 set(gRPC_BUILD_GRPC_PHP_PLUGIN OFF CACHE BOOL "" FORCE)
 set(gRPC_BUILD_GRPC_PYTHON_PLUGIN OFF CACHE BOOL "" FORCE)
 set(gRPC_BUILD_GRPC_RUBY_PLUGIN OFF CACHE BOOL "" FORCE)
+# Disable C++ reflection support (avoids extra proto generation)
+set(gRPC_BUILD_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPC_CPP_REFLECTION OFF CACHE BOOL "" FORCE)
+set(gRPC_BUILD_GRPCPP_REFLECTION OFF CACHE BOOL "" FORCE)

 set(gRPC_BENCHMARK_PROVIDER "none" CACHE STRING "" FORCE)
 set(gRPC_ZLIB_PROVIDER "module" CACHE STRING "" FORCE)

-# Skip install rule generation inside gRPC's dependency graph. This avoids
-# configure-time checks that require every transitive dependency (like Abseil
-# compatibility shims) to participate in install export sets, which we do not
-# need for the editor builds.
-set(CMAKE_SKIP_INSTALL_RULES ON CACHE BOOL "" FORCE)
-
 # Let gRPC fetch and build its own protobuf and abseil
 set(gRPC_PROTOBUF_PROVIDER "module" CACHE STRING "" FORCE)
 set(gRPC_ABSL_PROVIDER "module" CACHE STRING "" FORCE)
@@ -101,32 +56,27 @@ set(protobuf_BUILD_CONFORMANCE OFF CACHE BOOL "" FORCE)
 set(protobuf_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 set(protobuf_BUILD_PROTOC_BINARIES ON CACHE BOOL "" FORCE)
 set(protobuf_WITH_ZLIB ON CACHE BOOL "" FORCE)
-set(protobuf_MSVC_STATIC_RUNTIME ON CACHE BOOL "" FORCE)

 # Abseil configuration
 set(ABSL_PROPAGATE_CXX_STD ON CACHE BOOL "" FORCE)
-set(ABSL_ENABLE_INSTALL ON CACHE BOOL "" FORCE)
+set(ABSL_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
 set(ABSL_BUILD_TESTING OFF CACHE BOOL "" FORCE)
-set(ABSL_MSVC_STATIC_RUNTIME ON CACHE BOOL "" FORCE)
-set(gRPC_MSVC_STATIC_RUNTIME ON CACHE BOOL "" FORCE)

-# Disable x86-specific optimizations for ARM64 macOS builds
-if(APPLE AND CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
-  set(ABSL_USE_EXTERNAL_GOOGLETEST OFF CACHE BOOL "" FORCE)
-  set(ABSL_BUILD_TEST_HELPERS OFF CACHE BOOL "" FORCE)
-endif()
+# Additional protobuf settings to avoid export conflicts
+set(protobuf_BUILD_LIBPROTOC ON CACHE BOOL "" FORCE)
+set(protobuf_BUILD_LIBPROTOBUF ON CACHE BOOL "" FORCE)
+set(protobuf_BUILD_LIBPROTOBUF_LITE ON CACHE BOOL "" FORCE)
+set(protobuf_INSTALL OFF CACHE BOOL "" FORCE)
+
+set(utf8_range_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(utf8_range_INSTALL OFF CACHE BOOL "" FORCE)

 # Declare gRPC with platform-specific versions
-# - macOS/Linux: v1.75.1 (has ARM64 + modern Clang fixes)
-# - Windows: v1.75.1 (better NASM/clang-cl support than v1.67.1)
-set(_GRPC_VERSION "v1.75.1")
-if(WIN32)
-  set(_GRPC_VERSION_REASON "Windows clang-cl + MSVC compatibility")
-  # Disable BoringSSL ASM to avoid NASM build issues on Windows
-  # ASM optimizations cause NASM flag conflicts with clang-cl
-  set(OPENSSL_NO_ASM ON CACHE BOOL "" FORCE)
-  message(STATUS "Disabling BoringSSL ASM optimizations for Windows build compatibility")
+if(WIN32 AND MSVC)
+  set(_GRPC_VERSION "v1.67.1")
+  set(_GRPC_VERSION_REASON "MSVC-compatible, avoids linker regressions")
 else()
+  set(_GRPC_VERSION "v1.75.1")
  set(_GRPC_VERSION_REASON "ARM64 macOS + modern Clang compatibility")
 endif()

@@ -146,9 +96,23 @@ FetchContent_Declare(
 set(_SAVED_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
 set(CMAKE_PREFIX_PATH "")

+# Some toolchain presets set CMAKE_CROSSCOMPILING even when building for the
+# host (macOS arm64). gRPC treats that as a signal to locate host-side protoc
+# binaries via find_program, which fails since we rely on the bundled targets.
+# Suppress the flag when the host and target platforms match so the generator
+# expressions remain intact.
+set(_SAVED_CMAKE_CROSSCOMPILING ${CMAKE_CROSSCOMPILING})
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL CMAKE_SYSTEM_NAME
+   AND CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_CROSSCOMPILING FALSE)
+endif()
+
 # Download and build in isolation
 FetchContent_MakeAvailable(grpc)

+# Restore cross-compiling flag
+set(CMAKE_CROSSCOMPILING ${_SAVED_CMAKE_CROSSCOMPILING})
+
 # Restore CMAKE_PREFIX_PATH
 set(CMAKE_PREFIX_PATH ${_SAVED_CMAKE_PREFIX_PATH})

@@ -163,14 +127,15 @@ if(NOT TARGET grpc_cpp_plugin)
    message(FATAL_ERROR "Can not find target grpc_cpp_plugin")
 endif()

-set(_gRPC_PROTOBUF_PROTOC_EXECUTABLE $<TARGET_FILE:protoc>)
-set(_gRPC_CPP_PLUGIN $<TARGET_FILE:grpc_cpp_plugin>)
 set(_gRPC_PROTO_GENS_DIR ${CMAKE_BINARY_DIR}/gens)
+file(REMOVE_RECURSE ${_gRPC_PROTO_GENS_DIR})
 file(MAKE_DIRECTORY ${_gRPC_PROTO_GENS_DIR})

 get_target_property(_PROTOBUF_INCLUDE_DIRS libprotobuf INTERFACE_INCLUDE_DIRECTORIES)
 list(GET _PROTOBUF_INCLUDE_DIRS 0 _gRPC_PROTOBUF_WELLKNOWN_INCLUDE_DIR)

+message(STATUS "gRPC setup complete")
+
 # Export Abseil targets from gRPC's bundled abseil for use by the rest of the project
 # This ensures version compatibility between gRPC and our project
 # Note: Order matters for some linkers - put base libraries first
@@ -213,36 +178,6 @@ endif()

 # ABSL_TARGETS is now available to the rest of the project via include()

-# Fix Abseil ARM64 macOS compile flags (remove x86-specific flags)
-if(APPLE AND DEFINED CMAKE_OSX_ARCHITECTURES AND CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
-  foreach(_absl_target IN ITEMS absl_random_internal_randen_hwaes absl_random_internal_randen_hwaes_impl)
-    if(TARGET ${_absl_target})
-      get_target_property(_absl_opts ${_absl_target} COMPILE_OPTIONS)
-      if(_absl_opts AND NOT _absl_opts STREQUAL "NOTFOUND")
-        set(_absl_filtered_opts)
-        set(_absl_skip_next FALSE)
-        foreach(_absl_opt IN LISTS _absl_opts)
-          if(_absl_skip_next)
-            set(_absl_skip_next FALSE)
-            continue()
-          endif()
-          if(_absl_opt STREQUAL "-Xarch_x86_64")
-            set(_absl_skip_next TRUE)
-            continue()
-          endif()
-          if(_absl_opt STREQUAL "-maes" OR _absl_opt STREQUAL "-msse4.1")
-            continue()
-          endif()
-          list(APPEND _absl_filtered_opts ${_absl_opt})
-        endforeach()
-        set_property(TARGET ${_absl_target} PROPERTY COMPILE_OPTIONS ${_absl_filtered_opts})
-      endif()
-    endif()
-  endforeach()
-endif()
-
-message(STATUS "gRPC setup complete (includes bundled Abseil)")
-
 function(target_add_protobuf target)
    if(NOT TARGET ${target})
        message(FATAL_ERROR "Target ${target} doesn't exist")
@@ -270,10 +205,10 @@ function(target_add_protobuf target)
                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}_mock.grpc.pb.h"
                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.cc"
                "${_gRPC_PROTO_GENS_DIR}/${RELFIL_WE}.pb.h"
-        COMMAND ${_gRPC_PROTOBUF_PROTOC_EXECUTABLE}
+        COMMAND $<TARGET_FILE:protoc>
        ARGS --grpc_out=generate_mock_code=true:${_gRPC_PROTO_GENS_DIR}
            --cpp_out=${_gRPC_PROTO_GENS_DIR}
-            --plugin=protoc-gen-grpc=${_gRPC_CPP_PLUGIN}
+            --plugin=protoc-gen-grpc=$<TARGET_FILE:grpc_cpp_plugin>
            ${_protobuf_include_path}
            ${REL_FIL}
        DEPENDS ${ABS_FIL} protoc grpc_cpp_plugin
--- a/cmake/grpc_windows.cmake
+++ b/cmake/grpc_windows.cmake
@@ -11,10 +11,10 @@

 cmake_minimum_required(VERSION 3.16)

-# Option to use vcpkg for gRPC on Windows
-option(YAZE_USE_VCPKG_GRPC "Use vcpkg pre-compiled gRPC packages (Windows only)" ON)
+# Option to use vcpkg for gRPC on Windows (default OFF for CI reliability)
+option(YAZE_USE_VCPKG_GRPC "Use vcpkg pre-compiled gRPC packages (Windows only)" OFF)

-if(WIN32 AND YAZE_USE_VCPKG_GRPC)
+if(WIN32 AND YAZE_USE_VCPKG_GRPC AND DEFINED CMAKE_TOOLCHAIN_FILE)
  message(STATUS "Attempting to use vcpkg gRPC packages for faster Windows builds...")
  message(STATUS "  Note: If gRPC not in vcpkg.json, will fallback to FetchContent (recommended)")
  
@@ -144,10 +144,13 @@ if(WIN32 AND YAZE_USE_VCPKG_GRPC)
      absl::memory
      absl::container_memory
      absl::strings
+      absl::strings_internal
      absl::str_format
+      absl::str_format_internal
      absl::cord
      absl::hash
      absl::time
+      absl::time_zone
      absl::status
      absl::statusor
      absl::flags
@@ -165,12 +168,12 @@ if(WIN32 AND YAZE_USE_VCPKG_GRPC)
      absl::flat_hash_map
      absl::synchronization
      absl::symbolize
+      absl::strerror
      PARENT_SCOPE
    )
    
    # Export protobuf targets (vcpkg uses protobuf:: namespace)
    set(YAZE_PROTOBUF_TARGETS protobuf::libprotobuf PARENT_SCOPE)
-    set(YAZE_PROTOBUF_WHOLEARCHIVE_TARGETS protobuf::libprotobuf PARENT_SCOPE)
    
    # Get protobuf include directories for proto generation
    get_target_property(_PROTOBUF_INCLUDE_DIRS protobuf::libprotobuf 
@@ -242,7 +245,7 @@ if(WIN32 AND YAZE_USE_VCPKG_GRPC)
    message(STATUS "  vcpkg gRPC not found (expected if removed from vcpkg.json)")
    message(STATUS "  Using FetchContent build (faster with caching)")
    message(STATUS "  First build: ~10-15 min, subsequent: <1 min (cached)")
-    message(STATUS "  Using gRPC v1.75.1 with Windows compatibility fixes")
+    message(STATUS "  Using gRPC v1.75.1 (latest stable)")
    message(STATUS "  Note: BoringSSL ASM disabled for clang-cl compatibility")
    message(STATUS "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
  endif()
--- a/cmake/imgui.cmake
+++ b/cmake/imgui.cmake
@@ -1,42 +0,0 @@
-# gui libraries ---------------------------------------------------------------
-set(IMGUI_PATH  ${CMAKE_SOURCE_DIR}/src/lib/imgui)
-file(GLOB IMGUI_SOURCES ${IMGUI_PATH}/*.cpp)
-set(IMGUI_BACKEND_SOURCES
-  ${IMGUI_PATH}/backends/imgui_impl_sdl2.cpp
-  ${IMGUI_PATH}/backends/imgui_impl_sdlrenderer2.cpp
-  ${IMGUI_PATH}/misc/cpp/imgui_stdlib.cpp
-)
-add_library("ImGui" STATIC ${IMGUI_SOURCES} ${IMGUI_BACKEND_SOURCES})
-target_include_directories("ImGui" PUBLIC ${IMGUI_PATH} ${IMGUI_PATH}/backends)
-target_include_directories(ImGui PUBLIC ${SDL2_INCLUDE_DIR})
-target_compile_definitions(ImGui PUBLIC
-  IMGUI_IMPL_OPENGL_LOADER_CUSTOM=<SDL2/SDL_opengl.h>  GL_GLEXT_PROTOTYPES=1)
-
-# ImGui Test Engine - Always built when tests are enabled for simplified integration
-# The test infrastructure is tightly coupled with the editor, so we always include it
-if(YAZE_BUILD_TESTS)
-  set(IMGUI_TEST_ENGINE_PATH ${CMAKE_SOURCE_DIR}/src/lib/imgui_test_engine/imgui_test_engine)
-  file(GLOB IMGUI_TEST_ENGINE_SOURCES ${IMGUI_TEST_ENGINE_PATH}/*.cpp)
-  add_library("ImGuiTestEngine" STATIC ${IMGUI_TEST_ENGINE_SOURCES})
-  target_include_directories(ImGuiTestEngine PUBLIC ${IMGUI_PATH} ${CMAKE_SOURCE_DIR}/src/lib)
-  target_link_libraries(ImGuiTestEngine PUBLIC ImGui)
-  target_compile_definitions(ImGuiTestEngine PUBLIC 
-    IMGUI_ENABLE_TEST_ENGINE=1 
-    IMGUI_TEST_ENGINE_ENABLE_COROUTINE_STDTHREAD_IMPL=1)
-  
-  message(STATUS "✓ ImGui Test Engine enabled (tests are ON)")
-else()
-  message(STATUS "✗ ImGui Test Engine disabled (tests are OFF)")
-endif()
-
-set(
-  IMGUI_SRC
-  ${IMGUI_PATH}/imgui.cpp
-  ${IMGUI_PATH}/imgui_demo.cpp
-  ${IMGUI_PATH}/imgui_draw.cpp
-  ${IMGUI_PATH}/imgui_widgets.cpp
-  ${IMGUI_PATH}/backends/imgui_impl_sdl2.cpp
-  ${IMGUI_PATH}/backends/imgui_impl_sdlrenderer2.cpp
-  ${IMGUI_PATH}/misc/cpp/imgui_stdlib.cpp
-)
-
--- a/cmake/options.cmake
+++ b/cmake/options.cmake
@@ -0,0 +1,118 @@
+# YAZE Build Options
+# Centralized feature flags and build configuration
+
+# Core build options
+option(YAZE_BUILD_GUI "Build GUI application" ON)
+option(YAZE_BUILD_CLI "Build CLI tools (shared libraries)" ON)
+option(YAZE_BUILD_Z3ED "Build z3ed CLI executable" ON)
+option(YAZE_BUILD_EMU "Build emulator components" ON)
+option(YAZE_BUILD_LIB "Build static library" ON)
+option(YAZE_BUILD_TESTS "Build test suite" ON)
+
+# Feature flags
+option(YAZE_ENABLE_GRPC "Enable gRPC agent support" ON)
+option(YAZE_ENABLE_JSON "Enable JSON support" ON)
+option(YAZE_ENABLE_AI "Enable AI agent features" ON)
+
+# Advanced feature toggles
+option(YAZE_ENABLE_REMOTE_AUTOMATION
+  "Enable remote automation services (gRPC/protobuf servers + GUI automation clients)"
+  ${YAZE_ENABLE_GRPC})
+option(YAZE_ENABLE_AI_RUNTIME
+  "Enable AI runtime integrations (Gemini/Ollama, advanced routing, proposal planning)"
+  ${YAZE_ENABLE_AI})
+option(YAZE_BUILD_AGENT_UI
+  "Build ImGui-based agent/chat panels inside the GUI"
+  ${YAZE_BUILD_GUI})
+option(YAZE_ENABLE_AGENT_CLI
+  "Build the conversational agent CLI stack (z3ed agent commands)"
+  ${YAZE_BUILD_CLI})
+option(YAZE_ENABLE_HTTP_API
+  "Enable HTTP REST API server for external agent access"
+  ${YAZE_ENABLE_AGENT_CLI})
+
+if((YAZE_BUILD_CLI OR YAZE_BUILD_Z3ED) AND NOT YAZE_ENABLE_AGENT_CLI)
+  set(YAZE_ENABLE_AGENT_CLI ON CACHE BOOL "Build the conversational agent CLI stack (z3ed agent commands)" FORCE)
+endif()
+
+if(YAZE_ENABLE_HTTP_API AND NOT YAZE_ENABLE_AGENT_CLI)
+  set(YAZE_ENABLE_AGENT_CLI ON CACHE BOOL "Build the conversational agent CLI stack (z3ed agent commands)" FORCE)
+endif()
+
+# Build optimizations
+option(YAZE_ENABLE_LTO "Enable link-time optimization" OFF)
+option(YAZE_ENABLE_SANITIZERS "Enable AddressSanitizer/UBSanitizer" OFF)
+option(YAZE_ENABLE_COVERAGE "Enable code coverage" OFF)
+option(YAZE_UNITY_BUILD "Enable Unity (Jumbo) builds" OFF)
+
+# Platform-specific options
+option(YAZE_USE_VCPKG "Use vcpkg for Windows dependencies" OFF)
+option(YAZE_USE_SYSTEM_DEPS "Use system package manager for dependencies" OFF)
+
+# Development options
+option(YAZE_ENABLE_ROM_TESTS "Enable tests that require ROM files" OFF)
+option(YAZE_MINIMAL_BUILD "Minimal build for CI (disable optional features)" OFF)
+option(YAZE_VERBOSE_BUILD "Verbose build output" OFF)
+
+# Install options
+option(YAZE_INSTALL_LIB "Install static library" OFF)
+option(YAZE_INSTALL_HEADERS "Install public headers" ON)
+
+# Set preprocessor definitions based on options
+if(YAZE_ENABLE_REMOTE_AUTOMATION AND NOT YAZE_ENABLE_GRPC)
+  set(YAZE_ENABLE_GRPC ON CACHE BOOL "Enable gRPC agent support" FORCE)
+endif()
+
+if(NOT YAZE_ENABLE_REMOTE_AUTOMATION)
+  set(YAZE_ENABLE_GRPC OFF CACHE BOOL "Enable gRPC agent support" FORCE)
+endif()
+
+if(YAZE_ENABLE_GRPC)
+  add_compile_definitions(YAZE_WITH_GRPC)
+endif()
+
+if(YAZE_ENABLE_JSON)
+  add_compile_definitions(YAZE_WITH_JSON)
+endif()
+
+if(YAZE_ENABLE_AI_RUNTIME AND NOT YAZE_ENABLE_AI)
+  set(YAZE_ENABLE_AI ON CACHE BOOL "Enable AI agent features" FORCE)
+endif()
+
+if(NOT YAZE_ENABLE_AI_RUNTIME)
+  set(YAZE_ENABLE_AI OFF CACHE BOOL "Enable AI agent features" FORCE)
+endif()
+
+if(YAZE_ENABLE_AI)
+  add_compile_definitions(Z3ED_AI)
+endif()
+
+if(YAZE_ENABLE_AI_RUNTIME)
+  add_compile_definitions(YAZE_AI_RUNTIME_AVAILABLE)
+endif()
+
+if(YAZE_ENABLE_HTTP_API)
+  add_compile_definitions(YAZE_HTTP_API_ENABLED)
+endif()
+
+# Print configuration summary
+message(STATUS "=== YAZE Build Configuration ===")
+message(STATUS "GUI Application: ${YAZE_BUILD_GUI}")
+message(STATUS "CLI Tools: ${YAZE_BUILD_CLI}")
+message(STATUS "z3ed CLI: ${YAZE_BUILD_Z3ED}")
+message(STATUS "Emulator: ${YAZE_BUILD_EMU}")
+message(STATUS "Static Library: ${YAZE_BUILD_LIB}")
+message(STATUS "Tests: ${YAZE_BUILD_TESTS}")
+message(STATUS "gRPC Support: ${YAZE_ENABLE_GRPC}")
+message(STATUS "Remote Automation: ${YAZE_ENABLE_REMOTE_AUTOMATION}")
+message(STATUS "JSON Support: ${YAZE_ENABLE_JSON}")
+message(STATUS "AI Runtime: ${YAZE_ENABLE_AI_RUNTIME}")
+message(STATUS "AI Features (legacy): ${YAZE_ENABLE_AI}")
+message(STATUS "Agent UI Panels: ${YAZE_BUILD_AGENT_UI}")
+message(STATUS "Agent CLI Stack: ${YAZE_ENABLE_AGENT_CLI}")
+message(STATUS "HTTP API Server: ${YAZE_ENABLE_HTTP_API}")
+message(STATUS "LTO: ${YAZE_ENABLE_LTO}")
+message(STATUS "Sanitizers: ${YAZE_ENABLE_SANITIZERS}")
+message(STATUS "Coverage: ${YAZE_ENABLE_COVERAGE}")
+message(STATUS "=================================")
+
--- a/cmake/packaging/cpack.cmake
+++ b/cmake/packaging/cpack.cmake
@@ -0,0 +1,69 @@
+# CPack Configuration
+# Cross-platform packaging using CPack
+
+include(CPack)
+
+# Set package information
+set(CPACK_PACKAGE_NAME "yaze")
+set(CPACK_PACKAGE_VENDOR "scawful")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Yet Another Zelda3 Editor")
+set(CPACK_PACKAGE_VERSION_MAJOR ${YAZE_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${YAZE_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${YAZE_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION "${YAZE_VERSION_MAJOR}.${YAZE_VERSION_MINOR}.${YAZE_VERSION_PATCH}")
+
+# Set package directory
+set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}/packages")
+
+# Platform-specific packaging
+if(APPLE)
+  include(cmake/packaging/macos.cmake)
+elseif(WIN32)
+  include(cmake/packaging/windows.cmake)
+elseif(UNIX)
+  include(cmake/packaging/linux.cmake)
+endif()
+
+# Common files to include
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
+
+# Set default component
+set(CPACK_COMPONENTS_ALL yaze)
+set(CPACK_COMPONENT_YAZE_DISPLAY_NAME "YAZE Editor")
+set(CPACK_COMPONENT_YAZE_DESCRIPTION "Main YAZE application and libraries")
+
+# Install rules - these define what CPack packages
+include(GNUInstallDirs)
+
+# Install main executable
+if(APPLE)
+    install(TARGETS yaze
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        BUNDLE DESTINATION .
+        COMPONENT yaze
+    )
+else()
+    install(TARGETS yaze
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        COMPONENT yaze
+    )
+endif()
+
+# Install assets
+install(DIRECTORY ${CMAKE_SOURCE_DIR}/assets/
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/yaze/assets
+    COMPONENT yaze
+    PATTERN "*.png"
+    PATTERN "*.ttf"
+    PATTERN "*.asm"
+)
+
+# Install documentation
+install(FILES
+    ${CMAKE_SOURCE_DIR}/README.md
+    ${CMAKE_SOURCE_DIR}/LICENSE
+    DESTINATION ${CMAKE_INSTALL_DOCDIR}
+    COMPONENT yaze
+)
+
--- a/cmake/packaging/linux.cmake
+++ b/cmake/packaging/linux.cmake
@@ -0,0 +1,17 @@
+# Linux Packaging Configuration
+
+# DEB package
+set(CPACK_GENERATOR "DEB;TGZ")
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "scawful")
+set(CPACK_DEBIAN_PACKAGE_SECTION "games")
+set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libstdc++6, libsdl2-2.0-0")
+
+# RPM package
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+set(CPACK_RPM_PACKAGE_GROUP "Applications/Games")
+set(CPACK_RPM_PACKAGE_REQUIRES "glibc, libstdc++, SDL2")
+
+# Tarball
+set(CPACK_TGZ_PACKAGE_NAME "yaze-${CPACK_PACKAGE_VERSION}-linux-x64")
+
--- a/cmake/packaging/macos.cmake
+++ b/cmake/packaging/macos.cmake
@@ -0,0 +1,24 @@
+# macOS Packaging Configuration
+
+# Create .dmg package
+set(CPACK_GENERATOR "DragNDrop")
+set(CPACK_DMG_VOLUME_NAME "yaze")
+set(CPACK_DMG_FORMAT "UDZO")
+set(CPACK_DMG_BACKGROUND_IMAGE "${CMAKE_SOURCE_DIR}/assets/yaze.png")
+
+# App bundle configuration
+set(CPACK_BUNDLE_NAME "yaze")
+set(CPACK_BUNDLE_PACKAGE_TYPE "APPL")
+set(CPACK_BUNDLE_ICON "${CMAKE_SOURCE_DIR}/assets/yaze.icns")
+
+# Code signing (if available)
+if(DEFINED ENV{CODESIGN_IDENTITY})
+  set(CPACK_BUNDLE_APPLE_CERT_APP "$ENV{CODESIGN_IDENTITY}")
+  set(CPACK_BUNDLE_APPLE_CODESIGN_FORCE "ON")
+endif()
+
+# Notarization (if available)
+if(DEFINED ENV{NOTARIZATION_CREDENTIALS})
+  set(CPACK_BUNDLE_APPLE_NOTARIZATION_CREDENTIALS "$ENV{NOTARIZATION_CREDENTIALS}")
+endif()
+
--- a/cmake/packaging/windows.cmake
+++ b/cmake/packaging/windows.cmake
@@ -0,0 +1,22 @@
+# Windows Packaging Configuration
+
+# NSIS installer
+set(CPACK_GENERATOR "NSIS;ZIP")
+set(CPACK_NSIS_PACKAGE_NAME "YAZE Editor")
+set(CPACK_NSIS_DISPLAY_NAME "YAZE Editor v${CPACK_PACKAGE_VERSION}")
+set(CPACK_NSIS_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION}")
+set(CPACK_NSIS_CONTACT "scawful")
+set(CPACK_NSIS_URL_INFO_ABOUT "https://github.com/scawful/yaze")
+set(CPACK_NSIS_HELP_LINK "https://github.com/scawful/yaze")
+set(CPACK_NSIS_URL_INFO_ABOUT "https://github.com/scawful/yaze")
+set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL ON)
+
+# ZIP package
+set(CPACK_ZIP_PACKAGE_NAME "yaze-${CPACK_PACKAGE_VERSION}-windows-x64")
+
+# Code signing (if available)
+if(DEFINED ENV{SIGNTOOL_CERTIFICATE})
+  set(CPACK_NSIS_SIGN_TOOL "signtool.exe")
+  set(CPACK_NSIS_SIGN_COMMAND "${ENV{SIGNTOOL_CERTIFICATE}}")
+endif()
+
--- a/cmake/sdl2.cmake
+++ b/cmake/sdl2.cmake
@@ -27,14 +27,14 @@ if(WIN32)
  endif()
  
  # Fall back to bundled SDL if vcpkg not available or SDL2 not found
-  if(EXISTS "${CMAKE_SOURCE_DIR}/src/lib/SDL/CMakeLists.txt")
+  if(EXISTS "${CMAKE_SOURCE_DIR}/ext/SDL/CMakeLists.txt")
    message(STATUS "○ vcpkg SDL2 not found, using bundled SDL2")
-    add_subdirectory(src/lib/SDL)
+    add_subdirectory(ext/SDL)
    set(SDL_TARGETS SDL2-static)
    set(SDL2_INCLUDE_DIR 
-      ${CMAKE_SOURCE_DIR}/src/lib/SDL/include
-      ${CMAKE_BINARY_DIR}/src/lib/SDL/include
-      ${CMAKE_BINARY_DIR}/src/lib/SDL/include-config-${CMAKE_BUILD_TYPE}
+      ${CMAKE_SOURCE_DIR}/ext/SDL/include
+      ${CMAKE_BINARY_DIR}/ext/SDL/include
+      ${CMAKE_BINARY_DIR}/ext/SDL/include-config-${CMAKE_BUILD_TYPE}
    )
    set(SDL2_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
    if(TARGET SDL2main)
@@ -47,12 +47,12 @@ if(WIN32)
  endif()
 elseif(UNIX OR MINGW)
  # Non-Windows: use bundled SDL
-  add_subdirectory(src/lib/SDL)
+  add_subdirectory(ext/SDL)
  set(SDL_TARGETS SDL2-static)
  set(SDL2_INCLUDE_DIR 
-    ${CMAKE_SOURCE_DIR}/src/lib/SDL/include
-    ${CMAKE_BINARY_DIR}/src/lib/SDL/include
-    ${CMAKE_BINARY_DIR}/src/lib/SDL/include-config-${CMAKE_BUILD_TYPE}
+    ${CMAKE_SOURCE_DIR}/ext/SDL/include
+    ${CMAKE_BINARY_DIR}/ext/SDL/include
+    ${CMAKE_BINARY_DIR}/ext/SDL/include-config-${CMAKE_BUILD_TYPE}
  )
  set(SDL2_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
  message(STATUS "Using bundled SDL2")
--- a/cmake/toolchains/linux-gcc.cmake
+++ b/cmake/toolchains/linux-gcc.cmake
@@ -0,0 +1,22 @@
+# Linux GCC Toolchain
+# Optimized for Ubuntu 22.04+ with GCC 12+
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_C_COMPILER gcc)
+set(CMAKE_CXX_COMPILER g++)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG")
+
+# Link flags
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
+
+# Find packages
+find_package(PkgConfig REQUIRED)
+
--- a/cmake/toolchains/macos-clang.cmake
+++ b/cmake/toolchains/macos-clang.cmake
@@ -0,0 +1,25 @@
+# macOS Clang Toolchain
+# Optimized for macOS 14+ with Clang 18+
+
+set(CMAKE_SYSTEM_NAME Darwin)
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_CXX_COMPILER clang++)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# macOS deployment target
+set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0" CACHE STRING "macOS deployment target")
+
+# Compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG")
+
+# Link flags
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-dead_strip")
+
+# Find packages
+find_package(PkgConfig REQUIRED)
+
--- a/cmake/toolchains/windows-msvc.cmake
+++ b/cmake/toolchains/windows-msvc.cmake
@@ -0,0 +1,26 @@
+# Windows MSVC Toolchain
+# Optimized for Visual Studio 2022 with MSVC 19.30+
+
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_C_COMPILER cl)
+set(CMAKE_CXX_COMPILER cl)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# MSVC runtime library (static)
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
+# Compiler flags
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /permissive-")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /Ob2 /DNDEBUG")
+
+# Link flags
+set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG")
+
+# Windows-specific definitions
+add_definitions(-DWIN32_LEAN_AND_MEAN)
+add_definitions(-DNOMINMAX)
+