usearch 2.21.3 → 2.25.0

package/numkong/cmake/toolchain-riscv64-gnu.cmake

@@ -0,0 +1,107 @@
+# RISC-V 64 GNU toolchain for NumKong.
+#
+# Usage:
+#   cmake -B build_riscv -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-riscv64-gnu.cmake
+#   cmake --build build_riscv
+#
+# Optional inputs:
+#   -D RISCV_TOOLCHAIN_PATH=/path/to/riscv-gnu-toolchain
+#   -D RISCV_SYSROOT=/path/to/riscv64/sysroot
+#   -D RISCV_MARCH=rv64gcv_zvfh_zvfbfwma_zvbb
+#   -D RISCV_MABI=lp64d
+#
+# Prerequisites:
+#   Download the toolchain: https://github.com/riscv-collab/riscv-gnu-toolchain/releases
+#   sudo apt install qemu-user
+#
+# Testing with QEMU:
+#   Tests will automatically run under QEMU via CMAKE_CROSSCOMPILING_EMULATOR
+#
+# To customize the architecture, set RISCV_MARCH before configuring:
+#   cmake -B build_riscv -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-riscv64-gnu.cmake -D RISCV_MARCH=rv64gcv
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+# Cross-compiler from the riscv-collab toolchain.
+# Set RISCV_TOOLCHAIN_PATH to override the default location.
+if (NOT DEFINED RISCV_TOOLCHAIN_PATH)
+    if (DEFINED ENV{RISCV_TOOLCHAIN_PATH})
+        set(RISCV_TOOLCHAIN_PATH "$ENV{RISCV_TOOLCHAIN_PATH}")
+    else ()
+        set(RISCV_TOOLCHAIN_PATH "/tmp/riscv")
+    endif ()
+endif ()
+set(RISCV_TOOLCHAIN_PATH "${RISCV_TOOLCHAIN_PATH}" CACHE PATH "RISC-V GNU toolchain root")
+set(ENV{RISCV_TOOLCHAIN_PATH} "${RISCV_TOOLCHAIN_PATH}")
+
+set(CMAKE_C_COMPILER "${RISCV_TOOLCHAIN_PATH}/bin/riscv64-unknown-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "${RISCV_TOOLCHAIN_PATH}/bin/riscv64-unknown-linux-gnu-g++")
+
+# Sysroot for the target system. By default it is derived from RISCV_TOOLCHAIN_PATH.
+if (NOT DEFINED RISCV_SYSROOT)
+    if (DEFINED ENV{RISCV_SYSROOT})
+        set(RISCV_SYSROOT "$ENV{RISCV_SYSROOT}")
+    else ()
+        set(RISCV_SYSROOT "${RISCV_TOOLCHAIN_PATH}/sysroot")
+    endif ()
+endif ()
+set(RISCV_SYSROOT "${RISCV_SYSROOT}" CACHE PATH "RISC-V sysroot for GNU cross-compilation")
+set(ENV{RISCV_SYSROOT} "${RISCV_SYSROOT}")
+set(CMAKE_SYSROOT "${RISCV_SYSROOT}")
+
+# Target architecture with Vector extension (RVV 1.0)
+# Default: Enables all extensions supported by NumKong
+#
+# Base architecture components:
+#   rv64gc  : RV64 + G (IMAFD) + C (compressed)
+#   v       : Vector extension (RVV 1.0)
+#   lp64d   : 64-bit pointers, double-precision floats in FP registers
+#
+# Common profiles:
+#   rv64gcv                     : Base RVV 1.0 only
+#   rv64gcv_zvfh                : RVV + fp16 (SiFive-class)
+#   rv64gcv_zvfh_zvfbfwma       : RVV + fp16 + bf16
+#   rv64gcv_zvfh_zvfbfwma_zvbb  : RVV + fp16 + bf16 + bit-manip (full NumKong support)
+#
+if (NOT DEFINED RISCV_MARCH)
+    if (DEFINED ENV{RISCV_MARCH})
+        set(RISCV_MARCH "$ENV{RISCV_MARCH}")
+    else ()
+        set(RISCV_MARCH "rv64gcv_zvfh_zvfbfwma_zvbb")
+    endif ()
+endif ()
+set(RISCV_MARCH "${RISCV_MARCH}" CACHE STRING "RISC-V ISA string for GNU cross-compilation")
+set(ENV{RISCV_MARCH} "${RISCV_MARCH}")
+
+if (NOT DEFINED RISCV_MABI)
+    if (DEFINED ENV{RISCV_MABI})
+        set(RISCV_MABI "$ENV{RISCV_MABI}")
+    else ()
+        set(RISCV_MABI "lp64d")
+    endif ()
+endif ()
+set(RISCV_MABI "${RISCV_MABI}" CACHE STRING "RISC-V ABI for GNU cross-compilation")
+set(ENV{RISCV_MABI} "${RISCV_MABI}")
+
+# Nested try_compile() projects re-enter this toolchain file, so forward the
+# custom cross-compilation settings explicitly.
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES RISCV_TOOLCHAIN_PATH RISCV_SYSROOT RISCV_MARCH RISCV_MABI)
+
+# Toolchain validation only needs to prove the project compiles.
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS_INIT "-march=${RISCV_MARCH} -mabi=${RISCV_MABI}")
+set(CMAKE_CXX_FLAGS_INIT "-march=${RISCV_MARCH} -mabi=${RISCV_MABI}")
+
+# QEMU user-mode emulation for running tests.
+# -L sysroot provides the dynamic linker path.
+# -cpu max enables all supported extensions, including zvfh and zvfbfwma when available.
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-riscv64;-L;${RISCV_SYSROOT};-cpu;max")
+
+# Search paths for libraries and headers (target system only).
+set(CMAKE_FIND_ROOT_PATH "${RISCV_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

package/numkong/cmake/toolchain-riscv64-llvm.cmake

@@ -0,0 +1,114 @@
+# RISC-V 64 LLVM Clang toolchain for NumKong.
+#
+# Usage:
+#   cmake -B build_riscv_llvm -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-riscv64-llvm.cmake \
+#         -D RISCV_SYSROOT=/path/to/riscv64/sysroot
+#
+# Required inputs:
+#   -D RISCV_SYSROOT=/path/to/riscv64/sysroot
+#
+# Optional inputs:
+#   -D LLVM_ROOT=/path/to/llvm
+#   -D RISCV_TARGET=riscv64-unknown-linux-gnu
+#   -D RISCV_MARCH=rv64gcv_zvfh_zvfbfwma_zvbb
+#   -D RISCV_MABI=lp64d
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+if (NOT DEFINED RISCV_SYSROOT)
+    if (DEFINED ENV{RISCV_SYSROOT})
+        set(RISCV_SYSROOT "$ENV{RISCV_SYSROOT}")
+    else ()
+        message(FATAL_ERROR "RISCV_SYSROOT must point to a riscv64 Linux sysroot for LLVM cross-compilation.")
+    endif ()
+endif ()
+set(RISCV_SYSROOT "${RISCV_SYSROOT}" CACHE PATH "RISC-V sysroot for LLVM cross-compilation")
+set(ENV{RISCV_SYSROOT} "${RISCV_SYSROOT}")
+
+if (NOT DEFINED RISCV_TARGET)
+    if (DEFINED ENV{RISCV_TARGET})
+        set(RISCV_TARGET "$ENV{RISCV_TARGET}")
+    else ()
+        set(RISCV_TARGET "riscv64-unknown-linux-gnu")
+    endif ()
+endif ()
+set(RISCV_TARGET "${RISCV_TARGET}" CACHE STRING "RISC-V target triple for LLVM cross-compilation")
+set(ENV{RISCV_TARGET} "${RISCV_TARGET}")
+
+if (NOT DEFINED RISCV_MARCH)
+    if (DEFINED ENV{RISCV_MARCH})
+        set(RISCV_MARCH "$ENV{RISCV_MARCH}")
+    else ()
+        set(RISCV_MARCH "rv64gcv_zvfh_zvfbfwma_zvbb")
+    endif ()
+endif ()
+set(RISCV_MARCH "${RISCV_MARCH}" CACHE STRING "RISC-V ISA string for LLVM cross-compilation")
+set(ENV{RISCV_MARCH} "${RISCV_MARCH}")
+
+if (NOT DEFINED RISCV_MABI)
+    if (DEFINED ENV{RISCV_MABI})
+        set(RISCV_MABI "$ENV{RISCV_MABI}")
+    else ()
+        set(RISCV_MABI "lp64d")
+    endif ()
+endif ()
+set(RISCV_MABI "${RISCV_MABI}" CACHE STRING "RISC-V ABI for LLVM cross-compilation")
+set(ENV{RISCV_MABI} "${RISCV_MABI}")
+
+if (NOT DEFINED LLVM_ROOT)
+    if (DEFINED ENV{LLVM_ROOT})
+        set(LLVM_ROOT "$ENV{LLVM_ROOT}")
+    elseif (EXISTS "/opt/homebrew/opt/llvm/bin/clang")
+        set(LLVM_ROOT "/opt/homebrew/opt/llvm")
+    elseif (EXISTS "/usr/local/opt/llvm/bin/clang")
+        set(LLVM_ROOT "/usr/local/opt/llvm")
+    endif ()
+endif ()
+if (DEFINED LLVM_ROOT)
+    set(LLVM_ROOT "${LLVM_ROOT}" CACHE PATH "LLVM toolchain root for cross-compilation")
+    set(ENV{LLVM_ROOT} "${LLVM_ROOT}")
+endif ()
+
+# Nested try_compile() projects re-enter this toolchain file, so forward the
+# custom cross-compilation settings explicitly.
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES LLVM_ROOT RISCV_SYSROOT RISCV_TARGET RISCV_MARCH RISCV_MABI)
+
+# Toolchain validation only needs to prove the project compiles.
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+if (DEFINED LLVM_ROOT)
+    set(_NK_LLVM_BIN "${LLVM_ROOT}/bin")
+    set(CMAKE_C_COMPILER "${_NK_LLVM_BIN}/clang")
+    set(CMAKE_CXX_COMPILER "${_NK_LLVM_BIN}/clang++")
+    set(CMAKE_AR "${_NK_LLVM_BIN}/llvm-ar")
+    set(CMAKE_RANLIB "${_NK_LLVM_BIN}/llvm-ranlib")
+    if (EXISTS "${_NK_LLVM_BIN}/ld.lld")
+        set(CMAKE_LINKER "${_NK_LLVM_BIN}/ld.lld")
+    endif ()
+else ()
+    find_program(CMAKE_C_COMPILER clang REQUIRED)
+    find_program(CMAKE_CXX_COMPILER clang++ REQUIRED)
+    find_program(CMAKE_AR llvm-ar REQUIRED)
+    find_program(CMAKE_RANLIB llvm-ranlib REQUIRED)
+    find_program(CMAKE_LINKER ld.lld)
+endif ()
+
+set(CMAKE_SYSROOT "${RISCV_SYSROOT}")
+set(CMAKE_C_COMPILER_TARGET "${RISCV_TARGET}")
+set(CMAKE_CXX_COMPILER_TARGET "${RISCV_TARGET}")
+
+set(_NK_RISCV_FLAGS "--target=${RISCV_TARGET} --sysroot=${RISCV_SYSROOT} -march=${RISCV_MARCH} -mabi=${RISCV_MABI}")
+set(CMAKE_C_FLAGS_INIT "${_NK_RISCV_FLAGS}")
+set(CMAKE_CXX_FLAGS_INIT "${_NK_RISCV_FLAGS}")
+
+find_program(_NK_QEMU_RISCV64 qemu-riscv64)
+if (_NK_QEMU_RISCV64)
+    set(CMAKE_CROSSCOMPILING_EMULATOR "${_NK_QEMU_RISCV64};-L;${RISCV_SYSROOT};-cpu;max")
+endif ()
+
+set(CMAKE_FIND_ROOT_PATH "${RISCV_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

package/numkong/cmake/toolchain-wasi.cmake

@@ -0,0 +1,77 @@
+# WASI toolchain for NumKong (standalone WASM runtimes such as Wasmer and Wasmtime).
+# Usage: cmake -B build-wasi -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-wasi.cmake -DNK_BUILD_TEST=ON
+
+set(CMAKE_SYSTEM_NAME WASI)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR wasm32)
+
+# Locate the WASI SDK.
+if (NOT DEFINED WASI_SDK_PATH)
+    if (DEFINED ENV{WASI_SDK_PATH})
+        set(WASI_SDK_PATH "$ENV{WASI_SDK_PATH}")
+    elseif (EXISTS "$ENV{HOME}/wasi-sdk")
+        set(WASI_SDK_PATH "$ENV{HOME}/wasi-sdk")
+    else ()
+        message(
+            FATAL_ERROR
+                "WASI_SDK_PATH not set and ~/wasi-sdk not found.\n"
+                "Download from: https://github.com/WebAssembly/wasi-sdk/releases\n"
+                "Then set: export WASI_SDK_PATH=~/wasi-sdk"
+        )
+    endif ()
+endif ()
+
+file(TO_CMAKE_PATH "${WASI_SDK_PATH}" WASI_SDK_PATH)
+
+# Windows SDK archives ship executable suffixes that Unix hosts do not use.
+if (CMAKE_HOST_WIN32)
+    set(WASI_TOOL_SUFFIX ".exe")
+else ()
+    set(WASI_TOOL_SUFFIX "")
+endif ()
+
+# Set compilers.
+set(CMAKE_C_COMPILER "${WASI_SDK_PATH}/bin/clang${WASI_TOOL_SUFFIX}")
+set(CMAKE_CXX_COMPILER "${WASI_SDK_PATH}/bin/clang++${WASI_TOOL_SUFFIX}")
+set(CMAKE_AR "${WASI_SDK_PATH}/bin/llvm-ar${WASI_TOOL_SUFFIX}")
+set(CMAKE_RANLIB "${WASI_SDK_PATH}/bin/llvm-ranlib${WASI_TOOL_SUFFIX}")
+set(CMAKE_SYSROOT "${WASI_SDK_PATH}/share/wasi-sysroot")
+set(CMAKE_FIND_ROOT_PATH "${WASI_SDK_PATH}")
+
+# WASM SIMD flags (same as Emscripten for consistency).
+set(WASM_SIMD_FLAGS "-msimd128 -mrelaxed-simd")
+set(CMAKE_C_FLAGS_INIT "${WASM_SIMD_FLAGS} --target=wasm32-wasip1-threads -pthread")
+set(CMAKE_CXX_FLAGS_INIT "${WASM_SIMD_FLAGS} --target=wasm32-wasip1-threads -pthread -fno-exceptions")
+
+# Optimization flags.
+set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+
+# Linker flags for WASI.
+set(CMAKE_EXE_LINKER_FLAGS_INIT
+    "-Wl,--allow-undefined \
+     -Wl,--import-memory -Wl,--export-memory \
+     -Wl,--shared-memory -Wl,--max-memory=2147483648 \
+     -Wl,--export=main \
+     -Wl,--export=_start"
+)
+
+# Do not look for programs in build-host directories.
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Verify the WASI SDK version.
+if (EXISTS "${WASI_SDK_PATH}/VERSION")
+    file(READ "${WASI_SDK_PATH}/VERSION" WASI_SDK_VERSION)
+    string(STRIP "${WASI_SDK_VERSION}" WASI_SDK_VERSION)
+    message(STATUS "NumKong WASI: WASI-SDK ${WASI_SDK_VERSION}")
+else ()
+    message(STATUS "NumKong WASI: WASI-SDK version unknown")
+endif ()
+
+message(STATUS "NumKong WASI: SIMD128 and Relaxed SIMD enabled")
+message(STATUS "NumKong WASI: Toolchain at ${WASI_SDK_PATH}")

package/numkong/cmake/toolchain-wasm.cmake

@@ -0,0 +1,70 @@
+# WASM/Emscripten toolchain for NumKong.
+# Usage: cmake -B build-wasm -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-wasm.cmake
+
+set(CMAKE_SYSTEM_NAME Emscripten)
+set(CMAKE_SYSTEM_PROCESSOR wasm32)
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+# Verify the Emscripten SDK.
+if (NOT DEFINED ENV{EMSDK})
+    message(
+        FATAL_ERROR
+            "EMSDK environment variable not set.\n"
+            "Install Emscripten: https://emscripten.org/docs/getting_started/downloads.html\n"
+            "Then run: source $EMSDK/emsdk_env.sh"
+    )
+endif ()
+
+# Set compilers.
+set(EMSCRIPTEN_ROOT "$ENV{EMSDK}/upstream/emscripten")
+file(TO_CMAKE_PATH "${EMSCRIPTEN_ROOT}" EMSCRIPTEN_ROOT)
+
+if (CMAKE_HOST_WIN32)
+    set(EMSCRIPTEN_TOOL_SUFFIX ".bat")
+else ()
+    set(EMSCRIPTEN_TOOL_SUFFIX "")
+endif ()
+
+set(CMAKE_C_COMPILER "${EMSCRIPTEN_ROOT}/emcc${EMSCRIPTEN_TOOL_SUFFIX}")
+set(CMAKE_CXX_COMPILER "${EMSCRIPTEN_ROOT}/em++${EMSCRIPTEN_TOOL_SUFFIX}")
+set(CMAKE_AR "${EMSCRIPTEN_ROOT}/emar${EMSCRIPTEN_TOOL_SUFFIX}")
+set(CMAKE_RANLIB "${EMSCRIPTEN_ROOT}/emranlib${EMSCRIPTEN_TOOL_SUFFIX}")
+
+# Required WASM SIMD flags.
+set(WASM_SIMD_FLAGS "-msimd128 -mrelaxed-simd")
+set(CMAKE_C_FLAGS_INIT "${WASM_SIMD_FLAGS}")
+set(CMAKE_CXX_FLAGS_INIT "${WASM_SIMD_FLAGS}")
+
+# Enable GNU extensions for EM_ASM support (required for runtime detection).
+set(CMAKE_C_EXTENSIONS ON CACHE BOOL "" FORCE)
+set(CMAKE_CXX_EXTENSIONS ON CACHE BOOL "" FORCE)
+
+# Optimization.
+set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+
+# Linker flags for Node.js execution.
+set(CMAKE_EXE_LINKER_FLAGS_INIT
+    "-sALLOW_MEMORY_GROWTH=1 \
+     -sIMPORTED_MEMORY=1 \
+     -sINITIAL_MEMORY=64MB \
+     -sMAXIMUM_MEMORY=2GB \
+     -sSTACK_SIZE=5MB \
+     -sEXPORTED_FUNCTIONS=['_main'] \
+     -sEXPORTED_RUNTIME_METHODS=['ccall','cwrap']"
+)
+
+# Verify the Emscripten version (3.1.27+ recommended for relaxed SIMD).
+execute_process(
+    COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE EMCC_VERSION_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" EMCC_VERSION "${EMCC_VERSION_OUTPUT}")
+
+if (EMCC_VERSION VERSION_LESS "3.1.27")
+    message(WARNING "Emscripten ${EMCC_VERSION} < 3.1.27. Upgrade recommended for relaxed SIMD.")
+endif ()
+
+message(STATUS "NumKong WASM: Emscripten ${EMCC_VERSION}")
+message(STATUS "NumKong WASM: Relaxed SIMD enabled")

package/numkong/cmake/toolchain-wasm64.cmake

@@ -0,0 +1,62 @@
+# WASM64/Emscripten Memory64 toolchain for NumKong.
+# Usage: cmake -B build-wasm64 -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-wasm64.cmake
+
+set(CMAKE_SYSTEM_NAME Emscripten)
+set(CMAKE_SYSTEM_PROCESSOR wasm64)
+
+# Verify the Emscripten SDK.
+if (NOT DEFINED ENV{EMSDK})
+    message(
+        FATAL_ERROR
+            "EMSDK environment variable not set.\n"
+            "Install Emscripten: https://emscripten.org/docs/getting_started/downloads.html\n"
+            "Then run: source $EMSDK/emsdk_env.sh"
+    )
+endif ()
+
+# Set compilers.
+set(EMSCRIPTEN_ROOT "$ENV{EMSDK}/upstream/emscripten")
+set(CMAKE_C_COMPILER "${EMSCRIPTEN_ROOT}/emcc")
+set(CMAKE_CXX_COMPILER "${EMSCRIPTEN_ROOT}/em++")
+set(CMAKE_AR "${EMSCRIPTEN_ROOT}/emar")
+set(CMAKE_RANLIB "${EMSCRIPTEN_ROOT}/emranlib")
+
+# Required WASM SIMD flags and Memory64.
+set(WASM_SIMD_FLAGS "-msimd128 -mrelaxed-simd")
+set(CMAKE_C_FLAGS_INIT "${WASM_SIMD_FLAGS} -sMEMORY64=1")
+set(CMAKE_CXX_FLAGS_INIT "${WASM_SIMD_FLAGS} -sMEMORY64=1")
+
+# Enable GNU extensions for EM_ASM support (required for runtime detection).
+set(CMAKE_C_EXTENSIONS ON CACHE BOOL "" FORCE)
+set(CMAKE_CXX_EXTENSIONS ON CACHE BOOL "" FORCE)
+
+# Optimization.
+set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+
+# Linker flags for Node.js execution (larger memory limits for 64-bit).
+set(CMAKE_EXE_LINKER_FLAGS_INIT
+    "-s MEMORY64=1 \
+     -s ALLOW_MEMORY_GROWTH=1 \
+     -s IMPORTED_MEMORY=1 \
+     -s INITIAL_MEMORY=256MB \
+     -s MAXIMUM_MEMORY=16GB \
+     -s STACK_SIZE=5MB \
+     -s EXPORTED_FUNCTIONS='[\"_main\"]' \
+     -s EXPORTED_RUNTIME_METHODS='[\"ccall\",\"cwrap\"]'"
+)
+
+# Verify the Emscripten version (3.1.35+ recommended for Memory64).
+execute_process(
+    COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE EMCC_VERSION_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" EMCC_VERSION "${EMCC_VERSION_OUTPUT}")
+
+if (EMCC_VERSION VERSION_LESS "3.1.35")
+    message(WARNING "Emscripten ${EMCC_VERSION} < 3.1.35. Upgrade recommended for Memory64 support.")
+endif ()
+
+message(STATUS "NumKong WASM64: Emscripten ${EMCC_VERSION}")
+message(STATUS "NumKong WASM64: Relaxed SIMD + Memory64 enabled")

package/numkong/cmake/toolchain-x86_64-llvm.cmake

@@ -0,0 +1,47 @@
+# x86_64 LLVM Clang toolchain for NumKong.
+#
+# Native x86_64 hosts use this as a pinned LLVM toolchain.
+# Apple Silicon hosts use it to target x86_64 macOS via `-arch x86_64`.
+
+if (NOT DEFINED LLVM_ROOT)
+    if (EXISTS "/opt/homebrew/opt/llvm/bin/clang")
+        set(LLVM_ROOT "/opt/homebrew/opt/llvm")
+    elseif (EXISTS "/usr/local/opt/llvm/bin/clang")
+        set(LLVM_ROOT "/usr/local/opt/llvm")
+    endif ()
+endif ()
+
+if (DEFINED LLVM_ROOT)
+    set(_NK_LLVM_BIN "${LLVM_ROOT}/bin")
+    set(CMAKE_C_COMPILER "${_NK_LLVM_BIN}/clang")
+    set(CMAKE_CXX_COMPILER "${_NK_LLVM_BIN}/clang++")
+    set(CMAKE_AR "${_NK_LLVM_BIN}/llvm-ar")
+    set(CMAKE_RANLIB "${_NK_LLVM_BIN}/llvm-ranlib")
+    if (EXISTS "${_NK_LLVM_BIN}/ld.lld")
+        set(CMAKE_LINKER "${_NK_LLVM_BIN}/ld.lld")
+    endif ()
+else ()
+    find_program(CMAKE_C_COMPILER clang REQUIRED)
+    find_program(CMAKE_CXX_COMPILER clang++ REQUIRED)
+    find_program(CMAKE_AR llvm-ar REQUIRED)
+    find_program(CMAKE_RANLIB llvm-ranlib REQUIRED)
+    find_program(CMAKE_LINKER ld.lld)
+endif ()
+
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+if (APPLE)
+    set(CMAKE_SYSTEM_NAME Darwin)
+    set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "Target macOS architecture" FORCE)
+    set(CMAKE_C_FLAGS_INIT "-arch x86_64")
+    set(CMAKE_CXX_FLAGS_INIT "-arch x86_64")
+
+    if (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+        find_program(_NK_ARCH_PROGRAM arch)
+        if (_NK_ARCH_PROGRAM)
+            set(CMAKE_CROSSCOMPILING_EMULATOR "${_NK_ARCH_PROGRAM};-x86_64")
+        endif ()
+    endif ()
+else ()
+    set(CMAKE_SYSTEM_NAME "${CMAKE_HOST_SYSTEM_NAME}")
+endif ()