Bump qs from 6.14.0 to 6.14.1 (#703 )

* Bump qs from 6.11.2 to 6.14.1 Bumps [qs](https://github.com/ljharb/qs) from 6.11.2 to 6.14.1. - [Changelog](https://github.com/ljharb/qs/blob/main/CHANGELOG.md) - [Commits](https://github.com/ljharb/qs/compare/v6.11.2...v6.14.1) --- updated-dependencies: - dependency-name: qs dependency-version: 6.14.1 dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> * package.json version update --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Aparna Jyothi <aparnajyothi-y@github.com>
Bump actions/checkout from 5 to 6 (#686 )
2026-11-10 23:03:39 +03:00 · 2026-01-12 20:41:32 -06:00 · 2026-01-12 20:37:59 -06:00 · 2026-01-12 13:52:41 -06:00 · 2026-01-07 10:40:06 -06:00 · 2026-01-07 10:36:25 -06:00
112 changed files with 172973 additions and 114644 deletions
@@ -0,0 +1,6 @@
+# Ignore list
+/*
+
+# Do not ignore these folders:
+!__tests__/
+!src/
@@ -0,0 +1,51 @@
+// This is a reusable configuration file copied from https://github.com/actions/reusable-workflows/tree/main/reusable-configurations. Please don't make changes to this file as it's the subject of an automatic update.
+module.exports = {
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:eslint-plugin-jest/recommended',
+    'eslint-config-prettier'
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'eslint-plugin-node', 'eslint-plugin-jest'],
+  rules: {
+    '@typescript-eslint/no-require-imports': 'error',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/ban-ts-comment': [
+      'error',
+      {
+        'ts-ignore': 'allow-with-description'
+      }
+    ],
+    'no-console': 'error',
+    'yoda': 'error',
+    'prefer-const': [
+      'error',
+      {
+        destructuring: 'all'
+      }
+    ],
+    'no-control-regex': 'off',
+    'no-constant-condition': ['error', {checkLoops: false}],
+    'node/no-extraneous-import': 'error'
+  },
+  overrides: [
+    {
+      files: ['**/*{test,spec}.ts'],
+      rules: {
+        '@typescript-eslint/no-unused-vars': 'off',
+        'jest/no-standalone-expect': 'off',
+        'jest/no-conditional-expect': 'off',
+        'no-console': 'off',
+
+      }
+    }
+  ],
+  env: {
+    node: true,
+    es6: true,
+    'jest/globals': true
+  }
+};
@@ -1,2 +1,2 @@
-* text=auto
+* text=auto eol=lf
 .licenses/** -diff linguist-generated=true
@@ -7,7 +7,7 @@ assignees: ''

 ---

-<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.com/orgs/community/discussions/categories/actions --->
 <!--- Before opening up a new bug report, please make sure to check for similar existing issues -->

 **Description:**
@@ -1 +1 @@
-blank_issues_enabled: false
+blank_issues_enabled: false
@@ -5,7 +5,7 @@ title: ''
 labels: feature request, needs triage
 assignees: ''
 ---
-<!--- Please direct any generic questions related to actions to our support community forum at https://github.community/c/code-to-cloud/github-actions/41 --->
+<!--- Please direct any generic questions related to actions to our support community forum at https://github.com/orgs/community/discussions/categories/actions --->
 <!--- Before opening up a new feature request, please make sure to check for similar existing issues and pull requests -->

 **Description:**
@@ -0,0 +1,22 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  # Enable version updates for npm
+  - package-ecosystem: 'npm'
+    # Look for `package.json` and `lock` files in the `root` directory
+    directory: '/'
+    # Check the npm registry for updates every day (weekdays)
+    schedule:
+      interval: 'weekly'
+
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: 'github-actions'
+    # Workflow files stored in the default location of `.github/workflows`
+    # You don't need to specify `/.github/workflows` for `directory`. You can use `directory: "/"`.
+    directory: '/'
+    schedule:
+      interval: 'weekly'
@@ -0,0 +1,18 @@
+name: Basic validation
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  call-basic-validation:
+    name: Basic validation
+    uses: actions/reusable-workflows/.github/workflows/basic-validation.yml@main
+    with:
+      node-version: '24.x'
@@ -1,8 +1,3 @@
-# `dist/index.js` is a special file in Actions.
-# When you reference an action with `uses:` in a workflow,
-# `index.js` is the code that will run.
-# For our project, we generate this file through a build process from other source files.
-# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
 name: Check dist/

 on:
@@ -17,35 +12,8 @@ on:
  workflow_dispatch:

 jobs:
-  check-dist:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Rebuild the dist/ directory
-        run: npm run build
-
-      - name: Compare the expected and actual dist/ directories
-        run: |
-          if [ "$(git diff --ignore-space-at-eol dist/ | wc -l)" -gt "0" ]; then
-            echo "Detected uncommitted changes after build.  See status below:"
-            git diff
-            exit 1
-          fi
-        id: diff
-
-      # If index.js was different than expected, upload the expected version as an artifact
-      - uses: actions/upload-artifact@v3
-        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
-        with:
-          name: dist
-          path: dist/
+  call-check-dist:
+    name: Check dist/
+    uses: actions/reusable-workflows/.github/workflows/check-dist.yml@main
+    with:
+      node-version: '24.x'
@@ -0,0 +1,14 @@
+name: CodeQL analysis
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '0 3 * * 0'
+
+jobs:
+  call-codeQL-analysis:
+    name: CodeQL analysis
+    uses: actions/reusable-workflows/.github/workflows/codeql-analysis.yml@main
@@ -9,20 +9,6 @@ on:
      - main

 jobs:
-  test:
-    runs-on: ubuntu-latest
-    name: Check licenses
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-      - run: npm ci
-      - name: Install licensed
-        run: |
-          cd $RUNNER_TEMP
-          curl -Lfs -o licensed.tar.gz https://github.com/github/licensed/releases/download/3.4.4/licensed-3.4.4-linux-x64.tar.gz
-          sudo tar -xzf licensed.tar.gz
-          sudo mv licensed /usr/local/bin/licensed
-      - run: licensed status
+  call-licensed:
+    name: Licensed
+    uses: actions/reusable-workflows/.github/workflows/licensed.yml@main
@@ -0,0 +1,20 @@
+name: 'Publish Immutable Action Version'
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      packages: write
+
+    steps:
+      - name: Checking out
+        uses: actions/checkout@v6
+      - name: Publish
+        id: publish
+        uses: actions/publish-immutable-action@v0.0.4
@@ -1,4 +1,5 @@
 name: Release new action version
+
 on:
  release:
    types: [released]
@@ -21,7 +22,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Update the ${{ env.TAG_NAME }} tag
-        uses: actions/publish-action@v0.1.0
+        uses: actions/publish-action@v0.4.0
        with:
          source-tag: ${{ env.TAG_NAME }}
          slack-webhook: ${{ secrets.SLACK_WEBHOOK }}
@@ -0,0 +1,11 @@
+name: Update configuration files
+
+on:
+  schedule:
+    - cron: '0 3 * * 0'
+  workflow_dispatch:
+
+jobs:
+  call-update-configuration-files:
+    name: Update configuration files
+    uses: actions/reusable-workflows/.github/workflows/update-config-files.yml@main
@@ -1,4 +1,5 @@
 name: Validate 'setup-go'
+
 on:
  push:
    branches:
@@ -12,17 +13,76 @@ on:
    - cron: 0 0 * * *

 jobs:
+  stable:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go Stable
+        uses: ./
+        with:
+          go-version: stable
+      - name: Verify Go
+        run: go version
+
+  oldstable:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go oldStable
+        uses: ./
+        with:
+          go-version: oldstable
+      - name: Verify Go
+        run: go version
+
+  aliases-arch:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+        version: [stable, oldstable]
+        architecture: [x64, x32]
+        exclude:
+          - os: macos-latest
+            architecture: x32
+          - os: macos-latest-large
+            architecture: x32
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go ${{ matrix.version }} ${{ matrix.architecture }}
+        uses: ./
+        with:
+          go-version: ${{ matrix.version }}
+          architecture: ${{ matrix.architecture }}
+      - name: Verify Go
+        run: go version
+
  local-cache:
    name: Setup local-cache version
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        go: [1.12, 1.13, 1.14]
+        os: [macos-latest, windows-latest, ubuntu-latest, macos-latest-large]
+        go: [1.21.13, 1.22.8, 1.23.2]
+        include:
+          - os: windows-latest
+            go: 1.20.14
+        exclude:
+          - os: windows-latest
+            go: 1.23.2
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: setup-go ${{ matrix.go }}
        uses: ./
@@ -38,10 +98,10 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        go-version: [1.16, 1.17]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+        go-version: ['1.20', '1.21', '1.22', '1.23']
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
      - name: Setup Go and check latest
        uses: ./
        with:
@@ -55,28 +115,75 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
      - name: Setup Go and check latest
        uses: ./
        with:
          go-version-file: __tests__/data/go.mod
      - name: verify go
-        run: __tests__/verify-go.sh 1.14
+        run: __tests__/verify-go.sh 1.20.14
        shell: bash

-  setup-versions-from-manifest:
-    name: Setup ${{ matrix.go }} ${{ matrix.os }}
+  go-version-file-with-gowork:
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        go: [1.12.16, 1.13.11, 1.14.3]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go and check latest
+        uses: ./
+        with:
+          go-version-file: __tests__/data/go.work
+      - name: verify go
+        run: __tests__/verify-go.sh 1.21
+        shell: bash
+
+  go-version-file-with-tool-versions:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go and check latest
+        uses: ./
+        with:
+          go-version-file: __tests__/data/.tool-versions
+      - name: verify go
+        run: __tests__/verify-go.sh 1.23.2
+        shell: bash
+
+  go-version-file-with-go-version:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go from .go-version file
+        uses: ./
+        with:
+          go-version-file: __tests__/data/.go-version
+      - name: verify go
+        run: __tests__/verify-go.sh 1.22.4
+        shell: bash
+
+  setup-versions-from-manifest:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest, ubuntu-latest, macos-latest-large]
+        go: [1.20.14, 1.21.10, 1.22.8, 1.23.2]
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: setup-go ${{ matrix.go }}
        uses: ./
@@ -88,16 +195,15 @@ jobs:
        shell: bash

  setup-versions-from-dist:
-    name: Setup ${{ matrix.go }} ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        go: [1.9, 1.8.6]
+        os: [windows-latest, ubuntu-latest, macos-latest-large]
+        go: [1.11.12]
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: setup-go ${{ matrix.go }}
        uses: ./
@@ -107,3 +213,29 @@ jobs:
      - name: verify go
        run: __tests__/verify-go.sh ${{ matrix.go }}
        shell: bash
+
+  architecture:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-latest-large]
+        go-version: [1.20.14, 1.21, 1.22, 1.23]
+        include:
+          - os: macos-latest
+            architecture: arm64
+          - os: ubuntu-latest
+            architecture: x64
+          - os: windows-latest
+            architecture: x64
+          - os: macos-latest-large
+            architecture: x64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Go and check latest
+        uses: ./
+        with:
+          go-version: ${{ matrix.go-version }}
+          architecture: ${{ matrix.architecture }}
+      - name: Verify Go
+        run: go version
@@ -0,0 +1,136 @@
+name: Validate Windows installation
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+
+jobs:
+  create-link-if-not-default:
+    runs-on: windows-latest
+    name: 'Validate if symlink is created'
+    strategy:
+      matrix:
+        cache: [false, true]
+        go: [1.20.1]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup ${{ matrix.cache }}, cache: ${{ matrix.go }}'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Drive C: should have zero size link'
+        run: |
+          du -m -s 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'
+          # make sure drive c: contains only a link
+          size=$(du -m -s 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'|cut -f1 -d$'\t')
+          if [ $size -ne 0 ];then
+            echo 'Size of the link created on drive c: must be 0'
+            exit 1
+          fi
+        shell: bash
+
+      # Drive D: is small, take care the action does not eat up the space
+      - name: 'Drive D: space usage should be below 1G'
+        run: |
+          du -m -s 'D:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'
+          size=$(du -m -s 'D:\hostedtoolcache\windows\go\${{ matrix.go }}\x64'|cut -f1 -d$'\t')
+          # make sure archive does not take lot of space
+          if [ $size -gt 999 ];then
+            echo 'Size of installed on drive d: go is too big';
+            exit 1
+          fi
+        shell: bash
+
+      # make sure the Go installation has not been changed to the end user
+      - name: Test paths and environments
+        run: |
+          echo $PATH
+          which go
+          go version
+          go env
+          if [ $(which go) != '/c/hostedtoolcache/windows/go/${{ matrix.go }}/x64/bin/go' ];then
+            echo 'which go should return "/c/hostedtoolcache/windows/go/${{ matrix.go }}/x64/bin/go"'
+            exit 1
+          fi
+          if [ $(go env GOROOT) != 'C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64' ];then
+            echo 'go env GOROOT should return "C:\hostedtoolcache\windows\go\${{ matrix.go }}\x64"'
+            exit 1
+          fi
+        shell: bash
+
+  find-default-go:
+    name: 'Find default go version'
+    runs-on: windows-latest
+    outputs:
+      version: ${{ steps.goversion.outputs.version }}
+    steps:
+      - run: |
+          version=`go env GOVERSION|sed s/^go//`
+          echo "default go version: $version"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+        id: goversion
+        shell: bash
+
+  dont-create-link-if-default:
+    name: 'Validate if symlink is not created for default go'
+    runs-on: windows-latest
+    needs: find-default-go
+    strategy:
+      matrix:
+        cache: [false, true]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup default go, cache: ${{ matrix.cache }}'
+        uses: ./
+        with:
+          go-version: ${{ needs.find-default-go.outputs.version }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Drive C: should have Go installation, cache: ${{ matrix.cache}}'
+        run: |
+          size=$(du -m -s 'C:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64'|cut -f1 -d$'\t')
+          if [ $size -eq 0 ];then
+            echo 'Size of the hosted go installed on drive c: must be above zero'
+            exit 1
+          fi
+        shell: bash
+
+      - name: 'Drive D: should not have Go installation, cache: ${{ matrix.cache }}'
+        run: |
+          if [ -e 'D:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64' ];then
+            echo 'D:\hostedtoolcache\windows\go\${{ needs.find-default-go.outputs.version }}\x64 should not exist for hosted version of go';
+            exit 1
+          fi
+        shell: bash
+
+  hostedtoolcache:
+    name: 'Validate if hostedtoolcache works as expected'
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        cache: [false]
+        go: [1.20.1]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: 'Setup ${{ matrix.go }}, cache: ${{ matrix.cache }}'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}
+
+      - name: 'Setup ${{ matrix.go }}, cache: ${{ matrix.cache }} (from hostedtoolcache)'
+        uses: ./
+        with:
+          go-version: ${{ matrix.go }}
+          cache: ${{ matrix.cache }}
@@ -1,39 +0,0 @@
-name: build-test
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-jobs:
-  run:
-    name: Run
-    runs-on: ${{ matrix.operating-system }}
-    strategy:
-      matrix:
-        operating-system: [ubuntu-latest, windows-latest]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Setup node 16
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          cache: npm
-
-      - name: npm ci
-        run: npm ci
-
-      - name: Lint
-        run: npm run format-check
-
-      - name: npm test
-        run: npm test
-
-      - name: audit packages
-        run: npm audit --audit-level=high
-        if: matrix.operating-system == 'ubuntu-latest'
@@ -0,0 +1,7 @@
+# Ignore list
+/*
+
+# Do not ignore these folders:
+!__tests__/
+!.github/
+!src/
@@ -0,0 +1,11 @@
+// This is a reusable configuration file copied from https://github.com/actions/reusable-workflows/tree/main/reusable-configurations. Please don't make changes to this file as it's the subject of an automatic update.
+module.exports = {
+  printWidth: 80,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'none',
+  bracketSpacing: false,
+  arrowParens: 'avoid'
+};
@@ -1,11 +0,0 @@
-{
-    "printWidth": 80,
-    "tabWidth": 2,
-    "useTabs": false,
-    "semi": true,
-    "singleQuote": true,
-    "trailingComma": "none",
-    "bracketSpacing": false,
-    "arrowParens": "avoid",
-    "parser": "typescript"
-  }
@@ -1 +1 @@
-* @actions/actions-service
+* @actions/setup-actions-team
@@ -1,182 +1,486 @@
 # setup-go

-[![build-test](https://github.com/actions/setup-go/actions/workflows/workflow.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/workflow.yml)
+[![Basic validation](https://github.com/actions/setup-go/actions/workflows/basic-validation.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/basic-validation.yml)
 [![Validate 'setup-go'](https://github.com/actions/setup-go/actions/workflows/versions.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/versions.yml)

-This action sets up a go environment for use in actions by:
+This action sets up a Go environment for use in GitHub Actions by:

- Optionally downloading and caching a version of Go by version and adding to `PATH`.
- Registering problem matchers for error output.
+- Optionally downloading and caching a version of Go by version and adding to PATH
+- Registering problem matchers for error output
+- Providing intelligent caching for Go modules and build outputs

-# V3
-
-The V3 edition of the action offers:
-
- Adds `GOBIN` to the `PATH`
- Proxy support
- Check latest version
- Caching packages dependencies
- Bug Fixes (including issues around version matching and semver)
-
-The action will first check the local cache for a version match. If a version is not found locally, it will pull it from the `main` branch of the [go-versions](https://github.com/actions/go-versions/blob/main/versions-manifest.json) repository. On miss or failure, it will fall back to downloading directly from [go dist](https://storage.googleapis.com/golang). To change the default behavior, please use the [check-latest input](#check-latest-version).
-
-**Note:** The `setup-go` action uses executable binaries which are built by Golang side. The action does not build golang from source code.
-
-Matching by [semver spec](https://github.com/npm/node-semver):
+## Quick Start

 ```yaml
 steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
    with:
-      go-version: '^1.13.1' # The Go version to download (if necessary) and use.
+      go-version: '1.23'
  - run: go version
 ```

-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '>=1.17.0'
-  - run: go version
+## Breaking Changes
+
+### V6 Changes
+
+#### Node Runtime Upgrade
+- **Upgraded from Node 20 to Node 24**
+- ⚠️ **Action Required**: Ensure your runner is on version v2.327.1 or later for compatibility
+- See [Release Notes](https://github.com/actions/runner/releases/tag/v2.327.1) for more details
+
+#### Enhanced Go Toolchain Management
+
+V6 introduces significant improvements for reliable and consistent Go version selection:
+
+**Toolchain Directive Support**
+Now correctly interprets both `go` and `toolchain` directives from `go.mod`:
+```go
+go 1.23.0           // Minimum required version
+toolchain go1.23.2  // V6 uses this exact version
 ```

-Matching an unstable pre-release:
+**Intelligent Caching**
+Cache keys now incorporate the `toolchain` directive version from `go.mod`, eliminating cache conflicts when switching between different toolchain versions within the same Go minor release.
+
+For more details, see the [full release notes](https://github.com/actions/setup-go/releases/tag/v6.0.0).
+
+### V5 Changes
+
+- **Upgraded Node.js runtime from node16 to node20**
+- See [full release notes](https://github.com/actions/setup-go/releases) for complete details
+
+## Version Resolution Behavior
+
+The action follows this resolution order:
+1. **Local cache** - Checks for a cached version match
+2. **go-versions repository** - Pulls from the main branch of the [go-versions repository](https://github.com/actions/go-versions/blob/main/versions-manifest.json)
+3. **Direct download** - Falls back to downloading directly from [go.dev](https://go.dev/dl)
+
+To change the default behavior, use the `check-latest` input.
+
+> **Note**: The setup-go action uses executable binaries built by the Golang team. The action does not build golang from source code.
+
+## Usage
+
+### Basic Setup

 ```yaml
 steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
    with:
-      go-version: '1.18.0-rc.1' # The Go version to download (if necessary) and use.
-  - run: go version
-```
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.16.0-beta.1' # The Go version to download (if necessary) and use.
-  - run: go version
-```
-
-# Usage
-
-See [action.yml](action.yml)
-
-## Basic
-
-```yaml
-steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
-    with:
-      go-version: '1.16.1' # The Go version to download (if necessary) and use.
+      go-version: '1.23'
  - run: go run hello.go
 ```

+### Version Specifications

-## Check latest version
-
-The `check-latest` flag defaults to `false`. Use the default or set `check-latest` to `false` if you prefer stability and if you want to ensure a specific Go version is always used.
-
-If `check-latest` is set to `true`, the action first checks if the cached version is the latest one. If the locally cached version is not the most up-to-date, a Go version will then be downloaded. Set `check-latest` to `true` if you want the most up-to-date Go version to always be used.
-
-> Setting `check-latest` to `true` has performance implications as downloading Go versions is slower than using cached versions.
+#### Semantic Versioning

 ```yaml
 steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
    with:
-      go-version: '1.14'
+      go-version: '^1.23.1' # The Go version to download (if necessary) and use.
+  - run: go version
+```
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '>=1.22.0'
+  - run: go version
+```
+
+> **Important**: Due to YAML parsing behavior, always wrap version numbers in single quotes:
+> ```yaml
+> go-version: '1.22'  # Correct
+> go-version: 1.22    # Incorrect - YAML parser interprets as 1.2
+> ```
+
+#### Pre-release Versions
+
+```yaml
+# RC version
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+       go-version: '1.24.0-rc.1' # The Go version to download (if necessary) and use
+  - run: go version
+```
+
+```yaml
+# Beta version
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.23.0-beta.1' # The Go version to download (if necessary) and use
+  - run: go version
+```
+
+#### Version Aliases
+
+**Stable Release**
+
+If `stable` is provided, action will get the latest stable version from the [go-versions](https://github.com/actions/go-versions/blob/main/versions-manifest.json) repository manifest.
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: 'stable' # Latest stable version
+  - run: go version
+```
+
+**Previous Stable Release**
+
+If `oldstable` is provided, when the current release is 1.23.x, the action will resolve version as 1.22.x, where x is the latest patch release.
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: 'oldstable' # Previous stable version
+  - run: go version
+```
+
+> **Note**: Using aliases is equivalent to using the corresponding minor release with `check-latest: true`
+
+### go-version-file
+
+The action can automatically detect the Go version from various project files using the `go-version-file` input. This parameter supports `go.mod`, `go.work`, `.go-version`, and `.tool-versions` files.
+
+> **Note**: If both `go-version` and `go-version-file` are provided, `go-version` takes precedence.
+
+#### go.mod File
+
+Automatically detect the Go version from your project's `go.mod` file:
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version-file: 'go.mod'
+  - run: go version
+```
+
+**Version Resolution from go.mod:**
+1. Uses the `toolchain` directive version if present
+2. Falls back to the `go` directive version
+3. If no patch version is specified, uses the latest available patch
+
+#### go.work File
+
+Use the Go version specified in your `go.work` file:
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version-file: 'go.work'
+  - run: go version
+```
+
+#### .go-version File
+
+Read the Go version from a `.go-version` file:
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version-file: '.go-version'
+  - run: go version
+```
+
+#### .tool-versions File
+
+Use the Go version from an [`.tool-versions`](https://asdf-vm.com/manage/configuration.html#tool-versions) file:
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version-file: '.tool-versions'
+  - run: go version
+```
+
+#### Custom File Paths
+
+The action searches for version files relative to the repository root by default. You can specify a custom path:
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version-file: 'path/to/.go-version'
+  - run: go version
+```
+
+**Supported Version Formats:**
+- Major and minor only: `1.25` (action will use the latest patch version, e.g., `1.25.4`)
+- Major, minor, and patch: `1.25.4` (exact version)
+
+### Check Latest Version
+
+The check-latest flag defaults to false for stability. This ensures your workflow uses a specific, predictable Go version.
+When `check-latest: true`, the action verifies if your cached Go version is the latest available. If not, it downloads and uses the newest version.
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.23'
+      check-latest: true # Always check for the latest patch release
+  - run: go version
+```
+
+**Performance Considerations:**
+- `check-latest: false` (default) - Uses cached versions for faster builds
+- `check-latest: true` - Downloads the latest version, slower but ensures up-to-date releases
+
+### Caching
+
+The action features integrated caching for Go modules and build outputs. Built on [toolkit/cache](https://github.com/actions/toolkit/tree/main/packages/cache), it simplifies the caching process by requiring fewer configuration options. The cache input is optional, and caching is turned on by default.
+
+#### Automatic Caching
+
+Default behavior: Searches for `go.sum` in the repository root and uses its hash for the cache key.
+
+```yaml
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.23'
+      # cache: true (default)
+  - run: go run hello.go
+```
+
+#### Advanced Caching Scenarios
+
+For advanced scenarios, use `cache-dependency-path` to specify:
+- **Multiple dependency files**: When your project has dependencies in different directories
+- **Custom locations**: When your `go.sum` files are not in the repository root
+- **Monorepos**: When managing multiple Go modules in a single repository
+- **Glob patterns**: For flexible file matching
+
+```yaml
+# Example: Monorepo with multiple go.sum files
+steps:
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.23'
      check-latest: true
+      cache-dependency-path: |
+        subdir/go.sum
+        tools/go.sum
  - run: go run hello.go
 ```
-## Caching dependency files and build outputs:

-The action has a built-in functionality for caching and restoring go modules and build outputs. It uses [actions/cache](https://github.com/actions/cache) under the hood but requires less configuration settings. The `cache` input is optional, and caching is turned off by default.
-
-The action defaults to search for the dependency file - go.sum in the repository root, and uses its hash as a part of the cache key. Use `cache-dependency-path` input for cases when multiple dependency files are used, or they are located in different subdirectories.
-
-**Caching without specifying dependency file path**
 ```yaml
+# Example: Using glob patterns to match all go.sum files
 steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
    with:
-      go-version: '1.17'
-      check-latest: true
-      cache: true
+      go-version: '1.23'
+      cache-dependency-path: "**/*.sum"
  - run: go run hello.go
 ```

-**Caching in monorepos**
+#### Disable Caching
+
 ```yaml
 steps:
-  - uses: actions/checkout@v3
-  - uses: actions/setup-go@v3
+  - uses: actions/checkout@v6
+  - uses: actions/setup-go@v6
    with:
-      go-version: '1.17'
-      check-latest: true
-      cache: true
-      cache-dependency-path: subdir/go.sum
+      go-version: '1.23'
+      cache: false
  - run: go run hello.go
-  ```
-## Getting go version from the go.mod file
-
-The `go-version-file` input accepts a path to a `go.mod` file containing the version of Go to be used by a project. As the `go.mod` file contains only major and minor (e.g. 1.18) tags, the action will search for the latest available patch version sequentially in the runner's directory with the cached tools, in the [version-manifest.json](https://github.com/actions/go-versions/blob/main/versions-manifest.json) file or at the go servers.
-
-If both the `go-version` and the `go-version-file` inputs are provided then the `go-version` input is used.
-> The action will search for the `go.mod` file relative to the repository root
-
-```yaml
-steps:
- uses: actions/checkout@v3
- uses: actions/setup-go@v3
-  with:
-    go-version-file: 'path/to/go.mod'
- run: go version
 ```

-## Matrix testing
+> **Note**: If caching fails, the action logs a warning but continues execution without interrupting your workflow.
+
+**Restore-Only Cache**
+
+```yaml
+# In some workflows, you may want to restore a cache without saving it. This can help reduce cache writes and storage usage in workflows that only need to read from cache
+jobs:
+    build:
+      runs-on: ${{ matrix.os }}
+      strategy:
+        matrix:
+          os: [ubuntu-latest, macos-latest, windows-latest]
+      steps:
+        - uses: actions/checkout@v6
+        - name: Setup Go
+          id: setup-go
+          uses: actions/setup-go@v6
+          with:
+            go-version: '1.24.10'
+            cache: false
+        # Capture Go cache locations
+        - name: Set Go cache variables (Linux/macOS)
+          if: runner.os != 'Windows'
+          run: |
+            echo "GO_MOD_CACHE=$(go env GOMODCACHE)" >> $GITHUB_ENV
+            echo "GO_BUILD_CACHE=$(go env GOCACHE)" >> $GITHUB_ENV
+        - name: Set Go cache variables (Windows)
+          if: runner.os == 'Windows'
+          shell: pwsh
+          run: |
+            echo "GO_MOD_CACHE=$(go env GOMODCACHE)" | Out-File $env:GITHUB_ENV -Append
+            echo "GO_BUILD_CACHE=$(go env GOCACHE)"   | Out-File $env:GITHUB_ENV -Append
+        # Normalize runner.arch to lowercase to ensure consistent cache keys
+        - name: Normalize runner architecture (Linux/macOS)
+          if: runner.os != 'Windows'
+          shell: bash
+          run: echo "ARCH=$(echo '${{ runner.arch }}' | tr '[:upper:]' '[:lower:]')" >> $GITHUB_ENV
+        - name: Normalize runner architecture (Windows)
+          if: runner.os == 'Windows'
+          shell: pwsh
+          run: |
+            $arch = "${{ runner.arch }}".ToLower()
+            echo "ARCH=$arch" | Out-File $env:GITHUB_ENV -Append
+        - name: Set cache OS suffix for Linux
+          if: runner.os == 'Linux'
+          shell: bash
+          run: echo "CACHE_OS_SUFFIX=$ImageOS-" >> $GITHUB_ENV    
+        - name: Restore Go cache
+          id: go-cache
+          uses: actions/cache/restore@v5
+          with:
+            path: |
+              ${{ env.GO_MOD_CACHE }}
+              ${{ env.GO_BUILD_CACHE }}
+            key: setup-go-${{ runner.os }}-${{ env.ARCH }}-${{ env.CACHE_OS_SUFFIX }}go-${{ steps.setup-go.outputs.go-version }}-${{ hashFiles('**/go.sum') }}
+        - name: Download modules
+          run: go mod download
+        - name: Build
+          run: go build ./...
+```
+> If there are several builds on the same repo it might make sense to create a cache in one build and use it in the
+others. The action [actions/cache/restore](https://github.com/actions/cache/tree/main/restore#only-restore-cache)
+should be used in this case.
+
+### Matrix Testing
+
+Test across multiple Go versions:

 ```yaml
 jobs:
-  build:
+  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        go: [ '1.14', '1.13' ]
-    name: Go ${{ matrix.go }} sample
+        go-version: ['1.21', '1.22', '1.23']
    steps:
-      - uses: actions/checkout@v3
-      - name: Setup go
-        uses: actions/setup-go@v3
+      - uses: actions/checkout@v6
+      - uses: actions/setup-go@v6
        with:
-          go-version: ${{ matrix.go }}
-      - run: go run hello.go
+          go-version: ${{ matrix.go-version }}
+      - run: go test ./...
 ```

-### Supported version syntax
+## Advanced Configuration
+
+### Supported Version Syntax

 The `go-version` input supports the following syntax:

- Specific versions: `1.15`, `1.16.1`, `1.17.0-rc.2`, `1.16.0-beta.1`
- SemVer's version range syntax: `^1.13.1`, `>=1.18.0-rc.1`
+| Syntax Type | Example | Description |
+|-------------|---------|-------------|
+| Specific version | `1.23.2` | Installs this exact version |
+| Semantic range (caret) | `^1.23.0` | Allows newer minor/patch versions (1.24.x, 1.25.x, etc.) |
+| Semantic range (tilde) | `~1.23.0` | Allows newer patch versions only (1.23.1, 1.23.2, etc.) |
+| Comparison (gte) | `>=1.22.0` | Any version equal to or newer than specified |
+| Comparison (lt) | `<1.24.0` | Any version older than specified |
+| Comparison range | `>=1.22.0 <1.24.0` | Any version within the specified range |
+| Wildcard (patch) | `1.23.x` | Latest patch version of the specified minor release |
+| Wildcard (minor) | `1.*` | Latest available version in the major version |
+| Pre-release | `1.24.0-rc.1` | Beta/RC versions for testing upcoming releases |
+| Aliases | `stable`, `oldstable` | Latest stable or previous stable release |

-For more information about semantic versioning, please refer to [semver](https://github.com/npm/node-semver) documentation.
+For more information about semantic versioning, see the [semver documentation](https://semver.org/).

-# License
+### Complete Input Reference

-The scripts and documentation in this project are released under the [MIT License](LICENSE)
+```yaml
+- uses: actions/setup-go@v6
+  with:
+    # Version or version range of Go to use
+    go-version: '1.23'
+    
+    # Path to go.mod, go.work, .go-version, or .tool-versions file
+    go-version-file: 'go.mod'
+    
+    # Check for latest version
+    check-latest: false
+    
+    # GitHub token for authentication
+    token: ${{ github.token }}
+    
+    # Enable/disable caching
+    cache: true
+    
+    # Path to dependency files for caching
+    cache-dependency-path: 'go.sum'
+    
+    # Architecture to install (auto-detected if not specified)
+    architecture: 'x64'
+```

-# Contributions
+## Using setup-go on GHES

-Contributions are welcome! See [Contributor's Guide](docs/contributors.md)
+setup-go comes pre-installed on GHES when Actions is enabled. For dynamic Go version downloads, the action fetches distributions from the [go-versions repository](https://github.com/actions/go-versions/) on github.com (external to your appliance).
+
+These calls to `actions/go-versions` are made via unauthenticated requests, which are limited to 60 requests per hour per IP. If more requests are made within the time frame, then the action leverages the raw API to retrieve the version-manifest. This approach does not impose a rate limit and hence facilitates unrestricted consumption. This is particularly beneficial for GHES runners, which often share the same IP, to avoid the quick exhaustion of the unauthenticated rate limit. If that fails as well the action will try to download versions directly from [go.dev](https://go.dev/dl).
+
+If that fails as well you can get a higher rate limit with generating a personal access token on github.com and passing it as the token input to the action:
+
+```yaml
+uses: actions/setup-go@v6
+with:
+  token: ${{ secrets.GH_DOTCOM_TOKEN }}
+  go-version: '1.23'
+```
+
+### Offline Runners
+
+For runners without github.com access, Go versions must be pre-cached in the runner's tool cache. See "[Setting up the tool cache on self-hosted runners without internet access](https://docs.github.com/en/enterprise-server@3.2/admin/github-actions/managing-access-to-actions-from-githubcom/setting-up-the-tool-cache-on-self-hosted-runners-without-internet-access)".
+
+## Recommended Permissions
+
+When using the setup-go action in your GitHub Actions workflow, it is recommended to set the following permissions to ensure proper functionality:
+
+```yaml
+permissions:
+  contents: read # Required to checkout code and install dependencies
+```
+
+## License
+
+The scripts and documentation in this project are released under the [MIT License](LICENSE).
+
+## Contributions
+
+Contributions are welcome! See our [Contributor's Guide](docs/contributors.md) for details.

 ## Code of Conduct

-:wave: Be nice. See [our code of conduct](CONDUCT)
+👋 Be nice. See our [Code of Conduct](CODE_OF_CONDUCT.md).
@@ -8,15 +8,16 @@ import {PackageManagerInfo} from '../src/package-managers';

 describe('restoreCache', () => {
  //Arrange
-  let hashFilesSpy = jest.spyOn(glob, 'hashFiles');
-  let getCacheDirectoryPathSpy = jest.spyOn(
+  const hashFilesSpy = jest.spyOn(glob, 'hashFiles');
+  const getCacheDirectoryPathSpy = jest.spyOn(
    cacheUtils,
    'getCacheDirectoryPath'
  );
-  let restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
-  let infoSpy = jest.spyOn(core, 'info');
-  let setOutputSpy = jest.spyOn(core, 'setOutput');
+  const restoreCacheSpy = jest.spyOn(cache, 'restoreCache');
+  const infoSpy = jest.spyOn(core, 'info');
+  const setOutputSpy = jest.spyOn(core, 'setOutput');

+  const versionSpec = '1.13.1';
  const packageManager = 'default';
  const cacheDependencyPath = 'path';

@@ -39,9 +40,13 @@ describe('restoreCache', () => {
    });

    //Act + Assert
-    expect(async () => {
-      await cacheRestore.restoreCache(packageManager, cacheDependencyPath);
-    }).rejects.toThrowError(
+    await expect(async () => {
+      await cacheRestore.restoreCache(
+        versionSpec,
+        packageManager,
+        cacheDependencyPath
+      );
+    }).rejects.toThrow(
      'Some specified paths were not resolved, unable to cache dependencies.'
    );
  });
@@ -61,8 +66,12 @@ describe('restoreCache', () => {
    });

    //Act + Assert
-    await cacheRestore.restoreCache(packageManager, cacheDependencyPath);
-    expect(infoSpy).toBeCalledWith(`Cache is not found`);
+    await cacheRestore.restoreCache(
+      versionSpec,
+      packageManager,
+      cacheDependencyPath
+    );
+    expect(infoSpy).toHaveBeenCalledWith(`Cache is not found`);
  });

  it('should set output if cache hit is occured', async () => {
@@ -80,7 +89,11 @@ describe('restoreCache', () => {
    });

    //Act + Assert
-    await cacheRestore.restoreCache(packageManager, cacheDependencyPath);
-    expect(setOutputSpy).toBeCalledWith('cache-hit', true);
+    await cacheRestore.restoreCache(
+      versionSpec,
+      packageManager,
+      cacheDependencyPath
+    );
+    expect(setOutputSpy).toHaveBeenCalledWith('cache-hit', true);
  });
 });
@@ -6,7 +6,7 @@ import {PackageManagerInfo} from '../src/package-managers';

 describe('getCommandOutput', () => {
  //Arrange
-  let getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+  const getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');

  it('should return trimmed stdout in case of successful exit code', async () => {
    //Arrange
@@ -36,7 +36,7 @@ describe('getCommandOutput', () => {
    });

    //Act + Assert
-    expect(async () => {
+    await expect(async () => {
      await cacheUtils.getCommandOutput('command');
    }).rejects.toThrow();
  });
@@ -62,7 +62,7 @@ describe('getPackageManagerInfo', () => {
    const packageManagerName = 'invalidName';

    //Act + Assert
-    expect(async () => {
+    await expect(async () => {
      await cacheUtils.getPackageManagerInfo(packageManagerName);
    }).rejects.toThrow();
  });
@@ -70,7 +70,7 @@ describe('getPackageManagerInfo', () => {

 describe('getCacheDirectoryPath', () => {
  //Arrange
-  let getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');
+  const getExecOutputSpy = jest.spyOn(exec, 'getExecOutput');

  const validPackageManager: PackageManagerInfo = {
    dependencyFilePattern: 'go.sum',
@@ -93,6 +93,41 @@ describe('getCacheDirectoryPath', () => {
      .then(data => expect(data).toEqual(expectedResult));
  });

+  it('should return path to the cache folder if one command return empty str', async () => {
+    //Arrange
+    getExecOutputSpy.mockImplementationOnce((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 0, stdout: 'path/to/cache/folder', stderr: ''});
+      });
+    });
+
+    getExecOutputSpy.mockImplementationOnce((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 0, stdout: '', stderr: ''});
+      });
+    });
+
+    const expectedResult = ['path/to/cache/folder'];
+
+    //Act + Assert
+    return cacheUtils
+      .getCacheDirectoryPath(validPackageManager)
+      .then(data => expect(data).toEqual(expectedResult));
+  });
+
+  it('should throw if the both commands return empty str', async () => {
+    getExecOutputSpy.mockImplementation((commandLine: string) => {
+      return new Promise<exec.ExecOutput>(resolve => {
+        resolve({exitCode: 10, stdout: '', stderr: ''});
+      });
+    });
+
+    //Act + Assert
+    await expect(async () => {
+      await cacheUtils.getCacheDirectoryPath(validPackageManager);
+    }).rejects.toThrow();
+  });
+
  it('should throw if the specified package name is invalid', async () => {
    getExecOutputSpy.mockImplementation((commandLine: string) => {
      return new Promise<exec.ExecOutput>(resolve => {
@@ -101,7 +136,7 @@ describe('getCacheDirectoryPath', () => {
    });

    //Act + Assert
-    expect(async () => {
+    await expect(async () => {
      await cacheUtils.getCacheDirectoryPath(validPackageManager);
    }).rejects.toThrow();
  });
@@ -109,8 +144,8 @@ describe('getCacheDirectoryPath', () => {

 describe('isCacheFeatureAvailable', () => {
  //Arrange
-  let isFeatureAvailableSpy = jest.spyOn(cache, 'isFeatureAvailable');
-  let warningSpy = jest.spyOn(core, 'warning');
+  const isFeatureAvailableSpy = jest.spyOn(cache, 'isFeatureAvailable');
+  const warningSpy = jest.spyOn(core, 'warning');

  it('should return true when cache feature is available', () => {
    //Arrange
@@ -118,16 +153,14 @@ describe('isCacheFeatureAvailable', () => {
      return true;
    });

-    let functionResult;
-
    //Act
-    functionResult = cacheUtils.isCacheFeatureAvailable();
+    const functionResult = cacheUtils.isCacheFeatureAvailable();

    //Assert
    expect(functionResult).toBeTruthy();
  });

-  it('should warn when cache feature is unavailable and GHES is not used ', () => {
+  it('should warn when cache feature is unavailable and GHES is not used', () => {
    //Arrange
    isFeatureAvailableSpy.mockImplementation(() => {
      return false;
@@ -135,7 +168,7 @@ describe('isCacheFeatureAvailable', () => {

    process.env['GITHUB_SERVER_URL'] = 'https://github.com';

-    let warningMessage =
+    const warningMessage =
      'The runner was not able to contact the cache service. Caching will be skipped';

    //Act
@@ -153,16 +186,14 @@ describe('isCacheFeatureAvailable', () => {

    process.env['GITHUB_SERVER_URL'] = 'https://github.com';

-    let functionResult;
-
    //Act
-    functionResult = cacheUtils.isCacheFeatureAvailable();
+    const functionResult = cacheUtils.isCacheFeatureAvailable();

    //Assert
    expect(functionResult).toBeFalsy();
  });

-  it('should throw when cache feature is unavailable and GHES is used', () => {
+  it('should warn when cache feature is unavailable and GHES is used', () => {
    //Arrange
    isFeatureAvailableSpy.mockImplementation(() => {
      return false;
@@ -170,10 +201,49 @@ describe('isCacheFeatureAvailable', () => {

    process.env['GITHUB_SERVER_URL'] = 'https://nongithub.com';

-    let errorMessage =
+    const warningMessage =
      'Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.';

    //Act + Assert
-    expect(() => cacheUtils.isCacheFeatureAvailable()).toThrow(errorMessage);
+    expect(cacheUtils.isCacheFeatureAvailable()).toBeFalsy();
+    expect(warningSpy).toHaveBeenCalledWith(warningMessage);
+  });
+});
+
+describe('isGhes', () => {
+  const pristineEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = {...pristineEnv};
+  });
+
+  afterAll(() => {
+    process.env = pristineEnv;
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is not defined', async () => {
+    delete process.env['GITHUB_SERVER_URL'];
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is set to github.com', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://github.com';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable is set to a GitHub Enterprise Cloud-style URL', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://contoso.ghe.com';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns false when the GITHUB_SERVER_URL environment variable has a .localhost suffix', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://mock-github.localhost';
+    expect(cacheUtils.isGhes()).toBeFalsy();
+  });
+
+  it('returns true when the GITHUB_SERVER_URL environment variable is set to some other URL', async () => {
+    process.env['GITHUB_SERVER_URL'] = 'https://src.onpremise.fabrikam.com';
+    expect(cacheUtils.isGhes()).toBeTruthy();
  });
 });
@@ -0,0 +1 @@
+1.22.4
@@ -0,0 +1 @@
+golang 1.23.2
@@ -1,6 +1,6 @@
 module example.com/mymodule

-go 1.14
+go 1.20

 require (
 	example.com/othermodule v1.2.3
@@ -0,0 +1,3 @@
+go 1.21
+
+use .
@@ -3,16 +3,21 @@ import * as io from '@actions/io';
 import * as tc from '@actions/tool-cache';
 import fs from 'fs';
 import cp from 'child_process';
-import osm from 'os';
+import osm, {type} from 'os';
 import path from 'path';
 import * as main from '../src/main';
 import * as im from '../src/installer';
+import * as httpm from '@actions/http-client';

-let goJsonData = require('./data/golang-dl.json');
-let matchers = require('../matchers.json');
-let goTestManifest = require('./data/versions-manifest.json');
-let matcherPattern = matchers.problemMatcher[0].pattern[0];
-let matcherRegExp = new RegExp(matcherPattern.regexp);
+import goJsonData from './data/golang-dl.json';
+import matchers from '../matchers.json';
+import goTestManifest from './data/versions-manifest.json';
+const matcherPattern = matchers.problemMatcher[0].pattern[0];
+const matcherRegExp = new RegExp(matcherPattern.regexp);
+const win32Join = path.win32.join;
+const posixJoin = path.posix.join;
+
+jest.setTimeout(10000);

 describe('setup-go', () => {
  let inputs = {} as any;
@@ -27,16 +32,22 @@ describe('setup-go', () => {
  let getSpy: jest.SpyInstance;
  let platSpy: jest.SpyInstance;
  let archSpy: jest.SpyInstance;
+  let joinSpy: jest.SpyInstance;
  let dlSpy: jest.SpyInstance;
  let extractTarSpy: jest.SpyInstance;
+  let extractZipSpy: jest.SpyInstance;
  let cacheSpy: jest.SpyInstance;
  let dbgSpy: jest.SpyInstance;
  let whichSpy: jest.SpyInstance;
  let existsSpy: jest.SpyInstance;
  let readFileSpy: jest.SpyInstance;
  let mkdirpSpy: jest.SpyInstance;
+  let mkdirSpy: jest.SpyInstance;
+  let symlinkSpy: jest.SpyInstance;
  let execSpy: jest.SpyInstance;
  let getManifestSpy: jest.SpyInstance;
+  let getAllVersionsSpy: jest.SpyInstance;
+  let httpmGetJsonSpy: jest.SpyInstance;

  beforeAll(async () => {
    process.env['GITHUB_ENV'] = ''; // Stub out Environment file functionality so we can verify it writes to standard out (toolkit is backwards compatible)
@@ -61,13 +72,28 @@ describe('setup-go', () => {
    archSpy.mockImplementation(() => os['arch']);
    execSpy = jest.spyOn(cp, 'execSync');

+    // switch path join behaviour based on set os.platform
+    joinSpy = jest.spyOn(path, 'join');
+    joinSpy.mockImplementation((...paths: string[]): string => {
+      if (os['platform'] == 'win32') {
+        return win32Join(...paths);
+      }
+
+      return posixJoin(...paths);
+    });
+
    // @actions/tool-cache
    findSpy = jest.spyOn(tc, 'find');
    dlSpy = jest.spyOn(tc, 'downloadTool');
    extractTarSpy = jest.spyOn(tc, 'extractTar');
+    extractZipSpy = jest.spyOn(tc, 'extractZip');
    cacheSpy = jest.spyOn(tc, 'cacheDir');
    getSpy = jest.spyOn(im, 'getVersionsDist');
    getManifestSpy = jest.spyOn(tc, 'getManifestFromRepo');
+    getAllVersionsSpy = jest.spyOn(im, 'getManifest');
+
+    // httm
+    httpmGetJsonSpy = jest.spyOn(httpm.HttpClient.prototype, 'getJson');

    // io
    whichSpy = jest.spyOn(io, 'which');
@@ -75,6 +101,11 @@ describe('setup-go', () => {
    readFileSpy = jest.spyOn(fs, 'readFileSync');
    mkdirpSpy = jest.spyOn(io, 'mkdirP');

+    // fs
+    mkdirSpy = jest.spyOn(fs, 'mkdir');
+    symlinkSpy = jest.spyOn(fs, 'symlinkSync');
+    symlinkSpy.mockImplementation(() => {});
+
    // gets
    getManifestSpy.mockImplementation(() => <tc.IToolRelease[]>goTestManifest);

@@ -98,6 +129,9 @@ describe('setup-go', () => {
  });

  afterEach(() => {
+    // clear out env var set during 'run'
+    delete process.env[im.GOTOOLCHAIN_ENV_VAR];
+
    //jest.resetAllMocks();
    jest.clearAllMocks();
    //jest.restoreAllMocks();
@@ -116,7 +150,7 @@ describe('setup-go', () => {
    os.platform = 'darwin';
    os.arch = 'x64';

-    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
+    const match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
    expect(match).toBeDefined();
    expect(match!.resolvedVersion).toBe('1.9.7');
    expect(match!.type).toBe('manifest');
@@ -125,11 +159,26 @@ describe('setup-go', () => {
    );
  });

+  it('should return manifest from repo', async () => {
+    const manifest = await im.getManifest(undefined);
+    expect(manifest).toEqual(goTestManifest);
+  });
+
+  it('should return manifest from raw URL if repo fetch fails', async () => {
+    getManifestSpy.mockRejectedValue(new Error('Fetch failed'));
+    httpmGetJsonSpy.mockResolvedValue({
+      result: goTestManifest
+    });
+    const manifest = await im.getManifest(undefined);
+    expect(httpmGetJsonSpy).toHaveBeenCalled();
+    expect(manifest).toEqual(goTestManifest);
+  });
+
  it('can find 1.9 from manifest on linux', async () => {
    os.platform = 'linux';
    os.arch = 'x64';

-    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
+    const match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
    expect(match).toBeDefined();
    expect(match!.resolvedVersion).toBe('1.9.7');
    expect(match!.type).toBe('manifest');
@@ -142,7 +191,7 @@ describe('setup-go', () => {
    os.platform = 'win32';
    os.arch = 'x64';

-    let match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
+    const match = await im.getInfoFromManifest('1.9.7', true, 'mocktoken');
    expect(match).toBeDefined();
    expect(match!.resolvedVersion).toBe('1.9.7');
    expect(match!.type).toBe('manifest');
@@ -156,11 +205,11 @@ describe('setup-go', () => {
    os.arch = 'x64';

    // spec: 1.13.0 => 1.13
-    let match: im.IGoVersion | undefined = await im.findMatch('1.13.0');
+    const match: im.IGoVersion | undefined = await im.findMatch('1.13.0');
    expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
+    const version: string = match ? match.version : '';
    expect(version).toBe('go1.13');
-    let fileName = match ? match.files[0].filename : '';
+    const fileName = match ? match.files[0].filename : '';
    expect(fileName).toBe('go1.13.darwin-amd64.tar.gz');
  });

@@ -169,11 +218,11 @@ describe('setup-go', () => {
    os.arch = 'x64';

    // spec: 1.13 => 1.13.7 (latest)
-    let match: im.IGoVersion | undefined = await im.findMatch('1.13');
+    const match: im.IGoVersion | undefined = await im.findMatch('1.13');
    expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
+    const version: string = match ? match.version : '';
    expect(version).toBe('go1.13.7');
-    let fileName = match ? match.files[0].filename : '';
+    const fileName = match ? match.files[0].filename : '';
    expect(fileName).toBe('go1.13.7.linux-amd64.tar.gz');
  });

@@ -182,11 +231,11 @@ describe('setup-go', () => {
    os.arch = 'x64';

    // spec: ^1.13.6 => 1.13.7
-    let match: im.IGoVersion | undefined = await im.findMatch('^1.13.6');
+    const match: im.IGoVersion | undefined = await im.findMatch('^1.13.6');
    expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
+    const version: string = match ? match.version : '';
    expect(version).toBe('go1.13.7');
-    let fileName = match ? match.files[0].filename : '';
+    const fileName = match ? match.files[0].filename : '';
    expect(fileName).toBe('go1.13.7.linux-amd64.tar.gz');
  });

@@ -195,11 +244,11 @@ describe('setup-go', () => {
    os.arch = 'x32';

    // spec: 1 => 1.13.7 (latest)
-    let match: im.IGoVersion | undefined = await im.findMatch('1');
+    const match: im.IGoVersion | undefined = await im.findMatch('1');
    expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
+    const version: string = match ? match.version : '';
    expect(version).toBe('go1.13.7');
-    let fileName = match ? match.files[0].filename : '';
+    const fileName = match ? match.files[0].filename : '';
    expect(fileName).toBe('go1.13.7.windows-386.zip');
  });

@@ -208,11 +257,11 @@ describe('setup-go', () => {
    os.arch = 'x64';

    // spec: 1.14, stable=false => go1.14rc1
-    let match: im.IGoVersion | undefined = await im.findMatch('1.14.0-rc.1');
+    const match: im.IGoVersion | undefined = await im.findMatch('1.14.0-rc.1');
    expect(match).toBeDefined();
-    let version: string = match ? match.version : '';
+    const version: string = match ? match.version : '';
    expect(version).toBe('go1.14rc1');
-    let fileName = match ? match.files[0].filename : '';
+    const fileName = match ? match.files[0].filename : '';
    expect(fileName).toBe('go1.14rc1.linux-amd64.tar.gz');
  });

@@ -220,7 +269,7 @@ describe('setup-go', () => {
    inputs['go-version'] = '1.13.0';
    inputs.stable = 'true';

-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    findSpy.mockImplementation(() => toolPath);
    await main.run();

@@ -232,70 +281,67 @@ describe('setup-go', () => {

    inSpy.mockImplementation(name => inputs[name]);

-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    findSpy.mockImplementation(() => toolPath);
    await main.run();

    expect(logSpy).toHaveBeenCalledWith(`Setup go version spec 1.13.0`);
  });

-  it('does not export any variables for Go versions >=1.9', async () => {
+  it('does not export GOROOT for Go versions >=1.9', async () => {
    inputs['go-version'] = '1.13.0';
    inSpy.mockImplementation(name => inputs[name]);

-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    findSpy.mockImplementation(() => toolPath);

-    let vars: {[key: string]: string} = {};
+    const vars: {[key: string]: string} = {};
    exportVarSpy.mockImplementation((name: string, val: string) => {
      vars[name] = val;
    });

    await main.run();
-    expect(vars).toStrictEqual({});
+    expect(vars).not.toHaveProperty('GOROOT');
  });

  it('exports GOROOT for Go versions <1.9', async () => {
    inputs['go-version'] = '1.8';
    inSpy.mockImplementation(name => inputs[name]);

-    let toolPath = path.normalize('/cache/go/1.8.0/x64');
+    const toolPath = path.normalize('/cache/go/1.8.0/x64');
    findSpy.mockImplementation(() => toolPath);

-    let vars: {[key: string]: string} = {};
+    const vars: {[key: string]: string} = {};
    exportVarSpy.mockImplementation((name: string, val: string) => {
      vars[name] = val;
    });

    await main.run();
-    expect(vars).toStrictEqual({
-      GOROOT: toolPath
-    });
+    expect(vars).toHaveProperty('GOROOT', toolPath);
  });

  it('finds a version of go already in the cache', async () => {
    inputs['go-version'] = '1.13.0';

-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    findSpy.mockImplementation(() => toolPath);
    await main.run();

-    let expPath = path.join(toolPath, 'bin');
    expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`);
  });

  it('finds a version in the cache and adds it to the path', async () => {
    inputs['go-version'] = '1.13.0';
-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    findSpy.mockImplementation(() => toolPath);
    await main.run();

-    let expPath = path.join(toolPath, 'bin');
+    const expPath = path.join(toolPath, 'bin');
    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
  });

  it('handles unhandled error and reports error', async () => {
-    let errMsg = 'unhandled error message';
+    const errMsg = 'unhandled error message';
    inputs['go-version'] = '1.13.0';

    findSpy.mockImplementation(() => {
@@ -313,18 +359,43 @@ describe('setup-go', () => {

    findSpy.mockImplementation(() => '');
    dlSpy.mockImplementation(() => '/some/temp/path');
-    let toolPath = path.normalize('/cache/go/1.13.0/x64');
+    const toolPath = path.normalize('/cache/go/1.13.0/x64');
    extractTarSpy.mockImplementation(() => '/some/other/temp/path');
    cacheSpy.mockImplementation(() => toolPath);
    await main.run();

-    let expPath = path.join(toolPath, 'bin');
+    const expPath = path.join(toolPath, 'bin');

    expect(dlSpy).toHaveBeenCalled();
    expect(extractTarSpy).toHaveBeenCalled();
    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
  });

+  it('downloads a version not in the cache (windows)', async () => {
+    os.platform = 'win32';
+    os.arch = 'x64';
+
+    inputs['go-version'] = '1.13.1';
+    process.env['RUNNER_TEMP'] = 'C:\\temp\\';
+
+    findSpy.mockImplementation(() => '');
+    dlSpy.mockImplementation(() => 'C:\\temp\\some\\path');
+    extractZipSpy.mockImplementation(() => 'C:\\temp\\some\\other\\path');
+
+    const toolPath = path.normalize('C:\\cache\\go\\1.13.0\\x64');
+    cacheSpy.mockImplementation(() => toolPath);
+
+    await main.run();
+
+    const expPath = path.win32.join(toolPath, 'bin');
+    expect(dlSpy).toHaveBeenCalledWith(
+      'https://go.dev/dl/go1.13.1.windows-amd64.zip',
+      'C:\\temp\\go1.13.1.windows-amd64.zip',
+      undefined
+    );
+    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
+  });
+
  it('does not find a version that does not exist', async () => {
    os.platform = 'linux';
    os.arch = 'x64';
@@ -343,25 +414,25 @@ describe('setup-go', () => {
    os.platform = 'linux';
    os.arch = 'x64';

-    let versionSpec = '1.12.16';
+    const versionSpec = '1.12.16';

    inputs['go-version'] = versionSpec;
    inputs['token'] = 'faketoken';

-    let expectedUrl =
+    const expectedUrl =
      'https://github.com/actions/go-versions/releases/download/1.12.16-20200616.20/go-1.12.16-linux-x64.tar.gz';

    // ... but not in the local cache
    findSpy.mockImplementation(() => '');

    dlSpy.mockImplementation(async () => '/some/temp/path');
-    let toolPath = path.normalize('/cache/go/1.12.16/x64');
+    const toolPath = path.normalize('/cache/go/1.12.16/x64');
    extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
    cacheSpy.mockImplementation(async () => toolPath);

    await main.run();

-    let expPath = path.join(toolPath, 'bin');
+    const expPath = path.join(toolPath, 'bin');

    expect(dlSpy).toHaveBeenCalled();
    expect(extractTarSpy).toHaveBeenCalled();
@@ -380,25 +451,25 @@ describe('setup-go', () => {
    os.platform = 'linux';
    os.arch = 'x64';

-    let versionSpec = '1.12';
+    const versionSpec = '1.12';

    inputs['go-version'] = versionSpec;
    inputs['token'] = 'faketoken';

-    let expectedUrl =
+    const expectedUrl =
      'https://github.com/actions/go-versions/releases/download/1.12.17-20200616.21/go-1.12.17-linux-x64.tar.gz';

    // ... but not in the local cache
    findSpy.mockImplementation(() => '');

    dlSpy.mockImplementation(async () => '/some/temp/path');
-    let toolPath = path.normalize('/cache/go/1.12.17/x64');
+    const toolPath = path.normalize('/cache/go/1.12.17/x64');
    extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
    cacheSpy.mockImplementation(async () => toolPath);

    await main.run();

-    let expPath = path.join(toolPath, 'bin');
+    const expPath = path.join(toolPath, 'bin');

    expect(dlSpy).toHaveBeenCalled();
    expect(extractTarSpy).toHaveBeenCalled();
@@ -413,29 +484,26 @@ describe('setup-go', () => {
    expect(cnSpy).toHaveBeenCalledWith(`::add-path::${expPath}${osm.EOL}`);
  });

-  it('falls back to a version from node dist', async () => {
+  it('falls back to a version from go dist', async () => {
    os.platform = 'linux';
    os.arch = 'x64';

-    let versionSpec = '1.12.14';
+    const versionSpec = '1.12.14';

    inputs['go-version'] = versionSpec;
    inputs['token'] = 'faketoken';

-    let expectedUrl =
-      'https://github.com/actions/go-versions/releases/download/1.12.14-20200616.18/go-1.12.14-linux-x64.tar.gz';
-
    // ... but not in the local cache
    findSpy.mockImplementation(() => '');

    dlSpy.mockImplementation(async () => '/some/temp/path');
-    let toolPath = path.normalize('/cache/go/1.12.14/x64');
+    const toolPath = path.normalize('/cache/go/1.12.14/x64');
    extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
    cacheSpy.mockImplementation(async () => toolPath);

    await main.run();

-    let expPath = path.join(toolPath, 'bin');
+    const expPath = path.join(toolPath, 'bin');
    expect(logSpy).toHaveBeenCalledWith('Setup go version spec 1.12.14');
    expect(findSpy).toHaveBeenCalled();
    expect(logSpy).toHaveBeenCalledWith('Attempting to download 1.12.14...');
@@ -451,7 +519,7 @@ describe('setup-go', () => {
  });

  it('reports a failed download', async () => {
-    let errMsg = 'unhandled download message';
+    const errMsg = 'unhandled download message';
    os.platform = 'linux';
    os.arch = 'x64';

@@ -472,7 +540,7 @@ describe('setup-go', () => {
    whichSpy.mockImplementation(async () => {
      return '';
    });
-    let added = await main.addBinToPath();
+    const added = await main.addBinToPath();
    expect(added).toBeFalsy();
  });

@@ -486,12 +554,12 @@ describe('setup-go', () => {
    });

    mkdirpSpy.mockImplementation(async () => {});
-    existsSpy.mockImplementation(path => {
+    existsSpy.mockImplementation(() => {
      return false;
    });

-    let added = await main.addBinToPath();
-    expect(added).toBeTruthy;
+    const added = await main.addBinToPath();
+    expect(added).toBeTruthy();
  });

  interface Annotation {
@@ -505,9 +573,9 @@ describe('setup-go', () => {
  // problem matcher regex pattern tests

  function testMatch(line: string): Annotation {
-    let annotation = <Annotation>{};
+    const annotation = <Annotation>{};

-    let match = matcherRegExp.exec(line);
+    const match = matcherRegExp.exec(line);
    if (match) {
      annotation.line = parseInt(match[matcherPattern.line], 10);
      annotation.column = parseInt(match[matcherPattern.column], 10);
@@ -519,8 +587,8 @@ describe('setup-go', () => {
  }

  it('matches on relative unix path', async () => {
-    let line = './main.go:13:2: undefined: fmt.Printl';
-    let annotation = testMatch(line);
+    const line = './main.go:13:2: undefined: fmt.Printl';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(13);
    expect(annotation.column).toBe(2);
@@ -529,8 +597,8 @@ describe('setup-go', () => {
  });

  it('matches on unix path up the tree', async () => {
-    let line = '../main.go:13:2: undefined: fmt.Printl';
-    let annotation = testMatch(line);
+    const line = '../main.go:13:2: undefined: fmt.Printl';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(13);
    expect(annotation.column).toBe(2);
@@ -539,8 +607,8 @@ describe('setup-go', () => {
  });

  it('matches on unix path down the tree', async () => {
-    let line = 'foo/main.go:13:2: undefined: fmt.Printl';
-    let annotation = testMatch(line);
+    const line = 'foo/main.go:13:2: undefined: fmt.Printl';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(13);
    expect(annotation.column).toBe(2);
@@ -549,8 +617,8 @@ describe('setup-go', () => {
  });

  it('matches on rooted unix path', async () => {
-    let line = '/assert.go:4:1: missing return at end of function';
-    let annotation = testMatch(line);
+    const line = '/assert.go:4:1: missing return at end of function';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(4);
    expect(annotation.column).toBe(1);
@@ -559,8 +627,8 @@ describe('setup-go', () => {
  });

  it('matches on unix path with spaces', async () => {
-    let line = '   ./assert.go:5:2: missing return at end of function   ';
-    let annotation = testMatch(line);
+    const line = '   ./assert.go:5:2: missing return at end of function   ';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(5);
    expect(annotation.column).toBe(2);
@@ -569,8 +637,8 @@ describe('setup-go', () => {
  });

  it('matches on unix path with tabs', async () => {
-    let line = '\t./assert.go:5:2: missing return at end of function   ';
-    let annotation = testMatch(line);
+    const line = '\t./assert.go:5:2: missing return at end of function   ';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(5);
    expect(annotation.column).toBe(2);
@@ -579,8 +647,8 @@ describe('setup-go', () => {
  });

  it('matches on relative windows path', async () => {
-    let line = '.\\main.go:13:2: undefined: fmt.Printl';
-    let annotation = testMatch(line);
+    const line = '.\\main.go:13:2: undefined: fmt.Printl';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(13);
    expect(annotation.column).toBe(2);
@@ -589,8 +657,8 @@ describe('setup-go', () => {
  });

  it('matches on windows path up the tree', async () => {
-    let line = '..\\main.go:13:2: undefined: fmt.Printl';
-    let annotation = testMatch(line);
+    const line = '..\\main.go:13:2: undefined: fmt.Printl';
+    const annotation = testMatch(line);
    expect(annotation).toBeDefined();
    expect(annotation.line).toBe(13);
    expect(annotation.column).toBe(2);
@@ -664,11 +732,9 @@ describe('setup-go', () => {

      findSpy.mockImplementation(() => '');
      dlSpy.mockImplementation(async () => '/some/temp/path');
-      const toolPath = path.normalize('/cache/go/1.17.5/x64');
+      const toolPath = path.normalize('/cache/go/1.17.6/x64');
      extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
      cacheSpy.mockImplementation(async () => toolPath);
-      const expectedUrl =
-        'https://github.com/actions/go-versions/releases/download/1.17.6-1668090892/go-1.17.6-darwin-x64.tar.gz';

      await main.run();

@@ -694,7 +760,7 @@ describe('setup-go', () => {
      os.platform = 'linux';
      os.arch = 'x64';

-      let versionSpec = '1.13';
+      const versionSpec = '1.13';

      inputs['go-version'] = versionSpec;
      inputs['check-latest'] = true;
@@ -705,13 +771,13 @@ describe('setup-go', () => {
      findSpy.mockImplementation(() => '');

      dlSpy.mockImplementation(async () => '/some/temp/path');
-      let toolPath = path.normalize('/cache/go/1.13.7/x64');
+      const toolPath = path.normalize('/cache/go/1.13.7/x64');
      extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
      cacheSpy.mockImplementation(async () => toolPath);

      await main.run();

-      let expPath = path.join(toolPath, 'bin');
+      const expPath = path.join(toolPath, 'bin');

      expect(dlSpy).toHaveBeenCalled();
      expect(extractTarSpy).toHaveBeenCalled();
@@ -731,7 +797,7 @@ describe('setup-go', () => {
      os.platform = 'linux';
      os.arch = 'x64';

-      let versionSpec = '1.13';
+      const versionSpec = '1.13';

      process.env['GITHUB_PATH'] = '';

@@ -745,15 +811,19 @@ describe('setup-go', () => {
      getManifestSpy.mockImplementation(() => {
        throw new Error('Unable to download manifest');
      });
+      httpmGetJsonSpy.mockRejectedValue(
+        new Error('Unable to download manifest from raw URL')
+      );
+      getAllVersionsSpy.mockImplementationOnce(() => undefined);

      dlSpy.mockImplementation(async () => '/some/temp/path');
-      let toolPath = path.normalize('/cache/go/1.13.7/x64');
+      const toolPath = path.normalize('/cache/go/1.13.7/x64');
      extractTarSpy.mockImplementation(async () => '/some/other/temp/path');
      cacheSpy.mockImplementation(async () => toolPath);

      await main.run();

-      let expPath = path.join(toolPath, 'bin');
+      const expPath = path.join(toolPath, 'bin');

      expect(logSpy).toHaveBeenCalledWith(
        `Failed to resolve version ${versionSpec} from manifest`
@@ -792,9 +862,18 @@ replace example.com/thatmodule => ../thatmodule
 exclude example.com/thismodule v1.3.0
 `;

+    const goWorkContents = `go 1.19
+
+use .
+
+`;
+
+    const toolVersionsContents = `golang 1.23
+`;
+
    it('reads version from go.mod', async () => {
      inputs['go-version-file'] = 'go.mod';
-      existsSpy.mockImplementation(path => true);
+      existsSpy.mockImplementation(() => true);
      readFileSpy.mockImplementation(() => Buffer.from(goModContents));

      await main.run();
@@ -804,9 +883,33 @@ exclude example.com/thismodule v1.3.0
      expect(logSpy).toHaveBeenCalledWith('matching 1.14...');
    });

+    it('reads version from go.work', async () => {
+      inputs['go-version-file'] = 'go.work';
+      existsSpy.mockImplementation(() => true);
+      readFileSpy.mockImplementation(() => Buffer.from(goWorkContents));
+
+      await main.run();
+
+      expect(logSpy).toHaveBeenCalledWith('Setup go version spec 1.19');
+      expect(logSpy).toHaveBeenCalledWith('Attempting to download 1.19...');
+      expect(logSpy).toHaveBeenCalledWith('matching 1.19...');
+    });
+
+    it('reads version from .tool-versions', async () => {
+      inputs['go-version-file'] = '.tool-versions';
+      existsSpy.mockImplementation(() => true);
+      readFileSpy.mockImplementation(() => Buffer.from(toolVersionsContents));
+
+      await main.run();
+
+      expect(logSpy).toHaveBeenCalledWith('Setup go version spec 1.23');
+      expect(logSpy).toHaveBeenCalledWith('Attempting to download 1.23...');
+      expect(logSpy).toHaveBeenCalledWith('matching 1.23...');
+    });
+
    it('reads version from .go-version', async () => {
      inputs['go-version-file'] = '.go-version';
-      existsSpy.mockImplementation(path => true);
+      existsSpy.mockImplementation(() => true);
      readFileSpy.mockImplementation(() => Buffer.from(`1.13.0${osm.EOL}`));

      await main.run();
@@ -819,7 +922,7 @@ exclude example.com/thismodule v1.3.0
    it('is overwritten by go-version', async () => {
      inputs['go-version'] = '1.13.1';
      inputs['go-version-file'] = 'go.mod';
-      existsSpy.mockImplementation(path => true);
+      existsSpy.mockImplementation(() => true);
      readFileSpy.mockImplementation(() => Buffer.from(goModContents));

      await main.run();
@@ -831,7 +934,7 @@ exclude example.com/thismodule v1.3.0

    it('reports a read failure', async () => {
      inputs['go-version-file'] = 'go.mod';
-      existsSpy.mockImplementation(path => false);
+      existsSpy.mockImplementation(() => false);

      await main.run();

@@ -839,5 +942,167 @@ exclude example.com/thismodule v1.3.0
        `::error::The specified go version file at: go.mod does not exist${osm.EOL}`
      );
    });
+
+    it('acquires specified architecture of go', async () => {
+      for (const {arch, version, osSpec} of [
+        {arch: 'amd64', version: '1.13.7', osSpec: 'linux'},
+        {arch: 'armv6l', version: '1.12.2', osSpec: 'linux'}
+      ]) {
+        os.platform = osSpec;
+        os.arch = arch;
+
+        const fileExtension = os.platform === 'win32' ? 'zip' : 'tar.gz';
+
+        const platform = os.platform === 'win32' ? 'win' : os.platform;
+
+        inputs['go-version'] = version;
+        inputs['architecture'] = arch;
+
+        const expectedUrl =
+          platform === 'win32'
+            ? `https://github.com/actions/go-versions/releases/download/${version}/go-${version}-${platform}-${arch}.${fileExtension}`
+            : `https://go.dev/dl/go${version}.${osSpec}-${arch}.${fileExtension}`;
+
+        // ... but not in the local cache
+        findSpy.mockImplementation(() => '');
+
+        dlSpy.mockImplementation(async () => '/some/temp/path');
+        const toolPath = path.normalize(`/cache/go/${version}/${arch}`);
+        cacheSpy.mockImplementation(async () => toolPath);
+
+        await main.run();
+
+        expect(logSpy).toHaveBeenCalledWith(
+          `Acquiring go${version} from ${expectedUrl}`
+        );
+      }
+    }, 100000);
+
+    it.each(['stable', 'oldstable'])(
+      'acquires latest go version with %s go-version input',
+      async (alias: string) => {
+        const arch = 'x64';
+        os.platform = 'darwin';
+        os.arch = arch;
+
+        inputs['go-version'] = alias;
+        inputs['architecture'] = os.arch;
+
+        // ... but not in the local cache
+        findSpy.mockImplementation(() => '');
+
+        dlSpy.mockImplementation(async () => '/some/temp/path');
+        const toolPath = path.normalize(`/cache/go/${alias}/${arch}`);
+        cacheSpy.mockImplementation(async () => toolPath);
+
+        await main.run();
+
+        const releaseIndex = alias === 'stable' ? 0 : 1;
+
+        expect(logSpy).toHaveBeenCalledWith(
+          `${alias} version resolved as ${goTestManifest[releaseIndex].version}`
+        );
+      }
+    );
+  });
+
+  describe('go-version-file-toolchain', () => {
+    const goVersions = ['1.22.0', '1.21rc2', '1.18'];
+    const placeholderVersion = '1.19';
+    const buildGoMod = (
+      goVersion: string,
+      toolchainVersion: string
+    ) => `module example.com/mymodule
+
+go ${goVersion}
+
+toolchain go${toolchainVersion}
+
+require (
+	example.com/othermodule v1.2.3
+	example.com/thismodule v1.2.3
+	example.com/thatmodule v1.2.3
+)
+
+replace example.com/thatmodule => ../thatmodule
+exclude example.com/thismodule v1.3.0
+`;
+
+    const buildGoWork = (
+      goVersion: string,
+      toolchainVersion: string
+    ) => `go 1.19
+
+toolchain go${toolchainVersion}
+
+use .
+
+`;
+
+    goVersions.forEach(version => {
+      [
+        {
+          goVersionfile: 'go.mod',
+          fileContents: Buffer.from(buildGoMod(placeholderVersion, version)),
+          expected_version: version,
+          desc: 'from toolchain directive'
+        },
+        {
+          goVersionfile: 'go.work',
+          fileContents: Buffer.from(buildGoMod(placeholderVersion, version)),
+          expected_version: version,
+          desc: 'from toolchain directive'
+        },
+        {
+          goVersionfile: 'go.mod',
+          fileContents: Buffer.from(buildGoMod(placeholderVersion, version)),
+          gotoolchain_env: 'local',
+          expected_version: placeholderVersion,
+          desc: 'from go directive when GOTOOLCHAIN is local'
+        },
+        {
+          goVersionfile: 'go.work',
+          fileContents: Buffer.from(buildGoMod(placeholderVersion, version)),
+          gotoolchain_env: 'local',
+          expected_version: placeholderVersion,
+          desc: 'from go directive when GOTOOLCHAIN is local'
+        }
+      ].forEach(test => {
+        it(`reads version (${version}) in ${test.goVersionfile} ${test.desc}`, async () => {
+          inputs['go-version-file'] = test.goVersionfile;
+          if (test.gotoolchain_env !== undefined) {
+            process.env[im.GOTOOLCHAIN_ENV_VAR] = test.gotoolchain_env;
+          }
+          existsSpy.mockImplementation(() => true);
+          readFileSpy.mockImplementation(() => Buffer.from(test.fileContents));
+
+          await main.run();
+
+          expect(logSpy).toHaveBeenCalledWith(
+            `Setup go version spec ${test.expected_version}`
+          );
+          expect(logSpy).toHaveBeenCalledWith(
+            `Attempting to download ${test.expected_version}...`
+          );
+          expect(logSpy).toHaveBeenCalledWith(
+            `matching ${test.expected_version}...`
+          );
+        });
+      });
+    });
+  });
+
+  it('exports GOTOOLCHAIN and sets it in current process env', async () => {
+    inputs['go-version'] = '1.21.0';
+    inSpy.mockImplementation(name => inputs[name]);
+
+    const vars: {[key: string]: string} = {};
+    exportVarSpy.mockImplementation((name: string, val: string) => {
+      vars[name] = val;
+    });
+
+    await main.run();
+    expect(vars).toStrictEqual({GOTOOLCHAIN: 'local'});
+    expect(process.env).toHaveProperty('GOTOOLCHAIN', 'local');
  });
 });
@@ -0,0 +1,52 @@
+import {isSelfHosted} from '../src/utils';
+
+describe('utils', () => {
+  describe('isSelfHosted', () => {
+    let AGENT_ISSELFHOSTED: string | undefined;
+    let RUNNER_ENVIRONMENT: string | undefined;
+
+    beforeEach(() => {
+      AGENT_ISSELFHOSTED = process.env['AGENT_ISSELFHOSTED'];
+      delete process.env['AGENT_ISSELFHOSTED'];
+      RUNNER_ENVIRONMENT = process.env['RUNNER_ENVIRONMENT'];
+      delete process.env['RUNNER_ENVIRONMENT'];
+    });
+
+    afterEach(() => {
+      if (AGENT_ISSELFHOSTED === undefined) {
+        delete process.env['AGENT_ISSELFHOSTED'];
+      } else {
+        process.env['AGENT_ISSELFHOSTED'] = AGENT_ISSELFHOSTED;
+      }
+      if (RUNNER_ENVIRONMENT === undefined) {
+        delete process.env['RUNNER_ENVIRONMENT'];
+      } else {
+        process.env['RUNNER_ENVIRONMENT'] = RUNNER_ENVIRONMENT;
+      }
+    });
+
+    it('isSelfHosted should be true if no environment variables set', () => {
+      expect(isSelfHosted()).toBeTruthy();
+    });
+
+    it('isSelfHosted should be true if environment variable is not set to denote GitHub hosted', () => {
+      process.env['RUNNER_ENVIRONMENT'] = 'some';
+      expect(isSelfHosted()).toBeTruthy();
+    });
+
+    it('isSelfHosted should be true if environment variable set to denote Azure Pipelines self hosted', () => {
+      process.env['AGENT_ISSELFHOSTED'] = '1';
+      expect(isSelfHosted()).toBeTruthy();
+    });
+
+    it('isSelfHosted should be false if environment variable set to denote GitHub hosted', () => {
+      process.env['RUNNER_ENVIRONMENT'] = 'github-hosted';
+      expect(isSelfHosted()).toBeFalsy();
+    });
+
+    it('isSelfHosted should be false if environment variable is not set to denote Azure Pipelines self hosted', () => {
+      process.env['AGENT_ISSELFHOSTED'] = 'some';
+      expect(isSelfHosted()).toBeFalsy();
+    });
+  });
+});
@@ -0,0 +1,62 @@
+import fs from 'fs';
+import * as io from '@actions/io';
+import * as tc from '@actions/tool-cache';
+import path from 'path';
+
+describe('Windows performance workaround', () => {
+  let mkdirSpy: jest.SpyInstance;
+  let symlinkSpy: jest.SpyInstance;
+  let statSpy: jest.SpyInstance;
+  let readdirSpy: jest.SpyInstance;
+  let writeFileSpy: jest.SpyInstance;
+  let rmRFSpy: jest.SpyInstance;
+  let mkdirPSpy: jest.SpyInstance;
+  let cpSpy: jest.SpyInstance;
+
+  let runnerToolCache: string | undefined;
+  beforeEach(() => {
+    mkdirSpy = jest.spyOn(fs, 'mkdir');
+    symlinkSpy = jest.spyOn(fs, 'symlinkSync');
+    statSpy = jest.spyOn(fs, 'statSync');
+    readdirSpy = jest.spyOn(fs, 'readdirSync');
+    writeFileSpy = jest.spyOn(fs, 'writeFileSync');
+    rmRFSpy = jest.spyOn(io, 'rmRF');
+    mkdirPSpy = jest.spyOn(io, 'mkdirP');
+    cpSpy = jest.spyOn(io, 'cp');
+
+    // default implementations
+    // @ts-ignore - not implement unused methods
+    statSpy.mockImplementation(() => ({
+      isDirectory: () => true
+    }));
+    readdirSpy.mockImplementation(() => []);
+    writeFileSpy.mockImplementation(() => {});
+    mkdirSpy.mockImplementation(() => {});
+    symlinkSpy.mockImplementation(() => {});
+    rmRFSpy.mockImplementation(() => Promise.resolve());
+    mkdirPSpy.mockImplementation(() => Promise.resolve());
+    cpSpy.mockImplementation(() => Promise.resolve());
+
+    runnerToolCache = process.env['RUNNER_TOOL_CACHE'];
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+    process.env['RUNNER_TOOL_CACHE'] = runnerToolCache;
+  });
+  // cacheWindowsToolkitDir depends on implementation of tc.cacheDir
+  // with the assumption that target dir is passed by RUNNER_TOOL_CACHE environment variable
+  // Make sure the implementation has not been changed
+  it('addExecutablesToCache should depend on env[RUNNER_TOOL_CACHE]', async () => {
+    process.env['RUNNER_TOOL_CACHE'] = '/faked-hostedtoolcache1';
+    const cacheDir1 = await tc.cacheDir('/qzx', 'go', '1.2.3', 'arch');
+    expect(cacheDir1).toBe(
+      path.join('/', 'faked-hostedtoolcache1', 'go', '1.2.3', 'arch')
+    );
+
+    process.env['RUNNER_TOOL_CACHE'] = '/faked-hostedtoolcache2';
+    const cacheDir2 = await tc.cacheDir('/qzx', 'go', '1.2.3', 'arch');
+    expect(cacheDir2).toBe(
+      path.join('/', 'faked-hostedtoolcache2', 'go', '1.2.3', 'arch')
+    );
+  });
+});
@@ -3,27 +3,29 @@ description: 'Setup a Go environment and add it to the PATH'
 author: 'GitHub'
 inputs:
  go-version:
-    description: 'The Go version to download (if necessary) and use. Supports semver spec and ranges.'
+    description: 'The Go version to download (if necessary) and use. Supports semver spec and ranges. Be sure to enclose this option in single quotation marks.'
  go-version-file:
-    description: 'Path to the go.mod file.'
+    description: 'Path to the go.mod, go.work, .go-version, or .tool-versions file.'
  check-latest:
    description: 'Set this option to true if you want the action to always check for the latest available version that satisfies the version spec'
    default: false
  token:
-    description: Used to pull node distributions from go-versions.  Since there's a default, this is typically not supplied by the user.
-    default: ${{ github.token }}
+    description: Used to pull Go distributions from go-versions. Since there's a default, this is typically not supplied by the user. When running this action on github.com, the default value is sufficient. When running on GHES, you can pass a personal access token for github.com if you are experiencing rate limiting.
+    default: ${{ github.server_url == 'https://github.com' && github.token || '' }}
  cache:
    description: Used to specify whether caching is needed. Set to true, if you'd like to enable caching.
-    default: false
+    default: true
  cache-dependency-path:
    description: 'Used to specify the path to a dependency file - go.sum'
+  architecture:
+    description: 'Target architecture for Go to use. Examples: x86, x64. Will use system architecture by default.'
 outputs:
  go-version:
-    description: 'The installed Go version. Useful when given a version range as input.'  
-  cache-hit: 
+    description: 'The installed Go version. Useful when given a version range as input.'
+  cache-hit:
    description: 'A boolean value to indicate if a cache was hit'
 runs:
-  using: 'node16'
+  using: 'node24'
  main: 'dist/setup/index.js'
  post: 'dist/cache-save/index.js'
  post-if: success()
@@ -4,7 +4,7 @@ Date: 2022-04-13
 Status: Accepted

 # Context
-`actions/setup-go` is the one of the most popular action related to Golang in GitHub Actions. Many customers use it in conjunction with [actions/cache](https://github.com/actions/cache) to speed up dependency installation process.  
+`actions/setup-go` is the one of the most popular action related to Golang in GitHub Actions. Many customers use it in conjunction with [actions/cache](https://github.com/actions/cache) to speed up dependency installation process.
 See more examples on proper usage in [actions/cache documentation](https://github.com/actions/cache/blob/main/examples.md#go---modules).

 # Goals & Anti-Goals
@@ -16,7 +16,7 @@ Integration of caching functionality into `actions/setup-go` action will bring t
 We don't pursue the goal to provide wide customization of caching in scope of `actions/setup-go` action. The purpose of this integration is covering ~90% of basic use-cases. If user needs flexible customization, we should advice them to use `actions/cache` directly.

 # Decision
- Add `cache` input parameter to `actions/setup-go`. For now, input will accept the following values: 
+- Add `cache` input parameter to `actions/setup-go`. For now, input will accept the following values:
  - `true` - enable caching for go dependencies
  - `false`- disable caching for go dependencies. This value will be set as default value
 - Cache feature will be disabled by default to make sure that we don't break existing customers. We will consider enabling cache by default in next major releases
@@ -32,7 +32,7 @@ We don't pursue the goal to provide wide customization of caching in scope of `a

 ```yml
 steps:
- uses: actions/checkout@v3
+- uses: actions/checkout@v4
 - uses: actions/setup-go@v3
  with:
    go-version: '18'
@@ -43,7 +43,7 @@ steps:

 ```yml
 steps:
- uses: actions/checkout@v3
+- uses: actions/checkout@v4
 - uses: actions/setup-go@v3
  with:
    go-version: '18'
@@ -53,7 +53,7 @@ steps:

 ```yml
 steps:
- uses: actions/checkout@v3
+- uses: actions/checkout@v4
 - uses: actions/setup-go@v3
  with:
    go-version: '18'
@@ -66,4 +66,4 @@ steps:
 # Release process

 As soon as functionality is implemented, we will release minor update of action. No need to bump major version since there are no breaking changes for existing users.
-After that, we will update [starter-workflows](https://github.com/actions/starter-workflows/blob/main/ci/go.yml)
+After that, we will update [starter-workflows](https://github.com/actions/starter-workflows/blob/main/ci/go.yml)