add dist

.github/dependabot.yml

@@ -5,30 +5,15 @@ updates:
   schedule:
     interval: monthly
   open-pull-requests-limit: 99
-  groups:
-    # Group all Git submodules PRs into a single PR:
-    all-gitsubmodule-actions:
-      patterns:
-        - "*"
 
 - package-ecosystem: 'github-actions'
   directory: '/'
   schedule:
     interval: 'monthly'
   open-pull-requests-limit: 99
-  groups:
-    # Group all GitHub Actions PRs into a single PR:
-    all-github-actions:
-      patterns:
-        - "*"
     
 - package-ecosystem: npm
   directory: "/"
   schedule:
     interval: monthly
   open-pull-requests-limit: 99
-  groups:
-    # Group all NPM PRs into a single PR:
-    all-npm-actions:
-      patterns:
-        - "*"

.github/workflows/checkin.yml

@@ -0,0 +1,36 @@
+name: "PR Checks"
+on: [pull_request, push]
+
+concurrency:
+  # Skip intermediate builds: all builds except for builds on the `master`, `main`, or `release-*` branches
+  # Cancel intermediate builds: only pull request builds
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.ref != 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release-') || github.run_number }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+jobs:
+  check_pr:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version-file: '.tool-versions'
+
+    - name: "npm ci"
+      run: npm ci
+
+    - name: "npm run build"
+      run: npm run build
+
+    - name: "npm run test"
+      run: npm run test
+
+    - name: "check for uncommitted changes"
+      # Ensure no changes, but ignore node_modules dir since dev/fresh ci deps installed.
+      run: |
+        git diff --exit-code --stat -- . ':!node_modules' \
+        || (echo "##[error] found changed files after build. please 'npm ci && npm run build'" \
+                 "and check in all changes" \
+            && exit 1)

.github/workflows/example-builds-nightly-defaultarch.yml

@@ -22,9 +22,11 @@ jobs:
         os:
           - ubuntu-latest
           - windows-latest
+          # - macos-11 # Intel
+          - macos-12 # Intel
           - macos-13 # Intel
           - macos-14 # Apple Silicon
-          - macos-latest # Apple Silicon
+          - macos-latest # Currently Intel, but will probably point to Apple Silicon in the future
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/example-builds.yml

@@ -27,13 +27,6 @@ jobs:
         exclude:
           - os: macOS-latest
             julia-arch: x86
-        include:
-          - os: macOS-latest
-            julia-arch: aarch64
-            julia-version: 'lts'
-          - os: macOS-latest
-            julia-arch: aarch64
-            julia-version: '1'
 
     steps:
       - uses: actions/checkout@v4

.github/workflows/pr_checks.yml

@@ -1,222 +0,0 @@
-name: PR Checks
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-    tags: '*'
-concurrency:
-  # Skip intermediate builds: all builds except for builds on the `master` branch
-  # Cancel intermediate builds: only pull request builds
-  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.ref != 'refs/heads/master' || github.run_number }}
-  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
-permissions:
-  contents: read
-jobs:
-  finalize-pr-checks:
-    if: always() # this line is important to keep the `finalize` job from being marked as skipped; do not change or delete this line
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    needs:
-      - checked-in-files
-      - build
-      - npm-run-test
-      - make-targets
-      - stalecheck-npm-install
-    steps:
-      - run: |
-          echo checked-in-files: ${{ needs.checked-in-files.result }}
-          echo build: ${{ needs.build.result }}
-          echo npm-run-test: ${{ needs.npm-run-test.result }}
-          echo make-targets: ${{ needs.make-targets.result }}
-          echo stalecheck-npm-install: ${{ needs.stalecheck-npm-install.result }}
-      - run: exit 1
-        if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
-  checked-in-files:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@1902764435ca0dd2f3388eea723a4f92a4eb8302
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make pack
-      ### Clean (not cleanall!):
-      - run: make clean
-      ### Make sure there are no uncommited changes
-      - uses: julia-actions/setup-julia@5c9647d97b78a5debe5164e9eec09d653d29bd71 # v2.6.1
-        with:
-          version: '1'
-      - run: git --no-pager status
-      - run: git --no-pager diff
-      - run: julia ./ci/check_uncommitted_changes.jl
-  build:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@1902764435ca0dd2f3388eea723a4f92a4eb8302
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make build
-      - run: make pack
-      ### Make sure some other `make` targets don't bitrot:
-      - name: Run some other `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-      - name: Run all of the "cleaning" `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-  npm-run-test:
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@1902764435ca0dd2f3388eea723a4f92a4eb8302
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      # Windows:
-        # Windows does not support asdf, so we have to use `actions/setup-node`
-        # to install asdf:
-      - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b
-        if: runner.os == 'Windows'
-        with:
-          node-version-file: '.tool-versions'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Print some debugging info:
-      - name: Print the NodeJS version (for debugging)
-        run: |
-          which -a node
-          node --version
-          which -a npm
-          npm --version
-      ### Build:
-      - run: make build
-      - run: make test
-  make-targets: # This is a job to make sure that none of the `make` targets bitrot
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Cleanall:
-      - run: make cleanall
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@1902764435ca0dd2f3388eea723a4f92a4eb8302
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      ### Install the NodeJS packages that we depend on:
-      - run: make install-packages
-      ### Make sure some other `make` targets don't bitrot:
-      - name: Run some other `make` targets to ensure that they don't bitrot
-        run: |
-          make unix-asdf-install
-          make install-packages
-          make build
-          make pack
-          make everything-from-scratch
-      - name: Run all of the "cleaning" `make` targets to ensure that they don't bitrot
-        run: |
-          make clean
-          make cleanall
-  stalecheck-npm-install:
-    # In this job, we are basically trying to check if `package-lock.json` is in
-    # sync with `package-lock.json`.
-    #
-    # So, for example, if someone manually edits the `package.json` file, we want
-    # to make sure that the `package-lock.json` file is not out of sync with the
-    # `package.json` file.
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      ### Check out the repo:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
-        with:
-          persist-credentials: false
-      ### Install NodeJS
-      # Unix (non-Windows):
-      - uses: asdf-vm/actions/setup@1902764435ca0dd2f3388eea723a4f92a4eb8302
-        if: runner.os != 'Windows'
-      - run: make unix-asdf-install
-        if: runner.os != 'Windows'
-      ### Run the master commands for this job:
-      - run: make clean
-      - run: npm ci
-      # - run: npm install --package-lock-only
-      - run: npm install
-      ### Make sure there are no uncommited changes
-      - uses: julia-actions/setup-julia@5c9647d97b78a5debe5164e9eec09d653d29bd71 # v2.6.1
-        with:
-          version: '1'
-      - run: git --no-pager status
-      - run: git --no-pager diff
-      - run: julia ./ci/check_uncommitted_changes.jl

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "bin"]
+	path = bin
+	url = git@github.com:julia-actions/bin.git

Makefile

@@ -1,49 +0,0 @@
-.NOTPARALLEL:
-
-# This is the default target:
-.PHONY: pack
-pack: build
-	npm run pack
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.PHONY: everything-from-scratch
-everything-from-scratch: cleanall install-packages build pack clean
-
-# build does `npm run build`, but does not run `npm run pack`
-.PHONY: build
-build:
-	npm run build
-
-.PHONY: test
-test:
-	npm run test
-
-.PHONY: install-packages
-install-packages:
-	rm -rf node_modules/
-	# Note: we use `npm ci` instead of `npm install`, because we want to make sure
-	# that we respect the versions in the `package-lock.json` lockfile.
-	npm ci
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.PHONY: clean
-clean:
-	rm -rf node_modules/
-
-.PHONY: cleanall
-cleanall: clean
-	rm -rf lib/
-	rm -rf dist/
-
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-# asdf does not support Windows.
-# On Windows, users need to install the correct version of NodeJS themselves.
-.PHONY: unix-asdf-install
-unix-asdf-install:
-	asdf plugin add nodejs # update this list when we add more tools to `.tool-versions`
-	asdf install
-
-# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

README.md

@@ -41,7 +41,7 @@ This action sets up a Julia environment for use in actions by downloading a spec
     #          For example, `1.10` may be parsed as `1.1`.
     #
     # Default: '1'
-    version: '1'
+    version: ''
 
     # The architecture of the Julia binaries.
     #
@@ -53,20 +53,8 @@ This action sets up a Julia environment for use in actions by downloading a spec
     #
     # Note: you can use X64, X86, and ARM64 as synonyms for x64, x86, and aarch64, respectively.
     #
-    # Specifying 'default' uses the architecture of the runner executing the job.
-    arch: 'default'
-
-    # Force the use of the specified architecture even when it may be suboptimal on the runner.
-    #
-    # By default, requesting x86 or x64 on an aarch64 macOS runner (Apple Silicon) will fail with an error,
-    # as this is usually a misconfiguration. Set this to 'true' to override the error and allow the installation.
-    #
-    # Note: x64 Julia can run on Apple Silicon via Rosetta 2, but native aarch64 is typically preferred.
-    #
-    # Supported values: true | false
-    #
-    # Default: false
-    force-arch: 'false'
+    # Defaults to the architecture of the runner executing the job.
+    arch: ''
 
     # Set the display setting for printing InteractiveUtils.versioninfo() after installing.
     #
@@ -82,12 +70,12 @@ This action sets up a Julia environment for use in actions by downloading a spec
     # never: Never print versioninfo
     #
     # Default: false
-    show-versioninfo: 'false'
+    show-versioninfo: ''
 
     # Set the path to the project directory or file to use when resolving some versions (e.g. `min`).
     #
     # Defaults to using JULIA_PROJECT if defined, otherwise '.'
-    project: ${{ env.JULIA_PROJECT }} or '.' (if JULIA_PROJECT is unset)
+    project: ''
 ```
 
 ### Outputs
@@ -134,7 +122,6 @@ You can either specify specific Julia versions or version ranges. If you specify
 - `'~1.3.0-rc1'` is a **tilde** version range that includes pre-releases of `1.3.0` starting at `rc1`. It matches all versions `≥ 1.3.0-rc1` and `< 1.4.0`.
 - `'^1.3.0-0'` is a **caret** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 2.0.0`.
 - `'~1.3.0-0'` is a **tilde** version range that includes _all_ pre-releases of `1.3.0`. It matches all versions `≥ 1.3.0-` and `< 1.4.0`.
-- `'1'` will install the latest v1 version of Julia.
 - `'lts'` will install the latest LTS build.
 - `'pre'` will install the latest prerelease build (RCs, betas, and alphas).
 - `'nightly'` will install the latest nightly build.
@@ -206,18 +193,12 @@ jobs:
     strategy:
       matrix:
         julia-version: ['1.0', '1.2.0', '^1.3.0-rc1']
-        julia-arch: [x64, x86, aarch64]
+        julia-arch: [x64, x86]
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        # exclude unavailable/unwanted architectures
+        # 32-bit Julia binaries are not available on macOS
         exclude:
           - os: macOS-latest
             julia-arch: x86
-          - os: macOS-latest
-            julia-arch: x64 # can be run but via rosetta on apple silicon runners
-          - os: ubuntu-latest
-            julia-arch: aarch64
-          - os: windows-latest
-            julia-arch: aarch64
 
     steps:
       - uses: actions/checkout@v4

__tests__/installer.test.ts

@@ -26,8 +26,8 @@ const testVersions = [
     '1.7.0', '1.7.0-beta1', '1.7.0-beta2', '1.7.0-beta3', '1.7.0-beta4', '1.7.0-rc1', '1.7.0-rc2', '1.7.0-rc3', '1.7.1', '1.7.2', '1.7.3',
     '1.8.0', '1.8.0-beta1', '1.8.0-beta2', '1.8.0-beta3', '1.8.0-rc1', '1.8.0-rc2', '1.8.0-rc3', '1.8.0-rc4', '1.8.1', '1.8.2', '1.8.3', '1.8.4', '1.8.5',
     '1.9.0', '1.9.0-alpha1', '1.9.0-beta1', '1.9.0-beta2', '1.9.0-beta3', '1.9.0-beta4', '1.9.0-rc1', '1.9.0-rc2', '1.9.0-rc3', '1.9.1', '1.9.2', '1.9.3', '1.9.4',
-    '1.10.0', '1.10.0-alpha1', '1.10.0-beta1', '1.10.0-beta2', '1.10.0-beta3', '1.10.0-rc1', '1.10.0-rc2', '1.10.0-rc3', '1.10.1', '1.10.2', '1.10.3', '1.10.4', '1.10.5',
-    '1.11.0', '1.11.0-alpha1', '1.11.0-alpha2', '1.11.0-beta1', '1.11.0-beta2', '1.11.0-rc1', '1.11.0-rc2', '1.11.0-rc3', '1.11.0-rc4',
+    '1.10.0', '1.10.0-alpha1', '1.10.0-beta1', '1.10.0-beta2', '1.10.0-beta3', '1.10.0-rc1', '1.10.0-rc2', '1.10.0-rc3', '1.10.1', '1.10.2',
+    '1.11.0-alpha1', '1.11.0-alpha2', '1.11.0-beta1'
 ]
 
 const toolDir = path.join(__dirname, 'runner', 'tools')
@@ -187,30 +187,30 @@ describe('version matching tests', () => {
 
         it('LTS', () => {
             // Update test when LTS is updated
-            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual(installer.getJuliaVersion(testVersions, '1.10'))
-            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual('1.10.5')
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual(installer.getJuliaVersion(testVersions, '1.6'))
+            expect(installer.getJuliaVersion(testVersions, 'lts')).toEqual('1.6.7')
         })
 
         it('pre', () => {
-            expect(installer.getJuliaVersion(testVersions, 'pre')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, 'pre')).toEqual('1.11.0-beta1')
         })
     })
 
     describe('version ranges', () => {
         it('Chooses the highest available version that matches the input', () => {
-            expect(installer.getJuliaVersion(testVersions, '1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '1')).toEqual('1.10.2')
             expect(installer.getJuliaVersion(testVersions, '1.0')).toEqual('1.0.5')
-            expect(installer.getJuliaVersion(testVersions, '^1.3.0-rc1')).toEqual('1.11.0')
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-rc1')).toEqual('1.11.0')
-            expect(installer.getJuliaVersion(testVersions, '^1.10.0-rc1')).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.3.0-rc1')).toEqual('1.10.2')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-rc1')).toEqual('1.10.2')
+            expect(installer.getJuliaVersion(testVersions, '^1.10.0-rc1')).toEqual('1.10.2')
         })
     })
 
     describe('include-prereleases', () => {
         it('Chooses the highest available version that matches the input including prereleases', () => {
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', true)).toEqual('1.11.0')
-            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.11.0')
-            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.11.0')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', true)).toEqual('1.11.0-beta1')
+            expect(installer.getJuliaVersion(testVersions, '1', true)).toEqual('1.11.0-beta1')
+            expect(installer.getJuliaVersion(testVersions, '^1.2.0-0', false)).toEqual('1.10.2')
         })
     })
 

action.yml

@@ -13,10 +13,6 @@ inputs:
     description: 'Architecture of the Julia binaries. Defaults to the architecture of the runner executing the job.'
     required: false
     default: 'default'
-  force-arch:
-    description: 'Force the use of the specified architecture even when it may be suboptimal on the runner (e.g., x86 on Apple Silicon macOS runners). By default, requesting x86/x64 on aarch64 macOS runners will fail with an error.'
-    required: false
-    default: 'false'
   show-versioninfo:
     description: 'Display InteractiveUtils.versioninfo() after installing'
     required: false

ci/check_uncommitted_changes.jl

@@ -1,16 +0,0 @@
-const cmd = `git --no-pager diff --exit-code --stat`
-
-const proc = run(pipeline(cmd; stdin, stdout, stderr); wait = false)
-
-wait(proc)
-
-@info "" success(proc) proc.exitcode
-
-if !success(proc)
-    recommended_cmd = "make everything-from-scratch"
-    msg = "##[error] found changed files after build. " *
-           "Please run `$(recommended_cmd)` and " *
-           "then check in all changes."
-    println(stderr, msg)
-    exit(1)
-end

devdocs/local_setup.md

@@ -42,8 +42,6 @@ First, `cd` to your clone of the repo. Now you can run the following commands:
 npm ci
 
 npm run build
-
-npm run pack
 ```
 
 When you are ready, you can commit your changes and push them to your PR.

devdocs/making_a_new_release.md

@@ -1,56 +1,128 @@
 # Making a new release of this action (requires commit access)
 
-In this guide, as an example, `v2.2.0` refers to the version number of the new release that you want to make.
+If you have commit access to this repo, you can make a new release.
 
-## Part 1: Use the Git CLI to create and push the Git tags
+Here are the instructions.
 
-Step 1: Create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
+## Step 1: Clone a fresh copy of the repo
+
+We intentionally work in a brand-new copy of the repo.
 
 ```bash
 git clone git@github.com:julia-actions/setup-julia.git
 cd setup-julia
-git fetch --all --tags
-
-git checkout main
-
-git --no-pager log -1
-# Take note of the commit hash here.
-
-# Now, create a new lightweight tag of the form `vMAJOR.MINOR.PATCH`.
-#
-# Replace `commit_hash` with the commit hash that you obtained from the
-# `git log -1` step.
-#
-# Replace `v2.2.0` with the actual version number that you want to use.
-git tag v2.2.0 commit_hash
+git checkout master
+git submodule init
+git submodule update
 ```
 
-Step 2: Once you've created the new release, you need to update the `v2` tag to point to the new release. For example, suppose that the previous release was `v2.1.0`, and suppose that you just created the new release `v2.2.0`. You need to update the `v2` tag so that it points to `v2.2.0`. Here are the commands:
+## Step 2: Make sure you have the right version of NodeJS
+
+If you use [`asdf`](https://asdf-vm.com/), this is as simple as:
 
 ```bash
-# Create/update the new v2 tag locally, where the new v2 tag will point to the
-# release that you created in the previous step.
-#
-# Make sure to change `v2.2.0` to the actual value for the tag that you just
-# created in the previous step.
-#
-# The `-f` flag forcibly overwrites the old
-# `v2` tag (if it exists).
-git tag -f v2 v2.2.0
+asdf plugin add nodejs
+asdf install
 ```
 
-Step 3: Now you need to push the tags:
+If you don't use `asdf`, then you need to:
+1. Open the `./tool-versions` file in the root of the repo.
+2. Make note of the NodeJS version listed in the `.tool-versions` file.
+3. Install that same version of NodeJS on your machine.
+4. Make sure that you are currently using that version of NodeJS (i.e. it is at the front of your PATH).
+
+## Step 3: Edit the `version` field in `package.json`
 
 ```bash
-# Regular-push the new `v2.2.0` tag:
-git push origin tag v2.2.0
+vim package.json
 
-# Force-push the new v2 tag:
-git push origin tag v2 --force
+# Edit the `version` number (should be line 2)
+# Save your changes in Vim. Then exit Vim.
+
+# For the remaining of this guide, let MAJOR.MINOR.PATCH refer
+# to the new version number that you set.
+
+git add package.json
+
+# No need to commit yet.
+# The release script will run `git commit`.
 ```
 
-## Part 2: Create the GitHub Release
+## Step 4: Remove the `dist/` line from the `.gitignore` file
 
-Go to the [Releases](https://github.com/julia-actions/setup-julia/releases) section of this repo and create a new release (using the GitHub web interface).
+```bash
+vim .gitignore
+# Delete the line that says `dist/` (it should be line 3)
+# Save your changes in Vim. Then exit Vim.
 
-For the "choose a tag" drop-down field, select the `v2.2.0` tag that you created and pushed in Part 1 of this guide.
+git add .gitignore
+
+# No need to commit yet.
+# The release script will run `git commit`.
+```
+
+## Step 5: Make sure you have the necessary dependencies
+
+The `build-release.sh` script requires the following dependencies:
+
+1. Bash
+2. `curl`
+3. `git`
+4. `jq`
+5. `sed`
+
+## Step 6: Run the `build-release.sh` script
+
+```bash
+ls -l bin/build-release.sh
+chmod +x bin/build-release.sh
+ls -l bin/build-release.sh
+
+./bin/build-release.sh julia-actions/setup-julia
+```
+
+Wait a minute or two. The script will build everything and will create a new release branch named `releases/vMAJOR.MINOR.PATCH`.
+
+## Step 7: Push ONLY the `releases/vMAJOR.MINOR.PATCH` branch
+
+Only push the `releases/` branch. Do NOT push any tags yet.
+
+```bash
+git push origin releases/vMAJOR.MINOR.PATCH
+```
+
+Now you need to go to https://github.com/julia-actions/setup-julia/tree/releases/vMAJOR.MINOR.PATCH and wait for CI to finish running.
+
+Do NOT proceed to the next step until CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch.
+
+## Step 8: Push the tags (only after CI is all green)
+
+Once CI is all green on the `releases/vMAJOR.MINOR.PATCH` branch, you can push the tags.
+
+You need to force-push.
+
+```bash
+git push --tags --force
+```
+
+## Step 9: Use the GitHub web UI to create a new GitHub Release
+
+Go to https://github.com/julia-actions/setup-julia/releases  and create a new release for the now-existant `vMAJOR.MINOR.PATCH` tag using the GitHub web interface.
+
+## Step 10: Clean up your local repo
+
+```bash
+git submodule deinit --force .
+git submodule update --init
+git fetch --all --prune
+git checkout master
+git reset --hard origin/master
+```
+
+## Step 11: Delete your local repo
+
+```bash
+cd ..
+ls setup-julia
+rm -rf setup-julia
+```

lib/installer.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -62,7 +52,7 @@ const path = __importStar(require("path"));
 const retry = require("async-retry");
 const semver = __importStar(require("semver"));
 const toml = __importStar(require("toml"));
-const LTS_VERSION = '1.10';
+const LTS_VERSION = '1.6';
 const MAJOR_VERSION = '1'; // Could be deduced from versions.json
 // Translations between actions input and Julia arch names
 const osMap = {

lib/setup-julia.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -56,7 +46,6 @@ const installer = __importStar(require("./installer"));
 const archSynonyms = {
     'x86': 'x86',
     'x64': 'x64',
-    'x86_64': 'x64',
     'aarch64': 'aarch64',
     'arm64': 'aarch64'
 };
@@ -98,9 +87,6 @@ function run() {
             if (!originalArchInput) { // if `originalArchInput` is an empty string
                 throw new Error(`Arch input must not be null`);
             }
-            if (originalArchInput == 'x64' && os.platform() == 'darwin' && os.arch() == 'arm64') {
-                core.warning('[setup-julia] x64 arch has been requested on a macOS runner that has an arm64 (Apple Silicon) architecture. You may have meant to use the "aarch64" arch instead (or left it unspecified for the correct default).');
-            }
             let processedArchInput;
             if (originalArchInput == "default") {
                 // If the user sets the `arch` input to `default`, then we use the

package.json

@@ -1,5 +1,6 @@
 {
   "name": "setup-julia",
+  "version": "2.4.0",
   "private": true,
   "description": "setup Julia action",
   "main": "lib/setup-julia.js",
@@ -20,26 +21,26 @@
   "author": "Sascha Mann <git@mail.saschamann.eu>",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.11.1",
+    "@actions/core": "^1.10.1",
     "@actions/exec": "^1.1.1",
     "@actions/io": "^1.1.3",
-    "@actions/tool-cache": "^2.0.2",
+    "@actions/tool-cache": "^2.0.1",
     "async-retry": "^1.3.3",
-    "semver": "^7.7.0",
+    "semver": "^7.6.3",
     "toml": "^3.0.0"
   },
   "devDependencies": {
-    "@types/async-retry": "^1.4.9",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.1.0",
+    "@types/async-retry": "^1.4.8",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.5.1",
     "@types/retry": "^0.12.5",
-    "@types/semver": "^7.7.0",
-    "@vercel/ncc": "^0.38.3",
-    "jest": "^30.0.5",
-    "jest-circus": "^30.0.3",
-    "nock": "^14.0.8",
-    "prettier": "^3.6.2",
-    "ts-jest": "^29.4.0",
-    "typescript": "^5.9.2"
+    "@types/semver": "^7.5.8",
+    "@vercel/ncc": "^0.38.1",
+    "jest": "^29.7.0",
+    "jest-circus": "^29.7.0",
+    "nock": "^13.5.4",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.5.4"
   }
 }

src/installer.ts

@@ -11,7 +11,7 @@ import retry = require('async-retry')
 import * as semver from 'semver'
 import * as toml from 'toml'
 
-const LTS_VERSION = '1.10'
+const LTS_VERSION = '1.6'
 const MAJOR_VERSION = '1' // Could be deduced from versions.json
 
 // Translations between actions input and Julia arch names

src/setup-julia.ts

@@ -15,7 +15,6 @@ import * as installer from './installer'
 const archSynonyms = {
     'x86': 'x86',
     'x64': 'x64',
-    'x86_64': 'x64',
     'aarch64': 'aarch64',
     'arm64': 'aarch64'
 }
@@ -45,7 +44,6 @@ async function run() {
         const versionInput = core.getInput('version').trim()
         const includePrereleases = core.getInput('include-all-prereleases').trim() == 'true'
         const originalArchInput = core.getInput('arch').trim()
-        const forceArch = core.getInput('force-arch').trim() == 'true'
         const projectInput = core.getInput('project').trim()  // Julia project file
 
         // It can easily happen that, for example, a workflow file contains an input `version: ${{ matrix.julia-version }}`
@@ -63,14 +61,6 @@ async function run() {
             throw new Error(`Arch input must not be null`)
         }
 
-        if (originalArchInput == 'x64' && os.platform() == 'darwin' && os.arch() == 'arm64') {
-            if (forceArch) {
-                core.warning('[setup-julia] x64 arch has been requested on a macOS runner that has an arm64 (Apple Silicon) architecture. The "force-arch" input is set to "true", so proceeding with x64 installation. Note that this will mean Julia will be run under Rosetta emulation.')
-            } else {
-                throw new Error('[setup-julia] x64 arch has been requested on a macOS runner that has an arm64 (Apple Silicon) architecture. You may have meant to use the "aarch64" arch instead (or "default" or left it unspecified for the correct default). To force the use of x64 on this runner, set the "force-arch" input to "true".')
-            }
-        }
-
         let processedArchInput: string;
         if (originalArchInput == "default") {
             // If the user sets the `arch` input to `default`, then we use the