Add win11-arm64 to ImageOS mapping

Update 3rd party licenses

Co-authored-by: GitHub Actions <actions@user.noreply.github.com>

.github/workflows/action.yml

@@ -24,7 +24,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Version it!
         run: |
           # We expect a string such as const setupBeamVersion = 'undefined' in the code
@@ -45,10 +45,10 @@ jobs:
     runs-on: ubuntu-latest
     if: github.ref != 'refs/heads/main'
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
-      - uses: actions/setup-node@v4.4.0
+      - uses: actions/setup-node@v6.3.0
         with:
-          node-version: '20'
+          node-version: '24'
       - run: npm run build-dist
       - name: Check if build left artifacts
         run: git diff --exit-code --ignore-space-at-eol
@@ -58,45 +58,75 @@ jobs:
     runs-on: ubuntu-latest
     if: github.ref != 'refs/heads/main'
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
-      - uses: raven-actions/actionlint@v2.0.1
+      - uses: raven-actions/actionlint@v2.1.2
 
   unit_tests_ubuntu:
     name: Unit tests (Ubuntu)
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os:
+          - ubuntu-24.04-arm # ARM64
+          - ubuntu-latest # x86_64
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
-      - uses: actions/setup-node@v4.4.0
+      - uses: actions/setup-node@v6.3.0
         with:
-          node-version: '20'
+          node-version: '24'
       - run: npm ci
       - run: npm test
+        env:
+          NODE_ENV: test
       - name: .tool-versions test
         id: setup-beam
         uses: ./
         with:
           install-rebar: false
+          install-hex: false
           version-file: test/.tool-versions
           version-type: strict
 
   unit_tests_windows:
     name: Unit tests (Windows)
-    runs-on: windows-latest
+    strategy:
+      matrix:
+        os:
+          - windows-11-arm # ARM64
+          - windows-latest # x86_64
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
-      - uses: actions/setup-node@v4.4.0
+      - uses: actions/setup-node@v6.3.0
         with:
-          node-version: '20'
+          node-version: '24'
       - run: npm install --production
       - run: npm test
+        env:
+          NODE_ENV: test
+      - name: .tool-versions test
+        id: setup-beam
+        uses: ./
+        with:
+          install-rebar: false
+          install-hex: false
+          version-file: test/.tool-versions
+          version-type: strict
 
   unit_tests_macos:
     name: Unit tests (macOS)
-    runs-on: macos-latest
+    strategy:
+      matrix:
+        os:
+          - macos-latest # ARM64
+          - macos-15-intel # x86_64
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
-      - uses: actions/setup-node@v4.4.0
+      - uses: actions/setup-node@v6.3.0
         with:
-          node-version: '20'
+          node-version: '24'
       - run: npm ci
       - run: npm test
+        env:
+          NODE_ENV: test

.github/workflows/hexpm-mirrors.yml

@@ -26,7 +26,7 @@ jobs:
         install-rebar: [true, false]
         install-hex: [true, false]
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./

.github/workflows/macos.yml

@@ -43,14 +43,11 @@ jobs:
             elixir-version: '1.14.3'
             os: 'macos-latest'
             version-type: 'strict'
-          - otp-version: '27'
-            os: 'macos-15'
-            version-type: 'strict'
-          - otp-version: '26'
-            os: 'macos-15'
-            version-type: 'strict'
           - otp-version: '25'
             os: 'macos-15'
+          - otp-version: '27'
+            elixir-version: '1.18'
+            os: 'macos-26'
           - otp-version: '26'
             elixir-version: '1.16'
             rebar3-version: '3.25'
@@ -71,7 +68,7 @@ jobs:
             rebar3-version: 'latest'
             os: 'macos-latest'
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./
@@ -124,7 +121,7 @@ jobs:
             rebar3-version: 3.24
             os: macos-latest
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./

.github/workflows/ubuntu.yml

@@ -25,6 +25,15 @@ jobs:
       fail-fast: false
       matrix:
         combo:
+          - otp-version: '<26'
+            elixir-version: '<1.17'
+            os: 'ubuntu-22.04'
+          - otp-version: 'master'
+            elixir-version: '> 0'
+            os: 'ubuntu-24.04'
+          - otp-version: 'master'
+            elixir-version: 'main'
+            os: 'ubuntu-24.04'
           - otp-version: '27'
             elixir-version: 'v1.17.0'
             rebar3-version: '3.23'
@@ -44,12 +53,6 @@ jobs:
             elixir-version: '1.14.3'
             os: 'ubuntu-latest'
             version-type: 'strict'
-          - otp-version: '27'
-            os: 'ubuntu-24.04'
-            version-type: 'strict'
-          - otp-version: '26'
-            os: 'ubuntu-24.04'
-            version-type: 'strict'
           - otp-version: '25'
             os: 'ubuntu-24.04'
           - otp-version: '26'
@@ -83,7 +86,7 @@ jobs:
             escript_script: 'protoc-gen-elixir --version'
             os: 'ubuntu-latest'
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./
@@ -151,7 +154,7 @@ jobs:
             rebar3-version: 3.24
             os: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./

.github/workflows/update_3rd_party_licenses.yml

@@ -3,6 +3,7 @@ name: Update 3rd party licenses (automation)
 
 permissions:
   contents: write
+  pull-requests: write
 
 on:
   schedule:
@@ -14,7 +15,7 @@ jobs:
     name: Update 3rd party licenses
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - run:
           ./.github/workflows/update_3rd_party_licenses.sh
         env:

.github/workflows/windows.yml

@@ -25,6 +25,12 @@ jobs:
       fail-fast: false
       matrix:
         combo:
+          - otp-version: '<26'
+            elixir-version: '<1.17'
+            os: 'ubuntu-22.04'
+          - otp-version: 'master'
+            elixir-version: '> 0'
+            os: 'ubuntu-24.04'
           - otp-version: '27'
             elixir-version: 'v1.17.0'
             rebar3-version: '3.23'
@@ -64,7 +70,7 @@ jobs:
             escript_script: 'protoc-gen-elixir --version'
             os: 'windows-latest'
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./
@@ -131,7 +137,7 @@ jobs:
             rebar3-version: 3.24
             os: windows-latest
     steps:
-      - uses: actions/checkout@v4.2.2
+      - uses: actions/checkout@v6.0.2
       - name: Use erlef/setup-beam
         id: setup-beam
         uses: ./

.gitignore

@@ -1,2 +1,4 @@
-node_modules/**
+/node_modules
-test/.tool-versions
+/test/.tool-versions
+/test/mise.toml
+/dist/package.json

README.md

@@ -53,19 +53,25 @@ end up being parsed as `23`, which is not equivalent.
 
 #### Pre-release versions
 
-For pre-release versions, such as `v1.11.0-rc.0`, use the full version
+To use a pre-release version such as `v1.11.0-rc.0`, specify the exact version
-specifier (`v1.11.0-rc.0`) and set option `version-type` to `strict`. Pre-release versions are
+(`v1.11.0-rc.0`) and set `version-type` to `strict`.
-opt-in, so `1.11.x` will not match a pre-release.
+Note that pre-release versions are opt-in by default.
+Patterns like `1.11.x` do not include pre-release versions unless `latest` is specified.
 
 #### "Latest" versions
 
-Set a tool's version to `latest` to retrieve the latest version of a given tool.
+To retrieve the most recent available version of a tool, set the version to `latest`.
-The latest version is (locally) calculated by the action based on the (retrieved) versions
+This may include pre-release versions such as release candidates.
-it knows (**note**: it is not the same as [GitHub considers it](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository)
-and some repositories might propose).
 
-If in doubt do a test run and compare the obtained release with the one you were expecting to
+If you want to target only the latest stable release and exclude pre-releases, use a
-be the latest.
+version range like `> 0` instead.
+
+Note that the `latest` version is determined locally by the action based on the versions it
+has retrieved. This may differ from how [GitHub defines "latest"](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository),
+and some repositories may present different interpretations.
+
+If you're unsure, perform a test run and compare the resolved version against the version you
+expect to be considered the latest.
 
 ### Compatibility between Operating System and Erlang/OTP
 
@@ -78,13 +84,20 @@ and Erlang/OTP.
 | `ubuntu-24.04`   | 24.3 - 28    | x86_64, arm64    | ✅
 | `windows-2019`   | 21\* - 25    | x86_64, x86      | ✅
 | `windows-2022`   | 21\* - 28    | x86_64, x86      | ✅
+| `windows-2025`   | 21\* - 28    | x86_64, x86      | ✅
 | `macOS-13`       | 25.0 - 28    | x86_64, arm64    | ✅
 | `macOS-14`       | 25.0 - 28    | x86_64, arm64    | ✅
 | `macOS-15`       | 25.0 - 28    | x86_64, arm64    | ✅
+| `macOS-26`       | 25.0 - 28    | x86_64, arm64    | ✅
 
 **Note** \*: prior to 23, Windows builds are only available for minor versions, e.g. 21.0, 21.3,
 22.0, etc.
 
+### Compatibility between Erlang/OTP and rebar3
+
+Check [version compatibility](https://github.com/erlang/rebar3?tab=readme-ov-file#compatibility-between-rebar3-and-erlangotp)
+in `erlang/rebar3`.
+
 ### Self-hosted runners
 
 Self-hosted runners need to set env. variable `ImageOS` to one of the following, since the action
@@ -96,9 +109,11 @@ uses that to download assets:
 | `ubuntu24`         | `ubuntu-24.04`
 | `win19`            | `windows-2019`
 | `win22`            | `windows-2022`
+| `win25`            | `windows-2025`
 | `macos13`          | `macOS-13`
 | `macos14`          | `macOS-14`
 | `macos15`          | `macOS-15`
+| `macos26`          | `macOS-26`
 
 as per the following example:
 
@@ -133,23 +148,22 @@ e.g. `${{steps.setup-beam.outputs.erlang-version}}`
 
 ### Version file
 
-A version file is specified via input `version-file` (e.g.`.tool-versions`). This
+A version file is specified via input `version-file` (e.g. `.tool-versions` or `mise.toml`).
-allows not having to use YML input for versions, though the action does check (and
+The file type is inferred from the filename: files ending in `.toml` are parsed as
+[mise](https://mise.jdx.dev/configuration.html#tools-dev-tools) configuration, and all others
+are parsed as [`.tool-versions`](https://asdf-vm.com/manage/configuration.html) (asdf format).
+This allows not having to use YML input for versions, though the action does check (and
 will exit with error) if both inputs are set.
 
 **Note**: if you're using a version file, option `version-type` is checked to be `strict`,
 and will make the action exit with error otherwise.
 
-The following version file formats are supported:
-
-- `.tool-versions`, as specified by [asdf: Configuration](https://asdf-vm.com/manage/configuration.html)
-
 Supported version elements are the same as the ones defined for the YML portion of the action,
 with the following correspondence.
 
-#### `.tool-versions` format
+#### `.tool-versions` / `mise.toml` format
 
-| YML              | `.tool-versions`
+| YML              | Version file key
 |-                 |-
 | `otp-version`    | `erlang`
 | `elixir-version` | `elixir`
@@ -283,6 +297,34 @@ jobs:
       - run: rebar3 ct
 ```
 
+### Compatibility
+
+To execute matrix testing with specific dependency versions, configure the environment matrix to
+use pinned, compatible releases:
+
+```yaml
+  test:
+    runs-on: ${{matrix.compat.os}}
+    name: Erlang/OTP ${{matrix.compat.otp}} / rebar3 ${{matrix.compat.rebar3}}
+    strategy:
+      matrix:
+        compat:
+          - otp: "26.2.5.5"
+            rebar3: "3.22.1"
+            os: ubuntu-24.04
+          - otp: "27.1.2"
+            rebar3: "3.22.1"
+            os: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{matrix.compat.otp}}
+          rebar3-version: ${{matrix.compat.rebar3}}
+          version-type: strict
+      - run: rebar3 eunit
+```
+
 ### Erlang/OTP + `rebar3`, on Windows
 
 ```yaml
@@ -291,7 +333,7 @@ on: push
 
 jobs:
   test:
-    runs-on: windows-2022
+    runs-on: windows-2025
     steps:
       - uses: actions/checkout@v4
       - uses: erlef/setup-beam@v1

action.yml

@@ -69,7 +69,9 @@ inputs:
     required: false
 
   version-file:
-    description: a versions file (e.g. as used by `asdf`), which defines inputs
+    description: >-
+      a versions file (e.g. `.tool-versions` as used by `asdf`, or `mise.toml`
+      as used by `mise`), which defines inputs
     default: ''
     required: false
 
@@ -96,5 +98,5 @@ outputs:
     description: The commit unique id of the execution action version
 
 runs:
-  using: node20
+  using: node24
   main: dist/index.js

dist/erlang-matchers.json

@@ -0,0 +1,66 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "erlc-warning",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(\\S+):(\\d+):(\\d+): [wW]arning: (.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    },
+    {
+      "owner": "erlc-error",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(\\S+):(\\d+):(\\d+): (?![wW]arning)(.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    },
+    {
+      "owner": "ct-failure",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(\\S+) failed on line (\\d+)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^Reason: (.+)$",
+          "message": 1
+        }
+      ]
+    },
+    {
+      "owner": "eunit-failure",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^\\S+: .+\\.\\.\\.\\*failed\\*$"
+        },
+        {
+          "regexp": "^in function .+ \\((.+), line (\\d+)\\)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^in call from .+$"
+        },
+        {
+          "regexp": "^\\*\\*error:(.+)$",
+          "message": 1
+        }
+      ]
+    }
+  ]
+}

eslint.config.mjs

@@ -1,30 +1,27 @@
 import js from '@eslint/js'
 import globals from 'globals'
-import { defineConfig } from 'eslint/config'
+import yml from 'eslint-plugin-yml'
-import eslintPluginYml from 'eslint-plugin-yml'
+import * as yamlParser from 'yaml-eslint-parser'
 
-export default defineConfig([
+export default [
-  ...eslintPluginYml.configs['flat/recommended'],
+  js.configs.recommended,
   {
-    extends: ['js/recommended'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: globals.node,
+    },
+  },
+  {
+    files: ['**/*.yml'],
+    languageOptions: {
+      parser: yamlParser,
+    },
     plugins: {
-      js,
+      yml,
     },
-    languageOptions: {
+    rules: {
-      ecmaVersion: 2022,
+      ...yml.configs.recommended.rules,
-      globals: {
-        ...globals.node,
-      },
     },
   },
-  {
+]
-    extends: eslintPluginYml.configs['flat/recommended'],
-    files: ['*.yml'],
-    languageOptions: {
-      parserOptions: {
-        parser: 'yaml-eslint-parser',
-        defaultYAMLVersion: '1.2',
-      },
-    },
-  },
-])

matchers/erlang-matchers.json

@@ -0,0 +1,66 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "erlc-warning",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(\\S+):(\\d+):(\\d+): [wW]arning: (.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    },
+    {
+      "owner": "erlc-error",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(\\S+):(\\d+):(\\d+): (?![wW]arning)(.+)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4
+        }
+      ]
+    },
+    {
+      "owner": "ct-failure",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(\\S+) failed on line (\\d+)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^Reason: (.+)$",
+          "message": 1
+        }
+      ]
+    },
+    {
+      "owner": "eunit-failure",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^\\S+: .+\\.\\.\\.\\*failed\\*$"
+        },
+        {
+          "regexp": "^in function .+ \\((.+), line (\\d+)\\)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^in call from .+$"
+        },
+        {
+          "regexp": "^\\*\\*error:(.+)$",
+          "message": 1
+        }
+      ]
+    }
+  ]
+}

package.json

@@ -1,5 +1,6 @@
 {
   "name": "setup-beam",
+  "type": "module",
   "license": "MIT",
   "private": true,
   "scripts": {
@@ -16,25 +17,26 @@
     "build-dist": "npm run clean-dist && npm install && npm run build && npm run format && npm run lint"
   },
   "dependencies": {
-    "@actions/core": "1.11.1",
+    "@actions/core": "3.0.0",
-    "@actions/exec": "1.1.1",
+    "@actions/exec": "3.0.0",
-    "@actions/tool-cache": "2.0.2",
+    "@actions/tool-cache": "4.0.0",
-    "csv-parse": "5.6.0",
+    "csv-parse": "6.2.1",
-    "semver": "7.7.2",
+    "lodash": "4.17.23",
-    "lodash": "4.17.21"
+    "semver": "7.7.4",
+    "smol-toml": "1.6.1"
   },
   "devDependencies": {
-    "@vercel/ncc": "0.38.3",
+    "@eslint/js": "10.0.1",
-    "eslint": "9.29.0",
+    "@vercel/ncc": "0.38.4",
-    "@eslint/js": "9.29.0",
+    "eslint": "10.1.0",
-    "globals": "16.2.0",
+    "eslint-plugin-yml": "3.3.1",
-    "markdownlint-cli": "0.45.0",
+    "globals": "17.4.0",
-    "prettier": "3.6.0",
+    "markdownlint-cli": "0.48.0",
-    "shellcheck": "3.1.0",
+    "prettier": "3.8.1",
-    "eslint-plugin-yml": "1.18.0",
+    "shellcheck": "4.1.0",
     "yarn": "1.22.22"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   }
 }

src/setup-beam.js

@@ -1,18 +1,25 @@
-const core = require('@actions/core')
+import path from 'node:path'
-const { exec } = require('@actions/exec')
+import fs from 'node:fs'
-const tc = require('@actions/tool-cache')
+import os from 'node:os'
-const path = require('path')
+import { fileURLToPath } from 'node:url'
-const semver = require('semver')
+import * as core from '@actions/core'
-const fs = require('fs')
+import { exec } from '@actions/exec'
-const os = require('os')
+import * as tc from '@actions/tool-cache'
-const csv = require('csv-parse/sync')
+import * as semver from 'semver'
-const _ = require('lodash')
+import * as csv from 'csv-parse/sync'
+import _ from 'lodash'
+import toml from 'smol-toml'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 const MAX_HTTP_RETRIES = 3
+const APPS = ['erlang', 'elixir', 'gleam', 'rebar']
 
-main().catch((err) => {
+if (process.env.NODE_ENV !== 'test') {
-  core.setFailed(err.message)
+  main().catch((err) => {
-})
+    core.setFailed(err.message)
+  })
+}
 
 async function main() {
   checkOtpArchitecture()
@@ -28,15 +35,14 @@ async function main() {
     versions = parseVersionFile(versionFilePath)
   }
 
-  const osVersion = getRunnerOSVersion()
   const otpSpec = getInput('otp-version', true, 'erlang', versions)
   const elixirSpec = getInput('elixir-version', false, 'elixir', versions)
   const gleamSpec = getInput('gleam-version', false, 'gleam', versions)
   const rebar3Spec = getInput('rebar3-version', false, 'rebar', versions)
 
   if (otpSpec !== 'false') {
-    await installOTP(otpSpec, osVersion)
+    await installOTP(otpSpec)
-    const elixirInstalled = await maybeInstallElixir(elixirSpec, otpSpec)
+    const elixirInstalled = await maybeInstallElixir(elixirSpec)
     if (elixirInstalled === true) {
       const shouldMixRebar = getInput('install-rebar', false)
       await mix(shouldMixRebar, 'rebar')
@@ -52,11 +58,12 @@ async function main() {
   await maybeInstallRebar3(rebar3Spec)
 
   // undefined is replaced by a function, post- main branch merge
-  const setupBeamVersion = 'abd725c'
+  const setupBeamVersion = '7a27046'
   core.setOutput('setup-beam-version', setupBeamVersion)
 }
 
-async function installOTP(otpSpec, osVersion) {
+async function installOTP(otpSpec) {
+  const osVersion = getRunnerOSVersion()
   const otpVersion = await getOTPVersion(otpSpec, osVersion)
   core.startGroup(
     `Installing Erlang/OTP ${otpVersion} - built on ${getRunnerOSArchitecture()}/${osVersion}`,
@@ -73,15 +80,16 @@ async function installOTP(otpSpec, osVersion) {
     },
   })
   core.setOutput('otp-version', otpVersion)
+  maybeEnableProblemMatchers('erlang')
   core.endGroup()
 
   return otpVersion
 }
 
-async function maybeInstallElixir(elixirSpec, otpSpec) {
+async function maybeInstallElixir(elixirSpec) {
   let installed = false
   if (elixirSpec) {
-    const elixirVersion = await getElixirVersion(elixirSpec, otpSpec)
+    const elixirVersion = await getElixirVersion(elixirSpec)
     core.startGroup(`Installing Elixir ${elixirVersion}`)
     await doWithMirrors({
       hexMirrors: hexMirrorsInput(),
@@ -94,7 +102,7 @@ async function maybeInstallElixir(elixirSpec, otpSpec) {
       },
     })
     core.setOutput('elixir-version', elixirVersion)
-    maybeEnableElixirProblemMatchers()
+    maybeEnableProblemMatchers('elixir')
     core.endGroup()
 
     installed = true
@@ -103,16 +111,18 @@ async function maybeInstallElixir(elixirSpec, otpSpec) {
   return installed
 }
 
-function maybeEnableElixirProblemMatchers() {
+function problemMatchersEnabled() {
-  const disableProblemMatchers = getInput('disable_problem_matchers', false)
+  return getInput('disable_problem_matchers', false) === 'false'
-  if (disableProblemMatchers === 'false') {
+}
-    const elixirMatchers = path.join(
+
-      __dirname,
+// path.join with static strings helps ncc resolve and bundle the JSON files
-      '..',
+function maybeEnableProblemMatchers(language) {
-      'matchers',
+  if (problemMatchersEnabled()) {
-      'elixir-matchers.json',
+    const matcherFiles = {
-    )
+      erlang: path.join(`${__dirname}/../matchers/erlang-matchers.json`),
-    core.info(`##[add-matcher]${elixirMatchers}`)
+      elixir: path.join(`${__dirname}/../matchers/elixir-matchers.json`),
+    }
+    core.info(`##[add-matcher]${matcherFiles[language]}`)
   }
 }
 
@@ -168,10 +178,14 @@ async function maybeInstallRebar3(rebar3Spec) {
   return installed
 }
 
+function maybeRemoveOTPPrefix(otpSpec) {
+  return otpSpec.replace(/^OTP-/, '')
+}
+
 async function getOTPVersion(otpSpec0, osVersion) {
   const [otpVersions, originListing, hexMirrors] =
     await getOTPVersions(osVersion)
-  let spec = otpSpec0.replace(/^OTP-/, '')
+  let spec = maybeRemoveOTPPrefix(otpSpec0)
   const versions = otpVersions
   const otpVersion = getVersionFromSpec(spec, versions)
 
@@ -185,26 +199,50 @@ async function getOTPVersion(otpSpec0, osVersion) {
 }
 
 function requestedVersionFor(tool, version, originListing, mirrors) {
-  return (
+  const isVersionTypeStrict = isStrictVersion()
-    `Requested ${tool} version (${version}) not found in version list, ` +
+
-    `at ${originListing}${mirrors ? `, with mirrors ${mirrors}` : ''}; ` +
+  let versionType = 'loose'
-    "should you be using option 'version-type': 'strict'?"
+  if (isVersionTypeStrict) {
-  )
+    versionType = 'strict'
+  }
+
+  let ret =
+    `Requested ${versionType} ${tool} version (${version}) not found in version list, ` +
+    `at ${originListing}${mirrors ? `, with mirrors ${mirrors}` : ''}.`
+  if (!isVersionTypeStrict) {
+    ret = `${ret} Should you be using option 'version-type': 'strict'?`
+  }
+
+  return ret
 }
 
 const knownBranches = ['main', 'master', 'maint']
 const nonSpecificVersions = ['nightly', 'latest']
 
-async function getElixirVersion(exSpec0, otpVersion0) {
+async function getElixirVersion(exSpec0) {
-  const otpVersion = otpVersion0.match(/^(?:OTP-)?(.+)$/)[1]
-  const regex = `^(\\d{1,3}|${knownBranches.join('|')}|${nonSpecificVersions.join('|')})?.*$`
-  let otpVersionMajor = otpVersion.match(new RegExp(regex))[1]
-
   const otpSuffix = /-otp-(\d+)/
   const userSuppliedOtp = exSpec0.match(otpSuffix)?.[1] ?? null
+  let otpVersionMajor = ''
 
   if (userSuppliedOtp && isVersion(userSuppliedOtp)) {
     otpVersionMajor = userSuppliedOtp
+  } else {
+    let cmd = 'erl'
+    if (process.platform === 'win32') {
+      cmd = 'erl.exe'
+    }
+    const args = [
+      '-noshell',
+      '-eval',
+      'io:format(erlang:system_info(otp_release)), halt().',
+    ]
+    await exec(cmd, args, {
+      listeners: {
+        stdout: (data) => {
+          otpVersionMajor = data.toString()
+        },
+      },
+    })
   }
 
   const [otpVersionsForElixirMap, elixirVersions, originListing, hexMirrors] =
@@ -219,17 +257,29 @@ async function getElixirVersion(exSpec0, otpVersion0) {
     )
   }
 
-  const elixirVersionComp = otpVersionsForElixirMap[elixirVersionFromSpec]
+  let foundCombo = false
-  if (
+  let otpVersionMajorIter = parseInt(otpVersionMajor)
-    (elixirVersionComp && elixirVersionComp.includes(otpVersionMajor)) ||
+  let otpVersionsMajor = []
-    !isVersion(otpVersionMajor)
+  while (otpVersionMajorIter > otpVersionMajor - 3) {
-  ) {
+    otpVersionMajorIter += ''
-    core.info(
+    otpVersionsMajor.push(otpVersionMajorIter)
-      `Using Elixir ${elixirVersionFromSpec} (built for Erlang/OTP ${otpVersionMajor})`,
+    const elixirVersionComp = otpVersionsForElixirMap[elixirVersionFromSpec]
-    )
+    if (
-  } else {
+      (elixirVersionComp && elixirVersionComp.includes(otpVersionMajorIter)) ||
+      !isVersion(otpVersionMajorIter)
+    ) {
+      core.info(
+        `Using Elixir ${elixirVersionFromSpec} (built for Erlang/OTP ${otpVersionMajorIter})`,
+      )
+      foundCombo = true
+      break
+    }
+    otpVersionMajorIter = parseInt(otpVersionMajorIter) - 1
+  }
+
+  if (!foundCombo) {
     throw new Error(
-      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion0}) not ` +
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / tried ${otpVersionsMajor}) not ` +
         'found in version list (did you check Compatibility between Elixir and Erlang/OTP?).' +
         'Elixir and Erlang/OTP compatibility can be found at: ' +
         'https://hexdocs.pm/elixir/compatibility-and-deprecations.html',
@@ -238,8 +288,8 @@ async function getElixirVersion(exSpec0, otpVersion0) {
 
   let elixirVersionForDownload = elixirVersionFromSpec
 
-  if (isVersion(otpVersionMajor)) {
+  if (isVersion(otpVersionMajorIter)) {
-    elixirVersionForDownload = `${elixirVersionFromSpec}-otp-${otpVersionMajor}`
+    elixirVersionForDownload = `${elixirVersionFromSpec}-otp-${otpVersionMajorIter}`
   }
 
   return maybePrependWithV(elixirVersionForDownload)
@@ -321,12 +371,9 @@ async function getOTPVersions(osVersion) {
       .trim()
       .split('\n')
       .forEach((line) => {
-        const otpMatch = line
+        const otpVersionOrig = line.match(/^([^ ]+)?( .+)/)[1]
-          .match(/^([^ ]+)?( .+)/)[1]
+        const otpVersion = maybeRemoveOTPPrefix(otpVersionOrig)
-          .match(/^([^-]+-)?(.+)$/)
+        debugLog('OTP line and parsing', [line, otpVersion, otpVersionOrig])
-        const otpVersion = otpMatch[2]
-        const otpVersionOrig = otpMatch[0]
-        debugLog('OTP line and parsing', [line, otpVersion, otpMatch])
         otpVersions[otpVersion] = otpVersionOrig // we keep the original for later reference
       })
   } else if (process.platform === 'win32') {
@@ -340,10 +387,10 @@ async function getOTPVersions(osVersion) {
         .flat()
         .filter((x) => x.name.match(file_regex))
         .forEach((x) => {
-          const otpMatch = x.name.match(file_regex)
+          const otpVersionOrig = x.name.match(file_regex)[1]
-          const otpVersion = otpMatch[1]
+          const otpVersion = otpVersionOrig
-          debugLog('OTP line and parsing', [otpMatch, otpVersion])
+          debugLog('OTP line and parsing', [x.name, otpVersion, otpVersionOrig])
-          otpVersions[otpVersion] = otpVersion
+          otpVersions[otpVersion] = otpVersionOrig
         })
     })
   } else if (process.platform === 'darwin') {
@@ -352,10 +399,9 @@ async function getOTPVersions(osVersion) {
         columns: true,
       })
       .forEach((line) => {
-        const otpMatch = line.ref_name.match(/^([^-]+-)?(.+)$/)
+        const otpVersionOrig = line.ref_name
-        const otpVersion = otpMatch[2]
+        const otpVersion = maybeRemoveOTPPrefix(otpVersionOrig)
-        const otpVersionOrig = otpMatch[0]
+        debugLog('OTP line and parsing', [line, otpVersion, otpVersionOrig])
-        debugLog('OTP line and parsing', [line, otpVersion, otpMatch])
         otpVersions[otpVersion] = otpVersionOrig // we keep the original for later reference
       })
   }
@@ -448,6 +494,7 @@ function validVersion(v) {
     v.match(
       new RegExp(`${knownBranches.join('|')}|${nonSpecificVersions.join('|')}`),
     ) == null &&
+    // these ones are for rebar3, which has alpha and beta releases
     !v.startsWith('a') &&
     !v.startsWith('b')
   )
@@ -474,8 +521,14 @@ function getVersionFromSpec(spec0, versions0) {
   const altVersions = {}
   Object.entries(versions0).forEach(([version, altVersion]) => {
     let coerced
-    if (isStrictVersion() || isRC(version)) {
+    if (
-      // If `version-type: strict` or version is RC, we just try to remove a potential initial v
+      isStrictVersion() ||
+      isRC(version) ||
+      isKnownBranch(version) ||
+      isKnownVerBranch(version)
+    ) {
+      // If `version-type: strict`, version is an RC, or version is "a branch"
+      // we just try to remove a potential initial v
       coerced = maybeRemoveVPrefix(version)
     } else {
       // Otherwise, we place the version into a version bucket
@@ -492,13 +545,19 @@ function getVersionFromSpec(spec0, versions0) {
   const rangeMax = semver.maxSatisfying(versions, rangeForMax)
   let version = null
 
-  if (isStrictVersion() || isRC(spec0) || isKnownBranch(spec0)) {
+  if (spec0 === 'latest') {
+    version = versions0[versions0.latest]
+  } else if (
+    isStrictVersion() ||
+    isRC(spec0) ||
+    isKnownBranch(spec0) ||
+    isKnownVerBranch(spec0) ||
+    spec0 === 'nightly'
+  ) {
     if (versions0[spec]) {
-      // If `version-type: strict` or version is RC, we obtain it directly
+      // We obtain it directly
       version = versions0[spec]
     }
-  } else if (spec0 === 'latest') {
-    version = versions0[versions0.latest]
   } else if (rangeMax !== null) {
     // Otherwise, we compare alt. versions' semver ranges to this version, from highest to lowest
     const thatVersion = spec
@@ -525,7 +584,7 @@ function getVersionFromSpec(spec0, versions0) {
 }
 
 function maybeCoerced(v) {
-  let ret = null
+  let ret
   try {
     if (!isRC(v)) {
       ret = semver.coerce(v).version
@@ -605,23 +664,42 @@ function getRunnerOSVersion() {
   const ImageOSToContainer = {
     ubuntu22: 'ubuntu-22.04',
     ubuntu24: 'ubuntu-24.04',
+    'win11-arm64': 'windows-11-arm',
     win19: 'windows-2019',
     win22: 'windows-2022',
+    win25: 'windows-2025',
     macos13: 'macOS-13',
     macos14: 'macOS-14',
     macos15: 'macOS-15',
+    macos26: 'macOS-26',
+  }
+  const deprecatedImageOSToContainer = {
+    ubuntu18: 'ubuntu-18.04',
+    ubuntu20: 'ubuntu-20.04',
   }
   const containerFromEnvImageOS = ImageOSToContainer[process.env.ImageOS]
   if (!containerFromEnvImageOS) {
-    throw new Error(
+    const deprecatedContainerFromEnvImageOS =
-      "Tried to map a target OS from env. variable 'ImageOS' (got " +
+      deprecatedImageOSToContainer[process.env.ImageOS]
-        `${process.env.ImageOS}` +
+    if (deprecatedContainerFromEnvImageOS) {
-        "), but failed. If you're using a " +
+      core.warning(
-        "self-hosted runner, you should set 'env': 'ImageOS': ... to one of the following: " +
+        `You are using deprecated ImageOS ${deprecatedContainerFromEnvImageOS}. ` +
-        "['" +
+          'Support for maintenance is very limited. Consider a non-deprecated version as ' +
-        `${Object.keys(ImageOSToContainer).join("', '")}` +
+          'mentioned in the README.md.',
-        "']",
+      )
-    )
+
+      return deprecatedContainerFromEnvImageOS
+    } else {
+      throw new Error(
+        "Tried to map a target OS from env. variable 'ImageOS' (got " +
+          `${process.env.ImageOS}` +
+          "), but failed. If you're using a " +
+          "self-hosted runner, you should set 'env': 'ImageOS': ... to one of the following: " +
+          "['" +
+          `${Object.keys(ImageOSToContainer).join("', '")}` +
+          "']",
+      )
+    }
   }
 
   return containerFromEnvImageOS
@@ -701,7 +779,7 @@ function xyzAbcVersion(pref, suf) {
   // https://www.erlang.org/doc/system_principles/versions.html
   const dd = '\\.?(\\d+)?'
   return new RegExp(
-    `${pref}v?(\\d+)${dd}${dd}${dd}${dd}${dd}(?:-rc\\.?\\d+)?(?:-otp-\\d+)?${suf}`,
+    `${pref}(?:OTP-)?v?(\\d+)${dd}${dd}${dd}${dd}${dd}(?:-rc\\.?\\d+)?(?:-otp-\\d+)?${suf}`,
   )
 }
 
@@ -733,28 +811,14 @@ alongside ${alternativeName}=${alternativeValue} \
   return input
 }
 
-function parseVersionFile(versionFilePath0) {
+function parseToolVersionsFile(versionFilePath) {
-  const versionFilePath = path.resolve(
-    process.env.GITHUB_WORKSPACE,
-    versionFilePath0,
-  )
-  if (!fs.existsSync(versionFilePath)) {
-    throw new Error(
-      `The specified version file, ${versionFilePath0}, does not exist`,
-    )
-  }
-
-  core.startGroup(`Parsing version file at ${versionFilePath0}`)
   const appVersions = new Map()
   const versions = fs.readFileSync(versionFilePath, 'utf8')
-  // For the time being we parse .tool-versions
+  versions.split(/\r?\n/).forEach((line) => {
-  // If we ever start parsing something else, this should
-  // become default in a new option named e.g. version-file-type
-  versions.split('\n').forEach((line) => {
     const appVersion = line.match(/^([^ ]+)[ ]+(ref:v?)?([^ #]+)/)
     if (appVersion) {
       const app = appVersion[1]
-      if (['erlang', 'elixir', 'gleam', 'rebar'].includes(app)) {
+      if (APPS.includes(app)) {
         const [, , , version] = appVersion
         core.info(`Consuming ${app} at version ${version}`)
         appVersions.set(app, version)
@@ -771,6 +835,46 @@ function parseVersionFile(versionFilePath0) {
   return appVersions
 }
 
+function parseMiseTomlFile(versionFilePath) {
+  const appVersions = new Map()
+  const miseToml = fs.readFileSync(versionFilePath, 'utf8')
+  const miseTomlParsed = toml.parse(miseToml)
+  for (const app in miseTomlParsed.tools) {
+    if (APPS.includes(app)) {
+      const appVersion = miseTomlParsed.tools[app]
+      const version =
+        typeof appVersion == 'object' ? appVersion.version : appVersion
+
+      core.info(`Consuming ${app} at version ${version}`)
+      appVersions.set(app, version)
+    }
+  }
+
+  return appVersions
+}
+
+function parseVersionFile(versionFilePath0) {
+  const versionFilePath = path.resolve(
+    process.env.GITHUB_WORKSPACE,
+    versionFilePath0,
+  )
+  if (!fs.existsSync(versionFilePath)) {
+    throw new Error(
+      `The specified version file, ${versionFilePath0}, does not exist`,
+    )
+  }
+
+  if (versionFilePath0.endsWith('.toml')) {
+    core.startGroup(
+      `Parsing ${path.basename(versionFilePath0)} file at ${versionFilePath0}`,
+    )
+    return parseMiseTomlFile(versionFilePath)
+  }
+
+  core.startGroup(`Parsing .tool-versions file at ${versionFilePath0}`)
+  return parseToolVersionsFile(versionFilePath)
+}
+
 function debugLog(groupName, message) {
   const group = `Debugging for ${groupName}`
   core.debug(
@@ -953,12 +1057,14 @@ async function install(toolName, opts) {
         tool: 'Gleam',
         linux: {
           downloadToolURL: () => {
+            const arch = getRunnerOSArchitecture()
             let gz
             if (
               versionSpec === 'nightly' ||
               semver.gt(versionSpec, 'v0.22.1')
             ) {
-              gz = `gleam-${versionSpec}-x86_64-unknown-linux-musl.tar.gz`
+              const target = arch === 'arm64' ? 'aarch64' : 'x86_64'
+              gz = `gleam-${versionSpec}-${target}-unknown-linux-musl.tar.gz`
             } else {
               gz = `gleam-${versionSpec}-linux-amd64.tar.gz`
             }
@@ -1022,7 +1128,26 @@ async function install(toolName, opts) {
           },
         },
       }
-      installOpts.darwin = installOpts.linux
+      installOpts.darwin = {
+        downloadToolURL: () => {
+          const arch = getRunnerOSArchitecture()
+          let gz
+          if (versionSpec === 'nightly' || semver.gt(versionSpec, 'v0.22.1')) {
+            const target = arch === 'arm64' ? 'aarch64' : 'x86_64'
+            gz = `gleam-${versionSpec}-${target}-apple-darwin.tar.gz`
+          } else {
+            gz =
+              arch === 'arm64'
+                ? `gleam-${versionSpec}-macos-arm64.tar.gz`
+                : `gleam-${versionSpec}-macos.tar.gz`
+          }
+
+          return `https://github.com/gleam-lang/gleam/releases/download/${versionSpec}/${gz}`
+        },
+        extract: installOpts.linux.extract,
+        postExtract: installOpts.linux.postExtract,
+        reportVersion: installOpts.linux.reportVersion,
+      }
       break
     case 'rebar3':
       installOpts = {
@@ -1169,15 +1294,19 @@ function debugLoggingEnabled() {
   return !!process.env.RUNNER_DEBUG
 }
 
-module.exports = {
+export default {
   get,
-  getOTPVersion,
   getElixirVersion,
   getGleamVersion,
+  getOTPVersion,
   getRebar3Version,
   getVersionFromSpec,
   githubAMDRunnerArchs,
   githubARMRunnerArchs,
   install,
+  installOTP,
+  maybeInstallElixir,
+  maybeInstallGleam,
+  maybeInstallRebar3,
   parseVersionFile,
 }

test/setup-beam.test.js

@@ -1,3 +1,17 @@
+import assert from 'node:assert'
+import http from 'node:http'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+import * as csv from 'csv-parse/sync'
+import elixirMatchers from '../matchers/elixir-matchers.json' with { type: 'json' }
+import erlangMatchers from '../matchers/erlang-matchers.json' with { type: 'json' }
+const { problemMatcher } = elixirMatchers
+const { problemMatcher: erlangProblemMatcher } = erlangMatchers
+
+process.env.NODE_ENV = 'test'
+
 simulateInput('otp-version', '25.1.2')
 simulateInput('otp-architecture', '64')
 simulateInput('elixir-version', '1.14.2')
@@ -7,15 +21,7 @@ simulateInput('install-hex', 'true')
 simulateInput('github-token', process.env.GITHUB_TOKEN)
 simulateInput('hexpm-mirrors', 'https://builds.hex.pm', { multiline: true })
 
-const assert = require('assert')
+const { default: setupBeam } = await import('../src/setup-beam.js')
-const http = require('http')
-const fs = require('fs')
-const os = require('os')
-const path = require('path')
-const setupBeam = require('../src/setup-beam')
-const { problemMatcher } = require('../matchers/elixir-matchers.json')
-const { describe, it } = require('node:test')
-const csv = require('csv-parse/sync')
 
 const matrix = {
   otp: {
@@ -75,7 +81,7 @@ describe('OTP install', () => {
     const otpOSVersion = 'ubuntu-08.04'
     const otpVersion = 'OTP-23.2'
 
-    assert.rejects(
+    await assert.rejects(
       async () => {
         await setupBeam.install('otp', {
           hexMirror: 'https://builds.hex.pm',
@@ -95,7 +101,7 @@ describe('OTP install', () => {
 describe('Elixir install', () => {
   it('fails for version 0.11 without OTP', async () => {
     const exVersion = '0.11'
-    assert.rejects(
+    await assert.rejects(
       async () => {
         await setupBeam.install('elixir', {
           hexMirror: 'https://builds.hex.pm',
@@ -112,7 +118,7 @@ describe('Elixir install', () => {
 
   it('fails for version 1.0.0 on OTP 17 (without OTP)', async () => {
     const exVersion = 'v1.0.0-otp-17'
-    assert.rejects(
+    await assert.rejects(
       async () => {
         await setupBeam.install('elixir', {
           hexMirror: 'https://builds.hex.pm',
@@ -131,7 +137,7 @@ describe('Elixir install', () => {
 describe('Gleam install', () => {
   it('fails for unknown OTP', async () => {
     const gleamVersion = '0.1.3'
-    assert.rejects(
+    await assert.rejects(
       async () => {
         await setupBeam.install('gleam', { gleamVersion })
       },
@@ -147,7 +153,7 @@ describe('Gleam install', () => {
 describe('rebar3 install', () => {
   it('fails for unknown OTP', async () => {
     const r3Version = '0.14.4'
-    assert.rejects(
+    await assert.rejects(
       async () => {
         await setupBeam.install('rebar3', { r3Version })
       },
@@ -171,20 +177,9 @@ describe('.getOTPVersion(_) - Erlang', () => {
     'https://repo.hex.pm, https://cdn.jsdelivr.net/hex',
     { multiline: true },
   )
-  const previousRunnerArch = process.env.RUNNER_ARCH
 
   if (process.platform === 'linux') {
-    process.env.RUNNER_ARCH = 'X64'
-
     it('is Ok for known linux version', async () => {
-      before = simulateInput('version-type', 'strict')
-      spec = '26'
-      osVersion = 'ubuntu-24.04'
-      expected = 'maint-26'
-      got = await setupBeam.getOTPVersion(spec, osVersion)
-      assert.deepStrictEqual(got, expected)
-      simulateInput('version-type', before)
-
       before = simulateInput('version-type', 'strict')
       spec = '27.0'
       osVersion = 'ubuntu-24.04'
@@ -201,21 +196,21 @@ describe('.getOTPVersion(_) - Erlang', () => {
       assert.deepStrictEqual(got, expected)
       simulateInput('version-type', before)
 
-      spec = '19.3.x'
+      spec = '20.3.x'
-      osVersion = 'ubuntu-16.04'
+      osVersion = 'ubuntu-20.04'
-      expected = 'OTP-19.3.6.13'
+      expected = 'OTP-20.3.8.26'
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
 
-      spec = '^19.3.6'
+      spec = '^20.3.8'
-      osVersion = 'ubuntu-16.04'
+      osVersion = 'ubuntu-20.04'
-      expected = 'OTP-19.3.6.13'
+      expected = 'OTP-20.3.8.26'
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
 
-      spec = '^19.3'
+      spec = '^20.3'
-      osVersion = 'ubuntu-18.04'
+      osVersion = 'ubuntu-20.04'
-      expected = 'OTP-19.3.6.13'
+      expected = 'OTP-20.3.8.26'
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
 
@@ -309,19 +304,48 @@ describe('.getOTPVersion(_) - Erlang', () => {
   }
 
   if (process.platform === 'linux') {
-    it('is Ok for known linux ARM64 version', async () => {
+    it('is main-... only if strict/maint-... is used as input', async () => {
       const arm64Options = setupBeam.githubARMRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
       process.env.RUNNER_ARCH =
         arm64Options[Math.floor(Math.random() * arm64Options.length)]
 
       before = simulateInput('version-type', 'strict')
-      spec = '26'
+      await assert.rejects(
-      osVersion = 'ubuntu-24.04'
+        async () => {
-      expected = 'maint-26'
+          await setupBeam.getOTPVersion('27', 'ubuntu-24.04')
-      got = await setupBeam.getOTPVersion(spec, osVersion)
+        },
-      assert.deepStrictEqual(got, expected)
+        (err) => {
+          assert.ok(err instanceof Error)
+          return true
+        },
+        `Fetching strict OTP version maint-<v> with input <v> is supposed to fail`,
+      )
       simulateInput('version-type', before)
 
+      before = simulateInput('version-type', 'strict')
+      assert.strictEqual(
+        await setupBeam.getOTPVersion('maint-27', 'ubuntu-24.04'),
+        'maint-27',
+      )
+      simulateInput('version-type', before)
+
+      before = simulateInput('version-type', 'loose')
+      assert.strictEqual(
+        await setupBeam.getOTPVersion('maint-27', 'ubuntu-24.04'),
+        'maint-27',
+      )
+      simulateInput('version-type', before)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
+    })
+
+    it('is Ok for known linux ARM64 version', async () => {
+      const arm64Options = setupBeam.githubARMRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
+      process.env.RUNNER_ARCH =
+        arm64Options[Math.floor(Math.random() * arm64Options.length)]
+
       before = simulateInput('version-type', 'strict')
       spec = '27.0'
       osVersion = 'ubuntu-24.04'
@@ -379,21 +403,16 @@ describe('.getOTPVersion(_) - Erlang', () => {
       expected = 'master'
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
     })
 
     it('is Ok for known linux AMD64 version', async () => {
       const amd64Options = setupBeam.githubAMDRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
       process.env.RUNNER_ARCH =
         amd64Options[Math.floor(Math.random() * amd64Options.length)]
 
-      before = simulateInput('version-type', 'strict')
-      spec = '26'
-      osVersion = 'ubuntu-24.04'
-      expected = 'maint-26'
-      got = await setupBeam.getOTPVersion(spec, osVersion)
-      assert.deepStrictEqual(got, expected)
-      simulateInput('version-type', before)
-
       before = simulateInput('version-type', 'strict')
       spec = '27.0'
       osVersion = 'ubuntu-24.04'
@@ -469,12 +488,45 @@ describe('.getOTPVersion(_) - Erlang', () => {
       expected = 'master'
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
     })
   }
 
   if (process.platform === 'darwin') {
+    it('is main-... only if strict/maint-... is used as input', async () => {
+      const arm64Options = setupBeam.githubARMRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
+      process.env.RUNNER_ARCH =
+        arm64Options[Math.floor(Math.random() * arm64Options.length)]
+
+      before = simulateInput('version-type', 'strict')
+      await assert.rejects(
+        async () => {
+          await setupBeam.getOTPVersion('27')
+        },
+        (err) => {
+          assert.ok(err instanceof Error)
+          return true
+        },
+        `Fetching strict OTP version maint-<v> with input <v> is supposed to fail`,
+      )
+      simulateInput('version-type', before)
+
+      before = simulateInput('version-type', 'strict')
+      assert.strictEqual(await setupBeam.getOTPVersion('maint-27'), 'maint-27')
+      simulateInput('version-type', before)
+
+      before = simulateInput('version-type', 'loose')
+      assert.strictEqual(await setupBeam.getOTPVersion('maint-27'), 'maint-27')
+      simulateInput('version-type', before)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
+    })
+
     it('is Ok for known macos ARM64 version', async () => {
       const arm64Options = setupBeam.githubARMRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
       process.env.RUNNER_ARCH =
         arm64Options[Math.floor(Math.random() * arm64Options.length)]
 
@@ -485,10 +537,13 @@ describe('.getOTPVersion(_) - Erlang', () => {
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
       simulateInput('version-type', before)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
     })
 
     it('is Ok for known macos AMD64 version', async () => {
       const amd64Options = setupBeam.githubARMRunnerArchs()
+      const previousRunnerArch = process.env.RUNNER_ARCH
       process.env.RUNNER_ARCH =
         amd64Options[Math.floor(Math.random() * amd64Options.length)]
 
@@ -499,11 +554,12 @@ describe('.getOTPVersion(_) - Erlang', () => {
       got = await setupBeam.getOTPVersion(spec, osVersion)
       assert.deepStrictEqual(got, expected)
       simulateInput('version-type', before)
+
+      process.env.RUNNER_ARCH = previousRunnerArch
     })
   }
 
   simulateInput('hexpm-mirrors', hexMirrors, { multiline: true })
-  process.env.RUNNER_ARCH = previousRunnerArch
 })
 
 describe('OTP arch-specific install', () => {
@@ -515,7 +571,7 @@ describe('OTP arch-specific install', () => {
       const spec = '26'
       const osVersion = 'ubuntu-24.04'
 
-      assert.rejects(
+      await assert.rejects(
         async () => {
           await setupBeam.getOTPVersion(spec, osVersion)
         },
@@ -526,6 +582,7 @@ describe('OTP arch-specific install', () => {
         `Fetching OTP Version with invalid Github runner architecture is supposed to fail`,
       )
     }
+
     process.env.RUNNER_ARCH = previousRunnerArch
   })
 })
@@ -536,77 +593,65 @@ describe('.getOTPVersion(_) - Elixir', () => {
   let spec
   let otpVersion
   let before
-  const hexMirrors = simulateInput('hexpm-mirrors', 'https://repo.hex.pm', {
-    multiline: true,
-  })
 
-  it('returns the expected value', async () => {
+  if (process.platform === 'linux') {
-    spec = '1.1.x'
+    it('returns the expected value', async () => {
-    otpVersion = 'OTP-17'
+      spec = '1.18.x'
-    expected = 'v1.1.1-otp-17'
+      otpVersion = 'OTP-27'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      expected = 'v1.18.4-otp-27'
-    assert.deepStrictEqual(got, expected)
+      await setupBeam.installOTP(otpVersion)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
+      assert.deepStrictEqual(got, expected)
 
-    spec = '1.10.4'
+      spec = '1.18.2'
-    otpVersion = 'OTP-23'
+      otpVersion = 'OTP-27'
-    expected = 'v1.10.4-otp-23'
+      expected = 'v1.18.2-otp-27'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
+      assert.deepStrictEqual(got, expected)
 
-    spec = '1.16.2-otp-26'
+      spec = '1.16.2-otp-26'
-    otpVersion = 'OTP-27'
+      otpVersion = 'OTP-27'
-    expected = 'v1.16.2-otp-26'
+      expected = 'v1.16.2-otp-26'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
+      assert.deepStrictEqual(got, expected)
 
-    spec = '1.12.1'
+      spec = '1.12.1'
-    otpVersion = 'OTP-24.0.2'
+      otpVersion = 'OTP-24.3.4'
-    expected = 'v1.12.1-otp-24'
+      expected = 'v1.12.1-otp-24'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
+      assert.deepStrictEqual(got, expected)
 
-    before = simulateInput('version-type', 'strict')
+      before = simulateInput('version-type', 'strict')
-    spec = '1.14.0'
+      spec = '1.17'
-    otpVersion = 'main'
+      otpVersion = 'master'
-    expected = 'v1.14.0'
+      expected = 'v1.17-otp-27'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
-    simulateInput('version-type', before)
+      assert.deepStrictEqual(got, expected)
+      simulateInput('version-type', before)
 
-    before = simulateInput('version-type', 'strict')
+      before = simulateInput('version-type', 'strict')
-    spec = 'v1.11.0-rc.0'
+      spec = 'v1.15.0-rc.2'
-    otpVersion = 'OTP-23'
+      otpVersion = 'OTP-26.0'
-    expected = 'v1.11.0-rc.0-otp-23'
+      expected = 'v1.15.0-rc.2-otp-26'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
-    simulateInput('version-type', before)
+      assert.deepStrictEqual(got, expected)
+      simulateInput('version-type', before)
 
-    before = simulateInput('version-type', 'strict')
+      before = simulateInput('version-type', 'strict')
-    spec = 'v1.11.0-rc.0-otp-23'
+      spec = 'main'
-    otpVersion = 'OTP-23'
+      otpVersion = '25.2'
-    expected = 'v1.11.0-rc.0-otp-23'
+      expected = 'main-otp-25'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
+      await setupBeam.installOTP(otpVersion)
-    assert.deepStrictEqual(got, expected)
+      got = await setupBeam.getElixirVersion(spec, otpVersion)
-    simulateInput('version-type', before)
+      assert.deepStrictEqual(got, expected)
-
+      simulateInput('version-type', before)
-    before = simulateInput('version-type', 'strict')
+    })
-    spec = 'v1.11.0'
+  }
-    otpVersion = '22.3.4.2'
-    expected = 'v1.11.0-otp-22'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
-    assert.deepStrictEqual(got, expected)
-    simulateInput('version-type', before)
-
-    before = simulateInput('version-type', 'strict')
-    spec = 'main'
-    otpVersion = '23.1'
-    expected = 'main-otp-23'
-    got = await setupBeam.getElixirVersion(spec, otpVersion)
-    assert.deepStrictEqual(got, expected)
-    simulateInput('version-type', before)
-  })
-
-  simulateInput('hexpm-mirrors', hexMirrors, { multiline: true })
 })
 
 describe('.getOTPVersion(_) - Gleam', () => {
@@ -622,6 +667,12 @@ describe('.getOTPVersion(_) - Gleam', () => {
     got = await setupBeam.getGleamVersion(spec, otpVersion)
     assert.deepStrictEqual(got, expected)
 
+    spec = 'nightly'
+    otpVersion = '28'
+    expected = 'nightly'
+    got = await setupBeam.getGleamVersion(spec, otpVersion)
+    assert.deepStrictEqual(got, expected)
+
     spec = '0.13.2'
     otpVersion = 'OTP-24'
     expected = 'v0.13.2'
@@ -875,11 +926,21 @@ describe('.getVersionFromSpec(_)', () => {
     got = setupBeam.getVersionFromSpec(spec, matrix.otp['ubuntu-20.04'])
     assert.deepStrictEqual(got, expected)
 
+    spec = '> 0'
+    expected = 'OTP-26.2.5'
+    got = setupBeam.getVersionFromSpec(spec, matrix.otp['ubuntu-22.04'])
+    assert.deepStrictEqual(got, expected)
+
     spec = 'latest'
     expected = 'OTP-27.0-rc3'
     got = setupBeam.getVersionFromSpec(spec, matrix.otp['ubuntu-22.04'])
     assert.deepStrictEqual(got, expected)
 
+    spec = '> 0'
+    expected = 'OTP-27.0'
+    got = setupBeam.getVersionFromSpec(spec, matrix.otp['ubuntu-24.04'])
+    assert.deepStrictEqual(got, expected)
+
     spec = 'latest'
     expected = 'OTP-27.0'
     got = setupBeam.getVersionFromSpec(spec, matrix.otp['ubuntu-24.04'])
@@ -917,23 +978,25 @@ describe('.getVersionFromSpec(_)', () => {
   })
 })
 
-describe('version file', () => {
+describe('.tool-versions file', () => {
   const otpVersion = unsimulateInput('otp-version')
   const elixirVersion = unsimulateInput('elixir-version')
   const gleamVersion = unsimulateInput('gleam-version')
-  const rebar3Version = unsimulateInput('rebar3-version')
 
   it('is parsed correctly', async () => {
-    const erlang = '27'
+    const erlang = '27.3.4.1'
-    const elixir = '1.17.0'
+    const elixir = '1.18.4'
-    const gleam = '0.23.0'
+    const gleam = '1.9.1'
-    const rebar3 = '3.24.0'
+    let toolVersions = `# a comment
-    const toolVersions = `# a comment
+erlang   ref:v${erlang}
-erlang   ref:v${erlang}# comment, no space, and ref:v
 elixir ref:${elixir}  # comment, with space and ref:
  not-gleam 0.23 # not picked up
-gleam ${gleam} \nrebar ${rebar3}`
+gleam ${gleam} \n`
     const filename = 'test/.tool-versions'
+    if (process.platform === 'win32') {
+      // Force \r\n to test in Windows
+      toolVersions = toolVersions.replace(/\n/g, '\r\n')
+    }
     fs.writeFileSync(filename, toolVersions)
     process.env.GITHUB_WORKSPACE = ''
     const appVersions = setupBeam.parseVersionFile(filename)
@@ -957,15 +1020,62 @@ gleam ${gleam} \nrebar ${rebar3}`
     assert.ok(async () => {
       await setupBeam.install('gleam', { toolVersion: gleam })
     })
+  })
+
+  simulateInput('otp-version', otpVersion)
+  simulateInput('elixir-version', elixirVersion)
+  simulateInput('gleam-version', gleamVersion)
+})
+
+describe('mise.toml file', () => {
+  const otpVersion = unsimulateInput('otp-version')
+  const elixirVersion = unsimulateInput('elixir-version')
+  const gleamVersion = unsimulateInput('gleam-version')
+
+  it('is parsed correctly', async () => {
+    const erlang = '27.3.4.1'
+    const elixir = '1.18.4'
+    const gleam = '1.9.1'
+    let miseToml = `[tools]
+"erlang" = "${erlang}"
+elixir = { version = "${elixir}", postinstall="mix deps.get" }  # comment, with space and ref:
+"not-gleam" = 0.23 # not picked up
+"gleam" = "${gleam}"
+[env]
+_.file = ".env"\n`
+    const filename = 'test/mise.toml'
+    if (process.platform === 'win32') {
+      // Force \r\n to test in Windows
+      miseToml = miseToml.replace(/\n/g, '\r\n')
+    }
+    fs.writeFileSync(filename, miseToml)
+    process.env.GITHUB_WORKSPACE = ''
+    const appVersions = setupBeam.parseVersionFile(filename)
+    assert.strictEqual(appVersions.get('erlang'), erlang)
+    assert.strictEqual(appVersions.get('elixir'), elixir)
+
+    const absoluteFilename = path.join(os.tmpdir(), 'mise.toml')
+    fs.writeFileSync(absoluteFilename, miseToml)
+
+    process.env.GITHUB_WORKSPACE = process.cwd()
+    const absoluteAppVersions = setupBeam.parseVersionFile(absoluteFilename)
+    assert.strictEqual(absoluteAppVersions.get('erlang'), erlang)
+    assert.strictEqual(absoluteAppVersions.get('elixir'), elixir)
+
     assert.ok(async () => {
-      await setupBeam.install('rebar3', { toolVersion: rebar3 })
+      await setupBeam.install('otp', { toolVersion: erlang })
+    })
+    assert.ok(async () => {
+      await setupBeam.install('elixir', { toolVersion: elixir })
+    })
+    assert.ok(async () => {
+      await setupBeam.install('gleam', { toolVersion: gleam })
     })
   })
 
   simulateInput('otp-version', otpVersion)
   simulateInput('elixir-version', elixirVersion)
   simulateInput('gleam-version', gleamVersion)
-  simulateInput('rebar3-version', rebar3Version)
 })
 
 describe('.get(_)', () => {
@@ -1059,6 +1169,98 @@ describe("Elixir Mix matcher's", () => {
   })
 })
 
+describe("Erlang matcher's", () => {
+  it('erlc errors are properly matched', () => {
+    const [matcher] = erlangProblemMatcher.find(
+      ({ owner }) => owner === 'erlc-error',
+    ).pattern
+
+    const output = 'src/mymod.erl:42:5: head mismatch'
+    const match = output.match(matcher.regexp)
+    assert.equal(match[1], 'src/mymod.erl')
+    assert.equal(match[2], '42')
+    assert.equal(match[3], '5')
+    assert.equal(match[4], 'head mismatch')
+  })
+
+  it('erlc errors do not match warnings', () => {
+    const [matcher] = erlangProblemMatcher.find(
+      ({ owner }) => owner === 'erlc-error',
+    ).pattern
+
+    const output = 'src/mymod.erl:42:5: Warning: variable X is unused'
+    const match = output.match(matcher.regexp)
+    assert.equal(match, null)
+  })
+
+  it('erlc warnings are properly matched', () => {
+    const [matcher] = erlangProblemMatcher.find(
+      ({ owner }) => owner === 'erlc-warning',
+    ).pattern
+
+    const output = 'src/mymod.erl:10:3: Warning: variable X is unused'
+    const match = output.match(matcher.regexp)
+    assert.equal(match[1], 'src/mymod.erl')
+    assert.equal(match[2], '10')
+    assert.equal(match[3], '3')
+    assert.equal(match[4], 'variable X is unused')
+  })
+
+  it('dialyzer warnings are matched via erlc patterns', () => {
+    const [matcher] = erlangProblemMatcher.find(
+      ({ owner }) => owner === 'erlc-warning',
+    ).pattern
+
+    const output =
+      'src/mymod.erl:25:1: warning: Function foo/0 has no local return'
+    const match = output.match(matcher.regexp)
+    assert.equal(match[1], 'src/mymod.erl')
+    assert.equal(match[2], '25')
+    assert.equal(match[3], '1')
+    assert.equal(match[4], 'Function foo/0 has no local return')
+  })
+
+  it('CT failures are properly matched', () => {
+    const [filePattern, reasonPattern] = erlangProblemMatcher.find(
+      ({ owner }) => owner === 'ct-failure',
+    ).pattern
+
+    const firstOutput = 'test/mymod_SUITE.erl failed on line 55'
+    const secondOutput = 'Reason: {badmatch,{error,timeout}}'
+
+    const fileMatch = firstOutput.match(filePattern.regexp)
+    assert.equal(fileMatch[1], 'test/mymod_SUITE.erl')
+    assert.equal(fileMatch[2], '55')
+
+    const reasonMatch = secondOutput.match(reasonPattern.regexp)
+    assert.equal(reasonMatch[1], '{badmatch,{error,timeout}}')
+  })
+
+  it('EUnit failures are properly matched', () => {
+    const [headerPattern, funcPattern, callPattern, errorPattern] =
+      erlangProblemMatcher.find(
+        ({ owner }) => owner === 'eunit-failure',
+      ).pattern
+
+    const header = 'mymod_test: hello_test....*failed*'
+    const func =
+      'in function mymod_test:hello_test/0 (test/mymod_test.erl, line 12)'
+    const call = 'in call from mymod_test:hello_test/0'
+    const error = '**error:{badmatch,false}'
+
+    assert.ok(header.match(headerPattern.regexp))
+
+    const funcMatch = func.match(funcPattern.regexp)
+    assert.equal(funcMatch[1], 'test/mymod_test.erl')
+    assert.equal(funcMatch[2], '12')
+
+    assert.ok(call.match(callPattern.regexp))
+
+    const errorMatch = error.match(errorPattern.regexp)
+    assert.equal(errorMatch[1], '{badmatch,false}')
+  })
+})
+
 function unsimulateInput(key) {
   return simulateInput(key, '')
 }