ci.yml

---
name: CI
permissions: {}

on:
  pull_request:
  push:
    branches:
      - master

concurrency:
  group: "${{ github.workflow }}-${{ github.ref }}"
  cancel-in-progress: true

env:
  OPENCPPCOVERAGE_VERSION: '0.9.9.0'
  PYTHON_VERSION: '3.14'

jobs:
  setup_release:
    name: Setup Release
    outputs:
      publish_release: ${{ steps.setup_release.outputs.publish_release }}
      release_body: ${{ steps.setup_release.outputs.release_body }}
      release_commit: ${{ steps.setup_release.outputs.release_commit }}
      release_generate_release_notes: ${{ steps.setup_release.outputs.release_generate_release_notes }}
      release_tag: ${{ steps.setup_release.outputs.release_tag }}
      release_version: ${{ steps.setup_release.outputs.release_version }}
    permissions:
      contents: write
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3

      - name: Setup Release
        id: setup_release
        uses: LizardByte/actions/actions/release_setup@a46850981292c4bbc0c41715f286ad95adaaaf4a  # v2026.625.20301
        with:
          dotnet: true
          github_token: ${{ secrets.GITHUB_TOKEN }}

  build:
    name: Build (${{ matrix.name }})
    needs: setup_release
    permissions:
      contents: read
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: ${{ matrix.shell }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: Linux-GCC
            os: ubuntu-latest
            shell: bash
            kind: unix
            cc: gcc
            cxx: g++
            gcov_executable: gcov
          - name: Linux-Clang
            os: ubuntu-latest
            shell: bash
            kind: unix
            cc: clang
            cxx: clang++
            # Clang writes LLVM coverage notes, so gcovr needs llvm-cov's gcov compatibility mode.
            gcov_executable: llvm-cov gcov
          - name: macOS
            os: macos-latest
            shell: bash
            kind: unix
            cc: clang
            cxx: clang++
            gcov_executable: gcov
          - name: Windows-MinGW-UCRT64
            os: windows-latest
            shell: msys2 {0}
            kind: msys2
            cc: gcc
            cxx: g++
            msystem: ucrt64
            toolchain: ucrt-x86_64
            gcov_executable: gcov
          - name: Windows-MSVC
            os: windows-2022
            shell: pwsh
            kind: msvc
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3
        with:
          submodules: recursive

      - name: Setup Dependencies Linux
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            build-essential \
            clang \
            cmake \
            libevdev-dev \
            libinput-dev \
            libsdl2-dev \
            libx11-dev \
            libxtst-dev \
            llvm \
            ninja-build \
            pkg-config
          kernel_modules_package="linux-modules-extra-$(uname -r)"
          if apt-cache show "${kernel_modules_package}" >/dev/null 2>&1; then
            sudo apt-get install -y "${kernel_modules_package}"
          else
            echo "::warning::${kernel_modules_package} is unavailable; relying on the runner image kernel modules."
          fi
          sudo tee /etc/udev/rules.d/99-libvirtualhid-ci.rules >/dev/null <<'EOF'
          KERNEL=="hidraw*", ATTRS{name}=="libvirtualhid*", MODE="0666", TAG+="uaccess"
          SUBSYSTEMS=="input", ATTRS{name}=="libvirtualhid*", MODE="0666", TAG+="uaccess"
          EOF
          sudo udevadm control --reload-rules
          for module in uhid uinput; do
            if ! sudo modprobe "${module}"; then
              message="Unable to load ${module}; tests requiring /dev/${module}"
              message="${message} will fail unless the device already exists."
              echo "::warning::${message}"
            fi
          done
          for node in /dev/uhid /dev/uinput; do
            if [[ -e "${node}" ]]; then
              sudo chmod a+rw "${node}"
            else
              echo "::error::${node} does not exist after module setup."
              exit 1
            fi
          done

      - name: Setup Dependencies macOS
        if: runner.os == 'macOS'
        run: |
          brew install \
            cmake \
            ninja

      - name: Setup Dependencies Windows MinGW
        if: matrix.kind == 'msys2'
        uses: msys2/setup-msys2@66cd2cce69caa17b53920067426061ca1de3a884  # v2.32.0
        with:
          msystem: ${{ matrix.msystem }}
          update: true
          install: >-
            mingw-w64-${{ matrix.toolchain }}-cmake
            mingw-w64-${{ matrix.toolchain }}-ninja
            mingw-w64-${{ matrix.toolchain }}-toolchain

      - name: Setup Dependencies Windows MSVC
        if: matrix.kind == 'msvc'
        run: |
          choco install opencppcoverage --version=${{ env.OPENCPPCOVERAGE_VERSION }} --yes --no-progress

          $openCppCoverageDir = "${env:ProgramFiles}\OpenCppCoverage"
          if (!(Test-Path (Join-Path $openCppCoverageDir "OpenCppCoverage.exe"))) {
            $openCppCoverageDir = "${env:ProgramFiles(x86)}\OpenCppCoverage"
          }
          if (!(Test-Path (Join-Path $openCppCoverageDir "OpenCppCoverage.exe"))) {
            throw "OpenCppCoverage.exe was not found after Chocolatey install."
          }

          $openCppCoverageDir | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

      - name: Setup python
        id: setup-python
        if: matrix.kind != 'msvc'
        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: Setup uv
        if: matrix.kind != 'msvc'
        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39  # v8.2.0
        with:
          enable-cache: true

      - name: Sync Python tools
        if: matrix.kind != 'msvc'
        env:
          MSYS2_PATH_TYPE: inherit
          UV_PYTHON: ${{ steps.setup-python.outputs.python-path }}
        run: |
          uv sync --project third-party/lizardbyte-common --locked --only-group test-c \
            --no-python-downloads \
            --no-install-project

      - name: Configure
        if: matrix.kind != 'msvc'
        env:
          BRANCH: ${{ github.head_ref || github.ref_name }}
          BUILD_VERSION: ${{ needs.setup_release.outputs.release_version }}
          CC: ${{ matrix.cc }}
          COMMIT: ${{ needs.setup_release.outputs.release_commit }}
          CXX: ${{ matrix.cxx }}
        run: |
          cmake \
            -DBUILD_DOCS=OFF \
            -DBUILD_EXAMPLES=ON \
            -DBUILD_TESTS=ON \
            -DCMAKE_BUILD_TYPE:STRING=Debug \
            -B cmake-build-ci \
            -G Ninja \
            -S .

      - name: Configure MSVC
        if: matrix.kind == 'msvc'
        env:
          BRANCH: ${{ github.head_ref || github.ref_name }}
          BUILD_VERSION: ${{ needs.setup_release.outputs.release_version }}
          COMMIT: ${{ needs.setup_release.outputs.release_commit }}
        run: |
          cmake `
            -DBUILD_DOCS=OFF `
            -DBUILD_EXAMPLES=ON `
            -DBUILD_TESTS=ON `
            -A x64 `
            -B cmake-build-ci `
            -G "Visual Studio 17 2022" `
            -S .

      - name: Build
        if: matrix.kind != 'msvc'
        run: cmake --build cmake-build-ci -- -j2

      - name: Build MSVC
        if: matrix.kind == 'msvc'
        run: cmake --build cmake-build-ci --config Debug --parallel 2

      - name: Configure Windows test driver package
        if: >-
          matrix.kind == 'msvc' &&
          github.event_name == 'pull_request'
        env:
          BRANCH: ${{ github.head_ref || github.ref_name }}
          BUILD_VERSION: ${{ needs.setup_release.outputs.release_version }}
          COMMIT: ${{ needs.setup_release.outputs.release_commit }}
        run: |
          $certificatePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver-test\certificates\libvirtualhid-ci-test.cer"
          cmake `
            -DBUILD_DOCS=OFF `
            -DBUILD_EXAMPLES=OFF `
            -DBUILD_TESTS=OFF `
            -DLIBVIRTUALHID_BUILD_WINDOWS_DRIVER=ON `
            -DLIBVIRTUALHID_ENABLE_PACKAGING=OFF `
            "-DLIBVIRTUALHID_DRIVER_TEST_CERTIFICATE=$certificatePath" `
            -A x64 `
            -B cmake-build-driver-test `
            -G "Visual Studio 17 2022" `
            -S .

      - name: Build Windows test driver package
        if: >-
          matrix.kind == 'msvc' &&
          github.event_name == 'pull_request'
        run: cmake --build cmake-build-driver-test --config Release --target libvirtualhid_windows_catalog --parallel 2

      - name: Sign Windows test driver package
        if: >-
          matrix.kind == 'msvc' &&
          github.event_name == 'pull_request'
        run: |
          $packagePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver-test\src\platform\windows\driver\package\Release"
          $certificatePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver-test\certificates\libvirtualhid-ci-test.cer"
          .\scripts\windows\sign-driver-package.ps1 `
            -PackagePath $packagePath `
            -CertificatePath $certificatePath

      - name: Install Windows test driver package
        if: >-
          matrix.kind == 'msvc' &&
          github.event_name == 'pull_request'
        run: |
          $packagePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver-test\src\platform\windows\driver\package\Release"
          $certificatePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver-test\certificates\libvirtualhid-ci-test.cer"
          .\scripts\windows\install-driver.ps1 `
            -InfPath (Join-Path $packagePath "libvirtualhid.inf") `
            -CertificatePath $certificatePath

      - name: Prepare report directory
        run: cmake -E make_directory cmake-build-ci/reports

      - name: Run tests
        id: test
        if: matrix.kind != 'msvc'
        working-directory: cmake-build-ci/tests
        run: ./test_libvirtualhid --gtest_color=yes --gtest_output=xml:../reports/junit.xml

      - name: Run tests MSVC
        id: test_msvc
        if: matrix.kind == 'msvc'
        run: |
          $openCppCoverage = (Get-Command OpenCppCoverage.exe -ErrorAction SilentlyContinue).Source
          if (!$openCppCoverage) {
            $candidates = @(
              "${env:ProgramFiles}\OpenCppCoverage\OpenCppCoverage.exe",
              "${env:ProgramFiles(x86)}\OpenCppCoverage\OpenCppCoverage.exe"
            )
            $openCppCoverage = $candidates | Where-Object { Test-Path $_ } | Select-Object -First 1
          }
          if (!$openCppCoverage) {
            throw "OpenCppCoverage.exe was not found."
          }

          & $openCppCoverage `
            --sources "$env:GITHUB_WORKSPACE\src" `
            "--export_type=cobertura:$env:GITHUB_WORKSPACE\cmake-build-ci\reports\coverage.xml" `
            --working_dir "$env:GITHUB_WORKSPACE\cmake-build-ci\tests" `
            -- `
            "$env:GITHUB_WORKSPACE\cmake-build-ci\tests\Debug\test_libvirtualhid.exe" `
            --gtest_color=yes `
            "--gtest_output=xml:$env:GITHUB_WORKSPACE\cmake-build-ci\reports\junit.xml"

      - name: Normalize MSVC coverage paths
        if: >-
          always() &&
          matrix.kind == 'msvc' &&
          (steps.test_msvc.outcome == 'success' || steps.test_msvc.outcome == 'failure')
        run: |
          $coveragePath = Join-Path $env:GITHUB_WORKSPACE "cmake-build-ci\reports\coverage.xml"
          if (!(Test-Path $coveragePath)) {
            return
          }

          [xml] $coverage = Get-Content $coveragePath
          $workspace = $env:GITHUB_WORKSPACE.Replace('\', '/')
          foreach ($node in $coverage.SelectNodes('//*[@filename]')) {
            $filename = $node.GetAttribute('filename').Replace('\', '/')
            if ($filename.StartsWith("${workspace}/")) {
              $filename = $filename.Substring($workspace.Length + 1)
            }

            $node.SetAttribute('filename', $filename)
          }

          foreach ($source in $coverage.SelectNodes('//source')) {
            $source.InnerText = '.'
          }

          $coverage.Save($coveragePath)

      - name: Generate gcov report
        id: test_report
        if: >-
          always() &&
          matrix.kind != 'msvc' &&
          (steps.test.outcome == 'success' || steps.test.outcome == 'failure')
        working-directory: cmake-build-ci
        env:
          GCOV_EXECUTABLE: ${{ matrix.gcov_executable }}
          MSYS2_PATH_TYPE: inherit
        run: |
          uv run --project ../third-party/lizardbyte-common --locked --no-sync gcovr . -r ../src \
            --gcov-executable "${GCOV_EXECUTABLE}" \
            --exclude-noncode-lines \
            --exclude-throw-branches \
            --exclude-unreachable-branches \
            --verbose \
            --xml-pretty \
            -o reports/coverage.xml

      - name: Run gamepad adapter example
        if: matrix.kind != 'msvc'
        run: |
          if [[ "${RUNNER_OS}" == "Windows" ]]; then
            ./cmake-build-ci/examples/gamepad_adapter.exe
          else
            ./cmake-build-ci/examples/gamepad_adapter
          fi

      - name: Run gamepad adapter example MSVC
        if: matrix.kind == 'msvc'
        run: .\cmake-build-ci\examples\Debug\gamepad_adapter.exe

      - name: Uninstall Windows test driver package
        if: >-
          always() &&
          matrix.kind == 'msvc' &&
          github.event_name == 'pull_request'
        run: |
          .\scripts\windows\uninstall-driver.ps1 `
            -OriginalName "libvirtualhid.inf" `
            -RemoveCertificateSubject "CN=libvirtualhid CI Test Driver Signing" `
            -Force

      - name: Install
        if: matrix.kind != 'msvc'
        run: cmake --install cmake-build-ci --prefix cmake-build-ci/install

      - name: Install MSVC
        if: matrix.kind == 'msvc'
        run: cmake --install cmake-build-ci --config Debug --prefix cmake-build-ci/install

      - name: Upload install artifact
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
        with:
          name: install-${{ matrix.name }}
          path: cmake-build-ci/install
          if-no-files-found: error

      - name: Upload report artifact
        if: >-
          always() &&
          (
            steps.test_report.outcome == 'success' ||
            steps.test_msvc.outcome == 'success' ||
            steps.test_msvc.outcome == 'failure'
          )
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
        with:
          name: reports-${{ matrix.name }}
          path: cmake-build-ci/reports
          if-no-files-found: error

  windows_driver:
    name: Windows Driver Installer
    needs: setup_release
    permissions:
      contents: read
    runs-on: windows-2022
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3
        with:
          submodules: recursive

      - name: Setup dotnet
        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1  # v5.4.0
        with:
          dotnet-version: '10.x'

      - name: Configure Windows driver package
        shell: pwsh
        env:
          BRANCH: ${{ github.head_ref || github.ref_name }}
          BUILD_VERSION: ${{ needs.setup_release.outputs.release_version }}
          COMMIT: ${{ needs.setup_release.outputs.release_commit }}
        run: |
          $certificatePath = Join-Path $env:GITHUB_WORKSPACE "cmake-build-driver\certificates\libvirtualhid-ci-test.cer"
          cmake `
            -DBUILD_DOCS=OFF `
            -DBUILD_EXAMPLES=OFF `
            -DBUILD_TESTS=OFF `
            -DLIBVIRTUALHID_BUILD_WINDOWS_DRIVER=ON `
            -DLIBVIRTUALHID_ENABLE_PACKAGING=ON `
            "-DLIBVIRTUALHID_DRIVER_TEST_CERTIFICATE=$certificatePath" `
            -A x64 `
            -B cmake-build-driver `
            -G "Visual Studio 17 2022" `
            -S .

      - name: Build Windows driver package
        shell: pwsh
        run: cmake --build cmake-build-driver --config Release --target libvirtualhid_windows_catalog --parallel 2

      - name: Validate Azure signing configuration
        if: >-
          github.event_name == 'push' &&
          vars.AZURE_SIGNING_ACCOUNT == ''
        shell: pwsh
        run: throw "Push builds must use Azure Trusted Signing for the Windows driver package."

      - name: Sign Windows driver package with local test certificate
        if: github.event_name == 'pull_request'
        shell: pwsh
        run: |
          $packagePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver\src\platform\windows\driver\package\Release"
          $certificatePath = Join-Path `
            $env:GITHUB_WORKSPACE `
            "cmake-build-driver\certificates\libvirtualhid-ci-test.cer"
          .\scripts\windows\sign-driver-package.ps1 `
            -PackagePath $packagePath `
            -CertificatePath $certificatePath

      - name: Sign Windows driver package with Azure Trusted Signing
        if: >-
          github.event_name == 'push' &&
          vars.AZURE_SIGNING_ACCOUNT != ''
        uses: azure/trusted-signing-action@c7ab2a863ab5f9a846ddb8265964877ef296ee82  # v2.0.0
        with:
          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
          azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          certificate-profile-name: ${{ vars.AZURE_SIGNING_CERT_PROFILE }}
          endpoint: ${{ vars.AZURE_SIGNING_ENDPOINT }}
          files: |
            ${{ github.workspace }}/cmake-build-driver/src/platform/windows/driver/package/Release/libvirtualhid.cat
          signing-account-name: ${{ vars.AZURE_SIGNING_ACCOUNT }}

      - name: Package Windows driver installer
        shell: pwsh
        run: |
          Push-Location .\cmake-build-driver
          cpack -G WIX
          $packageExitCode = $LASTEXITCODE
          Pop-Location
          if ($packageExitCode -ne 0) {
            exit $packageExitCode
          }
          New-Item -ItemType Directory -Force -Path artifacts | Out-Null
          Copy-Item `
            -LiteralPath .\cmake-build-driver\cpack_artifacts\libvirtualhid.msi `
            -Destination .\artifacts\libvirtualhid-Windows-Driver-installer.msi

      - name: Sign Windows driver installer with Azure Trusted Signing
        if: >-
          github.event_name == 'push' &&
          vars.AZURE_SIGNING_ACCOUNT != ''
        uses: azure/trusted-signing-action@c7ab2a863ab5f9a846ddb8265964877ef296ee82  # v2.0.0
        with:
          azure-client-id: ${{ secrets.AZURE_CLIENT_ID }}
          azure-client-secret: ${{ secrets.AZURE_CLIENT_SECRET }}
          azure-tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          certificate-profile-name: ${{ vars.AZURE_SIGNING_CERT_PROFILE }}
          endpoint: ${{ vars.AZURE_SIGNING_ENDPOINT }}
          files-folder: artifacts
          files-folder-filter: msi
          files-folder-recurse: false
          signing-account-name: ${{ vars.AZURE_SIGNING_ACCOUNT }}

      - name: Debug wix
        if: always()
        shell: pwsh
        run: |
          Get-Content .\cmake-build-driver\cpack_artifacts\_CPack_Packages\win64\WIX\wix.log `
            -ErrorAction SilentlyContinue

      - name: Upload Windows driver installer artifact
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
        with:
          name: windows-driver-installer
          path: artifacts
          if-no-files-found: error

  codecov:
    name: Codecov-${{ matrix.flag }}
    if: >-
      always() &&
      (needs.build.result == 'success' || needs.build.result == 'failure') &&
      startsWith(github.repository, 'LizardByte/')
    needs: build
    permissions:
      contents: read
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
          - build_name: Linux-GCC
            flag: Linux-GCC
            has_coverage: true
          - build_name: Linux-Clang
            flag: Linux-Clang
            has_coverage: true
          - build_name: macOS
            flag: macOS
            has_coverage: true
          - build_name: Windows-MinGW-UCRT64
            flag: Windows-MinGW-UCRT64
            has_coverage: true
          - build_name: Windows-MSVC
            flag: Windows-MSVC
            has_coverage: true
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3

      - name: Download report artifact
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: reports-${{ matrix.build_name }}
          path: _reports

      - name: Debug coverage file
        if: matrix.has_coverage
        run: cat _reports/coverage.xml

      - name: Upload test coverage
        if: matrix.has_coverage
        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
        with:
          disable_search: true
          fail_ci_if_error: true
          files: ./_reports/coverage.xml
          report_type: coverage
          flags: ${{ matrix.flag }}
          token: ${{ secrets.CODECOV_TOKEN }}
          verbose: true

      - name: Upload test results
        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
        with:
          disable_search: true
          fail_ci_if_error: true
          files: ./_reports/junit.xml
          report_type: test_results
          flags: ${{ matrix.flag }}
          token: ${{ secrets.CODECOV_TOKEN }}
          verbose: true

  release:
    name: Release
    if: >-
      always() &&
      needs.setup_release.outputs.publish_release == 'true' &&
      needs.build.result == 'success' &&
      needs.windows_driver.result == 'success' &&
      startsWith(github.repository, 'LizardByte/')
    needs:
      - build
      - windows_driver
      - setup_release
    permissions:
      contents: read
    runs-on: ubuntu-latest
    steps:
      - name: Download install artifact (Linux-GCC)
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: install-Linux-GCC
          path: install-Linux-GCC

      - name: Download install artifact (Linux-Clang)
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: install-Linux-Clang
          path: install-Linux-Clang

      - name: Download install artifact (macOS)
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: install-macOS
          path: install-macOS

      - name: Download install artifact (Windows-MinGW-UCRT64)
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: install-Windows-MinGW-UCRT64
          path: install-Windows-MinGW-UCRT64

      - name: Download install artifact (Windows-MSVC)
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: install-Windows-MSVC
          path: install-Windows-MSVC

      - name: Download Windows driver installer artifact
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: windows-driver-installer
          path: windows-driver-installer

      - name: Package install artifacts
        run: |
          mkdir -p artifacts
          for name in Linux-GCC Linux-Clang macOS Windows-MinGW-UCRT64 Windows-MSVC; do
            zip -r \
              "artifacts/libvirtualhid-${{ needs.setup_release.outputs.release_tag }}-${name}.zip" \
              "install-${name}"
          done
          cp windows-driver-installer/* artifacts/

      - name: Create/Update GitHub Release
        if: needs.setup_release.outputs.publish_release == 'true'
        uses: LizardByte/actions/actions/release_create@a46850981292c4bbc0c41715f286ad95adaaaf4a  # v2026.625.20301
        with:
          allowUpdates: false
          body: ${{ needs.setup_release.outputs.release_body }}
          draft: true
          generateReleaseNotes: ${{ needs.setup_release.outputs.release_generate_release_notes }}
          name: ${{ needs.setup_release.outputs.release_tag }}
          prerelease: true
          tag: ${{ needs.setup_release.outputs.release_tag }}
          token: ${{ secrets.GH_BOT_TOKEN }}
          virustotal_api_key: ${{ secrets.VIRUSTOTAL_API_KEY }}