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:
  # One DefaultLib commit for the whole run: every package builds its default library from it, and
  # the test jobs run its tests, so they cannot straddle a push to DefaultLib made during the run.
  defaultlib_commit:
    name: Pick the Default Library commit
    runs-on: ubuntu-latest
    outputs:
      sha: ${{ steps.sha.outputs.sha }}
    steps:
      - name: Resolve the commit
        id: sha
        shell: bash
        run: |
          sha=$(git ls-remote https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git refs/heads/main | cut -f1)
          if [ -z "$sha" ]; then echo "could not resolve TypeScriptCompilerDefaultLib main"; exit 1; fi
          echo "Default Library commit: $sha" | tee -a "$GITHUB_STEP_SUMMARY"
          echo "sha=$sha" >> "$GITHUB_OUTPUT"

  build_on_windows:
    name: Create/Upload Release Asset (Windows)
    needs: defaultlib_commit
    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}}
        env:
          DEFAULTLIB_SHA: ${{ needs.defaultlib_commit.outputs.sha }}
        run: |
          if (!(Test-Path -Path ".\TypeScriptCompilerDefaultLib")) { git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git }
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
          git -C TypeScriptCompilerDefaultLib checkout --detach $env:DEFAULTLIB_SHA
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
        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

      # The Default Library's own tests run in test_defaultlib_windows, one job per memory model,
      # against the package this job uploads.

      # 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, .\tslang\msbuild\x64\release\lib\TypeScriptMimalloc.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 }})
    needs: defaultlib_commit

    # 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.
        # Public resolvers: the runner's own DNS sometimes fails on the Ubuntu mirrors ("Temporary
        # failure resolving 'azure.archive.ubuntu.com'") while every other host resolves. Even then a
        # lookup can drop for a few seconds, longer than apt's own retries, so the whole step retries.
        run: |
          printf 'nameserver 8.8.8.8\nnameserver 1.1.1.1\n' | sudo tee /etc/resolv.conf > /dev/null
          for i in 1 2 3 4 5; do
            sudo apt-get -o Acquire::Retries=3 update && sudo apt-get -o Acquire::Retries=3 install -y ninja-build libcurl4-openssl-dev zlib1g-dev libzstd-dev libxml2-dev && exit 0
            echo "apt-get failed (attempt $i), retrying in 30 s"; sleep 30
          done
          exit 1

  #    - 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
        env:
          DEFAULTLIB_SHA: ${{ needs.defaultlib_commit.outputs.sha }}
        run: |
          set -e
          if [ ! -d "./TypeScriptCompilerDefaultLib" ]; then git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git; fi
          git -C TypeScriptCompilerDefaultLib checkout --detach "$DEFAULTLIB_SHA"

      - 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

      # As on Windows: the Default Library's own tests run in test_defaultlib_linux.

      - 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 ./tslang/ninja/release/lib/libTypeScriptMimalloc.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

  # The Default Library's tests, one job per memory model so the models run side by side, as in
  # TypeScriptCompilerDefaultLib's tests.yml. Each job tests the package its build job uploaded:
  # the compiler and its libraries side by side, and the default library built into it, which goes
  # to the DefaultLib checkout's __build (tests.ps1 always looks for it there).
  test_defaultlib_windows:
    name: Test Default Library (Windows, -mm=${{ matrix.model }})
    needs: [defaultlib_commit, build_on_windows]
    strategy:
      fail-fast: false
      matrix:
        model: [gc, rc, none, own]
    runs-on: windows-2025-vs2026
    timeout-minutes: 120
    env:
      # All four together: tests.ps1 honours the library paths only alongside TOOL_PATH.
      TOOL_PATH: ${{ github.workspace }}\__tslang
      GC_LIB_PATH: ${{ github.workspace }}\__tslang
      LLVM_LIB_PATH: ${{ github.workspace }}\__tslang
      TSLANG_LIB_PATH: ${{ github.workspace }}\__tslang
    steps:
      - name: Clone Default Library
        shell: pwsh
        env:
          DEFAULTLIB_SHA: ${{ needs.defaultlib_commit.outputs.sha }}
        run: |
          git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
          git -C TypeScriptCompilerDefaultLib checkout --detach $env:DEFAULTLIB_SHA
          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

      - name: Download Release Asset from Store
        uses: actions/download-artifact@v4
        with:
          name: tslang-windows-asset

      - name: Unpack the package
        shell: pwsh
        run: |
          Expand-Archive -Path "${{ env.ASSET_NAME }}-windows-x64.zip" -DestinationPath $env:TOOL_PATH
          Remove-Item "${{ env.ASSET_NAME }}-windows-x64.zip"
          Get-ChildItem $env:TOOL_PATH
          New-Item -ItemType Directory -Force -Path TypeScriptCompilerDefaultLib\__build | Out-Null
          Move-Item -Path (Join-Path $env:TOOL_PATH 'defaultlib') -Destination TypeScriptCompilerDefaultLib\__build\defaultlib -ErrorAction Stop
          & (Join-Path $env:TOOL_PATH 'tslang.exe') --version

      # In its own pwsh: tests.ps1 reads the library paths once, at its start.
      - name: Test Default Library (-mm=${{ matrix.model }})
        shell: pwsh
        working-directory: ${{ github.workspace }}/TypeScriptCompilerDefaultLib
        env:
          MODEL: ${{ matrix.model }}
        run: |
          pwsh -NoProfile -File .\tests.ps1 -Model $env:MODEL
          exit $LASTEXITCODE

  # Each Ubuntu package is tested on the release it was built for.
  test_defaultlib_linux:
    name: Test Default Library (${{ matrix.os }}, -mm=${{ matrix.model }})
    needs: [defaultlib_commit, build_on_linux]
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-26.04]
        model: [gc, rc, none, own]
    runs-on: ${{ matrix.os }}
    timeout-minutes: 120
    env:
      TOOL_PATH: ${{ github.workspace }}/__tslang
      GC_LIB_PATH: ${{ github.workspace }}/__tslang
      LLVM_LIB_PATH: ${{ github.workspace }}/__tslang
      TSLANG_LIB_PATH: ${{ github.workspace }}/__tslang
    steps:
      - name: Install dependencies
        shell: bash
        # Public resolvers: see "Install Ninja" above.
        run: |
          printf 'nameserver 8.8.8.8\nnameserver 1.1.1.1\n' | sudo tee /etc/resolv.conf > /dev/null
          for i in 1 2 3 4 5; do
            sudo apt-get -o Acquire::Retries=3 update && sudo apt-get -o Acquire::Retries=3 install -y libcurl4-openssl-dev && exit 0
            echo "apt-get failed (attempt $i), retrying in 30 s"; sleep 30
          done
          exit 1

      - name: Clone Default Library
        shell: bash
        env:
          DEFAULTLIB_SHA: ${{ needs.defaultlib_commit.outputs.sha }}
        run: |
          set -e
          git clone https://github.com/ASDAlexander77/TypeScriptCompilerDefaultLib.git
          git -C TypeScriptCompilerDefaultLib checkout --detach "$DEFAULTLIB_SHA"

      - name: Download Release Asset from Store
        uses: actions/download-artifact@v4
        with:
          name: tslang-${{ matrix.os }}-asset

      - name: Unpack the package
        shell: bash
        run: |
          set -e
          mkdir -p "$TOOL_PATH"
          tar -xzf "${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz" -C "$TOOL_PATH"
          rm "${{ env.ASSET_NAME }}-${{ matrix.os }}-x64.tar.gz"
          ls "$TOOL_PATH"
          mkdir -p TypeScriptCompilerDefaultLib/__build
          mv "$TOOL_PATH/defaultlib" TypeScriptCompilerDefaultLib/__build/defaultlib
          "$TOOL_PATH/tslang" --version

      - name: Test Default Library (-mm=${{ matrix.model }})
        shell: bash
        working-directory: ${{ github.workspace }}/TypeScriptCompilerDefaultLib
        env:
          MODEL: ${{ matrix.model }}
        run: |
          chmod +x ./tests.sh
          ./tests.sh "$MODEL"

  # The build jobs above test release programs. The debug ones (TSLANG_TEST_PROGRAMS=debug: debug
  # info, no optimization), as a pull request's CI runs them: its own workflows, those legs only.
  test_debug_programs_windows:
    name: Debug programs (Windows)
    uses: ./.github/workflows/cmake-test-release-win.yml
    with:
      programs: '["debug"]'

  test_debug_programs_linux:
    name: Debug programs (Linux)
    uses: ./.github/workflows/cmake-test-release-linux.yml
    with:
      programs: '["debug"]'

  create_release:
    needs: [build_on_windows, build_on_linux, test_defaultlib_windows, test_defaultlib_linux,
            test_debug_programs_windows, test_debug_programs_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