test-suite.yml

name: test suite

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
  workflow_dispatch:
  schedule:
    - cron: "17 5 * * 0"

concurrency:
  group: ci-${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  neomacs-workspace-test-archive:
    name: workspace test archive (linux x86_64)
    runs-on: ubuntu-24.04
    timeout-minutes: 90
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      # A release workspace test archive links 96 test binaries (37 from
      # neomacs-tui-tests alone), each statically linking neovm-core and
      # Cranelift. Linking, not compiling, dominates this job (~21 of 29
      # minutes), so: lld runs multi-threaded, rustc and links share the
      # runner's 4 cores (binaries are stripped of debuginfo, which keeps
      # concurrent link RSS well below 16 GB), and test code uses relaxed
      # codegen-units — the perf-critical neomacs runtime ships from the
      # separate test-runtime job, never from these harness binaries.
      # If this OOMs on a hosted runner, halve CARGO_BUILD_JOBS before
      # ever re-serializing the linker.
      CARGO_BUILD_JOBS: "4"
      CARGO_PROFILE_RELEASE_LTO: "false"
      CARGO_PROFILE_RELEASE_CODEGEN_UNITS: "16"
      RUSTFLAGS: "-C link-arg=-fuse-ld=lld"
      TMPDIR: ${{ github.workspace }}/tmp
    steps:
      - &checkout
        name: Checkout
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - &prepare_workspace_tmp
        name: Prepare workspace temp directory
        run: mkdir -p "$TMPDIR/nextest"
      - uses: ./.github/actions/install-build-deps
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-workspace-archive-linux-x86_64
          cache-shared-key: linux-x86_64-release
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true

      - name: Build and archive workspace tests
        run: |
          cargo nextest archive \
            --release \
            --workspace \
            --archive-file neomacs-workspace-tests.tar.zst

      - name: Upload workspace test archive
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: neomacs-workspace-tests-nextest-archive-linux-x86_64
          path: neomacs-workspace-tests.tar.zst
          if-no-files-found: error
          retention-days: 1

  neomacs-melpa-direct-windows-tests:
    name: MELPA direct adapter Job Object contracts (windows x86_64)
    if: ${{ github.event_name != 'schedule' }}
    runs-on: windows-latest
    timeout-minutes: 30
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
    steps:
      - *checkout

      - name: Prepare workspace temp directory
        shell: pwsh
        run: |
          $taskTmp = Join-Path $env:GITHUB_WORKSPACE 'tmp'
          New-Item -ItemType Directory -Force -Path $taskTmp | Out-Null
          "TMPDIR=$taskTmp" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
          "TMP=$taskTmp" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
          "TEMP=$taskTmp" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append

      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-windows-direct-adapter-x86_64
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true

      - name: Run native Windows direct adapter contracts
        run: >-
          cargo nextest run
          -p neomacs-melpa-tests
          -E 'test(/direct_windows_/)'
          --success-output immediate
          --no-fail-fast

  neovm-core-tests:
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive]
    uses: ./.github/workflows/nextest-shards.yml
    with:
      suite: core

  gnu-emacs-oracle:
    name: GNU Emacs oracle (linux x86_64)
    runs-on: ubuntu-24.04
    timeout-minutes: 45
    steps:
      - *checkout

      # Warm the per-commit cache of the pinned GNU reference once, while the
      # runtime and test archives build, so the tui shards and the MELPA and
      # GUI parity jobs each restore one cached build instead of compiling
      # Emacs twenty-odd times in parallel on a cache miss.
      - name: Install Linux system dependencies
        run: scripts/ci/setup-linux.sh oracle

      - name: Set up GNU Emacs oracle
        uses: ./.github/actions/setup-gnu-emacs

  neomacs-test-runtime:
    name: Packaged Neomacs Runtime (linux x86_64)
    runs-on: ubuntu-24.04
    timeout-minutes: 150
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - uses: ./.github/actions/install-build-deps
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-shared-runtime-linux-x86_64
          cache-shared-key: linux-x86_64-release
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      - name: Build fresh release runtime
        run: cargo xtask fresh-build --release

      - name: Smoke the pdump relocating fallback (NEOVM_PDUMP_NO_FIXED_MAP)
        run: |
          # The planned-base hit path skips relocation validation wholesale;
          # this keeps the delta-apply fallback (and its bounds checks) green
          # forever. A green lane on purpose — the standing-red display jobs
          # would hide a fallback regression.
          NEOVM_PDUMP_NO_FIXED_MAP=1 target/release/neomacs --batch -Q --eval '(kill-emacs 0)'

      - name: Run upstream GNU SQLite ERT suite
        run: >-
          target/release/neomacs
          --batch -Q
          -l test/src/sqlite-tests.el
          -f ert-run-tests-batch-and-exit

      - name: Run unchanged upstream GNU file-notify ERT suite
        env:
          REMOTE_TEMPORARY_FILE_DIRECTORY: /dev/null
        run: |
          mkdir -p "$PWD/target/file-notify-ert-tmp"
          TMPDIR="$PWD/target/file-notify-ert-tmp" \
            target/release/neomacs --batch -Q \
              -l test/lisp/filenotify-tests.el \
              -f ert-run-tests-batch-and-exit

      # The standing detector for the missing-GC-root class (DIVERGENCES.md
      # 161/162). This collector is precise, so a Lisp value that rides Rust
      # control flow is invisible to trace_roots unless it was rooted
      # deliberately -- and such a bug is invisible to an ordinary green suite:
      # the whole 38k-pin oracle suite was green on BOTH sides of 161's
      # use-after-free. NEOVM_GC_STRESS=1 collects at every allocation-bearing
      # safe point, which turns "sometimes" into "always".
      - name: GC-stress the shipped runtime
        run: cargo xtask gc-stress

      # Exercise install.sh end-to-end against a release-shaped tree built
      # from THIS commit (file:// download base), so the curl|bash path --
      # download, checksum, versioned install, symlink chain, runtime-root
      # resolution with no environment variables -- is proven before any
      # release publishes it.
      #
      # BOTH tarball shapes are staged, because install.sh has a branch for
      # each and a release that only exercises one of them ships the other
      # untested: the current layout, whose dump sits in the archlib
      # (libexec/neomacs/<version>/<triple>, GNU's archlibdir), and the
      # pre-0.0.16 layout, whose dump sits in bin/ -- which --tag still has to
      # be able to install.
      - name: Verify install.sh against a staged release tree
        run: |
          set -eux
          triple=x86_64-unknown-linux-gnu
          crate_version="$(
            awk '/^\[workspace\.package\]/{s=1;next} /^\[/{s=0}
                 s && /^version[[:space:]]*=/{gsub(/^version[[:space:]]*=[[:space:]]*"/,"");gsub(/".*$/,"");print;exit}' \
              Cargo.toml
          )"
          archlib="libexec/neomacs/$crate_version/$triple"

          stage_release() {
            local version="$1" layout="$2"
            local stage_root="$TMPDIR/install-release-$layout"
            local staged="$stage_root/v$version"
            local pkg_parent="$stage_root/pkg"
            local pkg="$pkg_parent/neomacs-$version-$triple"
            rm -rf "$stage_root"
            mkdir -p "$staged" "$pkg/bin" "$pkg/share/neomacs"
            cp target/release/neomacs target/release/neomacsclient "$pkg/bin/"
            if [ "$layout" = archlib ]; then
              mkdir -p "$pkg/$archlib"
              cp target/release/neomacs.pdump "$pkg/$archlib/neomacs.pdump"
            else
              cp target/release/neomacs.pdump "$pkg/bin/neomacs.pdump"
            fi
            cp -r lisp etc "$pkg/share/neomacs/"
            tar czf "$staged/neomacs-$version-$triple.tar.gz" \
              -C "$pkg_parent" "neomacs-$version-$triple"
            ( cd "$staged" && sha256sum "neomacs-$version-$triple.tar.gz" > SHA256SUMS )
            local prefix="$stage_root/prefix"
            NEOMACS_DOWNLOAD_BASE="file://$stage_root" \
              sh install.sh --tag "v$version" --prefix "$prefix"
            test -x "$prefix/bin/neomacs"
            test "$(readlink "$prefix/share/neomacs/current")" = "versions/$version"
            test "$(readlink "$prefix/bin/neomacs")" = "../share/neomacs/current/bin/neomacs"
            local exe ver_dir
            exe="$(readlink -f "$prefix/bin/neomacs")"
            ver_dir="$(dirname "$(dirname "$exe")")"
            if [ "$layout" = archlib ]; then
              test -f "$ver_dir/$archlib/neomacs.pdump"
              test ! -f "$(dirname "$exe")/neomacs.pdump"
              # exec-directory is PATH_EXEC (GNU src/callproc.c:1961), so the
              # installed tree has to answer with its own archlib.
              env -u NEOMACS_RUNTIME_ROOT -u EMACSPATH \
                "$prefix/bin/neomacs" --batch \
                --eval "(princ exec-directory)" | grep -Fx "$ver_dir/$archlib/"
            else
              test -f "$(dirname "$exe")/neomacs.pdump"
            fi
            test -d "$ver_dir/share/neomacs/lisp"
            env -u NEOMACS_RUNTIME_ROOT \
              "$prefix/bin/neomacs" --batch --eval '(princ (emacs-version))'
          }

          stage_release citest archlib
          stage_release citestlegacy legacy

      - name: Package shared test runtime
        run: |
          test -x target/release/neomacs
          test -f target/release/neomacs.pdump
          test -f lisp/international/charscript.el
          test -f lisp/international/charprop.el
          test -d etc/charsets
          tar czf neomacs-test-runtime-linux-x86_64.tar.gz \
            target/release/neomacs \
            target/release/neomacs.pdump \
            lisp \
            etc

      - name: Upload shared test runtime
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: neomacs-test-runtime-linux-x86_64
          path: neomacs-test-runtime-linux-x86_64.tar.gz
          if-no-files-found: error
          retention-days: 1

  neovm-oracle-tests:
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive]
    uses: ./.github/workflows/nextest-shards.yml
    with:
      suite: oracle

  neomacs-tui-tests:
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive, gnu-emacs-oracle]
    uses: ./.github/workflows/nextest-shards.yml
    with:
      suite: tui

  neomacs-melpa-tests:
    name: MELPA ${{ matrix.suite }} compatibility and GNU parity (linux x86_64)
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive, gnu-emacs-oracle]
    runs-on: ubuntu-24.04
    timeout-minutes: 30
    strategy:
      fail-fast: false
      matrix:
        include:
          - suite: batch
            filter: binary_id(=neomacs-melpa-test-support)|(binary_id(=neomacs-melpa-tests)-test(~gui_parity_tests::))
          - suite: tui
            filter: binary_id(=neomacs-melpa-tests::melpa_tui)
          - suite: gui
            filter: binary_id(=neomacs-melpa-tests)&test(~gui_parity_tests::)
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
      NEXTEST_FILTER: ${{ matrix.filter }}
      NEOMACS_BIN: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_RUNTIME_ROOT: ${{ github.workspace }}
      NEOMACS_MELPA_ORACLE_EMACS: /opt/gnu-emacs-oracle/bin/emacs
      NEOMACS_GUI_TEST_BACKEND: x11
      NEOMACS_GUI_TEST_BINARY: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_GUI_TEST_GNU_EMACS: /opt/gnu-emacs-oracle/bin/emacs
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - name: Install Linux ecosystem dependencies
        run: scripts/ci/setup-linux.sh ecosystem
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-melpa-${{ matrix.suite }}
          # Runs prebuilt binaries out of the downloaded nextest archive and
          # never invokes rustc, so a Cargo build cache here can never be read
          # back.  Measured: these entries were ~246 MiB each and carried the
          # SAME content hash as each other, in a 10 GiB store whose overflow
          # was evicting the release caches.
          cache: "false"
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true
      - &download_test_runtime
        name: Download shared test runtime
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: neomacs-test-runtime-linux-x86_64
          path: .

      - &unpack_test_runtime
        name: Unpack shared test runtime
        run: |
          tar xzf neomacs-test-runtime-linux-x86_64.tar.gz
          chmod +x target/release/neomacs
          test -f lisp/international/charscript.el
          test -f lisp/international/charprop.el

      - &download_workspace_test_archive
        name: Download workspace test archive
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: neomacs-workspace-tests-nextest-archive-linux-x86_64
          path: .

      - name: Install Nix for exact MELPA test runtimes
        uses: cachix/install-nix-action@13d8dd58da0234aa297dedd986986ccb8e7f3e24 # v31

      # After the MELPA Nix install so the action reuses that Nix instead of
      # provisioning its own.
      - name: Set up GNU Emacs oracle
        uses: ./.github/actions/setup-gnu-emacs

      - name: Run deterministic package ecosystem compatibility tests
        env:
          NEOMACS_TUI_RECORD: ${{ matrix.suite == 'tui' && 'on' || 'off' }}
        run: |
          cargo nextest run \
            --archive-file neomacs-workspace-tests.tar.zst \
            --extract-to "$TMPDIR/nextest" \
            -E "$NEXTEST_FILTER" \
            --workspace-remap "$GITHUB_WORKSPACE" \
            --success-output immediate \
            --no-fail-fast

      - name: Upload MELPA TUI recordings
        if: matrix.suite == 'tui' && always()
        uses: ./.github/actions/upload-tui-recordings
        with:
          artifact-name: neomacs-melpa-tui-recordings-${{ github.run_id }}

  neomacs-display-tests:
    name: display stack tests (linux x86_64)
    if: ${{ github.event_name != 'schedule' }}
    needs: neomacs-workspace-test-archive
    runs-on: ubuntu-24.04
    timeout-minutes: 60
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
      NEXTEST_FILTER: "package(neomacs-display-protocol)|package(neomacs-display-runtime)|package(neomacs-layout-engine)|package(neomacs-renderer-wgpu)"
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - uses: ./.github/actions/install-build-deps
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-display-tests
          # Runs prebuilt binaries out of the downloaded nextest archive and
          # never invokes rustc, so a Cargo build cache here can never be read
          # back.  Measured: these entries were ~246 MiB each and carried the
          # SAME content hash as each other, in a 10 GiB store whose overflow
          # was evicting the release caches.
          cache: "false"
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true
      - *download_workspace_test_archive

      - name: Run display stack tests
        run: |
          cargo nextest run \
            --archive-file neomacs-workspace-tests.tar.zst \
            --extract-to "$TMPDIR/nextest" \
            -E "$NEXTEST_FILTER" \
            --workspace-remap "$GITHUB_WORKSPACE" \
            --no-fail-fast

  neomacs-prefix-face-tui-parity:
    name: GNU prefix face TUI parity (linux x86_64)
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive, gnu-emacs-oracle]
    runs-on: ubuntu-24.04
    timeout-minutes: 30
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
      NEOMACS_TUI_NEOMACS_BIN: ${{ github.workspace }}/target/release/neomacs
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - name: Install GNU Emacs oracle dependencies
        run: scripts/ci/setup-linux.sh oracle
      - name: Set up GNU Emacs oracle
        uses: ./.github/actions/setup-gnu-emacs
      - name: Set up test runner
        uses: ./.github/actions/setup-rust
        with:
          # This job executes the archived test binary against the shared
          # fresh-build runtime and never invokes rustc.
          cache: "false"
          cache-key: ci-prefix-face-tui-parity
          install-nextest: true
      - *download_test_runtime
      - *unpack_test_runtime
      - *download_workspace_test_archive

      - name: Compare buffer-remapped prefix faces with GNU Emacs
        env:
          NEOMACS_TUI_RECORD: on
        run: |
          cargo nextest run \
            --archive-file neomacs-workspace-tests.tar.zst \
            --extract-to "$TMPDIR/nextest" \
            -E 'package(neomacs-tui-tests) and test(~line_and_wrap_prefix_named_face_remapping_match_gnu)' \
            --workspace-remap "$GITHUB_WORKSPACE" \
            --no-fail-fast

      - name: Upload prefix-face TUI recordings
        if: always()
        uses: ./.github/actions/upload-tui-recordings
        with:
          artifact-name: neomacs-prefix-face-tui-recordings-${{ github.run_id }}

  neomacs-gui-tests:
    name: real GUI tests (linux x86_64, X11 + Wayland)
    if: ${{ github.event_name != 'schedule' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive, gnu-emacs-oracle]
    runs-on: ubuntu-24.04
    timeout-minutes: 60
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
      NEOMACS_GUI_TEST_BACKEND: x11
      NEOMACS_GUI_TEST_BINARY: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_GUI_TEST_GNU_EMACS: /opt/gnu-emacs-oracle/bin/emacs
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - name: Install Linux ecosystem dependencies
        run: scripts/ci/setup-linux.sh ecosystem
      - name: Set up GNU Emacs oracle
        uses: ./.github/actions/setup-gnu-emacs
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-real-gui-tests
          # Runs prebuilt binaries out of the downloaded nextest archive and
          # never invokes rustc, so a Cargo build cache here can never be read
          # back.  Measured: these entries were ~246 MiB each and carried the
          # SAME content hash as each other, in a 10 GiB store whose overflow
          # was evicting the release caches.
          cache: "false"
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true
      - *download_test_runtime
      - *unpack_test_runtime
      - *download_workspace_test_archive

      - name: Prepare pinned GUI package fixtures
        run: bash scripts/ci/setup-gui-test-packages.sh

      - name: Run real GUI tests
        run: |
          cargo nextest run \
            --archive-file neomacs-workspace-tests.tar.zst \
            --extract-to "$TMPDIR/nextest" \
            -E 'package(neomacs-gui-tests)' \
            --workspace-remap "$GITHUB_WORKSPACE" \
            --no-fail-fast

      - name: Upload GUI diagnostics
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: neomacs-gui-tests-linux-${{ github.run_id }}
          path: |
            target/neomacs-gui-tests
            tmp/neomacs-gui-tests
          if-no-files-found: ignore
          retention-days: 14

  neomacs-melpa-live-canary:
    name: MELPA live ecosystem canary (linux x86_64)
    if: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
    needs: [neomacs-test-runtime, neomacs-workspace-test-archive, gnu-emacs-oracle]
    runs-on: ubuntu-24.04
    timeout-minutes: 30
    env:
      CARGO_TERM_COLOR: always
      RUST_BACKTRACE: 1
      TMPDIR: ${{ github.workspace }}/tmp
      NEOMACS_BIN: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_RUNTIME_ROOT: ${{ github.workspace }}
      NEOMACS_MELPA_ORACLE_EMACS: /opt/gnu-emacs-oracle/bin/emacs
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - name: Install Linux ecosystem dependencies
        run: scripts/ci/setup-linux.sh ecosystem
      - name: Set up GNU Emacs oracle
        uses: ./.github/actions/setup-gnu-emacs
      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: ci-melpa-live-canary
          # Runs prebuilt binaries out of the downloaded nextest archive and
          # never invokes rustc, so a Cargo build cache here can never be read
          # back.  Measured: these entries were ~246 MiB each and carried the
          # SAME content hash as each other, in a 10 GiB store whose overflow
          # was evicting the release caches.
          cache: "false"
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
          install-nextest: true
      - *download_test_runtime
      - *unpack_test_runtime
      - *download_workspace_test_archive

      - name: Run current MELPA ecosystem canary
        run: |
          cargo nextest run \
            --archive-file neomacs-workspace-tests.tar.zst \
            --extract-to "$TMPDIR/nextest" \
            --run-ignored only \
            -E 'package(neomacs-melpa-tests) and test(=live_melpa_ecosystem_installs_and_survives_restart)' \
            --workspace-remap "$GITHUB_WORKSPACE" \
            --success-output immediate \
            --no-fail-fast

  doom-install-compatibility:
    name: doom install compatibility (linux x86_64)
    if: ${{ github.event_name != 'schedule' }}
    needs: neomacs-test-runtime
    runs-on: ubuntu-24.04
    timeout-minutes: 60
    env:
      TMPDIR: ${{ github.workspace }}/tmp
      NEOMACS_BIN: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_RUNTIME_ROOT: ${{ github.workspace }}
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - uses: ./.github/actions/install-build-deps
      - *download_test_runtime
      - *unpack_test_runtime

      - name: Install unmodified Doom with Neomacs
        run: ./scripts/test-doom-install.sh

  # A separate job rather than a second matrix arm, because the darwin side
  # shares nothing with Linux beyond the script itself. There is no packaged
  # darwin runtime to restore: the shared artifact is linux-x86_64 by
  # construction and a Linux binary cannot run on darwin, so this arm compiles
  # what it tests. A matrix would also force it to `needs:
  # neomacs-test-runtime` -- waiting up to 150 minutes on a Linux artifact it
  # never reads, for no ordering benefit.
  doom-install-compatibility-macos:
    name: doom install compatibility (macos aarch64)
    if: ${{ github.event_name != 'schedule' }}
    runs-on: macos-latest
    timeout-minutes: 120
    env:
      TMPDIR: ${{ github.workspace }}/tmp
      NEOMACS_BIN: ${{ github.workspace }}/target/release/neomacs
      NEOMACS_RUNTIME_ROOT: ${{ github.workspace }}
    steps:
      - *checkout
      - *prepare_workspace_tmp
      - uses: ./.github/actions/install-build-deps

      - name: Set up Rust tooling
        uses: ./.github/actions/setup-rust
        with:
          cache-key: doom-install-macos
          target: aarch64-apple-darwin

      - name: Build the runtime this job installs Doom into
        run: cargo xtask fresh-build --release

      - name: Install unmodified Doom with Neomacs
        run: ./scripts/test-doom-install.sh