GKI_KernelSU_SUSFS/.github/workflows/build.yml

name: Kernel Build Process
permissions:
  contents: write
  actions: write

on:
  workflow_call:
    inputs:
      kernel_version:
        required: true
        type: string
      variant:
        required: false
        type: string
      feature_set:
        required: true
        type: string
      use_repo:
        required: false
        type: boolean

jobs:
  build-gki:
    name: "${{ inputs.kernel_version }} (${{ inputs.variant }})"
    runs-on: ubuntu-latest
    timeout-minutes: 60

    steps:
    - name: Checkout Repository
      uses: actions/checkout@v5

    - name: Parse kernel version
      id: parse
      uses: ./.github/actions/parse-kernel-version
      with:
        kernel_version: ${{ inputs.kernel_version }}

    - name: Free Disk Space
      if: true
      uses: endersonmenezes/free-disk-space@v3  # Use @main for latest, @v3 for stable
      with:
        remove_android: true
        remove_dotnet: true
        remove_haskell: true
        remove_tool_cache: true
        remove_packages: "azure-cli google-cloud-cli microsoft-edge-stable google-chrome-stable firefox postgresql* temurin-* *llvm* mysql* dotnet-sdk-*"
        remove_packages_one_command: true
        remove_folders: "/usr/share/swift /usr/share/miniconda /usr/share/az* /usr/local/lib/node_modules /usr/local/share/chromium /usr/local/share/powershell /usr/local/julia /usr/local/aws-cli /usr/local/aws-sam-cli /usr/share/gradle"
        rm_cmd: "rmz"  # Use 'rmz' for faster deletion (default: 'rm')
        rmz_version: "3.1.1"  # Required when rm_cmd is 'rmz'
        testing: false

    - name: Setup more Swap (for LTO)
      uses: thejerrybao/setup-swap-space@v1   # or pierotofy/set-swap-space
      with:
        swap-size-gb: 10          # 10-24 GB is common for heavy LTO
        # swap-space-path: /mnt/swapfile   # optional

    - name: Setup Build Environment
      uses: ./.github/actions/setup-build-environment
      env:
        BOOT_SIGN_KEY: ${{ secrets.BOOT_SIGN_KEY }}
          
    - name: Download Kernel Repository
      uses: ./.github/actions/download-kernel
      with:
        android_version: ${{ steps.parse.outputs.android_version }}
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        os_patch_level: ${{ steps.parse.outputs.os_patch_level }}
        use_repo: ${{ inputs.use_repo }}

    - name: Extract Sublevel and Set File Name
      id: extract
      uses: ./.github/actions/extract-sublevel-file-name
      with:
        variant: ${{ inputs.variant }}

    - name: Kernel Fixes
      uses: ./.github/actions/kernel-fixes
      with:
        android_version: ${{ steps.parse.outputs.android_version }}
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        sublevel: ${{ steps.extract.outputs.sublevel }}
        os_patch_level: ${{ steps.parse.outputs.os_patch_level }}

    - name: Setup KernelSU-Next
      if: contains(inputs.feature_set, 'KSUN') || inputs.feature_set == 'FULL'
      uses: ./.github/actions/kernelsu

    - name: SUSFS
      if: contains(inputs.feature_set, 'SUSFS') || inputs.feature_set == 'FULL'
      uses: ./.github/actions/susfs
      with:
        android_version: ${{ steps.parse.outputs.android_version }}
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        os_patch_level: ${{ steps.parse.outputs.os_patch_level }}
        sublevel: ${{ steps.extract.outputs.sublevel }}

    - name: Baseband Guard
      if: contains(inputs.feature_set, 'BBG') || inputs.feature_set == 'FULL'
      uses: ./.github/actions/bbg

    - name: Setup Networking
      if: contains(inputs.feature_set, 'NET') || inputs.feature_set == 'FULL'
      uses: ./.github/actions/networking
      with:
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        android_version: ${{ steps.parse.outputs.android_version }}

    - name: DroidSpaces-OSS Patches
      if: contains(inputs.feature_set, 'DS') || inputs.feature_set == 'FULL'
      uses: ./.github/actions/droidspaces
      with:
        kernel_version: ${{ steps.parse.outputs.kernel_version }}

    - name: Setup Misc Configs
      uses: ./.github/actions/misc
      with:
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        android_version: ${{ steps.parse.outputs.android_version }}

    - name: Apply Module Check Bypass
      if: ${{ inputs.variant == 'Bypass' }}
      uses: ./.github/actions/module-check-bypass
      with:
        kernel_version: ${{ steps.parse.outputs.kernel_version }}

    - name: Apply Device-Specific Patches
      uses: ./.github/actions/apply-device-patches
      with:
        kernel_version: ${{ steps.parse.outputs.kernel_version }}

    - name: Apply ABI Compare Bypass
      if: false
      working-directory: ${{ github.workspace }}/kernel
      run: |
        # ABI compare bypass per kernel/android version
        # Edit each block as needed per version
        if [[ "$ANDROID_VERSION" == "android12" && "$KERNEL_VERSION" == "5.10" ]]; then
          sed -i 's/^\s*exit 1$/    echo "Who Cares? Bypassing Now!"/' build/abi/compare_to_symbol_list
        elif [[ "$ANDROID_VERSION" == "android13" && "$KERNEL_VERSION" == "5.10" ]]; then
          sed -i 's/^\s*exit 1$/    echo "Who Cares? Bypassing Now!"/' build/kernel/abi/compare_to_symbol_list
        elif [[ "$ANDROID_VERSION" == "android13" && "$KERNEL_VERSION" == "5.15" ]]; then
          sed -i 's/^\s*exit 1$/    echo "Who Cares? Bypassing Now!"/' build/kernel/abi/compare_to_symbol_list
        elif [[ "$ANDROID_VERSION" == "android14" && "$KERNEL_VERSION" == "5.15" ]]; then
          perl -i -pe 's/^(\s*)return 1$/$1print("Who Cares? Bypassing Now!")\n$1return 0/g if /if missing_symbols:/../return 1/' build/kernel/abi/check_buildtime_symbol_protection.py
        elif [[ "$ANDROID_VERSION" == "android14" && "$KERNEL_VERSION" == "6.1" ]]; then
          perl -i -pe 's/^(\s*)return 1$/$1print("Who Cares? Bypassing Now!")\n$1return 0/g if /if missing_symbols:/../return 1/' build/kernel/abi/check_buildtime_symbol_protection.py
        elif [[ "$ANDROID_VERSION" == "android15" && "$KERNEL_VERSION" == "6.6" ]]; then
          perl -i -pe 's/^(\s*)return 1$/$1print("Who Cares? Bypassing Now!")\n$1return 0/g if /if missing_symbols:/../return 1/' build/kernel/abi/check_buildtime_symbol_protection.py
        fi

    - name: Apply Kernel Branding
      uses: ./.github/actions/apply-kernel-branding
      with:
        variant: ${{ inputs.variant }}
        kernel_version: ${{ steps.parse.outputs.kernel_version }}
        android_version: ${{ steps.parse.outputs.android_version }}
        sublevel: ${{ steps.extract.outputs.sublevel }}

    - name: Remove Protected Exports
      uses: ./.github/actions/remove-protected-exports

    - name: Clean Kernel Flags
      uses: ./.github/actions/clean-kernel-flags

    - name: Scan and collect patch rejects
      id: scan
      if: ${{ always() && inputs.variant == 'Normal' }}
      uses: ./.github/actions/scan-patch-rejects
        
    - name: Upload Rejects
      if: ${{ always() && inputs.variant == 'Normal' }}
      uses: actions/upload-artifact@v7
      with:
        name: ${{ steps.extract.outputs.file_name }}-Rejects
        path: patch-rejects/
        if-no-files-found: ignore
        compression-level: 9

    - name: Restore build caches (ccache)
      id: restore-ccache
      uses: ./.github/actions/restore-cache
      with:
        cache_path: /home/runner/.ccache
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "ccache-cache"
        compression_level: 9
        restore_keys: |
          buildcache-

    - name: Check ccache hit
      run: |
        if [ "${{ steps.restore-ccache.outputs.cache-hit }}" = "true" ]; then
          echo "✅ ccache HIT - Key: ${{ steps.restore-ccache.outputs.cache-key }} - Size: ${{ steps.restore-ccache.outputs.cache-size }}"
        else
          echo "❌ ccache MISS - Fresh build"
        fi
    
    - name: Restore build caches (bazel)
      id: restore-bazel-cache
      uses: ./.github/actions/restore-cache
      with:
        cache_path: /home/runner/.cache/bazel
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "bazel-cache"
        compression_level: 9
        restore_keys: |
          buildcache-
    
    - name: Check bazel cache hit
      run: |
        if [ "${{ steps.restore-bazel-cache.outputs.cache-hit }}" = "true" ]; then
          echo "✅ bazel cache HIT - Key: ${{ steps.restore-bazel-cache.outputs.cache-key }} - Size: ${{ steps.restore-bazel-cache.outputs.cache-size }}"
        else
          echo "❌ bazel cache MISS - Fresh build"
        fi

    - name: Restore build caches (LTO/ld_cache)
      id: restore-ldcache
      uses: ./.github/actions/restore-cache
      with:
        cache_path: /home/runner/.ld_cache
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "lto-cache"
        compression_level: 9
        restore_keys: |
          buildcache-

    - name: Check ld_cache hit
      run: |
        if [ "${{ steps.restore-ldcache.outputs.cache-hit }}" = "true" ]; then
          echo "✅ ld_cache HIT - Key: ${{ steps.restore-ldcache.outputs.cache-key }} - Size: ${{ steps.restore-ldcache.outputs.cache-size }}"
        else
          echo "❌ ld_cache MISS - Fresh build"
        fi

    - name: Pre-build cache stats
      id: pre-cache-stats
      run: |
        set -euo pipefail
        stats=$(ccache -s || true)
        pre_hits=$(echo "$stats" | awk '/cache hit/ {h+=$NF} END{print (h+0)}')
        pre_misses=$(echo "$stats" | awk '/cache miss/ {m+=$NF} END{print (m+0)}')
        echo "pre_hits=$pre_hits" >> $GITHUB_OUTPUT
        echo "pre_misses=$pre_misses" >> $GITHUB_OUTPUT
        pre_ld_size=$(du -sh "/home/runner/.ld_cache" 2>/dev/null | awk '{print $1}' || echo "0B")
        pre_ld_files=$(find "/home/runner/.ld_cache" -type f 2>/dev/null | wc -l || true)
        echo "pre_ld_size=$pre_ld_size" >> $GITHUB_OUTPUT
        echo "pre_ld_files=$pre_ld_files" >> $GITHUB_OUTPUT

    - name: 'Setup ccache and Build Environment'
      shell: bash
      working-directory: ${{ github.workspace }}
      run: |
        set -euo pipefail
        
        # Download and install ccache
        echo "Installing ccache..."
        curl -LfsS --retry 5 --retry-delay 5 --retry-all-errors --connect-timeout 30 --tcp-fastopen -H "User-Agent: Mozilla/5.0" "https://github.com/WildKernels/kernel_patches/raw/refs/heads/main/ccache/ccache-x86-64" -o ccache || { echo "❌ Failed to download ccache"; exit 1; }
        sudo cp -f ./ccache /usr/bin/ccache || { echo "❌ Failed to install ccache"; exit 1; }
        sudo chmod +x /usr/bin/ccache
        rm -f ./ccache
        
        # Step 1: Verify ccache is installed
        echo "Verifying ccache installation..."
        /usr/bin/ccache --version || { echo "❌ ccache not found"; exit 1; }
        echo "✅ ccache installed at /usr/bin/ccache"
        
        # Step 2: Create symlinks directory
        SYMLINK_DIR="/usr/lib/ccache"
        echo "Creating symlinks directory: $SYMLINK_DIR"
        sudo mkdir -p "$SYMLINK_DIR"
        
        # Step 3: Create symlinks for compilers (DO USE symlinks, NOT hard links)
        echo "Creating compiler symlinks..."
        for compiler in gcc g++ cc c++ clang clang++; do
          sudo ln -sf /usr/bin/ccache "$SYMLINK_DIR/$compiler" || { echo "❌ Failed to create symlink for $compiler"; exit 1; }
        done
        echo "✅ Symlinks created in $SYMLINK_DIR"
        
        # Step 4: Prepend symlinks directory to PATH (MUST come before /usr/bin)
        echo "Prepending $SYMLINK_DIR to PATH..."
        echo "export PATH=\"$SYMLINK_DIR:\$PATH\"" >> "$GITHUB_ENV"
        export PATH="$SYMLINK_DIR:$PATH"
        
        # Step 5: Verify the setup
        echo "Verifying compiler masquerading..."
        which gcc | grep "$SYMLINK_DIR" || { echo "❌ gcc not pointing to ccache symlinks"; exit 1; }
        which g++ | grep "$SYMLINK_DIR" || { echo "❌ g++ not pointing to ccache symlinks"; exit 1; }
        echo "✅ gcc and g++ now routed through ccache"
        
        # Step 6: Configure ccache (optional - set max size, compression, etc.)
        CCACHE_MAX_SIZE="12G"
        echo "Setting max cache size to $CCACHE_MAX_SIZE..."
        sudo ccache -M "$CCACHE_MAX_SIZE" || ccache -M "$CCACHE_MAX_SIZE"
        
        # Enable compression (faster cache, slightly slower compilation)
        ccache --set-config compression=true
        
        # Step 7: Show ccache stats setup
        echo "✅ ccache setup complete!"
        ccache --show-stats
        
        # Step 8: Print what's done for debugging
        echo "--- ccache setup info ---"
        echo "ccache binary: $(which ccache)"
        echo "gcc via ccache: $(which gcc)"
        echo "g++ via ccache: $(which g++)"
        echo "symlinks dir: $SYMLINK_DIR"
        echo "max size: $(ccache --show-stats | grep 'cache size' | awk '{print $3}')"
    - name: 'Setup ccache and Build Environment'
      shell: bash
      if: false
      working-directory: ${{ github.workspace }}
      run: |
        set -euo pipefail
        
        # Download and install ccache
        #echo "Installing ccache..."
        #curl -LfsS --retry 5 --retry-delay 5 --retry-all-errors --connect-timeout 30 --tcp-fastopen -H "User-Agent: Mozilla/5.0" "https://github.com/WildKernels/kernel_patches/raw/refs/heads/main/ccache/ccache-x86-64" -o ccache || { echo "❌ Failed to download ccache"; exit 1; }
        #sudo cp -f ./ccache /usr/bin/ccache || { echo "❌ Failed to install ccache"; exit 1; }
        #sudo chmod +x /usr/bin/ccache
        #rm -f ./ccache
        
        # Verify ccache
        if ! /usr/bin/ccache --version > /dev/null 2>&1; then
          echo "❌ ccache installation failed or binary is corrupted"
          exit 1
        fi
        echo "✅ ccache binary verified: $(/usr/bin/ccache --version | head -1)"
        
        # Setup cache directories
        #export CCACHE_DIR="/home/runner/.ccache"
        #echo "CCACHE_DIR=$CCACHE_DIR" >> $GITHUB_ENV
        #export LDCACHE_DIR="/home/runner/.ld_cache"
        #echo "LDCACHE_DIR=$LDCACHE_DIR" >> $GITHUB_ENV
        #mkdir -p "$CCACHE_DIR" "$LDCACHE_DIR"
        
        # Create LD wrapper for thin-LTO caching
        #cat > "$GITHUB_WORKSPACE/kernel/common/ld-wrapper" << 'EOF'
        #!/bin/bash
        #ld.lld "$@" --thinlto-cache-dir="$LDCACHE_DIR" --thinlto-jobs="$(nproc --all)"
        #EOF
        #chmod +x "$GITHUB_WORKSPACE/kernel/common/ld-wrapper"

        # Setup ccache compiler wrappers in PATH (masquerade method)
        # This intercepts compiler invocations regardless of how the build system calls them
        #mkdir -p "$GITHUB_WORKSPACE/ccache-bin"
        #cp /usr/bin/ccache "$GITHUB_WORKSPACE/ccache-bin/clang"
        #cp /usr/bin/ccache "$GITHUB_WORKSPACE/ccache-bin/clang++"
        #cp /usr/bin/ccache "$GITHUB_WORKSPACE/ccache-bin/gcc"
        #cp /usr/bin/ccache "$GITHUB_WORKSPACE/ccache-bin/g++"
        #cp /usr/bin/ccache "$GITHUB_WORKSPACE/ccache-bin/ld.lld"
        #chmod +x "$GITHUB_WORKSPACE/ccache-bin"/*
        
        # Export environment variables for subsequent steps
        #echo "PATH=$GITHUB_WORKSPACE/ccache-bin:$PATH" >> $GITHUB_ENV
        
        #export CC="/usr/bin/ccache clang"
        #echo "CC=$CC" >> $GITHUB_ENV
        #export CXX="/usr/bin/ccache clang++"
        #echo "CXX=$CXX" >> $GITHUB_ENV
        #export HOSTCC="/usr/bin/ccache clang"
        #echo "HOSTCC=$HOSTCC" >> $GITHUB_ENV
        #export HOSTCXX="/usr/bin/ccache clang++"
        #echo "HOSTCXX=$HOSTCXX" >> $GITHUB_ENV
        #export LD="$GITHUB_WORKSPACE/kernel/common/ld-wrapper"
        #echo "LD=$LD" >> $GITHUB_ENV
        #export HOSTLD="$GITHUB_WORKSPACE/kernel/common/ld-wrapper"
        #echo "HOSTLD=$HOSTLD" >> $GITHUB_ENV
        #echo "CLANG_PREBUILT_BIN=$GITHUB_WORKSPACE/ccache-bin" >> $GITHUB_ENV

        export CCACHE_MAXSIZE="12G"
        echo CCACHE_MAXSIZE="$CCACHE_MAXSIZE" >> $GITHUB_ENV
        export CCACHE_COMPILERCHECK="%compiler% -dumpmachine; %compiler% -dumpversion"
        echo CCACHE_COMPILERCHECK="$CCACHE_COMPILERCHECK" >> $GITHUB_ENV
        #export CCACHE_BASEDIR="${GITHUB_WORKSPACE}"
        #echo CCACHE_BASEDIR="${GITHUB_WORKSPACE}" >> $GITHUB_ENV
        export CCACHE_NOHASHDIR="true"
        echo CCACHE_NOHASHDIR="true" >> $GITHUB_ENV
        #export CCACHE_IGNOREOPTIONS="--sysroot*"
        #echo CCACHE_IGNOREOPTIONS="--sysroot*" >> $GITHUB_ENV
        #export CCACHE_COMPRESSION="true"
        #echo CCACHE_COMPRESSION="true" >> $GITHUB_ENV
        #export CCACHE_COMPRESSLEVEL="3"
        #echo CCACHE_COMPRESSION_LEVEL="3" >> $GITHUB_ENV
        #export CCACHE_DIRECT="true"
        #echo CCACHE_DIRECT="true" >> $GITHUB_ENV
        #export CCACHE_FILE_CLONE="true"
        #echo CCACHE_FILE_CLONE="true" >> $GITHUB_ENV
        #export CCACHE_INODE_CACHE="true"
        #echo CCACHE_INODE_CACHE="true" >> $GITHUB_ENV
        #export CCACHE_IS_KERNEL_COMPILING="true"
        #echo CCACHE_IS_KERNEL_COMPILING="true" >> $GITHUB_ENV
        #export CCACHE_UMASK="002"
        #echo CCACHE_UMASK="002" >> $GITHUB_ENV
        #export CCACHE_SLOPPINESS="file_macro,time_macros,include_file_mtime,include_file_ctime,pch_defines,system_headers,locale"
        #echo CCACHE_SLOPPINESS="file_macro,time_macros,include_file_mtime,include_file_ctime,pch_defines,system_headers,locale" >> $GITHUB_ENV
        export CCACHE_HARDLINK="true"
        echo CCACHE_HARDLINK="$CCACHE_HARDLINK" >> $GITHUB_ENV

        #if ccache --help 2>&1 | grep -q 'depend_mode'; then
        #  export CCACHE_DEPEND=true
        #  echo "CCACHE_DEPEND=true" >> "$GITHUB_ENV"
        #fi
        
        # Initialize ccache
        #ccache -M 100G
        #ccache -p
        #ccache -s
        #ccache -z
        
        echo "✅ Build environment ready"
        echo "   CCACHE_DIR: $CCACHE_DIR"
        #echo "   LDCACHE_DIR: $LDCACHE_DIR"
        #echo "   Compiler wrappers: $GITHUB_WORKSPACE/ccache-bin"

    - name: Build Kernel
      env:
        SOURCE_DATE_EPOCH: ${{ env.SOURCE_DATE_EPOCH }}
        KBUILD_BUILD_TIMESTAMP: ${{ env.KBUILD_BUILD_TIMESTAMP }}
      uses: ./.github/actions/build-kernel

    - name: 'Report Cache Sizes'
      shell: bash
      run: |
        set -euo pipefail
        echo "📊 Cache sizes after build:"
        echo "   CCACHE usage:"
        du -sh "$CCACHE_DIR" || echo "   (no ccache directory)"
        #echo "   LDCACHE usage:"
        #du -sh "$LDCACHE_DIR" || echo "   (no ldcache directory)"
        
        echo "Perform cache eviction!"
        # 3h = 10800s using seconds to support older ccache
        ccache --evict-older-than 10800s

    - name: Post-build cache stats
      id: post-cache-stats
      run: |
        set -euo pipefail
        stats=$(ccache -s || true)
        post_hits=$(echo "$stats" | awk '/cache hit/ {h+=$NF} END{print (h+0)}')
        post_misses=$(echo "$stats" | awk '/cache miss/ {m+=$NF} END{print (m+0)}')
        pre_hits=${{ steps.pre-cache-stats.outputs.pre_hits }}
        pre_misses=${{ steps.pre-cache-stats.outputs.pre_misses }}
        delta_hits=$((post_hits - pre_hits)) || true
        delta_misses=$((post_misses - pre_misses)) || true
        delta_total=$((delta_hits + delta_misses))
        if [ "$delta_total" -gt 0 ]; then
          percent=$(( delta_hits * 100 / delta_total ))
          echo "ccache hit during build: ${percent}% (${delta_hits} hits / ${delta_total} accesses)"
        else
          echo "No compiler activity detected (no ccache accesses)."
        fi
        post_ld_size=$(du -sh "/home/runner/.ld_cache" 2>/dev/null | awk '{print $1}' || echo "0B")
        post_ld_files=$(find "/home/runner/.ld_cache" -type f 2>/dev/null | wc -l || true)
        echo "ld_cache size before: ${{ steps.pre-cache-stats.outputs.pre_ld_size }}, after: $post_ld_size"
        echo "ld_cache files before: ${{ steps.pre-cache-stats.outputs.pre_ld_files }}, after: $post_ld_files"

    - name: List cache contents
      working-directory: ${{ github.workspace }}
      run: |
        echo "=== .ccache ==="
        du -sh /home/runner/.ccache || true
        ls -l /home/runner/.ccache || true
        echo "=== .cache/bazel ==="
        du -sh /home/runner/.cache/bazel || true
        ls -l /home/runner/.cache/bazel || true

    - name: Save ccache cache
      uses: ./.github/actions/save-cache
      with:
        cache_path: /home/runner/.ccache
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "ccache-cache"
        compression_level: 9
        github_token: ${{ secrets.GITHUB_TOKEN }}

    - name: Save bazel cache
      uses: ./.github/actions/save-cache
      with:
        cache_path: /home/runner/.cache/bazel
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "bazel-cache"
        compression_level: 9
        github_token: ${{ secrets.GITHUB_TOKEN }}

    - name: Save LTO LD cache
      uses: ./.github/actions/save-cache
      with:
        cache_path: /home/runner/.ld_cache
        cache_key: buildcache-${{ inputs.kernel_version }}
        cache_bucket: "lto-cache"
        compression_level: 9
        github_token: ${{ secrets.GITHUB_TOKEN }}

    - name: Create Bootimgs Folder and Build Boot Images
      uses: ./.github/actions/build-boot-images

    - name: Upload Boot Image (boot.img)
      uses: actions/upload-artifact@v7
      with:
        path: ${{ github.workspace }}/boot-artifacts/${{ steps.extract.outputs.file_name }}-boot.img
        if-no-files-found: error
        archive: false

    - name: Upload Boot Image (boot-gz.img)
      uses: actions/upload-artifact@v7
      with:
        path: ${{ github.workspace }}/boot-artifacts/${{ steps.extract.outputs.file_name }}-boot-gz.img
        if-no-files-found: error
        archive: false

    - name: Upload Boot Image (boot-lz4.img)
      uses: actions/upload-artifact@v7
      with:
        path: ${{ github.workspace }}/boot-artifacts/${{ steps.extract.outputs.file_name }}-boot-lz4.img
        if-no-files-found: error
        archive: false

    - name: Prepare AnyKernel3 Zip
      uses: ./.github/actions/prepare-anykernel3

    - name: Upload Artifacts
      uses: actions/upload-artifact@v7
      with:
        name: ${{ steps.extract.outputs.file_name }}-AnyKernel3
        path: ${{ github.workspace }}/AnyKernel3/**
        if-no-files-found: ignore
        compression-level: 9