QVAC-13445: Feature media generation

.github/workflows/integration-test-lib-infer-diffusion.yml

@@ -23,7 +23,7 @@ on:
 
 jobs:
   run-integration-tests:
-    timeout-minutes: 360
+    timeout-minutes: ${{ matrix.timeout || 360 }}
     continue-on-error: true
     runs-on: ${{ matrix.runner }}
     name: test-${{ matrix.platform }}-${{ matrix.arch }}
@@ -72,6 +72,7 @@ jobs:
             platform: win32
             arch: x64
             runner: ai-run-windows11-gpu
+            timeout: 600
 
     steps:
       - name: Setup Node.js
@@ -238,6 +239,33 @@ jobs:
         shell: bash
         run: sudo apt-get update && sudo apt-get install -y mesa-vulkan-drivers
 
+      - name: macOS — Metal GPU diagnostic
+        if: matrix.platform == 'darwin'
+        shell: bash
+        run: |
+          echo "=== GPU Hardware ==="
+          system_profiler SPDisplaysDataType 2>/dev/null || echo "(system_profiler unavailable)"
+          echo ""
+          echo "=== Metal Device Check ==="
+          cat > /tmp/metal_check.m << 'OBJC'
+          #import <Metal/Metal.h>
+          #import <stdio.h>
+          int main() {
+            id<MTLDevice> dev = MTLCreateSystemDefaultDevice();
+            if (!dev) { printf("No Metal device available\n"); return 1; }
+            printf("Device    : %s\n", [[dev name] UTF8String]);
+            printf("Headless  : %s\n", dev.headless ? "yes" : "no");
+            printf("LowPower  : %s\n", dev.lowPower ? "yes" : "no");
+            printf("Apple4    : %d\n", [dev supportsFamily:MTLGPUFamilyApple4]);
+            printf("Apple7    : %d\n", [dev supportsFamily:MTLGPUFamilyApple7]);
+            printf("Metal3    : %d\n", [dev supportsFamily:MTLGPUFamilyMetal3]);
+            printf("simdgroup : %d\n", [dev supportsFamily:MTLGPUFamilyApple7]);
+            return 0;
+          }
+          OBJC
+          clang -x objective-c -framework Metal -framework Foundation \
+                -o /tmp/metal_check /tmp/metal_check.m 2>/dev/null && /tmp/metal_check || echo "(Metal check failed to compile/run)"
+
       - name: Run integration test (Linux/macOS)
         if: ${{ matrix.platform != 'win32' }}
         working-directory: ${{ env.WORKDIR }}

.github/workflows/prebuilds-lib-infer-diffusion.yml

@@ -403,7 +403,7 @@ jobs:
         working-directory: ${{ env.WORKDIR }}
         run: |
           if [[ "${{ matrix.platform }}" == "android" ]]; then
-            find prebuilds -name "*.bare" -exec $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip {} \;
+            find prebuilds \( -name "*.bare" -o -name "*.so" \) -exec $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip {} \;
           elif [[ "${{ matrix.platform }}" == "darwin" || "${{ matrix.platform }}" == "ios" ]]; then
             find prebuilds -name "*.bare" -exec strip -S {} \;
           else

packages/lib-infer-diffusion/.gitignore

@@ -0,0 +1,26 @@
+.vs/
+build/
+dist/
+models/
+store/
+node_modules/
+prebuilds/
+
+.npmrc
+package-lock.json
+.cache/
+.idea/
+**/store/
+.DS_Store
+logs/
+*.gguf
+*.safetensors
+*.ckpt
+*.log
+.clang-tidy
+# Added by qvac-lint-cpp
+.clang-format
+output/
+temp/
+*.deb
+test/integration/all.js

packages/lib-infer-diffusion/.lsan-suppressions.txt

@@ -0,0 +1,3 @@
+# Known false positive with N-API callbacks under ASan
+leak:SdModel::process
+leak:SdModel::load

packages/lib-infer-diffusion/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## [0.1.0] - 2026-03-19
+
+### Added
+
+#### Stable Diffusion inference addon
+
+Initial release of the `@qvac/diffusion-cpp` native addon for image generation, supporting SD1.x, SD2.x, SDXL, SD3, and FLUX model families.
+
+#### GPU acceleration
+
+- Metal backend on macOS, iOS
+- Vulkan backends on Windows, Linux, Android
+- OpenCL backend on Android devices with Adreno GPU
+- CPU fallback on all platforms
+
+#### Android dynamic backend loading
+
+Dynamic ggml backend loading (`GGML_BACKEND_DL`) on Android with `libqvac-diffusion-ggml-*` naming to avoid symbol conflicts with system-installed ggml libraries. CPU backends remain statically linked (`GGML_CPU_STATIC`) while GPU backends are loaded at runtime.
+
+#### vcpkg-based build system
+
+vcpkg overlay ports for `ggml` and `stable-diffusion-cpp` with clang override triplets for Linux and PIC static linking. Custom patches for runtime backend selection, abort callbacks, failure-path cleanup, and Android Vulkan diagnostics.

packages/lib-infer-diffusion/CMakeLists.txt

@@ -0,0 +1,145 @@
+cmake_minimum_required(VERSION 3.25)
+
+option(ANDROID_STL "Android STL linkage" c++_shared)
+option(BUILD_TESTING "Build tests" OFF)
+if(BUILD_TESTING)
+  list(APPEND VCPKG_MANIFEST_FEATURES "tests")
+endif()
+
+option(SD_CUDA "Enable CUDA GPU backend" OFF)
+if(SD_CUDA)
+  list(APPEND VCPKG_MANIFEST_FEATURES "cuda")
+endif()
+
+option(SD_OPENCL "Enable OpenCL GPU backend (Android/Adreno)" OFF)
+if(SD_OPENCL)
+  list(APPEND VCPKG_MANIFEST_FEATURES "opencl")
+endif()
+
+# Vulkan and Metal are auto-enabled via default-features in the ggml and
+# stable-diffusion-cpp overlay ports.  CUDA requires a specific build machine
+# so it remains opt-in via SD_CUDA.
+#
+# GGML_BACKEND_DL is ON only on Android (set in the ggml portfile), mirroring
+# qvac-fabric. On Linux/macOS/Windows GPU backends are statically linked.
+
+find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
+find_package(cmake-vcpkg REQUIRED PATHS node_modules/cmake-vcpkg)
+
+set(VCPKG_OVERLAY_TRIPLETS "${CMAKE_CURRENT_SOURCE_DIR}/vcpkg/triplets;${VCPKG_OVERLAY_TRIPLETS}")
+
+project(qvac-lib-inference-addon-sd C CXX)
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  add_compile_options(-stdlib=libc++)
+  add_link_options(-stdlib=libc++ -static-libstdc++)
+endif()
+
+find_path(VCPKG_INSTALLED_PATH share/qvac-lint-cpp/.clang-format REQUIRED)
+configure_file(${VCPKG_INSTALLED_PATH}/share/qvac-lint-cpp/.clang-format
+               ${CMAKE_CURRENT_SOURCE_DIR}/.clang-format COPYONLY)
+configure_file(${VCPKG_INSTALLED_PATH}/share/qvac-lint-cpp/.clang-tidy
+               ${CMAKE_CURRENT_SOURCE_DIR}/.clang-tidy COPYONLY)
+
+find_path(PICOJSON_INCLUDE_DIRS "picojson/picojson.h")
+find_path(QVAC_LIB_INFERENCE_ADDON_CPP_INCLUDE_DIRS "qvac-lib-inference-addon-cpp/JsInterface.hpp")
+
+# stable-diffusion.cpp – uses the CMake config installed by the overlay port
+find_package(stable-diffusion-cpp CONFIG REQUIRED)
+
+# ggml is installed alongside stable-diffusion.cpp as separate static libs.
+# stable-diffusion.a references ggml symbols externally, so we must link them.
+find_package(ggml CONFIG REQUIRED)
+
+find_path(STB_IMAGE_WRITE_INCLUDE_DIR "stb_image_write.h" REQUIRED)
+
+if(WIN32)
+  add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -DNOGDI)
+endif()
+
+bare_target(bare_target_value)
+bare_module_target("." unused_target NAME module_name VERSION unused_version)
+set(BACKENDS_SUBDIR_VALUE "${bare_target_value}/${module_name}")
+message("Building qvac-lib-inference-addon-sd with BACKENDS_SUBDIR='${BACKENDS_SUBDIR_VALUE}'")
+
+# On Android with GGML_BACKEND_DL, install GPU backend .so modules alongside
+# the addon so ggml can dlopen them at runtime.  CPU backends are statically
+# linked (GGML_CPU_STATIC) and excluded from this loop.
+set(BACKEND_DL_EXPORTS "")
+if(ANDROID AND GGML_BACKEND_DL)
+  foreach(_backend ${GGML_AVAILABLE_BACKENDS})
+    if("${_backend}" MATCHES "^ggml-cpu")
+      continue()
+    endif()
+    # qvac ggml overlays prefix backend module filenames (e.g.
+    # libqvac-ggml-vulkan.so / libqvac-diffusion-ggml-vulkan.so). These
+    # modules are installed under vcpkg's bin/ directory on Android.
+    find_library(_${_backend}_LIB NAMES
+      "qvac-diffusion-${_backend}"
+      "${_backend}"
+      PATHS
+        "${VCPKG_INSTALLED_PATH}/bin"
+        "${VCPKG_INSTALLED_PATH}/lib"
+      REQUIRED)
+    add_library(ggml::${_backend} SHARED IMPORTED)
+    set_target_properties(ggml::${_backend} PROPERTIES
+      IMPORTED_LOCATION "${_${_backend}_LIB}"
+      IMPORTED_NO_SONAME TRUE)
+    list(APPEND BACKEND_DL_EXPORTS INSTALL TARGET ggml::${_backend})
+  endforeach()
+endif()
+
+add_bare_module(qvac-lib-inference-addon-sd EXPORTS ${BACKEND_DL_EXPORTS})
+  set(ADDON_SOURCES
+    ${PROJECT_SOURCE_DIR}/addon/src/js-interface/binding.cpp
+    ${PROJECT_SOURCE_DIR}/addon/src/handlers/SdCtxHandlers.cpp
+    ${PROJECT_SOURCE_DIR}/addon/src/handlers/SdGenHandlers.cpp
+    ${PROJECT_SOURCE_DIR}/addon/src/model-interface/SdModel.cpp
+    ${PROJECT_SOURCE_DIR}/addon/src/utils/LoggingMacros.cpp
+    ${PROJECT_SOURCE_DIR}/addon/src/utils/BackendSelection.cpp
+  )
+
+  target_sources(
+    ${qvac-lib-inference-addon-sd}
+    PRIVATE
+      ${ADDON_SOURCES}
+  )
+
+  target_include_directories(
+    ${qvac-lib-inference-addon-sd}
+    PRIVATE
+      ${PICOJSON_INCLUDE_DIRS}
+      ${QVAC_LIB_INFERENCE_ADDON_CPP_INCLUDE_DIRS}
+      ${STB_IMAGE_WRITE_INCLUDE_DIR}
+      ${PROJECT_SOURCE_DIR}/addon/src
+  )
+
+  target_link_libraries(
+    ${qvac-lib-inference-addon-sd}
+    PRIVATE
+      stable-diffusion::stable-diffusion
+  )
+
+target_compile_features(${qvac-lib-inference-addon-sd} PRIVATE cxx_std_20)
+target_compile_definitions(${qvac-lib-inference-addon-sd} PUBLIC JS_LOGGER)
+target_compile_definitions(${qvac-lib-inference-addon-sd} PRIVATE BACKENDS_SUBDIR="${BACKENDS_SUBDIR_VALUE}")
+
+if(GGML_BACKEND_DL)
+  target_compile_definitions(${qvac-lib-inference-addon-sd} PRIVATE GGML_BACKEND_DL)
+endif()
+
+if(BUILD_TESTING)
+  find_package(GTest CONFIG REQUIRED)
+  include(GoogleTest)
+  enable_testing()
+  add_subdirectory(test/unit)
+endif()
+
+if(WIN32)
+  target_link_libraries(
+    ${qvac-lib-inference-addon-sd}
+    PRIVATE
+      msvcrt.lib
+  )
+endif()
+