build.yml

name: AMD Build & Release

# ──────────────────────────────────────────────────────────────────────────────
# Triggers
# ──────────────────────────────────────────────────────────────────────────────
on:
  schedule:
    - cron: '0 2 * * 1'   # Weekly – every Monday at 02:00 UTC
  workflow_dispatch:
    inputs:
      create_release:
        description: 'Create GitHub Release'
        required: true
        type: boolean
        default: false
      pre_release_tag:
        description: 'Pre-release tag name (optional, overrides auto-tag)'
        required: false
        type: string
      run_type:
        description: 'Workflow scope'
        required: true
        type: choice
        options:
          - full-ci        # all jobs
          - release-only   # release-producing jobs only
        default: full-ci
      gfx_targets:
        description: 'ROCm GPU targets (comma-separated)'
        required: false
        type: string
        default: 'gfx1151,gfx1150,gfx120X,gfx110X'
      rocm_version:
        description: 'ROCm version (e.g. 7.12.0)'
        required: false
        type: string
        default: '7.12.0'
  push:
    tags:
      - 'v*'
  pull_request:
    branches:
      - master
      - main
    types: [opened, synchronize, reopened]

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
  cancel-in-progress: true

permissions:
  contents: write

# ──────────────────────────────────────────────────────────────────────────────
# Shared environment
# ──────────────────────────────────────────────────────────────────────────────
env:
  BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
  GFX_TARGETS: ${{ github.event.inputs.gfx_targets || 'gfx1151,gfx1150,gfx120X,gfx110X' }}
  ROCM_VERSION: ${{ github.event.inputs.rocm_version || '7.12.0' }}
  FLEXML_URL: "https://github.com/lemonade-sdk/whisper.cpp/releases/download/deps/flexmlrt1.7.0-win.zip"
  VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"

jobs:

# ════════════════════════════════════════════════════════════════════════════════
# 0. Determine release tag
# ════════════════════════════════════════════════════════════════════════════════
  determine-tag:
    runs-on: ubuntu-latest
    outputs:
      tag_name:       ${{ steps.tag.outputs.name }}
      version:        ${{ steps.tag.outputs.version }}
      should_release: ${{ steps.tag.outputs.should_release }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Determine tag and version
        id: tag
        shell: bash
        run: |
          BUILD_NUMBER=$(git rev-list --count HEAD)
          SHORT_HASH=$(git rev-parse --short=7 HEAD)
          CUSTOM_TAG="${{ github.event.inputs.pre_release_tag }}"
          SHOULD_RELEASE="false"

          if [[ "${{ github.ref_type }}" == "tag" ]]; then
            # Triggered by sync.yml pushing a vX.Y.Z tag — this is the primary release path
            TAG_NAME="${{ github.ref_name }}"
            SHOULD_RELEASE="true"
          elif [[ -n "$CUSTOM_TAG" ]]; then
            TAG_NAME="$CUSTOM_TAG"
            SHOULD_RELEASE="true"
          elif [[ "${{ github.event.inputs.create_release }}" == "true" ]]; then
            TAG_NAME="b${BUILD_NUMBER}"
            SHOULD_RELEASE="true"
          elif [[ "${{ env.BRANCH_NAME }}" == "main" || "${{ env.BRANCH_NAME }}" == "master" ]]; then
            TAG_NAME="b${BUILD_NUMBER}"
            SHOULD_RELEASE="false"
          else
            SAFE=$(echo "${{ env.BRANCH_NAME }}" | tr '/' '-')
            TAG_NAME="${SAFE}-b${BUILD_NUMBER}-${SHORT_HASH}"
            SHOULD_RELEASE="false"
          fi

          # Version used in artifact filenames — keep leading 'v' to match lemonade expectations
          # e.g. v1.8.4 → v1.8.4,  b1234 → b1234
          VERSION="${TAG_NAME}"

          echo "name=$TAG_NAME"                >> $GITHUB_OUTPUT
          echo "version=$VERSION"              >> $GITHUB_OUTPUT
          echo "should_release=$SHOULD_RELEASE" >> $GITHUB_OUTPUT

# ════════════════════════════════════════════════════════════════════════════════
# 1. ROCm matrix (Linux + Windows per GFX target)
# ════════════════════════════════════════════════════════════════════════════════
  prepare-rocm-matrix:
    runs-on: ubuntu-latest
    outputs:
      ubuntu_matrix:  ${{ steps.m.outputs.ubuntu_matrix }}
      windows_matrix: ${{ steps.m.outputs.windows_matrix }}
    steps:
      - name: Build matrix JSON
        id: m
        run: |
          targets="${{ env.GFX_TARGETS }}"
          arr=$(echo "$targets" | tr ',' '\n' | sed 's/^ *//;s/ *$//' | jq -R . | jq -s .)

          ubuntu_matrix=$(echo "$arr" | jq -c \
            '{gfx_target: ., build: ["Release"], sdl2: ["ON"], arch: ["linux/amd64"]}')

          windows_matrix=$(echo "$arr" | jq -c \
            '{gfx_target: ., build: ["Release"], sdl2: ["ON"], arch: ["x64"], s2arc: ["x64"], s2ver: ["2.28.5"]}')

          echo "ubuntu_matrix=$ubuntu_matrix"   >> $GITHUB_OUTPUT
          echo "windows_matrix=$windows_matrix" >> $GITHUB_OUTPUT

# ════════════════════════════════════════════════════════════════════════════════
# 2. ROCm — Linux
# ════════════════════════════════════════════════════════════════════════════════
  linux-rocm:
    runs-on: ubuntu-22.04
    needs: [determine-tag, prepare-rocm-matrix]
    strategy:
      matrix: ${{ fromJson(needs.prepare-rocm-matrix.outputs.ubuntu_matrix) }}
      fail-fast: false

    steps:
      - name: Free disk space
        run: |
          sudo rm -rf /usr/local/lib/android /opt/ghc /usr/local/share/boost \
            /usr/share/dotnet /usr/local/.ghcup /opt/hostedtoolcache/CodeQL
          sudo docker image prune --all --force 2>/dev/null || true

      - uses: actions/checkout@v4

      - name: Install dependencies
        run: sudo apt-get update && sudo apt-get install -y cmake ninja-build curl build-essential libsdl2-dev git patchelf

      - name: Download ROCm tarball
        run: |
          source ci/resolve-rocm-version.sh linux "${{ matrix.gfx_target }}" "${{ env.ROCM_VERSION }}"
          echo "DETECTED_ROCM_VERSION=$ROCM_RESOLVED_VERSION" >> $GITHUB_ENV
          sudo mkdir -p /opt/rocm
          curl -L "$ROCM_TARBALL_URL" | sudo tar --use-compress-program=gzip -xf - -C /opt/rocm --strip-components=1

      - name: Set ROCm env
        run: |
          echo "HIP_PATH=/opt/rocm"  >> $GITHUB_ENV
          echo "ROCM_PATH=/opt/rocm" >> $GITHUB_ENV
          echo "HIP_PLATFORM=amd"    >> $GITHUB_ENV
          echo "/opt/rocm/bin:/opt/rocm/llvm/bin:$PATH" >> $GITHUB_PATH

      - name: Find bitcode path
        run: |
          BITCODE_PATH=$(find /opt/rocm -type d -name bitcode -print -quit)
          [ -z "$BITCODE_PATH" ] && { echo "::error::bitcode dir not found"; exit 1; }
          echo "ROCM_BITCODE_PATH=$BITCODE_PATH" >> $GITHUB_ENV

      - name: Configure CMake
        run: |
          source ci/map-gpu-target.sh "${{ matrix.gfx_target }}"
          cmake -S . -B build -G Ninja \
            -DCMAKE_C_COMPILER=/opt/rocm/llvm/bin/clang \
            -DCMAKE_CXX_COMPILER=/opt/rocm/llvm/bin/clang++ \
            -DCMAKE_HIP_FLAGS="--rocm-path=/opt/rocm --rocm-device-lib-path=${{ env.ROCM_BITCODE_PATH }}" \
            -DCMAKE_PREFIX_PATH=/opt/rocm \
            -DCMAKE_BUILD_TYPE=${{ matrix.build }} \
            -DGPU_TARGETS="$MAPPED_GPU_TARGET" \
            -DGGML_HIP=ON \
            -DWHISPER_BUILD_SERVER=ON \
            -DWHISPER_SDL2=${{ matrix.sdl2 }}

      - name: Build
        run: |
          cmake --build build --config ${{ matrix.build }} -j$(nproc) > build.log 2>&1
          exit_code=$?
          grep -E "error:|FAILED|Linking|Built target|warning:" build.log || true
          if [ $exit_code -ne 0 ]; then
            echo "--- Last 100 lines of build log ---"
            tail -100 build.log
            echo "Build failed with exit code $exit_code"
            exit $exit_code
          fi
          echo "Build succeeded."

      - name: Verify build output
        run: |
          if [ ! -f build/bin/whisper-cli ]; then
            echo "::error::whisper-cli not found - build likely truncated"
            ls -lh build/bin/ 2>/dev/null || true
            exit 1
          fi
          if [ ! -f build/bin/whisper-server ]; then
            echo "::error::whisper-server not found - build likely truncated"
            ls -lh build/bin/ 2>/dev/null || true
            exit 1
          fi
          echo "Build output:"; ls -lh build/bin/whisper-cli build/bin/whisper-server

      - name: Inspect shared library dependencies
        run: |
          echo "--- ldd whisper-cli ---"
          ldd build/bin/whisper-cli || true
          echo "--- ldd whisper-server ---"
          ldd build/bin/whisper-server || true
          echo "--- missing libs ---"
          MISSING_CLI=$(ldd build/bin/whisper-cli 2>/dev/null | grep "not found" || true)
          MISSING_SRV=$(ldd build/bin/whisper-server 2>/dev/null | grep "not found" || true)
          if [ -z "$MISSING_CLI" ] && [ -z "$MISSING_SRV" ]; then
            echo "All dependencies resolved."
          else
            [ -n "$MISSING_CLI" ] && echo "whisper-cli missing:" && echo "$MISSING_CLI"
            [ -n "$MISSING_SRV" ] && echo "whisper-server missing:" && echo "$MISSING_SRV"
          fi
          echo "--- .so* files in build/bin/ ---"
          ls -lh build/bin/*.so* 2>/dev/null || echo "(none)"

      - name: Copy ROCm runtime libs
        run: |
          BIN="build/bin"
          mkdir -p "$BIN"

          cp -a build/src/libwhisper.so*                "$BIN"/ 2>/dev/null || true
          cp -a build/ggml/src/libggml.so*              "$BIN"/ 2>/dev/null || true
          cp -a build/ggml/src/libggml-base.so*         "$BIN"/ 2>/dev/null || true
          cp -a build/ggml/src/libggml-cpu.so*          "$BIN"/ 2>/dev/null || true
          cp -a build/ggml/src/ggml-hip/libggml-hip.so* "$BIN"/ 2>/dev/null || true
          export LD_LIBRARY_PATH="$PWD/$BIN:/opt/rocm/lib:/opt/rocm/lib/llvm/lib:/opt/rocm/lib/rocm_sysdeps/lib:${LD_LIBRARY_PATH:-}"

          ROCM_ROOTS="/opt/rocm/lib /opt/rocm/lib/llvm/lib /opt/rocm/lib/rocm_sysdeps/lib"

          for binary in "$BIN"/*; do
            [ -f "$binary" ] && [ -x "$binary" ] && file "$binary" | grep -q ELF || continue
            ldd "$binary" 2>/dev/null | awk '{print $3}' | grep -E "^/opt/rocm" | while read lib; do
              [ -f "$lib" ] || continue
              cp -n "$lib" "$BIN/" 2>/dev/null || true
              # Also copy the soname symlink if it exists alongside the real file
              dir=$(dirname "$lib")
              base=$(basename "$lib")
              find "$dir" -maxdepth 1 -name "${base%%.*}.so*" -exec cp -Pn {} "$BIN/" \; 2>/dev/null || true
            done
          done

          # Transitive deps: repeat ldd over any newly copied ROCm .so to catch indirect deps
          for pass in 1 2; do
            for lib in "$BIN"/lib*.so*; do
              [ -f "$lib" ] && [ ! -L "$lib" ] || continue
              ldd "$lib" 2>/dev/null | awk '{print $3}' | grep -E "^/opt/rocm" | while read dep; do
                [ -f "$dep" ] || continue
                cp -n "$dep" "$BIN/" 2>/dev/null || true
              done
            done
          done

          # Kernel library data dirs (loaded at runtime by path, not via soname)
          [ -d /opt/rocm/lib/rocblas/library ]   && { mkdir -p "$BIN/rocblas";   cp -r /opt/rocm/lib/rocblas/library   "$BIN/rocblas/"; }
          [ -d /opt/rocm/lib/hipblaslt/library ] && { mkdir -p "$BIN/hipblaslt"; cp -r /opt/rocm/lib/hipblaslt/library "$BIN/hipblaslt/"; }

      - name: Set portable RPATH
        run: |
          cd build/bin
          for f in *.so* whisper-*; do
            [ -f "$f" ] && [ ! -L "$f" ] && file "$f" | grep -q ELF && patchelf --set-rpath '$ORIGIN' "$f" 2>/dev/null || true
          done

      - name: Package
        run: |
          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-linux-rocm-${{ matrix.gfx_target }}.tar.gz"
          STAGE="whisper-${VER}-linux-rocm-${{ matrix.gfx_target }}"
          mkdir -p "$STAGE" && cp -r build/bin/* "$STAGE/"
          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 3. ROCm — Windows
# ════════════════════════════════════════════════════════════════════════════════
  windows-rocm:
    runs-on: windows-2022
    needs: [determine-tag, prepare-rocm-matrix]
    strategy:
      matrix: ${{ fromJson(needs.prepare-rocm-matrix.outputs.windows_matrix) }}
      fail-fast: false

    steps:
      - uses: actions/checkout@v4

      - name: Install Ninja
        shell: powershell
        run: choco install ninja -y

      - name: Fetch SDL2 and patch header
        if: matrix.sdl2 == 'ON'
        shell: powershell
        run: |
          $url = "https://github.com/libsdl-org/SDL/releases/download/release-${{ matrix.s2ver }}/SDL2-devel-${{ matrix.s2ver }}-VC.zip"
          Invoke-WebRequest -Uri $url -OutFile sdl2.zip
          7z x sdl2.zip
          $cmake = Get-ChildItem -Recurse -Filter "sdl2-config.cmake" | Select-Object -First 1
          if ($cmake) { echo "SDL2_DIR=$($cmake.DirectoryName)" >> $env:GITHUB_ENV }
          else { Write-Error "sdl2-config.cmake not found"; exit 1 }
          $hdr = Get-ChildItem -Recurse -Filter "SDL_endian.h" | Select-Object -First 1
          if ($hdr) {
            $c = Get-Content $hdr.FullName -Raw
            if ($c -match 'extern void _m_prefetch') {
              $c = $c -replace 'extern void _m_prefetch\(void \*__P\);','// extern void _m_prefetch(void *__P);'
              Set-Content $hdr.FullName $c
            }
          } else { Write-Error "SDL_endian.h not found"; exit 1 }

      - name: Download and extract ROCm tarball
        shell: powershell
        run: |
          $gfx  = "${{ matrix.gfx_target }}"
          $ver  = "${{ env.ROCM_VERSION }}"
          $base = switch ($gfx) {
            "gfx110X" { "gfx110X-all" }
            "gfx120X" { "gfx120X-all" }
            "gfx1150" { "gfx1150"     }
            "gfx1151" { "gfx1151"     }
            "gfx1152" { "gfx1152"     }
            default   { $gfx          }
          }
          $url  = "https://repo.amd.com/rocm/tarball/therock-dist-windows-${base}-${ver}.tar.gz"
          Write-Host "ROCm URL: $url"
          "DETECTED_ROCM_VERSION=$ver" | Out-File $env:GITHUB_ENV -Append -Encoding utf8
          curl.exe -L --retry 3 --retry-delay 5 -o rocm.tar.gz $url
          if ($LASTEXITCODE -ne 0) { Write-Error "curl failed with exit code $LASTEXITCODE"; exit 1 }
          New-Item -ItemType Directory -Force -Path "C:\opt\rocm" | Out-Null
          tar -xzf rocm.tar.gz -C C:\opt\rocm --strip-components=1

      - name: Map GPU target
        id: gpu
        shell: powershell
        run: |
          $gfx = "${{ matrix.gfx_target }}"
          $mapped = switch ($gfx) {
            "gfx110X" { "gfx1100;gfx1101;gfx1102" }
            "gfx120X" { "gfx1200;gfx1201" }
            default   { $gfx }
          }
          Write-Host "Mapped GPU target: $gfx -> $mapped"
          "mapped=$mapped" | Out-File $env:GITHUB_OUTPUT -Append -Encoding utf8

      - name: Configure CMake
        shell: powershell
        run: |
          $env:HIP_PATH   = "C:\opt\rocm"
          $env:HIP_PLATFORM = "amd"
          $env:PATH = "$env:HIP_PATH\bin;$env:HIP_PATH\lib\llvm\bin;$env:PATH"
          cmake -S . -B build `
            -G "Ninja Multi-Config" `
            -DGPU_TARGETS="${{ steps.gpu.outputs.mapped }}" `
            -DGGML_HIP=ON `
            -DCMAKE_C_COMPILER="$env:HIP_PATH/lib/llvm/bin/amdclang.exe" `
            -DCMAKE_CXX_COMPILER="$env:HIP_PATH/lib/llvm/bin/amdclang++.exe" `
            -DCMAKE_HIP_COMPILER="$env:HIP_PATH/lib/llvm/bin/amdclang++.exe" `
            "-DCMAKE_C_FLAGS='-D__PRFCHWINTRIN_H'" `
            "-DCMAKE_CXX_FLAGS='-D__PRFCHWINTRIN_H'" `
            "-DCMAKE_HIP_FLAGS=--rocm-path=C:/opt/rocm" `
            -DCMAKE_PREFIX_PATH="$env:HIP_PATH" `
            -DCMAKE_BUILD_TYPE=${{ matrix.build }} `
            -DWHISPER_BUILD_SERVER=ON `
            -DWHISPER_SDL2=${{ matrix.sdl2 }}

      - name: Build
        shell: powershell
        run: |
          cmake --build build --config ${{ matrix.build }} -j $env:NUMBER_OF_PROCESSORS > build.log 2>&1
          $exit = $LASTEXITCODE
          # Show only errors and link steps - keeps log under GitHub's line limit
          Get-Content build.log | Select-String -Pattern "error:|FAILED|Linking|Built target|warning: " | Write-Host
          if ($exit -ne 0) {
            Write-Host "--- Last 100 lines of build log ---"
            Get-Content build.log -Tail 100
            Write-Error "Build failed with exit code $exit"
            exit $exit
          }
          Write-Host "Build succeeded."

      - name: Copy ROCm DLLs
        shell: powershell
        run: |
          $bin    = "build/bin/${{ matrix.build }}"
          $rocBin = "C:\opt\rocm\bin"
          @("amdhip64_*.dll","amd_comgr*.dll","libhipblas.dll","rocblas.dll",
            "rocsolver.dll","hipblaslt.dll","libhipblaslt.dll","hipblas.dll") | ForEach-Object {
            Get-ChildItem $rocBin -Name $_ -ErrorAction SilentlyContinue |
              ForEach-Object { Copy-Item (Join-Path $rocBin $_) (Join-Path $bin $_) }
          }
          $rocLib = Join-Path $rocBin "rocblas\library"
          if (Test-Path $rocLib) { Copy-Item $rocLib -Destination (Join-Path $bin "rocblas\library") -Recurse -Force }
          $hipLib = Join-Path $rocBin "hipblaslt\library"
          if (Test-Path $hipLib) { Copy-Item $hipLib -Destination (Join-Path $bin "hipblaslt\library") -Recurse -Force }

      - name: Copy SDL2.dll
        if: matrix.sdl2 == 'ON'
        shell: powershell
        run: copy "$env:SDL2_DIR/../lib/${{ matrix.s2arc }}/SDL2.dll" "build/bin/${{ matrix.build }}"

      - name: Verify build output
        shell: powershell
        run: |
          $bin = "build/bin/${{ matrix.build }}"
          if (-not (Test-Path "$bin/whisper-cli.exe")) {
            Write-Error "whisper-cli.exe not found in $bin - build likely truncated"
            Get-ChildItem $bin -ErrorAction SilentlyContinue | Format-Table Name, Length
            exit 1
          }
          if (-not (Test-Path "$bin/whisper-server.exe")) {
            Write-Error "whisper-server.exe not found in $bin - build likely truncated"
            Get-ChildItem $bin -ErrorAction SilentlyContinue | Format-Table Name, Length
            exit 1
          }
          Write-Host "Build output:"
          Get-ChildItem $bin -Filter "*.exe" | Format-Table Name, Length

      - name: Package
        shell: powershell
        run: |
          $a = "whisper-${{ needs.determine-tag.outputs.version }}-windows-rocm-${{ matrix.gfx_target }}.zip"
          Compress-Archive -Path "build/bin/${{ matrix.build }}/*" -DestinationPath $a -Force
          "ARCHIVE=$a" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 4. Vulkan — Linux
# ════════════════════════════════════════════════════════════════════════════════
  linux-vulkan:
    runs-on: ubuntu-latest
    needs: determine-tag

    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y build-essential cmake git libsdl2-dev pkg-config libvulkan-dev vulkan-tools
          sudo apt-get install -y glslc || sudo apt-get install -y shaderc

      - name: Check Vulkan availability
        run: |
          if ! command -v glslc >/dev/null 2>&1 && ! command -v glslangValidator >/dev/null 2>&1; then
            echo "::error::No GLSL compiler found (glslc / shaderc)"; exit 1
          fi

      - name: Configure CMake
        run: |
          cmake -B build \
            -DCMAKE_BUILD_TYPE=Release \
            -DGGML_NATIVE=OFF \
            -DGGML_AVX=ON \
            -DGGML_AVX2=ON \
            -DGGML_FMA=ON \
            -DGGML_AVX512=OFF \
            -DCMAKE_C_FLAGS="-march=x86-64-v3" \
            -DCMAKE_CXX_FLAGS="-march=x86-64-v3" \
            -DGGML_VULKAN=ON \
            -DWHISPER_BUILD_EXAMPLES=ON \
            -DWHISPER_BUILD_TESTS=OFF \
            -DWHISPER_BUILD_SERVER=ON

      - name: Build
        run: cmake --build build --config Release -j$(nproc)

      - name: Validate Vulkan artifacts
        run: |
          VFILES=$(find build -type f \( -iname "*vulkan*.so*" -o -iname "*vulkan*" \) 2>/dev/null | wc -l)
          if [ "$VFILES" -eq 0 ]; then
            echo "::warning::No Vulkan-related artifacts found"
          else
            echo "Vulkan artifacts found: $VFILES file(s)"
          fi

      - name: Package
        run: |
          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-linux-vulkan-x86_64.tar.gz"
          STAGE="whisper-${VER}-linux-vulkan-x86_64"
          mkdir -p "$STAGE"
          cp -r build/bin/* "$STAGE/" 2>/dev/null || true
          find build -name "*.so*" -exec cp {} "$STAGE/" \; 2>/dev/null || true
          # Rewrite the absolute build-tree rpath to $ORIGIN so the relocated musl
          # binaries find their sibling .so files (musl doesn't search the exe dir).
          if ! command -v patchelf >/dev/null; then sudo apt-get update -qq && sudo apt-get install -y -qq patchelf; fi
          for f in "$STAGE"/*; do
            [ -f "$f" ] && [ ! -L "$f" ] && file "$f" | grep -q ELF && patchelf --set-rpath '$ORIGIN' "$f" 2>/dev/null || true
          done
          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 5. Vulkan — Windows
# ════════════════════════════════════════════════════════════════════════════════
  windows-vulkan:
    runs-on: windows-latest
    needs: determine-tag

    steps:
      - uses: actions/checkout@v4

      - uses: microsoft/setup-msbuild@v2

      - name: Install Vulkan SDK
        shell: pwsh
        run: |
          winget install --id KhronosGroup.VulkanSDK -e --silent --accept-package-agreements --accept-source-agreements
          $sdk = Get-ChildItem "C:\VulkanSDK" -ErrorAction SilentlyContinue | Select-Object -First 1
          if (-not $sdk) { throw "Vulkan SDK not found under C:\VulkanSDK" }
          "VULKAN_SDK=$($sdk.FullName)" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - name: Fetch SDL2
        shell: pwsh
        run: |
          C:/msys64/usr/bin/wget.exe -qO sdl2.zip https://github.com/libsdl-org/SDL/releases/download/release-2.28.5/SDL2-devel-2.28.5-VC.zip
          7z x sdl2.zip
          "SDL2_DIR=$env:GITHUB_WORKSPACE/SDL2-2.28.5/cmake" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - name: Configure CMake
        shell: pwsh
        run: |
          cmake -S . -B ./build -A x64 `
            -DCMAKE_BUILD_TYPE=Release `
            -DBUILD_SHARED_LIBS=ON `
            -DGGML_VULKAN=ON `
            -DWHISPER_BUILD_SERVER=ON `
            -DWHISPER_SDL2=ON `
            -DVULKAN_SDK="$env:VULKAN_SDK"

      - name: Build
        run: cd ./build && msbuild ALL_BUILD.vcxproj -t:build -p:configuration=Release -p:platform=x64

      - name: Copy SDL2.dll
        shell: pwsh
        run: copy "$env:SDL2_DIR/../lib/x64/SDL2.dll" build/bin/Release

      - name: Package
        shell: pwsh
        run: |
          $a = "whisper-${{ needs.determine-tag.outputs.version }}-windows-vulkan-x64.zip"
          Compress-Archive -Path "build/bin/Release/*" -DestinationPath $a -Force
          "ARCHIVE=$a" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 6. NPU (VitisAI / RyzenAI) — Windows only (self-hosted runner)
# ════════════════════════════════════════════════════════════════════════════════
  windows-npu:
    runs-on: [self-hosted, Windows, stx, rai300_400]
    needs: determine-tag
    continue-on-error: true   # runner may be offline; don't block release

    steps:
      - uses: actions/checkout@v4

      - uses: microsoft/setup-msbuild@v2

      - name: Install CMake if not available
        shell: powershell
        run: |
          $installed = Get-Command cmake -ErrorAction SilentlyContinue
          if (-not $installed) {
            $ver = "3.28.1"
            $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-x86_64.msi"
            Invoke-WebRequest -Uri $url -OutFile cmake.msi
            Start-Process msiexec.exe -ArgumentList "/i cmake.msi /quiet /norestart" -Wait
            $p = "C:\Program Files\CMake\bin"
            $env:PATH = "$p;$env:PATH"
            echo $p >> $env:GITHUB_PATH
            cmake --version
            if ($LASTEXITCODE -ne 0) { Write-Error "CMake install failed"; exit 1 }
          } else { cmake --version }

      - name: Download FlexML Runtime
        shell: powershell
        run: |
          Invoke-WebRequest -Uri "${{ env.FLEXML_URL }}" -OutFile flexmlrt.zip
          if (-Not (Test-Path "flexmlrt.zip")) { Write-Error "flexmlrt.zip not downloaded"; exit 1 }
          if ((Get-Item "flexmlrt.zip").Length -eq 0) { Write-Error "flexmlrt.zip is empty"; exit 1 }
          Write-Host "FlexML: $([math]::Round((Get-Item 'flexmlrt.zip').Length/1MB,2)) MB downloaded"

      - name: Extract FlexML Runtime
        shell: powershell
        run: |
          tar xvf flexmlrt.zip
          if ($LASTEXITCODE -ne 0) { Write-Error "Extraction failed"; exit 1 }
          $dirs = Get-ChildItem -Directory | Where-Object { $_.Name -like "flexmlrt*" }
          if (-not $dirs) { Write-Error "No flexmlrt directory found after extraction"; exit 1 }
          Write-Host "Extracted: $($dirs.Name)"

      - name: Setup FlexML, configure and build
        shell: cmd
        run: |
          cd flexmlrt
          call setup.bat
          if errorlevel 1 ( echo ERROR: FlexML setup.bat failed! & exit /b 1 )
          cd ..
          cmake -B build -A x64 -DCMAKE_BUILD_TYPE=Release -DWHISPER_VITISAI=ON -DWHISPER_BUILD_SERVER=ON
          if errorlevel 1 ( echo ERROR: CMake configure failed! & exit /b 1 )
          cmake --build build --config Release -j
          if errorlevel 1 ( echo ERROR: Build failed! & exit /b 1 )

      - name: List build output
        shell: powershell
        run: |
          if (Test-Path "build/bin/Release") {
            Get-ChildItem -Path "build/bin/Release" -Recurse | Format-Table Name, Length
          } else { Write-Error "build/bin/Release not found"; exit 1 }

      - name: Copy FlexML DLLs to build output
        shell: powershell
        run: |
          $copied = 0
          if (Test-Path "flexmlrt/bin") {
            $d = Get-ChildItem -Path "flexmlrt/bin/*.dll" -ErrorAction SilentlyContinue
            if ($d) { Copy-Item "flexmlrt/bin/*.dll" "build/bin/Release/" -Force; $copied += $d.Count }
          }
          if (Test-Path "flexmlrt/lib") {
            $d = Get-ChildItem -Path "flexmlrt/lib/*.dll" -ErrorAction SilentlyContinue
            if ($d) { Copy-Item "flexmlrt/lib/*.dll" "build/bin/Release/" -Force; $copied += $d.Count }
          }
          Write-Host "FlexML DLLs copied: $copied"

      - name: Package
        shell: powershell
        run: |
          $a = "whisper-${{ needs.determine-tag.outputs.version }}-windows-npu-x64.zip"
          Compress-Archive -Path "build/bin/Release/*" -DestinationPath $a -Force
          if (-not (Test-Path $a)) { Write-Error "Package creation failed"; exit 1 }
          $mb = [math]::Round((Get-Item $a).Length/1MB,2)
          Write-Host "Package: $a ($mb MB)"
          "ARCHIVE=$a" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - name: Build summary
        shell: powershell
        run: |
          Write-Host "NPU build complete. Artifact: $env:ARCHIVE"

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 7. Metal — macOS (arm64)
# ════════════════════════════════════════════════════════════════════════════════
  macos-metal:
    runs-on: macos-latest
    needs: determine-tag

    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: brew install cmake ninja

      - name: Configure CMake
        run: |
          cmake -B build \
            -DCMAKE_BUILD_TYPE=Release \
            -DCMAKE_MACOSX_RPATH=ON \
            -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON \
            -DCMAKE_INSTALL_RPATH="@loader_path" \
            -DGGML_METAL=ON \
            -DWHISPER_BUILD_EXAMPLES=ON \
            -DWHISPER_BUILD_TESTS=OFF \
            -DWHISPER_BUILD_SERVER=ON

      - name: Build
        run: |
          cmake --build build --config Release -j$(sysctl -n hw.logicalcpu) > build.log 2>&1
          exit_code=$?
          grep -E "error:|FAILED|Linking|Built target" build.log || true
          if [ $exit_code -ne 0 ]; then
            tail -100 build.log
            exit $exit_code
          fi
          echo "Build succeeded."

      - name: Verify build output
        run: |
          if [ ! -f build/bin/whisper-cli ]; then
            echo "::error::whisper-cli not found"
            ls -lh build/bin/ 2>/dev/null || true
            exit 1
          fi

          if [ ! -f build/bin/whisper-server ]; then
            echo "::error::whisper-server not found"
            ls -lh build/bin/ 2>/dev/null || true
            exit 1
          fi

          echo "--- build/bin ---"
          ls -lh build/bin/

          echo "--- macOS dylibs produced by build ---"
          find build -name "*.dylib" -print | sort

          echo "--- whisper-server dependencies before packaging ---"
          otool -L build/bin/whisper-server

      - name: Package
        run: |
          set -euo pipefail

          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-darwin-metal-arm64.tar.gz"
          STAGE="whisper-${VER}-darwin-metal-arm64"

          rm -rf "$STAGE" "$ARCHIVE"
          mkdir -p "$STAGE"

          cp -R build/bin/* "$STAGE/" 2>/dev/null || true

          # whisper-server depends on libwhisper / ggml dylibs that CMake may
          # leave under build/src and build/ggml/src rather than build/bin.
          # Package all produced dylibs next to the executables so @loader_path
          # can resolve them on downstream machines and GitHub macOS runners.
          while IFS= read -r lib; do
            cp -P "$lib" "$STAGE/"
          done < <(find build -name "*.dylib" -print | sort)

          # Make dylib lookup portable inside the extracted archive.
          for target in "$STAGE"/whisper-* "$STAGE"/*.dylib; do
            [ -e "$target" ] || continue

            install_name_tool -add_rpath "@loader_path" "$target" 2>/dev/null || true

            if [ "${target##*.}" = "dylib" ] && [ ! -L "$target" ]; then
              install_name_tool -id "@rpath/$(basename "$target")" "$target" 2>/dev/null || true
            fi

            while IFS= read -r dep; do
              case "$dep" in
                "$PWD"/build/*|/Users/runner/work/whisper.cpp-rocm/*)
                  install_name_tool -change "$dep" "@rpath/$(basename "$dep")" "$target" 2>/dev/null || true
                  ;;
              esac
            done < <(otool -L "$target" 2>/dev/null | awk 'NR > 1 {print $1}')
          done

          echo "--- packaged files ---"
          find "$STAGE" -maxdepth 1 -type f -o -type l | sort

          echo "--- whisper-server dependencies after packaging ---"
          otool -L "$STAGE/whisper-server"
          otool -l "$STAGE/whisper-server" | grep -A2 LC_RPATH || true

          if otool -L "$STAGE/whisper-server" | grep -q "/Users/runner/work/whisper.cpp-rocm"; then
            echo "::error::whisper-server still references non-portable build paths"
            exit 1
          fi

          if ! find "$STAGE" -maxdepth 1 \( -type f -o -type l \) -name "libwhisper*.dylib" | grep -q .; then
            echo "::error::packaged archive is missing libwhisper dylib"
            exit 1
          fi

          set +e
          DYLD_LIBRARY_PATH="$PWD/$STAGE" "$STAGE/whisper-server" --help > whisper-server-smoke.log 2>&1
          smoke_status=$?
          set -e

          cat whisper-server-smoke.log

          if grep -q "Library not loaded" whisper-server-smoke.log; then
            echo "::error::whisper-server has unresolved dylib dependencies"
            exit 1
          fi

          echo "whisper-server smoke command exited with status ${smoke_status}"

          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> "$GITHUB_ENV"

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 8. CPU — Linux
# ════════════════════════════════════════════════════════════════════════════════
  linux-cpu:
    runs-on: ubuntu-latest
    needs: determine-tag

    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y build-essential cmake git libsdl2-dev pkg-config
          echo "cmake $(cmake --version | head -1)"
          echo "gcc $(gcc --version | head -1)"

      - name: Configure CMake
        run: |
          cmake -B build \
            -DCMAKE_BUILD_TYPE=Release \
            -DGGML_NATIVE=OFF \
            -DGGML_AVX=ON \
            -DGGML_AVX2=ON \
            -DGGML_FMA=ON \
            -DGGML_AVX512=OFF \
            -DCMAKE_C_FLAGS="-march=x86-64-v3" \
            -DCMAKE_CXX_FLAGS="-march=x86-64-v3" \
            -DWHISPER_BUILD_EXAMPLES=ON \
            -DWHISPER_BUILD_TESTS=OFF \
            -DWHISPER_BUILD_SERVER=ON

      - name: Build
        run: cmake --build build --config Release -j$(nproc)

      - name: List build output
        run: |
          find build/bin -type f | sort
          find build/bin -type f -executable | while read f; do ls -lh "$f"; done

      - name: Package
        run: |
          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-linux-cpu-x86_64.tar.gz"
          STAGE="whisper-${VER}-linux-cpu-x86_64"
          mkdir -p "$STAGE"
          cp -r build/bin/* "$STAGE/" 2>/dev/null || true
          find build -name "*.so*" -exec cp {} "$STAGE/" \; 2>/dev/null || true
          printf "whisper.cpp CPU build for Linux\nDate: %s\nArch: %s\n" \
            "$(date -u +"%Y-%m-%d %H:%M:%S UTC")" "$(uname -m)" > "$STAGE/README.txt"
          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 8b. CPU / Vulkan — Linux musl (Alpine)
# Compiled inside an Alpine container so it links musl; libstdc++/libgcc are
# static so the archive is self-contained. arm64 drops the x86-only march/AVX
# flags. Runs on native ARM runners for arm64 (no QEMU).
# ════════════════════════════════════════════════════════════════════════════════
  linux-musl-cpu:
    runs-on: ${{ matrix.runner }}
    needs: determine-tag
    strategy:
      fail-fast: false
      matrix:
        include:
          - runner: ubuntu-latest
            arch: x86_64
            cpu_flags: "-DGGML_AVX=ON -DGGML_AVX2=ON -DGGML_FMA=ON -DGGML_AVX512=OFF -DCMAKE_C_FLAGS=-march=x86-64-v3 -DCMAKE_CXX_FLAGS=-march=x86-64-v3"
          - runner: ubuntu-24.04-arm
            arch: aarch64
            cpu_flags: ""
    steps:
      - uses: actions/checkout@v4

      - name: Build (Alpine / musl)
        run: |
          docker run --rm -v "$PWD:/src" -w /src alpine:latest sh -euxc '
            apk add --no-cache build-base cmake git sdl2-dev
            cmake -B build \
              -DCMAKE_BUILD_TYPE=Release \
              -DGGML_NATIVE=OFF \
              ${{ matrix.cpu_flags }} \
              -DWHISPER_BUILD_EXAMPLES=ON \
              -DWHISPER_BUILD_TESTS=OFF \
              -DWHISPER_BUILD_SERVER=ON \
              -DCMAKE_EXE_LINKER_FLAGS="-static-libgcc -static-libstdc++" \
              -DCMAKE_SHARED_LINKER_FLAGS="-static-libgcc -static-libstdc++"
            cmake --build build --config Release -j"$(nproc)"
            chmod -R a+rwX build
          '

      - name: Package
        run: |
          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-linux-musl-cpu-${{ matrix.arch }}.tar.gz"
          STAGE="whisper-${VER}-linux-musl-cpu-${{ matrix.arch }}"
          mkdir -p "$STAGE"
          cp -r build/bin/* "$STAGE/" 2>/dev/null || true
          find build -name "*.so*" -exec cp {} "$STAGE/" \; 2>/dev/null || true
          # Rewrite the absolute build-tree rpath to $ORIGIN so the relocated musl
          # binaries find their sibling .so files (musl doesn't search the exe dir).
          if ! command -v patchelf >/dev/null; then sudo apt-get update -qq && sudo apt-get install -y -qq patchelf; fi
          for f in "$STAGE"/*; do
            [ -f "$f" ] && [ ! -L "$f" ] && file "$f" | grep -q ELF && patchelf --set-rpath '$ORIGIN' "$f" 2>/dev/null || true
          done
          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

  linux-musl-vulkan:
    runs-on: ${{ matrix.runner }}
    needs: determine-tag
    strategy:
      fail-fast: false
      matrix:
        include:
          - runner: ubuntu-latest
            arch: x86_64
            cpu_flags: "-DGGML_AVX=ON -DGGML_AVX2=ON -DGGML_FMA=ON -DGGML_AVX512=OFF -DCMAKE_C_FLAGS=-march=x86-64-v3 -DCMAKE_CXX_FLAGS=-march=x86-64-v3"
          - runner: ubuntu-24.04-arm
            arch: aarch64
            cpu_flags: ""
    steps:
      - uses: actions/checkout@v4

      - name: Build (Alpine / musl)
        run: |
          docker run --rm -v "$PWD:/src" -w /src alpine:latest sh -euxc '
            apk add --no-cache build-base cmake git sdl2-dev \
              vulkan-loader-dev vulkan-headers glslang shaderc spirv-tools spirv-headers
            cmake -B build \
              -DCMAKE_BUILD_TYPE=Release \
              -DGGML_NATIVE=OFF \
              ${{ matrix.cpu_flags }} \
              -DGGML_VULKAN=ON \
              -DWHISPER_BUILD_EXAMPLES=ON \
              -DWHISPER_BUILD_TESTS=OFF \
              -DWHISPER_BUILD_SERVER=ON \
              -DCMAKE_EXE_LINKER_FLAGS="-static-libgcc -static-libstdc++" \
              -DCMAKE_SHARED_LINKER_FLAGS="-static-libgcc -static-libstdc++"
            cmake --build build --config Release -j"$(nproc)"
            chmod -R a+rwX build
          '

      - name: Package
        run: |
          VER="${{ needs.determine-tag.outputs.version }}"
          ARCHIVE="whisper-${VER}-linux-musl-vulkan-${{ matrix.arch }}.tar.gz"
          STAGE="whisper-${VER}-linux-musl-vulkan-${{ matrix.arch }}"
          mkdir -p "$STAGE"
          cp -r build/bin/* "$STAGE/" 2>/dev/null || true
          find build -name "*.so*" -exec cp {} "$STAGE/" \; 2>/dev/null || true
          # Rewrite the absolute build-tree rpath to $ORIGIN so the relocated musl
          # binaries find their sibling .so files (musl doesn't search the exe dir).
          if ! command -v patchelf >/dev/null; then sudo apt-get update -qq && sudo apt-get install -y -qq patchelf; fi
          for f in "$STAGE"/*; do
            [ -f "$f" ] && [ ! -L "$f" ] && file "$f" | grep -q ELF && patchelf --set-rpath '$ORIGIN' "$f" 2>/dev/null || true
          done
          tar -czf "$ARCHIVE" "$STAGE"
          echo "ARCHIVE=$ARCHIVE" >> $GITHUB_ENV

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 8. CPU — Windows
# ════════════════════════════════════════════════════════════════════════════════
  windows-cpu:
    runs-on: windows-latest
    needs: determine-tag

    steps:
      - uses: actions/checkout@v4

      - uses: microsoft/setup-msbuild@v2

      - name: Fetch SDL2
        shell: pwsh
        run: |
          C:/msys64/usr/bin/wget.exe -qO sdl2.zip https://github.com/libsdl-org/SDL/releases/download/release-2.28.5/SDL2-devel-2.28.5-VC.zip
          7z x sdl2.zip
          "SDL2_DIR=$env:GITHUB_WORKSPACE/SDL2-2.28.5/cmake" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - name: Configure CMake
        shell: pwsh
        run: |
          cmake -S . -B ./build -A x64 `
            -DCMAKE_BUILD_TYPE=Release `
            -DGGML_NATIVE=OFF `
            -DGGML_AVX=ON `
            -DGGML_AVX2=ON `
            -DGGML_FMA=ON `
            -DGGML_AVX512=OFF `
            -DBUILD_SHARED_LIBS=ON `
            -DWHISPER_BUILD_SERVER=ON `
            -DWHISPER_SDL2=ON

      - name: Build
        run: cd ./build && msbuild ALL_BUILD.vcxproj -t:build -p:configuration=Release -p:platform=x64

      - name: Copy SDL2.dll
        shell: pwsh
        run: copy "$env:SDL2_DIR/../lib/x64/SDL2.dll" build/bin/Release

      - name: Package
        shell: pwsh
        run: |
          $a = "whisper-${{ needs.determine-tag.outputs.version }}-windows-cpu-x64.zip"
          Compress-Archive -Path "build/bin/Release/*" -DestinationPath $a -Force
          "ARCHIVE=$a" | Out-File $env:GITHUB_ENV -Append -Encoding utf8

      - uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ARCHIVE }}
          path: ${{ env.ARCHIVE }}

# ════════════════════════════════════════════════════════════════════════════════
# 9. Publish GitHub Release
# ════════════════════════════════════════════════════════════════════════════════
# Shared model download step (reused across all test jobs via inline steps)
# Models: ggml-tiny.bin from HuggingFace ggerganov/whisper.cpp
#         ggml-tiny-encoder-vitisai.rai from amd/whisper-tiny-onnx-npu
# ════════════════════════════════════════════════════════════════════════════════

# ════════════════════════════════════════════════════════════════════════════════
# 9. Test — CPU Windows (GitHub-hosted, no GPU needed)
# ════════════════════════════════════════════════════════════════════════════════
  test-cpu-windows:
    runs-on: windows-latest
    needs: [determine-tag, windows-cpu]
    if: needs.windows-cpu.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-windows-cpu-x64.zip
          path: ./artifact

      - name: Extract
        shell: pwsh
        run: |
          New-Item -ItemType Directory -Force -Path bin | Out-Null
          Expand-Archive -Path (Get-ChildItem artifact -Filter "*.zip" | Select-Object -First 1).FullName -DestinationPath bin -Force

      - name: Download tiny model
        shell: pwsh
        run: |
          New-Item -ItemType Directory -Force -Path models | Out-Null
          Invoke-WebRequest -Uri "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin" -OutFile "models\ggml-tiny.bin"

      - name: Run and verify
        shell: pwsh
        run: |
          .\bin\whisper-cli.exe -m models\ggml-tiny.bin -f samples\jfk.wav -otxt -of jfk-result
          $text = Get-Content "jfk-result.txt" -Raw
          Write-Host $text
          if ($text -match "country|ask not|nation|kennedy") { Write-Host "PASS" -ForegroundColor Green }
          else { Write-Error "FAIL: expected words not found"; exit 1 }

# ════════════════════════════════════════════════════════════════════════════════
# 10. Test — CPU Linux (GitHub-hosted, no GPU needed)
# ════════════════════════════════════════════════════════════════════════════════
  test-cpu-linux:
    runs-on: ubuntu-latest
    needs: [determine-tag, linux-cpu]
    if: needs.linux-cpu.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-linux-cpu-x86_64.tar.gz
          path: ./artifact

      - name: Extract
        run: |
          mkdir -p bin
          tar -xzf artifact/*.tar.gz --strip-components=1 -C bin
          chmod +x bin/whisper-cli

      - name: Download tiny model
        run: |
          mkdir -p models
          curl -L -o models/ggml-tiny.bin "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin"

      - name: Run and verify
        run: |
          LD_LIBRARY_PATH=$(pwd)/bin:$LD_LIBRARY_PATH ./bin/whisper-cli -m models/ggml-tiny.bin -f samples/jfk.wav -otxt -of jfk-result
          cat jfk-result.txt
          grep -qi "country\|ask not\|nation\|kennedy" jfk-result.txt && echo "PASS" || { echo "FAIL"; exit 1; }

# ════════════════════════════════════════════════════════════════════════════════
# 11. Test — Vulkan Windows (stx-halo, has Vulkan driver)
# ════════════════════════════════════════════════════════════════════════════════
  test-vulkan-windows:
    runs-on: [self-hosted, Windows, stx-halo]
    needs: [determine-tag, windows-vulkan]
    if: needs.windows-vulkan.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-windows-vulkan-x64.zip
          path: ./artifact

      - name: Extract
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path bin | Out-Null
          Expand-Archive -Path (Get-ChildItem artifact -Filter "*.zip" | Select-Object -First 1).FullName -DestinationPath bin -Force

      - name: Download tiny model
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path models | Out-Null
          Invoke-WebRequest -Uri "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin" -OutFile "models\ggml-tiny.bin"

      - name: Run and verify
        shell: powershell
        run: |
          .\bin\whisper-cli.exe -m models\ggml-tiny.bin -f samples\jfk.wav -otxt -of jfk-result
          $text = Get-Content "jfk-result.txt" -Raw
          Write-Host $text
          if ($text -match "country|ask not|nation|kennedy") { Write-Host "PASS" }
          else { Write-Error "FAIL: expected words not found"; exit 1 }

# ════════════════════════════════════════════════════════════════════════════════
# 12. Test — Vulkan Linux (stx-halo, has Vulkan driver)
# ════════════════════════════════════════════════════════════════════════════════
  test-vulkan-linux:
    runs-on: [self-hosted, Linux, stx-halo]
    needs: [determine-tag, linux-vulkan]
    if: needs.linux-vulkan.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-linux-vulkan-x86_64.tar.gz
          path: ./artifact

      - name: Extract
        run: |
          mkdir -p bin
          tar -xzf artifact/*.tar.gz --strip-components=1 -C bin
          chmod +x bin/whisper-cli

      - name: Download tiny model
        run: |
          mkdir -p models
          curl -L -o models/ggml-tiny.bin "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin"

      - name: Run and verify
        run: |
          LD_LIBRARY_PATH=$(pwd)/bin:$LD_LIBRARY_PATH ./bin/whisper-cli -m models/ggml-tiny.bin -f samples/jfk.wav -otxt -of jfk-result
          cat jfk-result.txt
          grep -qi "country\|ask not\|nation\|kennedy" jfk-result.txt && echo "PASS" || { echo "FAIL"; exit 1; }

# ════════════════════════════════════════════════════════════════════════════════
# 13. Test — ROCm Windows (stx-halo, gfx1151)
# ════════════════════════════════════════════════════════════════════════════════
  test-rocm-windows:
    runs-on: [self-hosted, Windows, stx-halo]
    needs: [determine-tag, windows-rocm]
    if: needs.windows-rocm.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download ROCm artifact (gfx1151 - stx-halo GPU target)
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-windows-rocm-gfx1151.zip
          path: ./artifact

      - name: Extract
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path bin | Out-Null
          Expand-Archive -Path (Get-ChildItem artifact -Filter "*.zip" | Select-Object -First 1).FullName -DestinationPath bin -Force

      - name: Download tiny model
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path models | Out-Null
          Invoke-WebRequest -Uri "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin" -OutFile "models\ggml-tiny.bin"

      - name: Run and verify
        shell: powershell
        run: |
          .\bin\whisper-cli.exe -m models\ggml-tiny.bin -f samples\jfk.wav -otxt -of jfk-result
          $text = Get-Content "jfk-result.txt" -Raw
          Write-Host $text
          if ($text -match "country|ask not|nation|kennedy") { Write-Host "PASS" }
          else { Write-Error "FAIL: expected words not found"; exit 1 }

# ════════════════════════════════════════════════════════════════════════════════
# 14. Test — ROCm Linux (stx-halo, gfx1151)
# ════════════════════════════════════════════════════════════════════════════════
  test-rocm-linux:
    runs-on: [self-hosted, Linux, stx-halo]
    needs: [determine-tag, linux-rocm]
    if: needs.linux-rocm.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download ROCm artifact (gfx1151)
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-linux-rocm-gfx1151.tar.gz
          path: ./artifact

      - name: Extract
        run: |
          mkdir -p bin
          tar -xzf artifact/*.tar.gz --strip-components=1 -C bin
          chmod +x bin/whisper-cli

      - name: Download tiny model
        run: |
          mkdir -p models
          curl -L -o models/ggml-tiny.bin "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin"

      - name: Run and verify
        run: |
          LD_LIBRARY_PATH=$(pwd)/bin:$LD_LIBRARY_PATH ./bin/whisper-cli -m models/ggml-tiny.bin -f samples/jfk.wav -otxt -of jfk-result
          cat jfk-result.txt
          grep -qi "country\|ask not\|nation\|kennedy" jfk-result.txt && echo "PASS" || { echo "FAIL"; exit 1; }

# ════════════════════════════════════════════════════════════════════════════════
# 15. Test — NPU Windows (rai300_400 runner, needs FlexML + .rai model)
# ════════════════════════════════════════════════════════════════════════════════
  test-npu-windows:
    runs-on: [self-hosted, Windows, stx, rai300_400]
    needs: [determine-tag, windows-npu]
    if: needs.windows-npu.result == 'success'
    continue-on-error: true
    steps:
      - uses: actions/checkout@v4

      - name: Download NPU artifact
        uses: actions/download-artifact@v4
        with:
          name: whisper-${{ needs.determine-tag.outputs.version }}-windows-npu-x64.zip
          path: ./artifact

      - name: Extract
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path bin | Out-Null
          Expand-Archive -Path (Get-ChildItem artifact -Filter "*.zip" | Select-Object -First 1).FullName -DestinationPath bin -Force

      - name: Download FlexML Runtime and setup environment
        shell: powershell
        run: |
          Invoke-WebRequest -Uri "${{ env.FLEXML_URL }}" -OutFile flexmlrt.zip
          tar xvf flexmlrt.zip
          Remove-Item flexmlrt.zip

      - name: Setup FlexML environment
        shell: cmd
        run: |
          cd flexmlrt
          call setup.bat
          if errorlevel 1 ( echo ERROR: FlexML setup failed! & exit /b 1 )

      - name: Copy FlexML DLLs to bin
        shell: powershell
        run: |
          $flexml = Get-ChildItem -Directory | Where-Object { $_.Name -like "flexmlrt*" } | Select-Object -First 1
          foreach ($sub in @("bin","lib")) {
            $path = Join-Path $flexml.FullName $sub
            if (Test-Path $path) {
              Get-ChildItem "$path\*.dll" -ErrorAction SilentlyContinue |
                ForEach-Object { Copy-Item $_.FullName "bin\" -Force }
            }
          }

      - name: Download models (ggml weights + .rai NPU encoder)
        shell: powershell
        run: |
          New-Item -ItemType Directory -Force -Path models | Out-Null
          Invoke-WebRequest -Uri "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin" -OutFile "models\ggml-tiny.bin"
          Invoke-WebRequest -Uri "https://huggingface.co/amd/whisper-tiny-onnx-npu/resolve/main/ggml-tiny-encoder-vitisai.rai" -OutFile "models\ggml-tiny-encoder-vitisai.rai"
          Write-Host "Models:"
          Get-ChildItem models | Format-Table Name, Length

      - name: Run and verify (NPU encoder + CPU decoder)
        shell: powershell
        run: |
          .\bin\whisper-cli.exe -m models\ggml-tiny.bin -f samples\jfk.wav -otxt -of jfk-result
          $text = Get-Content "jfk-result.txt" -Raw
          Write-Host $text
          if ($text -match "country|ask not|nation|kennedy") { Write-Host "PASS: transcription correct" -ForegroundColor Green }
          else { Write-Error "FAIL: expected words not found"; exit 1 }

# ════════════════════════════════════════════════════════════════════════════════
# 16. Publish GitHub Release (only after all tests pass or are skipped)
# ════════════════════════════════════════════════════════════════════════════════
  release:
    if: |
      always() &&
      needs.determine-tag.outputs.should_release == 'true' &&
      (needs.test-cpu-windows.result == 'success' || needs.test-cpu-windows.result == 'skipped') &&
      (needs.test-cpu-linux.result == 'success' || needs.test-cpu-linux.result == 'skipped') &&
      (needs.test-vulkan-windows.result == 'success' || needs.test-vulkan-windows.result == 'skipped') &&
      (needs.test-vulkan-linux.result == 'success' || needs.test-vulkan-linux.result == 'skipped') &&
      (needs.test-rocm-windows.result == 'success' || needs.test-rocm-windows.result == 'skipped') &&
      (needs.test-rocm-linux.result == 'success' || needs.test-rocm-linux.result == 'skipped') &&
      (needs.test-npu-windows.result == 'success' || needs.test-npu-windows.result == 'skipped') &&
      (needs.macos-metal.result == 'success' || needs.macos-metal.result == 'skipped')
    runs-on: ubuntu-latest
    needs:
      - determine-tag
      - linux-rocm
      - windows-rocm
      - linux-vulkan
      - windows-vulkan
      - windows-npu
      - macos-metal
      - linux-cpu
      - windows-cpu
      - linux-musl-cpu
      - linux-musl-vulkan
      - test-cpu-windows
      - test-cpu-linux
      - test-vulkan-windows
      - test-vulkan-linux
      - test-rocm-windows
      - test-rocm-linux
      - test-npu-windows

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Download all artifacts
        uses: actions/download-artifact@v4
        with:
          path: ./artifacts

      - name: Flatten artifacts into release/
        run: |
          mkdir -p release
          find ./artifacts -mindepth 2 \( -name '*.zip' -o -name '*.tar.gz' \) -exec mv {} release/ \;
          echo "Release assets:"
          ls -lh release/

      - name: Delete existing release/tag if present
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          TAG="${{ needs.determine-tag.outputs.tag_name }}"
          RELEASE_ID=$(gh api repos/${{ github.repository }}/releases/tags/"$TAG" --jq '.id' 2>/dev/null || true)
          if [ -n "$RELEASE_ID" ]; then
            echo "Deleting existing release $RELEASE_ID for tag $TAG"
            gh api -X DELETE repos/${{ github.repository }}/releases/"$RELEASE_ID"
          fi
          git push --delete origin "refs/tags/$TAG" 2>/dev/null || true

      - name: Create release
        id: create_release
        uses: ggml-org/action-create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name:     ${{ needs.determine-tag.outputs.tag_name }}
          release_name: "whisper.cpp ${{ needs.determine-tag.outputs.tag_name }} - AMD Builds"
          prerelease:   ${{ github.event.inputs.pre_release_tag != '' }}
          draft: false
          body: |
            ## AMD whisper.cpp ${{ needs.determine-tag.outputs.tag_name }}

            AMD-based pre-built binaries of [whisper.cpp ${{ needs.determine-tag.outputs.tag_name }}](https://github.com/ggerganov/whisper.cpp/releases/tag/${{ needs.determine-tag.outputs.tag_name }}) with full hardware acceleration across ROCm GPU (iGPU and dGPU), NPU (RyzenAI), and CPU — for Linux and Windows.
            All ROCm runtime libraries (ROCm ${{ env.ROCM_VERSION }}) are bundled. No drivers or separate installs required — download, extract, and run.

            ### Packages

            | Target | Linux | Windows |
            |---|---|---|
            | ROCm gfx1151 (Ryzen AI MAX+ Pro 395) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-rocm-gfx1151.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-rocm-gfx1151.zip` |
            | ROCm gfx1150 (Ryzen AI 300) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-rocm-gfx1150.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-rocm-gfx1150.zip` |
            | ROCm gfx120X (RDNA4 dGPU) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-rocm-gfx120X.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-rocm-gfx120X.zip` |
            | ROCm gfx110X (RDNA3 dGPU & iGPU) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-rocm-gfx110X.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-rocm-gfx110X.zip` |
            | Vulkan (cross-vendor) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-vulkan-x86_64.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-vulkan-x64.zip` |
            | NPU (RyzenAI) | — | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-npu-x64.zip` |
            | Metal (Apple Silicon) | `whisper-${{ needs.determine-tag.outputs.tag_name }}-darwin-metal-arm64.tar.gz` | — |
            | CPU only | `whisper-${{ needs.determine-tag.outputs.tag_name }}-linux-cpu-x86_64.tar.gz` | `whisper-${{ needs.determine-tag.outputs.tag_name }}-windows-cpu-x64.zip` |

      - name: Upload release assets
        uses: actions/github-script@v7
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const fs   = require('fs');
            const path = require('path');
            const id   = '${{ steps.create_release.outputs.id }}';
            for (const file of fs.readdirSync('./release')) {
              if (!file.endsWith('.zip') && !file.endsWith('.tar.gz')) continue;
              console.log('Uploading:', file);
              await github.rest.repos.uploadReleaseAsset({
                owner: context.repo.owner,
                repo:  context.repo.repo,
                release_id: id,
                name: file,
                data: fs.readFileSync(`./release/${file}`),
              });
            }

      - name: Update README download links
        run: |
          TAG="${{ needs.determine-tag.outputs.tag_name }}"
          # Replace the placeholder tag in all download URLs with the actual release tag
          sed -i "s|/releases/download/[^/]*/whisper-[^-]*-|/releases/download/${TAG}/whisper-${TAG}-|g" README.md
          git config user.name  "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add README.md
          git diff --cached --quiet || git commit -m "docs: update download links to ${TAG}"
          git push