create-release.yml

name: Create Release/Upload Asset

on:
  push:
    # Sequence of patterns matched against refs/tags
    tags:
    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10

env:
  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
  BUILD_TYPE: Release
  # release archives carry the version (the pushed tag) and the OS they were built on:
  # tslang-v0.0-pre-alpha83-windows-x64.zip, tslang-v0.0-pre-alpha83-ubuntu-24.04-x64.tar.gz
  ASSET_NAME: tslang-${{ github.ref_name }}
  CACHE_VERSION: v10
  # The official LLVM release package (plus, on Windows, a prebuilt MLIR archive), installed where
  # a custom LLVM build would be - see scripts/install_llvm_prebuilt_release.{ps1,sh}.
  LLVM_FULL_VERSION: "22.1.8"
  GC_VERSION: "8.2.12"
  LIBATOMIC_OPS_VERSION: "7.10.0"

jobs:
  build_on_windows:
    name: Create/Upload Release Asset (Windows)
    runs-on: windows-2025-vs2026
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Build project # This would actually build your project, using zip for an example artifact
        run: echo 'SELECTED_COLOR=green Build project (Windows)' >> "$GITHUB_OUTPUT"

      - name: Cache 3rd Party binaries
        id: cache-3rd-party-binary
        uses: actions/cache@v4
        with:
          path: 3rdParty
          key: ${{ runner.os }}-3rd-party-${{ env.LLVM_FULL_VERSION }}-${{ env.CACHE_VERSION }}-${{ hashFiles('scripts/install_llvm_prebuilt_release.ps1', 'scripts/llvm_prebuilt_common.ps1') }}

      - name: Retrieve version
        run: echo "TAG_NAME=$(git describe --abbrev=0 --tags)" >> "$GITHUB_OUTPUT"
        id: version
        #shell: pwsh
        shell: bash

      - name: Delete __Build TS folders
        continue-on-error: true
        run: if (Test-Path -Path ".\__build\tslang\msbuild\x64\release") { Remove-Item -Recurse -Force ".\__build\tslang\msbuild\x64\release" }
        shell: pwsh

      - name: Create __Build Folders
        run: if (!(Test-Path -Path ".\__build\tslang\msbuild\x64\release")) { New-Item -ItemType Directory -Force -Path ".\__build\tslang\msbuild\x64\release" }; if (!(Test-Path -Path ".\__build\gc\msbuild\x64\release")) { New-Item -ItemType Directory -Force -Path ".\__build\gc\msbuild\x64\release" };
        shell: pwsh
      
      # Downloads and unpacks the official LLVM package and the prebuilt MLIR archive - nothing is
      # compiled. Skips itself when the cached 3rdParty already has them.
      - name: Install 3rd party - LLVM ${{ env.LLVM_FULL_VERSION }} + MLIR
        continue-on-error: false
        run: ./scripts/install_llvm_prebuilt_release.ps1 -Version ${{ env.LLVM_FULL_VERSION }}
        shell: pwsh

      - name: Download 3rd party source - GC
        continue-on-error: true
        shell: pwsh
        run: Invoke-WebRequest -SkipCertificateCheck -Uri "https://github.com/bdwgc/bdwgc/releases/download/v${{ env.GC_VERSION }}/gc-${{ env.GC_VERSION }}.tar.gz" -OutFile "gc-${{ env.GC_VERSION }}.tar.gz"

      - name: Download 3rd party source - GC:Atomic_ops
        continue-on-error: true
        shell: pwsh
        run: Invoke-WebRequest -SkipCertificateCheck -Uri "https://github.com/bdwgc/libatomic_ops/releases/download/v${{ env.LIBATOMIC_OPS_VERSION }}/libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz" -OutFile "libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz"

      - name: UnZip 3rd party source - GC
        continue-on-error: false
        run: tar -xvzf gc-${{ env.GC_VERSION }}.tar.gz -C ./3rdParty/
        shell: pwsh

      - name: UnZip 3rd party source - GC:Atomic_ops
        continue-on-error: false
        run: tar -xvzf libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz -C ./3rdParty/
        shell: pwsh

      - name: Create gc-${{ env.GC_VERSION }}\libatomic_ops Folders
        run: if (!(Test-Path -Path ".\3rdParty\gc-${{ env.GC_VERSION }}\libatomic_ops")) { New-Item -ItemType Directory -Force -Path ".\3rdParty\gc-${{ env.GC_VERSION }}\libatomic_ops" };
        shell: pwsh

      - name: Copy Atomic_ops to GC
        continue-on-error: false
        run:  xcopy  /E /H /C /I /Y ".\3rdParty\libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}" ".\3rdParty\gc-${{ env.GC_VERSION }}\libatomic_ops"
        shell: pwsh

      - name: Configure GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/msbuild/x64/release
        run: cmake ../../../../../3rdParty/gc-${{ env.GC_VERSION }} -G "Visual Studio 18 2026" -A x64 -Wno-dev -DCMAKE_INSTALL_PREFIX=${{github.workspace}}/3rdParty/gc/x64/release -DBUILD_SHARED_LIBS=OFF -Denable_threads=ON -Denable_cplusplus=OFF -Denable_docs=OFF -DCMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded
        shell: pwsh

      - name: Build GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/msbuild/x64/release
        run: cmake --build . --config ${{ env.BUILD_TYPE }} -j 8
        shell: pwsh

      - name: Install GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/msbuild/x64/release
        # Generates the BDWgc CMake package files (lib/cmake/bdwgc/BDWgcConfig.cmake)
        # that the tslang build looks up via find_package(BDWgc CONFIG).
        run: cmake --install . --config ${{ env.BUILD_TYPE }}
        shell: pwsh

      # Boehm as a DLL: an executable and a tslang shared library that each link the static
      # gc.lib get two collectors, and one frees what the other still holds (item 5ao). Used by
      # the -shared tests, and shipped in the zip's gcdll folder. Mirrors
      # scripts/build_gc_release_shared_vs.bat; installed before tslang is configured, since the
      # test CMakeLists checks for it at configure time.
      - name: Configure GC (shared)
        continue-on-error: false
        run: New-Item -ItemType Directory -Force -Path ".\__build\gcdll\msbuild\x64\release" | Out-Null; cd ".\__build\gcdll\msbuild\x64\release"; cmake ../../../../../3rdParty/gc-${{ env.GC_VERSION }} -G "Visual Studio 18 2026" -A x64 -Wno-dev -DCMAKE_INSTALL_PREFIX=${{github.workspace}}/3rdParty/gcdll/x64/release -DBUILD_SHARED_LIBS=ON -Denable_threads=ON -Denable_cplusplus=OFF -Denable_docs=OFF -DCMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded
        shell: pwsh

      - name: Build GC (shared)
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gcdll/msbuild/x64/release
        run: cmake --build . --config ${{ env.BUILD_TYPE }} -j 8
        shell: pwsh

      - name: Install GC (shared)
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gcdll/msbuild/x64/release
        run: cmake --install . --config ${{ env.BUILD_TYPE }}
        shell: pwsh

      - name: Configure
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/msbuild/x64/release
        run: cmake ../../../../../tslang -G "Visual Studio 18 2026" -A x64 -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} -DTSLANG_PACKAGE_VERSION:STRING="${{ steps.version.outputs.TAG_NAME }}" -Wno-dev
        shell: pwsh

      - name: Build
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/msbuild/x64/release
        run: cmake --build . --config ${{ env.BUILD_TYPE }} -j 8
        shell: pwsh

      - name: Test
        working-directory: ${{github.workspace}}/__build/tslang/msbuild/x64/release
        # Execute tests defined by the CMake configuration.
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -j8 -C ${{ env.BUILD_TYPE }} -T test --output-on-failure -T test --output-on-failure
        shell: pwsh

      # Replicates installDefaultLib() from tslang/defaultlib.cpp: clone the default
      # library sources and build them against the tslang/gc/llvm/runtime we just built.
      - name: Clone Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}
        run: if (!(Test-Path -Path ".\TypeScriptCompilerDefaultLib")) { git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git }
        shell: pwsh

      - name: Build Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/TypeScriptCompilerDefaultLib
        env:
          TOOL_PATH: ${{github.workspace}}/__build/tslang/msbuild/x64/release/bin
          GC_LIB_PATH: ${{github.workspace}}/__build/gc/msbuild/x64/release/${{ env.BUILD_TYPE }}
          # the DLL build links Boehm from gc.dll (one collector per process)
          GC_SHARED_LIB_PATH: ${{github.workspace}}/3rdParty/gcdll/x64/release/lib
          LLVM_LIB_PATH: ${{github.workspace}}/3rdParty/llvm/x64/release/lib
          TSLANG_LIB_PATH: ${{github.workspace}}/__build/tslang/msbuild/x64/release/lib
          # This package ships only release-CRT (/MT) builds of TypeScriptAsyncRuntime.lib and
          # gc.lib, so the debug archive has to be /MT too or a `--di` program cannot
          # link with them (LNK2038). It keeps its debug info. See DefaultLib's build_core.bat.
          TSLANG_DEBUG_CRT: /MT
        run: |
          $env:VSWHERE_PATH = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
          .\build.bat
        shell: pwsh

      # The compiler suite runs before the default library exists, so its default-library tests
      # skip there; run them now against the library just built. One collector per process with
      # the default library in it: tslang/test/tester/defaultlib-collector.cmake.
      - name: Test Compiler with Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/msbuild/x64/release
        env:
          DEFAULT_LIB_PATH: ${{github.workspace}}/TypeScriptCompilerDefaultLib/__build
          TSLANG_REQUIRE_DEFAULT_LIB: 1
        run: ctest -C ${{ env.BUILD_TYPE }} -R gc-defaultlib-collector --output-on-failure
        shell: pwsh

      - name: Test Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/TypeScriptCompilerDefaultLib
        env:
          TOOL_PATH: ${{github.workspace}}/__build/tslang/msbuild/x64/release/bin
          GC_LIB_PATH: ${{github.workspace}}/__build/gc/msbuild/x64/release/${{ env.BUILD_TYPE }}
          LLVM_LIB_PATH: ${{github.workspace}}/3rdParty/llvm/x64/release/lib
          TSLANG_LIB_PATH: ${{github.workspace}}/__build/tslang/msbuild/x64/release/lib
        run: |
          .\tests.ps1
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
        shell: pwsh

      # Android (API 29, arm64-v8a, armeabi-v7a and x86_64): the collector, the async runtime and the default
      # library, cross-built with the runner's Android NDK by the same scripts a developer runs.
      # tslang links for Android through the NDK too (--android-ndk-path / ANDROID_NDK_HOME).
      - name: Install Ninja (Android builds)
        continue-on-error: false
        run: choco install ninja -y --no-progress
        shell: pwsh

      - name: Build Android Collector and Async Runtime
        continue-on-error: false
        working-directory: ${{github.workspace}}
        run: |
          $ndk = if ($env:ANDROID_NDK_LATEST_HOME) { $env:ANDROID_NDK_LATEST_HOME } else { $env:ANDROID_NDK_HOME }
          if (-not $ndk -or -not (Test-Path "$ndk\build\cmake\android.toolchain.cmake")) { Write-Error "no Android NDK on this runner (ANDROID_NDK_LATEST_HOME / ANDROID_NDK_HOME)"; exit 1 }
          Get-Content "$ndk\source.properties" | Select-String "Pkg.Revision"
          "ANDROID_NDK_HOME=$ndk" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
          $env:ANDROID_NDK_HOME = $ndk
          .\scripts\build_gc_release_android.bat
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
          .\scripts\build_tslang_runtime_release_android.bat
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
        shell: pwsh

      - name: Build Android Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/TypeScriptCompilerDefaultLib
        env:
          TOOL_PATH: ${{github.workspace}}/__build/tslang/msbuild/x64/release/bin
        run: |
          .\scripts\build_android.bat
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
        shell: pwsh

      # An executable and a shared library linked for x86_64 Android with what was just built;
      # test-compile-android-link skips when the libraries are missing, so require them here.
      - name: Test Compiler for Android
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/msbuild/x64/release
        env:
          TSLANG_ANDROID_DEFAULT_LIB_PATH: ${{github.workspace}}/TypeScriptCompilerDefaultLib/__build
        run: |
          $out = ctest -C ${{ env.BUILD_TYPE }} -R "test-compile-android-" --output-on-failure 2>&1 | Out-String
          $out
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
          if ($out -match "Skipped") { Write-Error "the Android link test was skipped: its libraries were not found"; exit 1 }
        shell: pwsh

      - name: Create Zip of Windows Asset
        working-directory: ${{github.workspace}}/__build
        # Flatten the compiler/runtime binaries into the archive root, and add the
        # default library as a whole tree so its per-target, per-build, per-memory-model
        # subfolders are preserved, Android's among them (tslang --print-default-lib-dir names one):
        #   defaultlib/{dll,lib}/<arch>/<vendor>/<os>/<env>/{debug,release}/{gc,rc,none},
        #   defaultlib/*.d.ts, defaultlib/generics/ (shared by every target)
        # plus the shared collector in its own folder, because its import library is also named
        # gc.lib: gcdll/gc.lib + gcdll/gc.dll, for programs that load a tslang shared library.
        # tsbindgen looks for clang's resource directory next to itself as lib/clang/<major>
        # (findResourceDir's "release package" candidate), so stage that layout too - its headers
        # only: the official LLVM package also puts compiler-rt's libraries under
        # lib/clang/<major>/lib, which neither tsbindgen nor tslang uses.
        # Android, per ABI (arm64-v8a, armeabi-v7a, x86_64): android/<abi>/lib/{libgc.a,libTypeScriptAsyncRuntime.a}
        # (--gc-lib-path and --tslang-lib-path); its default library is in the defaultlib tree above.
        run: |
          foreach ($abi in 'arm64-v8a', 'armeabi-v7a', 'x86_64') {
            $dest = ".\android_stage\android\$abi"
            New-Item -ItemType Directory -Force -Path "$dest\lib" | Out-Null
            Copy-Item -Path "..\3rdParty\gc\android\$abi\release\lib\libgc.a", ".\tslang-runtime\release\android\$abi\libTypeScriptAsyncRuntime.a" -Destination "$dest\lib" -ErrorAction Stop
          }
          New-Item -ItemType Directory -Force -Path .\gcdll_stage\gcdll | Out-Null
          Copy-Item -Path ..\3rdParty\gcdll\x64\release\lib\gc.lib, ..\3rdParty\gcdll\x64\release\bin\gc.dll -Destination .\gcdll_stage\gcdll -ErrorAction Stop
          Get-ChildItem -Path ..\3rdParty\llvm\x64\release\lib\clang -Directory | ForEach-Object { $dest = ".\resourcedir_stage\lib\clang\$($_.Name)"; New-Item -ItemType Directory -Force -Path $dest | Out-Null; Copy-Item -Path (Join-Path $_.FullName "include") -Destination $dest -Recurse -ErrorAction Stop }
          Get-ChildItem -Path .\tslang\msbuild\x64\release\bin\tslang.exe, .\tslang\msbuild\x64\release\bin\tsbindgen.exe, .\tslang\msbuild\x64\release\bin\TypeScriptRuntime.dll, .\tslang\msbuild\x64\release\bin\gc.dll, .\gc\msbuild\x64\release\${{ env.BUILD_TYPE }}\gc.lib, .\tslang\msbuild\x64\release\lib\TypeScriptAsyncRuntime.lib, ..\3rdParty\llvm\x64\release\bin\wasm-ld.exe, ..\TypeScriptCompilerDefaultLib\__build, .\gcdll_stage, .\resourcedir_stage, .\android_stage | Compress-Archive -DestinationPath ..\${{ env.ASSET_NAME }}-windows-x64.zip
        shell: pwsh

      - name: Archive Zip of Windows Asset
        uses: actions/upload-artifact@v4
        with:
          name: tslang-windows-asset
          path: ${{ env.ASSET_NAME }}-windows-x64.zip
          retention-days: 1          
  
  build_on_linux:
    name: Create/Upload Release Asset (${{ matrix.os }})

    # One package per Ubuntu release: each is built, tested and packaged on that release, so its
    # binaries match that release's glibc and libstdc++.
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-26.04]
    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4

      # No 3rdParty cache: the LLVM prefix is about 9.6 GB, too big for the cache, and downloading
      # it from GitHub each run is quick; GC is rebuilt every run anyway.
      - name: Retrieve version
        run: echo "TAG_NAME=$(git describe --abbrev=0 --tags)" >> $GITHUB_OUTPUT
        id: version

      - name: Delete __Build TS folders
        continue-on-error: true
        run: rm -R ./__build/tslang/ninja/release
        shell: sh

      - name: Create __Build Folders
        run: mkdir -p ./__build/tslang/ninja/release; mkdir -p ./__build/gc/ninja/release
        shell: sh
      
      # Downloads and unpacks the official LLVM package - nothing is compiled.
      - name: Install 3rd party - LLVM ${{ env.LLVM_FULL_VERSION }}
        continue-on-error: false
        shell: sh
        run: sh ./scripts/install_llvm_prebuilt_release.sh ${{ env.LLVM_FULL_VERSION }} && df -h .

      - name: Download 3rd party source - GC
        continue-on-error: true
        shell: sh
        run: curl --insecure -L https://github.com/bdwgc/bdwgc/releases/download/v${{ env.GC_VERSION }}/gc-${{ env.GC_VERSION }}.tar.gz --output gc-${{ env.GC_VERSION }}.tar.gz

      - name: Download 3rd party source - GC:Atomic_ops
        continue-on-error: true
        shell: sh
        run: curl --insecure -L https://github.com/bdwgc/libatomic_ops/releases/download/v${{ env.LIBATOMIC_OPS_VERSION }}/libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz --output libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz

      - name: UnZip 3rd party source - GC
        continue-on-error: false
        shell: sh
        run: tar -xvzf gc-${{ env.GC_VERSION }}.tar.gz -C ./3rdParty/

      - name: UnZip 3rd party source - GC:Atomic_ops
        continue-on-error: false
        shell: sh
        run: tar -xvzf libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}.tar.gz -C ./3rdParty/

      - name: Copy Atomic_ops to GC
        continue-on-error: false
        shell: sh
        run:  cp -a ./3rdParty/libatomic_ops-${{ env.LIBATOMIC_OPS_VERSION }}/ ./3rdParty/gc-${{ env.GC_VERSION }}/libatomic_ops/

      - name: Install Ninja
        continue-on-error: false
        shell: sh
        # zlib, zstd and libxml2: the official LLVM package's CMake targets link against them.
        run: sudo apt-get update && sudo apt-get install -y ninja-build libcurl4-openssl-dev zlib1g-dev libzstd-dev libxml2-dev

  #    - name: Install Clang 12
  #      continue-on-error: false
  #      shell: sh
  #      run: sudo apt install clang-12

      - name: Configure GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/ninja/release
        shell: sh
        run: cmake ../../../../3rdParty/gc-${{ env.GC_VERSION }} -G "Ninja" -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} -Wno-dev -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_INSTALL_PREFIX=${{github.workspace}}/3rdParty/gc/release -DBUILD_SHARED_LIBS=OFF -Denable_threads=ON -Denable_cplusplus=OFF -Denable_docs=OFF

      - name: Build GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/ninja/release
        shell: sh
        run: cmake --build . --config ${{ env.BUILD_TYPE }} -j 8

      - name: Install GC
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/gc/ninja/release
        shell: sh
        # Generates the BDWgc CMake package files (lib/cmake/bdwgc/BDWgcConfig.cmake)
        # that the tslang build looks up via find_package(BDWgc CONFIG).
        run: cmake --install . --config ${{ env.BUILD_TYPE }}

      - name: Configure
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/ninja/release
        shell: sh
        run: cmake ../../../../tslang -G "Ninja" -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} -DTSLANG_PACKAGE_VERSION:STRING="${{ steps.version.outputs.TAG_NAME }}" -Wno-dev

      - name: Build
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/ninja/release
        shell: sh
        run: cmake --build . --config ${{ env.BUILD_TYPE }} -j 4

      - name: Test
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/ninja/release
        shell: sh
        # Execute tests defined by the CMake configuration.  
        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
        run: ctest -j8 -C ${{ env.BUILD_TYPE }} -T test --output-on-failure -T test --output-on-failure
        env:
          LLVM_SYMBOLIZER_PATH: ${{github.workspace}}/3rdParty/llvm/release/bin

      # Replicates installDefaultLib() from tslang/defaultlib.cpp: clone the default
      # library sources and build them against the tslang/gc/llvm/runtime we just built.
      - name: Clone Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}
        shell: sh
        run: if [ ! -d "./TypeScriptCompilerDefaultLib" ]; then git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git; fi

      - name: Build Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/TypeScriptCompilerDefaultLib
        shell: sh
        env:
          TOOL_PATH: ${{github.workspace}}/__build/tslang/ninja/release/bin
          GC_LIB_PATH: ${{github.workspace}}/__build/gc/ninja/release
          LLVM_LIB_PATH: ${{github.workspace}}/3rdParty/llvm/release/lib
          TSLANG_LIB_PATH: ${{github.workspace}}/__build/tslang/ninja/release/lib
        run: chmod +x ./build.sh ./scripts/*.sh; ./build.sh

      # See the Windows job: the default-library tests skip in the compiler suite and run here.
      - name: Test Compiler with Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/__build/tslang/ninja/release
        shell: sh
        env:
          DEFAULT_LIB_PATH: ${{github.workspace}}/TypeScriptCompilerDefaultLib/__build
          TSLANG_REQUIRE_DEFAULT_LIB: 1
        run: ctest -C ${{ env.BUILD_TYPE }} -R gc-defaultlib-collector --output-on-failure

      - name: Test Default Library
        continue-on-error: false
        working-directory: ${{github.workspace}}/TypeScriptCompilerDefaultLib
        shell: sh
        env:
          TOOL_PATH: ${{github.workspace}}/__build/tslang/ninja/release/bin
          GC_LIB_PATH: ${{github.workspace}}/__build/gc/ninja/release
          LLVM_LIB_PATH: ${{github.workspace}}/3rdParty/llvm/release/lib
          TSLANG_LIB_PATH: ${{github.workspace}}/__build/tslang/ninja/release/lib
        run: chmod +x ./tests.sh; ./tests.sh

      - name: Create Tar.GZ of Linux Asset
        working-directory: ${{github.workspace}}/__build
        shell: sh
        # Match the Windows zip layout: flatten all binaries into the archive
        # root, then add the default library release contents at the root too.
        run: |
          rm -rf ./__stage
          mkdir -p ./__stage
          cp ./tslang/ninja/release/bin/tslang ./__stage/
          cp ./tslang/ninja/release/bin/tsbindgen ./__stage/
          cp ./tslang/ninja/release/lib/libTypeScriptRuntime.so ./__stage/
          cp ./gc/ninja/release/libgc.a ./__stage/
          cp ./tslang/ninja/release/lib/libTypeScriptAsyncRuntime.a ./__stage/
          cp ../3rdParty/llvm/release/bin/wasm-ld ./__stage/
          # Add the default library as a whole tree so its per-target, per-build, per-memory-model
          # subfolders are preserved:
          # defaultlib/{dll,lib}/<arch>/<vendor>/<os>/<env>/{debug,release}/{gc,rc,none},
          # defaultlib/*.d.ts, defaultlib/generics/
          cp -r ../TypeScriptCompilerDefaultLib/__build/defaultlib ./__stage/
          # tsbindgen looks for clang's resource directory next to itself as lib/clang/<major>
          # (findResourceDir's "release package" candidate) - its headers only: the official LLVM
          # package also puts compiler-rt's libraries under lib/clang/<major>/lib, which neither
          # tsbindgen nor tslang uses.
          for d in ../3rdParty/llvm/release/lib/clang/*/; do v=$(basename "$d"); mkdir -p "./__stage/lib/clang/$v"; cp -r "$d/include" "./__stage/lib/clang/$v/"; done
          tar -czvhf ../${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz -C ./__stage .

      - name: Archive Tar.GZ of Linux Asset
        uses: actions/upload-artifact@v4
        with:
          name: tslang-${{ matrix.os }}-asset
          path: ${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz
          retention-days: 1

  create_release:
    needs: [build_on_windows, build_on_linux]
    name: Create Release
    runs-on: ubuntu-latest
    steps:
      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: true
          prerelease: true
    outputs:
      upload_url: ${{ steps.create_release.outputs.upload_url }}

  deploy_windows_asset:
    needs: create_release
    name: Upload Release (Windows)
    runs-on: windows-latest
    steps:
      - name: Download Release Asset from Store
        uses: actions/download-artifact@v4
        with:
          name: tslang-windows-asset

      - name: Upload Release Asset (Windows)
        id: upload-release-asset 
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
          asset_path: ./${{ env.ASSET_NAME }}-windows-x64.zip
          asset_name: ${{ env.ASSET_NAME }}-windows-x64.zip
          asset_content_type: application/zip

  deploy_linux_asset:
    needs: create_release
    name: Upload Release (${{ matrix.os }})
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-26.04]
    runs-on: ubuntu-latest
    steps:
      - name: Download Release Asset from Store
        uses: actions/download-artifact@v4
        with:
          name: tslang-${{ matrix.os }}-asset

      - name: Upload Release Asset (${{ matrix.os }})
        id: upload-release-asset 
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
          asset_path: ./${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz
          asset_name: ${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz
          asset_content_type: application/tar+gzip