wyvrnpm 2.0.4 → 2.3.2

package/cmake/macros.cmake

@@ -0,0 +1,233 @@
+
+# Transitional helper for unified versioning.
+#
+# The shared generated header is produced once at the top-level and placed under:
+#   ${CMAKE_BINARY_DIR}/wyvrn/WyvrnConfig.h
+# Targets that want to include it as `#include "wyvrn/WyvrnConfig.h"` should
+# have `${CMAKE_BINARY_DIR}` on their include path.
+#
+# This macro exists to preserve older module CMake patterns during migration.
+macro(WYVRN_CONFIGURE_VERSION_HEADER)
+    if(ARGC GREATER 0)
+        set(_wyvrn_version_target ${ARGV0})
+    else()
+        set(_wyvrn_version_target ${PROJECT_NAME})
+    endif()
+
+    if(NOT DEFINED WYVRN_VERSION_HEADER_INCLUDE_DIR)
+        set(WYVRN_VERSION_HEADER_INCLUDE_DIR ${CMAKE_BINARY_DIR})
+    endif()
+
+    target_include_directories(${_wyvrn_version_target}
+        PUBLIC
+            $<BUILD_INTERFACE:${WYVRN_VERSION_HEADER_INCLUDE_DIR}>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+endmacro()
+
+function(WYVRN_INSTALL_PACKAGE_EXPORT)
+    set(options)
+    set(oneValueArgs
+        TARGET
+        EXPORT_NAME
+        CONFIG_INPUT
+        CONFIG_OUTPUT
+        VERSION_OUTPUT
+        INSTALL_CMAKEDIR
+        NAMESPACE
+        EXPORT_FILE
+        PACKAGE_VERSION
+    )
+    set(multiValueArgs)
+    cmake_parse_arguments(WYVRN_EXPORT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    include(CMakePackageConfigHelpers)
+
+    if(NOT WYVRN_EXPORT_TARGET)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires TARGET")
+    endif()
+    if(NOT WYVRN_EXPORT_EXPORT_NAME)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires EXPORT_NAME")
+    endif()
+    if(NOT WYVRN_EXPORT_CONFIG_INPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires CONFIG_INPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_CONFIG_OUTPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires CONFIG_OUTPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_VERSION_OUTPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires VERSION_OUTPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_INSTALL_CMAKEDIR)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires INSTALL_CMAKEDIR")
+    endif()
+    if(NOT WYVRN_EXPORT_NAMESPACE)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires NAMESPACE")
+    endif()
+    if(NOT WYVRN_EXPORT_EXPORT_FILE)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires EXPORT_FILE")
+    endif()
+
+    if(NOT WYVRN_EXPORT_PACKAGE_VERSION)
+        if(DEFINED PROJECT_VERSION AND NOT "${PROJECT_VERSION}" STREQUAL "")
+            set(WYVRN_EXPORT_PACKAGE_VERSION ${PROJECT_VERSION})
+        elseif(DEFINED WYVRN_PROJECT_VERSION AND NOT "${WYVRN_PROJECT_VERSION}" STREQUAL "")
+            set(WYVRN_EXPORT_PACKAGE_VERSION ${WYVRN_PROJECT_VERSION})
+        else()
+            message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires PACKAGE_VERSION or a non-empty PROJECT_VERSION/WYVRN_PROJECT_VERSION")
+        endif()
+    endif()
+
+    configure_package_config_file(
+        "${WYVRN_EXPORT_CONFIG_INPUT}"
+        "${WYVRN_EXPORT_CONFIG_OUTPUT}"
+        INSTALL_DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+
+    write_basic_package_version_file(
+        "${WYVRN_EXPORT_VERSION_OUTPUT}"
+        VERSION "${WYVRN_EXPORT_PACKAGE_VERSION}"
+        COMPATIBILITY SameMajorVersion
+    )
+
+    install(FILES
+        "${WYVRN_EXPORT_CONFIG_OUTPUT}"
+        "${WYVRN_EXPORT_VERSION_OUTPUT}"
+        DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+
+    install(TARGETS ${WYVRN_EXPORT_TARGET}
+        EXPORT ${WYVRN_EXPORT_EXPORT_NAME}
+        RUNTIME DESTINATION bin/$<CONFIG>          # .dll files (Windows)
+        LIBRARY DESTINATION lib/$<CONFIG>           # .so files (Linux/macOS)
+        ARCHIVE DESTINATION lib/$<CONFIG>           # .lib files (static or import libs)
+    )
+
+    install(EXPORT ${WYVRN_EXPORT_EXPORT_NAME}
+        FILE ${WYVRN_EXPORT_EXPORT_FILE}
+        NAMESPACE ${WYVRN_EXPORT_NAMESPACE}
+        DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+endfunction()
+
+function(WYVRN_INSTALL_MODULE)
+    set(options
+        COPY_DLL_TO_OUTPUT
+    )
+    set(oneValueArgs
+        TARGET
+        PACKAGE_NAME
+        INSTALL_CMAKEDIR
+        NAMESPACE
+        EXPORT_NAME
+        EXPORT_FILE
+        DLL_OUTPUT_DIR
+        CONSUMER_DLL_OUTPUT_DIR
+    )
+    set(multiValueArgs
+        DEPENDENCIES
+        FIND_PACKAGES
+    )
+    cmake_parse_arguments(WYVRN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT WYVRN_TARGET)
+        message(FATAL_ERROR "WYVRN_INSTALL_MODULE requires TARGET")
+    endif()
+    if(NOT WYVRN_PACKAGE_NAME)
+        message(FATAL_ERROR "WYVRN_INSTALL_MODULE requires PACKAGE_NAME (example: WyvrnMemory)")
+    endif()
+
+    if(NOT WYVRN_NAMESPACE)
+        set(WYVRN_NAMESPACE wyvrn::)
+    endif()
+    if(NOT WYVRN_EXPORT_NAME)
+        set(WYVRN_EXPORT_NAME "${WYVRN_PACKAGE_NAME}Targets")
+    endif()
+    if(NOT WYVRN_EXPORT_FILE)
+        set(WYVRN_EXPORT_FILE "${WYVRN_PACKAGE_NAME}Targets.cmake")
+    endif()
+    if(NOT WYVRN_INSTALL_CMAKEDIR)
+        set(WYVRN_INSTALL_CMAKEDIR "${CMAKE_INSTALL_DATADIR}/${WYVRN_PACKAGE_NAME}")
+    endif()
+
+    if(WYVRN_COPY_DLL_TO_OUTPUT)
+        get_target_property(_wyvrn_target_type ${WYVRN_TARGET} TYPE)
+        set(_wyvrn_enable_dll_copy FALSE)
+
+        if(NOT WYVRN_DLL_OUTPUT_DIR)
+            if(DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY AND NOT "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" STREQUAL "")
+                set(WYVRN_DLL_OUTPUT_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>")
+            else()
+                set(WYVRN_DLL_OUTPUT_DIR "${CMAKE_BINARY_DIR}/bin/$<CONFIG>")
+            endif()
+        endif()
+
+        if(WIN32 AND (_wyvrn_target_type STREQUAL "SHARED_LIBRARY" OR _wyvrn_target_type STREQUAL "MODULE_LIBRARY"))
+            set(_wyvrn_enable_dll_copy TRUE)
+            add_custom_command(TARGET ${WYVRN_TARGET} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${WYVRN_DLL_OUTPUT_DIR}"
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    "$<TARGET_FILE:${WYVRN_TARGET}>"
+                    "${WYVRN_DLL_OUTPUT_DIR}/"
+                COMMENT "Copying DLL for ${WYVRN_TARGET} to ${WYVRN_DLL_OUTPUT_DIR}"
+            )
+        else()
+            message(WARNING "WYVRN_INSTALL_MODULE(COPY_DLL_TO_OUTPUT) is set for '${WYVRN_TARGET}', but it is not a Windows shared/module library. Skipping DLL copy.")
+        endif()
+    endif()
+
+    set(_wyvrn_config_in "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}Config.cmake.in")
+    set(_wyvrn_config_out "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}Config.cmake")
+    set(_wyvrn_version_out "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}ConfigVersion.cmake")
+
+    set(_wyvrn_config_text "@PACKAGE_INIT@\n\n")
+
+    if(WYVRN_FIND_PACKAGES OR WYVRN_DEPENDENCIES)
+        string(APPEND _wyvrn_config_text "include(CMakeFindDependencyMacro)\n")
+    endif()
+
+    foreach(_wyvrn_pkg IN LISTS WYVRN_FIND_PACKAGES)
+        string(APPEND _wyvrn_config_text "find_package(${_wyvrn_pkg} CONFIG REQUIRED)\n")
+    endforeach()
+
+    foreach(_wyvrn_dep IN LISTS WYVRN_DEPENDENCIES)
+        string(APPEND _wyvrn_config_text "find_dependency(${_wyvrn_dep} CONFIG REQUIRED)\n")
+    endforeach()
+
+    string(APPEND _wyvrn_config_text "\ninclude(\"\${CMAKE_CURRENT_LIST_DIR}/${WYVRN_EXPORT_FILE}\")\n")
+
+    if(WYVRN_COPY_DLL_TO_OUTPUT AND _wyvrn_enable_dll_copy)
+        if(NOT WYVRN_CONSUMER_DLL_OUTPUT_DIR)
+            set(WYVRN_CONSUMER_DLL_OUTPUT_DIR "\${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>")
+        endif()
+
+        string(APPEND _wyvrn_config_text "\nif(WIN32 AND TARGET ${WYVRN_NAMESPACE}${WYVRN_TARGET})\n")
+        string(APPEND _wyvrn_config_text "  if(NOT TARGET ${WYVRN_PACKAGE_NAME}RuntimeCopy)\n")
+        string(APPEND _wyvrn_config_text "    set(_wyvrn_runtime_out \"${WYVRN_CONSUMER_DLL_OUTPUT_DIR}\")\n")
+        string(APPEND _wyvrn_config_text "    if(\"\${_wyvrn_runtime_out}\" STREQUAL \"/$<CONFIG>\")\n")
+        string(APPEND _wyvrn_config_text "      set(_wyvrn_runtime_out \"\${CMAKE_BINARY_DIR}/bin/$<CONFIG>\")\n")
+        string(APPEND _wyvrn_config_text "    endif()\n")
+        string(APPEND _wyvrn_config_text "    add_custom_target(${WYVRN_PACKAGE_NAME}RuntimeCopy ALL\n")
+        string(APPEND _wyvrn_config_text "      COMMAND \${CMAKE_COMMAND} -E make_directory \"\${_wyvrn_runtime_out}\"\n")
+        string(APPEND _wyvrn_config_text "      COMMAND \${CMAKE_COMMAND} -E copy_if_different\n")
+        string(APPEND _wyvrn_config_text "              \"$<TARGET_FILE:${WYVRN_NAMESPACE}${WYVRN_TARGET}>\"\n")
+        string(APPEND _wyvrn_config_text "              \"\${_wyvrn_runtime_out}/\"\n")
+        string(APPEND _wyvrn_config_text "      COMMENT \"Copying runtime DLL for ${WYVRN_NAMESPACE}${WYVRN_TARGET} to \${_wyvrn_runtime_out}\"\n")
+        string(APPEND _wyvrn_config_text "    )\n")
+        string(APPEND _wyvrn_config_text "  endif()\n")
+        string(APPEND _wyvrn_config_text "endif()\n")
+    endif()
+
+    file(WRITE "${_wyvrn_config_in}" "${_wyvrn_config_text}")
+
+    WYVRN_INSTALL_PACKAGE_EXPORT(
+        TARGET ${WYVRN_TARGET}
+        EXPORT_NAME ${WYVRN_EXPORT_NAME}
+        CONFIG_INPUT "${_wyvrn_config_in}"
+        CONFIG_OUTPUT "${_wyvrn_config_out}"
+        VERSION_OUTPUT "${_wyvrn_version_out}"
+        INSTALL_CMAKEDIR "${WYVRN_INSTALL_CMAKEDIR}"
+        NAMESPACE ${WYVRN_NAMESPACE}
+        EXPORT_FILE ${WYVRN_EXPORT_FILE}
+    )
+endfunction()

package/cmake/options.cmake

@@ -0,0 +1,23 @@
+option(WYVRN_ENABLE_ASSERTION     "Enable assertions"                     ON)
+option(WYVRN_ENABLE_LOG           "Enable logging"                        ON)
+option(WYVRN_ENABLE_PROFILER      "Enable profiler"                       OFF)
+option(WYVRN_COMPILE_PROFILER_EXE "Compile the profiler executable"       OFF)
+option(WYVRN_ENABLE_MEMORY_TRACK  "Enable memory tracking"                OFF)
+option(WYVRN_MEMORY_TRACK_VERBOSE "Verbose memory tracking (very slow)"   OFF)
+
+set(WYVRN_OPTIONS 
+    WYVRN_ENABLE_ASSERTION
+    WYVRN_ENABLE_LOG
+    WYVRN_ENABLE_PROFILER
+    WYVRN_COMPILE_PROFILER_EXE
+    WYVRN_ENABLE_MEMORY_TRACK
+    WYVRN_MEMORY_TRACK_VERBOSE)
+
+foreach(opt IN LISTS WYVRN_OPTIONS)
+    if(${opt})
+        add_compile_definitions(${opt}=1)
+        message(STATUS "Enabled option: ${opt}")
+    else()
+        add_compile_definitions(${opt}=0)
+    endif()
+endforeach()

package/cmake/variables.cmake

@@ -0,0 +1,171 @@
+if(MSVC)
+    list(APPEND WYVRN_COMPILER_FLAGS
+        /W3
+        /sdl
+        /permissive-
+        /EHsc
+    )
+else()
+    list(APPEND WYVRN_COMPILER_FLAGS
+        -Wall
+        -Wextra
+    )
+endif()
+
+option(WYVRN_UNICODE "Enable Unicode character set (_UNICODE, UNICODE)" ON)
+if(WYVRN_UNICODE)
+    add_compile_definitions(_UNICODE UNICODE)
+endif()
+
+# MSVC runtime library is controlled by CMAKE_MSVC_RUNTIME_LIBRARY (CMP0091),
+# which the wyvrnpm toolchain sets from the active build profile
+# (compiler.runtime=dynamic|static). CMake emits the correct /MD[d] or /MT[d]
+# automatically; appending the flag here would duplicate or conflict when the
+# profile requests a different runtime than the old default of /MD.
+
+SET(VENDOR_DIR ${PROJECT_SOURCE_DIR}/vendors)
+
+# ── Platform detection ────────────────────────────────────────────────────────
+# Leaf platforms (set exactly one primary leaf; SteamOS is an overlay on Linux)
+#
+#   WYVRN_PLATFORM_WINDOWS   – desktop Windows (Win32/Win64)
+#   WYVRN_PLATFORM_XBOX      – Xbox GDK / XDK  (pass -DWYVRN_XBOX=ON)
+#   WYVRN_PLATFORM_PS4       – PlayStation 4   (CMAKE_SYSTEM_NAME == ORBIS)
+#   WYVRN_PLATFORM_PS5       – PlayStation 5   (CMAKE_SYSTEM_NAME == Prospero)
+#   WYVRN_PLATFORM_LINUX     – generic Linux
+#   WYVRN_PLATFORM_STEAMOS   – SteamOS (overlay; set alongside LINUX)
+#   WYVRN_PLATFORM_ANDROID   – Android NDK
+#   WYVRN_PLATFORM_MACOS     – macOS
+#   WYVRN_PLATFORM_IOS       – iOS / iPadOS
+
+# -- Initialise all leaf variables to FALSE --
+set(WYVRN_PLATFORM_WINDOWS FALSE)
+set(WYVRN_PLATFORM_XBOX    FALSE)
+set(WYVRN_PLATFORM_PS4     FALSE)
+set(WYVRN_PLATFORM_PS5     FALSE)
+set(WYVRN_PLATFORM_LINUX   FALSE)
+set(WYVRN_PLATFORM_STEAMOS FALSE)
+set(WYVRN_PLATFORM_ANDROID FALSE)
+set(WYVRN_PLATFORM_MACOS   FALSE)
+set(WYVRN_PLATFORM_IOS     FALSE)
+
+# -- Detect leaf --
+if(CMAKE_SYSTEM_NAME STREQUAL "ORBIS")
+    set(WYVRN_PLATFORM_PS4 TRUE)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Prospero")
+    set(WYVRN_PLATFORM_PS5 TRUE)
+elseif(WIN32)
+    if(WYVRN_XBOX OR CHROMA_XBOX)
+        set(WYVRN_PLATFORM_XBOX TRUE)
+    else()
+        set(WYVRN_PLATFORM_WINDOWS TRUE)
+    endif()
+elseif(ANDROID)
+    set(WYVRN_PLATFORM_ANDROID TRUE)
+elseif(APPLE)
+    if(IOS)
+        set(WYVRN_PLATFORM_IOS TRUE)
+    else()
+        set(WYVRN_PLATFORM_MACOS TRUE)
+    endif()
+elseif(UNIX)
+    set(WYVRN_PLATFORM_LINUX TRUE)
+    if(WYVRN_STEAMOS)
+        set(WYVRN_PLATFORM_STEAMOS TRUE)
+    endif()
+endif()
+
+# -- Derived family tier --
+if(WYVRN_PLATFORM_WINDOWS OR WYVRN_PLATFORM_XBOX)
+    set(WYVRN_PLATFORM_MICROSOFT TRUE)
+else()
+    set(WYVRN_PLATFORM_MICROSOFT FALSE)
+endif()
+
+if(WYVRN_PLATFORM_MACOS OR WYVRN_PLATFORM_IOS)
+    set(WYVRN_PLATFORM_DARWIN TRUE)
+else()
+    set(WYVRN_PLATFORM_DARWIN FALSE)
+endif()
+
+if(WYVRN_PLATFORM_PS4 OR WYVRN_PLATFORM_PS5)
+    set(WYVRN_PLATFORM_PLAYSTATION TRUE)
+else()
+    set(WYVRN_PLATFORM_PLAYSTATION FALSE)
+endif()
+
+if(WYVRN_PLATFORM_LINUX OR WYVRN_PLATFORM_ANDROID OR WYVRN_PLATFORM_DARWIN OR WYVRN_PLATFORM_PLAYSTATION)
+    set(WYVRN_PLATFORM_UNIX TRUE)
+else()
+    set(WYVRN_PLATFORM_UNIX FALSE)
+endif()
+
+# -- Derived broad grouping tier --
+if(WYVRN_PLATFORM_WINDOWS OR WYVRN_PLATFORM_MACOS OR WYVRN_PLATFORM_LINUX)
+    set(WYVRN_PLATFORM_DESKTOP TRUE)
+else()
+    set(WYVRN_PLATFORM_DESKTOP FALSE)
+endif()
+
+if(WYVRN_PLATFORM_ANDROID OR WYVRN_PLATFORM_IOS)
+    set(WYVRN_PLATFORM_MOBILE TRUE)
+else()
+    set(WYVRN_PLATFORM_MOBILE FALSE)
+endif()
+
+if(WYVRN_PLATFORM_XBOX OR WYVRN_PLATFORM_PLAYSTATION)
+    set(WYVRN_PLATFORM_CONSOLE TRUE)
+else()
+    set(WYVRN_PLATFORM_CONSOLE FALSE)
+endif()
+
+# -- Emit WYVRN_PLATFORM_* compile definitions (value = 1) --
+foreach(_plat
+    WINDOWS XBOX PS4 PS5 LINUX STEAMOS ANDROID MACOS IOS
+    MICROSOFT DARWIN PLAYSTATION UNIX
+    DESKTOP MOBILE CONSOLE)
+    if(WYVRN_PLATFORM_${_plat})
+        add_compile_definitions(WYVRN_PLATFORM_${_plat}=1)
+    endif()
+endforeach()
+
+# -- Backward-compat CHROMA_* CMake variables and compile definitions --
+set(CHROMA_WINDOWS ${WYVRN_PLATFORM_WINDOWS})
+set(CHROMA_XBOX    ${WYVRN_PLATFORM_XBOX})
+set(CHROMA_LINUX   ${WYVRN_PLATFORM_LINUX})
+set(CHROMA_ANDROID ${WYVRN_PLATFORM_ANDROID})
+set(CHROMA_MACOS   ${WYVRN_PLATFORM_MACOS})
+set(CHROMA_IOS     ${WYVRN_PLATFORM_IOS})
+
+foreach(_plat WINDOWS XBOX LINUX ANDROID MACOS IOS)
+    if(WYVRN_PLATFORM_${_plat})
+        add_compile_definitions(CHROMA_${_plat}=1)
+    endif()
+endforeach()
+
+# Status
+message(STATUS "Platform leaf  : WINDOWS=${WYVRN_PLATFORM_WINDOWS} XBOX=${WYVRN_PLATFORM_XBOX} PS4=${WYVRN_PLATFORM_PS4} PS5=${WYVRN_PLATFORM_PS5} LINUX=${WYVRN_PLATFORM_LINUX} STEAMOS=${WYVRN_PLATFORM_STEAMOS} ANDROID=${WYVRN_PLATFORM_ANDROID} MACOS=${WYVRN_PLATFORM_MACOS} IOS=${WYVRN_PLATFORM_IOS}")
+message(STATUS "Platform family: MICROSOFT=${WYVRN_PLATFORM_MICROSOFT} DARWIN=${WYVRN_PLATFORM_DARWIN} PLAYSTATION=${WYVRN_PLATFORM_PLAYSTATION} UNIX=${WYVRN_PLATFORM_UNIX}")
+message(STATUS "Platform broad : DESKTOP=${WYVRN_PLATFORM_DESKTOP} MOBILE=${WYVRN_PLATFORM_MOBILE} CONSOLE=${WYVRN_PLATFORM_CONSOLE}")
+
+# Arch
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    message(STATUS "Building for x64 (64-bit)")
+    add_definitions(-DWYVRN_64)
+    set(WYVRN_64 TRUE)
+elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    message(STATUS "Building for x86 (32-bit)")
+     add_definitions(-DWYVRN_32)
+    set(WYVRN_32 TRUE)
+else()
+    message(STATUS "Unknown architecture")
+endif()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/lib/")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/lib/")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/bin")
+
+add_compile_definitions(
+    $<$<CONFIG:Debug>:WYVRN_DEBUG>
+    $<$<CONFIG:Release>:WYVRN_RELEASE>
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.0.4",
+  "version": "2.3.2",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",
@@ -19,6 +19,8 @@
   "files": [
     "bin/",
     "src/",
+    "cmake/",
+    "claude/skills/wyvrnpm.skill",
     "README.md"
   ],
   "scripts": {

package/src/build/cache.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+/**
+ * Root directory for the wyvrnpm source-build cache.
+ *   Windows: %LOCALAPPDATA%\wyvrnpm\bc\           (short name — Windows 260-char path limits bite nested CMake builds)
+ *   Unix   : ~/.cache/wyvrnpm/bc/
+ *
+ * @returns {string}
+ */
+function getBuildCacheRoot() {
+  const base = process.env.LOCALAPPDATA
+    ? path.join(process.env.LOCALAPPDATA, 'wyvrnpm')
+    : path.join(process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache'), 'wyvrnpm');
+  return path.join(base, 'bc');
+}
+
+/**
+ * Per-build cache directory, keyed by `(name, version, profileHash)`. Each
+ * consumer profile gets its own cache line because the toolchain's output
+ * differs per profile.
+ *
+ * Layout inside this dir:
+ *   src/               git clone
+ *   wyvrn_internal/    package's own deps + generated toolchain
+ *   build/             cmake -B
+ *   build/install/     cmake install prefix → zipped as the artefact
+ *   wyvrn.zip          final artefact (treated as if downloaded)
+ *
+ * @param {{ name: string, version: string, profileHash: string }} args
+ * @returns {string}
+ */
+function getPackageBuildDir({ name, version, profileHash }) {
+  // Sanitise — names should be filesystem-safe already, but guard against
+  // accidental path traversal.
+  const safeName    = name.replace(/[^\w.-]/g, '_');
+  const safeVersion = version.replace(/[^\w.-]/g, '_');
+  const safeHash    = profileHash.replace(/[^\w.-]/g, '_');
+  return path.join(getBuildCacheRoot(), `${safeName}-${safeVersion}-${safeHash}`);
+}
+
+/**
+ * Names of the artefacts inside a package build dir.
+ */
+const LAYOUT = Object.freeze({
+  srcDir:        'src',
+  internalDir:   'wyvrn_internal',
+  buildDir:      'build',
+  installSubdir: 'install', // relative to buildDir — can be overridden by recipe.installDir
+  artefactZip:   'wyvrn.zip',
+  uploadSidecar: '.uploaded-to.json',
+});
+
+/**
+ * Resolve the standard sub-paths within a package build dir.
+ */
+function getBuildPaths({ name, version, profileHash }) {
+  const root = getPackageBuildDir({ name, version, profileHash });
+  return {
+    root,
+    src:        path.join(root, LAYOUT.srcDir),
+    internal:   path.join(root, LAYOUT.internalDir),
+    build:      path.join(root, LAYOUT.buildDir),
+    install:    path.join(root, LAYOUT.buildDir, LAYOUT.installSubdir),
+    artefact:   path.join(root, LAYOUT.artefactZip),
+  };
+}
+
+/**
+ * Remove the entire build cache root. Used by `wyvrnpm clean --build-cache`.
+ * @returns {string|null}  the path removed, or null if nothing was there.
+ */
+function clearBuildCache() {
+  const root = getBuildCacheRoot();
+  if (!fs.existsSync(root)) return null;
+  fs.rmSync(root, { recursive: true, force: true });
+  return root;
+}
+
+/**
+ * Check whether a valid cached artefact exists for this `(name, version, profileHash)`
+ * — used to short-circuit re-builds on re-run.
+ *
+ * @param {{ name, version, profileHash }} args
+ * @returns {boolean}
+ */
+function hasValidArtefact(args) {
+  const { artefact } = getBuildPaths(args);
+  return fs.existsSync(artefact);
+}
+
+/**
+ * Find every `.uploaded-to.json` sidecar under the build cache. Each file
+ * records the destinations that a cached artefact has been pushed to via
+ * `wyvrnpm install --build=missing --upload-built`.
+ *
+ * Used by `wyvrnpm clean --uploaded-built` and for audit tooling.
+ *
+ * @returns {Array<{ cacheDir: string, sidecarPath: string, uploads: Array<object> }>}
+ */
+function listUploadSidecars() {
+  const root = getBuildCacheRoot();
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const cacheDir    = path.join(root, entry.name);
+    const sidecarPath = path.join(cacheDir, LAYOUT.uploadSidecar);
+    if (!fs.existsSync(sidecarPath)) continue;
+    let uploads = [];
+    try {
+      const raw = JSON.parse(fs.readFileSync(sidecarPath, 'utf8'));
+      if (Array.isArray(raw?.uploads)) uploads = raw.uploads;
+    } catch { /* corrupt — surface as empty uploads */ }
+    out.push({ cacheDir, sidecarPath, uploads });
+  }
+  return out;
+}
+
+/**
+ * Remove every `.uploaded-to.json` sidecar under the build cache. Used by
+ * `wyvrnpm clean --uploaded-built`. Leaves all other cache content intact
+ * (the artefact zips, source clones, and build dirs stay put).
+ *
+ * @returns {number}  count of sidecar files removed
+ */
+function clearUploadSidecars() {
+  const entries = listUploadSidecars();
+  let removed = 0;
+  for (const { sidecarPath } of entries) {
+    try { fs.unlinkSync(sidecarPath); removed++; } catch { /* ignore */ }
+  }
+  return removed;
+}
+
+module.exports = {
+  getBuildCacheRoot,
+  getPackageBuildDir,
+  getBuildPaths,
+  clearBuildCache,
+  hasValidArtefact,
+  listUploadSidecars,
+  clearUploadSidecars,
+  LAYOUT,
+};