@zackees/soldr 0.8.29 → 0.8.31

package/README.md

@@ -421,30 +421,29 @@ If you also have many separate test binaries, consider consolidating them under
 
 ## Architecture
 
-**Monocrate.** A single Rust crate `soldr-cli` under `crates/soldr-cli/`, with four module trees inside it. The earlier four-crate workspace (`soldr-core` / `soldr-fetch` / `soldr-cache` / `soldr-cli`) was collapsed in 2026-05; the regression guard `crates/soldr-cli/tests/monocrate_guard.rs` fails the build if anyone reintroduces a second crate.
+**Internal workspace crates.** Five `publish = false` crates under `crates/`. The 2026-05 monocrate collapse was reversed by the #1490 split; soldr publishes no crates, so workspace membership has no external surface, and `soldr-cli` re-exports the others at their historical paths (`soldr_cli::core`, `soldr_cli::fetch`, …) so existing imports are unchanged.
 
 ```
 soldr/
 |-- crates/
-|   `-- soldr-cli/
-|       |-- src/
-|       |   |-- core/            # Shared types, config, cache paths (formerly soldr-core)
-|       |   |-- fetch/           # Binary resolution + download (formerly soldr-fetch)
-|       |   |-- cache_lib/       # RUSTC_WRAPPER + daemon IPC (formerly soldr-cache)
-|       |   `-- main.rs + cli/   # Mode detection, dispatch, cargo front door
-|       `-- tests/
+|   |-- soldr-core/               # Shared types, config, target resolution, wire schema
+|   |-- soldr-fetch/              # Binary resolution + download
+|   |-- soldr-cache/              # RUSTC_WRAPPER + daemon IPC + archive transport
+|   |-- soldr-daemon/             # Daemon runtime + embedded zccache service
+|   `-- soldr-cli/                # Facade + the `soldr` binary
 |-- src/soldr/                    # Python package (maturin bin bindings)
 `-- tests/
 ```
 
-| Module | Role |
+| Crate | Role |
 |---|---|
-| `src/core/` | Shared types, config (`~/.soldr/config.toml`), target-triple resolution (MSVC default on Windows), cache paths, error types. No I/O beyond config files. |
-| `src/fetch/` | Binary resolution. `known_tools` registry, `trust` (SHA-256 pins + `SOLDR_TRUST_MODE` enforcement), rustup auto-bootstrap, resolution chain (local cache → repo lookup → GitHub Releases → extract). |
-| `src/cache_lib/` | `RUSTC_WRAPPER` mode: hash inputs (blake3), check `~/.soldr/cache/`, daemon IPC (Unix socket / Windows named pipe), LRU eviction, `soldr save` / `soldr load` archive transport, auto-GC. |
-| `src/main.rs` + cli/ | Mode detection (chameleon dispatch), clap for built-ins, exec for tool fetch, cargo front door (`soldr cargo ...`). |
+| `soldr-core` | Shared types, config (`~/.soldr/config.toml`), target-triple resolution (MSVC default on Windows), the daemon wire schema, error types, the `timed_test!` watchdog. No I/O beyond config files. |
+| `soldr-fetch` | Binary resolution. `known_tools` registry, `trust` (SHA-256 pins + `SOLDR_TRUST_MODE` enforcement), rustup auto-bootstrap, resolution chain (local cache → repo lookup → GitHub Releases → extract). |
+| `soldr-cache` | `RUSTC_WRAPPER` mode: hash inputs (blake3), check `~/.soldr/cache/`, daemon IPC (Unix socket / Windows named pipe), LRU eviction, `soldr save` / `soldr load` archive transport, auto-GC. |
+| `soldr-daemon` | Daemon lifecycle (spawn/displacement/relocation), IPC server, wire codec, and the embedded zccache service. Depends on `soldr-core` + `soldr-cache`. |
+| `soldr-cli` | Mode detection (chameleon dispatch), clap for built-ins, exec for tool fetch, cargo front door (`soldr cargo ...`), and the `[[bin]]` entry point. |
 
-A thin `src/lib.rs` re-exports `pub mod core; pub mod fetch; pub mod cache_lib;` so the library integration tests can keep `use soldr_cli::core::*`-style imports. This is not a supported public Rust library API.
+Dependency flow: every crate reaches into `core` for shared types; `fetch` and `cache` each consume `core`; `daemon` consumes `core` + `cache`; `cli` consumes all four. The re-exports are for internal consumers and tests — this is not a supported public Rust library API.
 
 ## Prior art
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zackees/soldr",
-  "version": "0.8.29",
+  "version": "0.8.31",
   "description": "Instant Rust tools and builds from one command.",
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/zackees/soldr",

package/scripts/install.js

@@ -40,49 +40,97 @@ const TARGETS = {
 // time based on `target.binary`.
 const BUNDLED_BINARIES = zccacheContract.RELEASE_BUNDLED_BINARIES;
 
-// Detect whether the running Linux uses musl or glibc. Three layered probes:
-//   1. process.report.header.glibcVersionRuntime is the documented Node
-//      surface for runtime glibc version — present on glibc, absent /
-//      empty on musl. Same approach used by @swc/core, @napi-rs/*, etc.
-//   2. Filesystem check for `/lib/ld-musl-*.so.1` covers cases where the
-//      Node binary itself is glibc (e.g. someone running glibc Node on
-//      alpine via apk add nodejs-current) but the system is musl — the
-//      soldr binary we download must match the SYSTEM libc, not Node's.
-//   3. Final fallback: assume glibc. The mismatch will surface
-//      immediately at runtime as "soldr: not found" or
-//      "soldr: error while loading shared libraries", which is louder
-//      than silently downloading the wrong tarball.
-function detectLibc(platform = process.platform) {
+// The lowest glibc a host must have before the `-gnu` artifact is worth
+// downloading (soldr#1060).
+//
+// Those artifacts are built natively on ubuntu-24.04, so they currently
+// require GLIBC_2.39 — measured on the published v0.8.29 binaries, x86_64 and
+// aarch64. On Debian 12 (glibc 2.36) the gnu binary dies with
+// "version `GLIBC_2.39' not found" while the musl artifact from the same
+// release runs fine, so "is this host glibc?" is the wrong question. The
+// question is "is this host's glibc new enough for the binary we ship?".
+//
+// Kept in lockstep with the `--max-glibc` ceiling in release-auto.yml by a
+// check in test-npm-package.js. When the release build is fixed to link
+// against a 2.17 baseline that ceiling drops, and this must follow it down.
+const MIN_GLIBC_FOR_GNU = "2.39";
+
+function compareVersions(left, right) {
+  // Numeric, part by part. A lexical compare would rank "2.9" above "2.39"
+  // and wave through a host that cannot run the binary.
+  const a = String(left).split(".").map((p) => parseInt(p, 10) || 0);
+  const b = String(right).split(".").map((p) => parseInt(p, 10) || 0);
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const diff = (a[i] || 0) - (b[i] || 0);
+    if (diff !== 0) {
+      return diff < 0 ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+// Decide which Linux artifact this host should download. Ordered probes:
+//
+//   1. A musl loader in /lib means the SYSTEM is musl, and that outranks
+//      whatever Node was linked against. This has to run first: a glibc Node
+//      on alpine (`apk add nodejs-current`) reports a perfectly good glibc
+//      version, so checking Node's header first would answer "gnu" and never
+//      consult the filesystem at all — which is precisely the case the probe
+//      was written for.
+//   2. Node's reported runtime glibc. This is the only source that gives a
+//      VERSION, and gnu is chosen only at or above MIN_GLIBC_FOR_GNU.
+//   3. Anything else → musl.
+//
+// musl is the safe end of every unknown because that artifact is verified
+// statically linked before it is ever staged (release-auto.yml → "Verify musl
+// binary is statically linked"), so it has no dynamic loader dependency and
+// runs on glibc hosts too. The mistakes are not symmetric:
+//
+//   pick musl, actually glibc      → works, nothing to resolve
+//   pick gnu,  actually musl       → hard failure, "soldr: not found"
+//   pick gnu,  glibc too old       → hard failure, "GLIBC_2.39 not found"
+//
+// Only the first is recoverable.
+//
+// `probes` exists so the branches can be tested on any host; the defaults are
+// the real detectors.
+function detectLibc(platform = process.platform, probes = {}) {
   if (platform !== "linux") {
     return null;
   }
+  const readHeader =
+    probes.readHeader ||
+    (() => process.report && process.report.getReport && process.report.getReport().header);
+  const listLib = probes.listLib || (() => fs.readdirSync("/lib"));
+
   try {
-    const header = process.report && process.report.getReport && process.report.getReport().header;
-    if (header && typeof header.glibcVersionRuntime === "string" && header.glibcVersionRuntime.length > 0) {
-      return "gnu";
-    }
-    if (header && Object.prototype.hasOwnProperty.call(header, "glibcVersionRuntime")) {
-      // Field present but empty / null → Node was built against musl.
+    const entries = listLib();
+    if (entries.some((name) => /^ld-musl-.+\.so\.1$/.test(name))) {
       return "musl";
     }
   } catch (err) {
-    // process.report can throw on locked-down environments; fall through.
+    // /lib may not be readable in heavily sandboxed containers; fall through.
   }
   try {
-    const entries = fs.readdirSync("/lib");
-    if (entries.some((name) => /^ld-musl-.+\.so\.1$/.test(name))) {
-      return "musl";
+    const header = readHeader();
+    const runtime = header && header.glibcVersionRuntime;
+    if (
+      typeof runtime === "string" &&
+      runtime.length > 0 &&
+      compareVersions(runtime, MIN_GLIBC_FOR_GNU) >= 0
+    ) {
+      return "gnu";
     }
   } catch (err) {
-    // /lib may not be readable in heavily sandboxed containers; fall through.
+    // process.report can throw on locked-down environments; fall through.
   }
-  return "gnu";
+  return "musl";
 }
 
 function platformTarget(platform = process.platform, arch = process.arch, libc = detectLibc(platform)) {
   const key =
     platform === "linux"
-      ? `${platform}-${arch}-${libc || "gnu"}`
+      ? `${platform}-${arch}-${libc || "musl"}`
       : `${platform}-${arch}`;
   const target = TARGETS[key];
   if (!target) {
@@ -153,6 +201,24 @@ function checksumFor(checksumsText, filename) {
   throw new Error(`checksum entry not found for ${filename}`);
 }
 
+// The integrity check for everything this package installs
+// (docs/TRUST_BOUNDARIES.md). Extracted from `install()` so it can be
+// tested: while it was inline, `checksumFor` was covered but the comparison
+// itself was not, so deleting the mismatch branch would have disabled
+// verification with every test still green.
+//
+// Throws rather than returning a boolean, because the only correct response
+// to a mismatch is to stop, and a caller that forgot to check a returned
+// false would install the archive anyway.
+function verifyArchiveChecksum(archive, checksumsText, filename) {
+  const expected = checksumFor(checksumsText, filename);
+  const actual = crypto.createHash("sha256").update(archive).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`checksum mismatch for ${filename}: expected ${expected}, got ${actual}`);
+  }
+  return actual;
+}
+
 function run(command, args, options = {}) {
   const result = childProcess.spawnSync(command, args, {
     stdio: "inherit",
@@ -232,11 +298,7 @@ async function install() {
       download(checksumUrl).then((buffer) => buffer.toString("utf8")),
     ]);
 
-    const expected = checksumFor(checksums, filename);
-    const actual = crypto.createHash("sha256").update(archive).digest("hex");
-    if (actual !== expected) {
-      throw new Error(`checksum mismatch for ${filename}: expected ${expected}, got ${actual}`);
-    }
+    verifyArchiveChecksum(archive, checksums, filename);
 
     const archivePath = path.join(tmp, filename);
     const extractDir = path.join(tmp, "extract");
@@ -312,9 +374,12 @@ if (require.main === module) {
 
 module.exports = {
   ARCHIVE_EXT,
+  MIN_GLIBC_FOR_GNU,
+  compareVersions,
   BUNDLED_BINARIES,
   TARGETS,
   checksumFor,
+  verifyArchiveChecksum,
   detectLibc,
   platformTarget,
   releaseBaseUrl,

package/scripts/test-npm-package.js

@@ -100,6 +100,12 @@ assert.strictEqual(
 // Default (no libc arg) falls back to detectLibc; on most CI hosts that's
 // gnu. We don't assert the triple here — just that the call resolves.
 assert.ok(install.platformTarget("linux", "x64").triple.startsWith("x86_64-unknown-linux-"));
+// An explicitly-unknown libc must take the runs-anywhere build, matching
+// detectLibc's own unknown case rather than contradicting it.
+assert.strictEqual(
+  install.platformTarget("linux", "x64", null).triple,
+  "x86_64-unknown-linux-musl",
+);
 assert.strictEqual(install.platformTarget("darwin", "x64").triple, "x86_64-apple-darwin");
 assert.strictEqual(install.platformTarget("darwin", "arm64").triple, "aarch64-apple-darwin");
 assert.strictEqual(install.platformTarget("win32", "x64").triple, "x86_64-pc-windows-msvc");
@@ -115,6 +121,193 @@ assert.strictEqual(install.detectLibc("win32"), null);
 const linuxLibc = install.detectLibc("linux");
 assert.ok(linuxLibc === "gnu" || linuxLibc === "musl", `unexpected libc: ${linuxLibc}`);
 
+// detectLibc's branches, driven through the probe seam so they are
+// exercised on every host rather than only on whichever libc CI runs.
+const throwingProbe = () => {
+  throw new Error("probe unavailable");
+};
+const NEW_ENOUGH = install.MIN_GLIBC_FOR_GNU;
+
+// Numeric version comparison. A lexical compare ranks "2.9" above "2.39"
+// and would wave through a host that cannot run the binary.
+assert.strictEqual(install.compareVersions("2.9", "2.39"), -1);
+assert.strictEqual(install.compareVersions("2.39", "2.9"), 1);
+assert.strictEqual(install.compareVersions("2.39", "2.39"), 0);
+assert.strictEqual(install.compareVersions("2.40", "2.39"), 1);
+assert.strictEqual(install.compareVersions("2.2.5", "2.14"), -1);
+
+// 1. A glibc new enough for the shipped artifact takes the gnu build.
+assert.strictEqual(
+  install.detectLibc("linux", {
+    readHeader: () => ({ glibcVersionRuntime: NEW_ENOUGH }),
+    listLib: () => ["ld-linux-x86-64.so.2", "libc.so.6"],
+  }),
+  "gnu",
+);
+
+// 2. A glibc that is too old must NOT take the gnu build. This is the live
+//    bug: Debian 12 reports 2.36, the published gnu binary requires
+//    GLIBC_2.39, and it dies with "version `GLIBC_2.39' not found" while the
+//    musl artifact from the same release runs fine.
+assert.strictEqual(
+  install.detectLibc("linux", {
+    readHeader: () => ({ glibcVersionRuntime: "2.36" }),
+    listLib: () => ["ld-linux-x86-64.so.2", "libc.so.6"],
+  }),
+  "musl",
+);
+
+// 3. A musl SYSTEM wins over whatever Node was linked against. Node built
+//    against glibc on alpine (`apk add nodejs-current`) reports a perfectly
+//    good glibc version, so the filesystem probe has to be consulted FIRST --
+//    otherwise this answers "gnu" and never looks at /lib at all.
+assert.strictEqual(
+  install.detectLibc("linux", {
+    readHeader: () => ({ glibcVersionRuntime: NEW_ENOUGH }),
+    listLib: () => ["ld-musl-x86_64.so.1"],
+  }),
+  "musl",
+);
+
+// 4. Real musl Node omits the property entirely (verified on node:22-alpine:
+//    hasOwnProperty is false, not present-and-empty).
+assert.strictEqual(
+  install.detectLibc("linux", {
+    readHeader: () => ({}),
+    listLib: () => ["ld-musl-x86_64.so.1"],
+  }),
+  "musl",
+);
+
+// 5. Both probes unavailable (heavily sandboxed container) -> musl, the only
+//    artifact that runs without knowing anything about the host.
+assert.strictEqual(
+  install.detectLibc("linux", { readHeader: throwingProbe, listLib: throwingProbe }),
+  "musl",
+);
+
+// 6. A glibc host whose version cannot be read is also unknown: /lib says
+//    glibc but carries no version, so the floor cannot be confirmed.
+assert.strictEqual(
+  install.detectLibc("linux", {
+    readHeader: throwingProbe,
+    listLib: () => ["ld-linux-x86-64.so.2", "libc.so.6"],
+  }),
+  "musl",
+);
+
+// The probe seam must not leak to other platforms: a non-Linux host still
+// short-circuits to null before any probe runs.
+assert.strictEqual(
+  install.detectLibc("darwin", { readHeader: throwingProbe, listLib: throwingProbe }),
+  null,
+);
+
+// MIN_GLIBC_FOR_GNU must track the ceiling release-auto.yml enforces on the
+// gnu BINARIES. If the release build is fixed to link a 2.17 baseline and that
+// ceiling drops, the installer must follow it down -- otherwise every glibc
+// host below 2.39 keeps being sent to musl long after gnu would work.
+//
+// Anchored on the script name rather than on any `--max-glibc`. release-auto
+// now passes that flag twice: 2.39 to verify_glibc_baseline.py for the
+// binaries, and 2.17 to verify_wheel_glibc.py for the wheel contents. A bare
+// match takes whichever appears first, so this was correct only by the order
+// the steps happen to sit in. Reorder them and the lockstep would demand the
+// installer drop to 2.17, routing glibc 2.17-2.38 hosts to a binary that needs
+// 2.39 -- the bug #2081 fixed, reintroduced by its own guard.
+function glibcCeilingsFor(workflowText, scriptName) {
+  const found = [];
+  const lines = workflowText.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    if (!lines[i].includes(scriptName)) {
+      continue;
+    }
+    // The invocation may be split across continuation lines, so look at the
+    // matching line and the few that follow it.
+    const window = lines.slice(i, i + 4).join("\n");
+    const match = window.match(/--max-glibc\s+([0-9][0-9.]*)/);
+    if (match) {
+      found.push(match[1]);
+    }
+  }
+  return found;
+}
+
+function glibcCeilingFor(workflowText, scriptName) {
+  const found = glibcCeilingsFor(workflowText, scriptName);
+  if (found.length === 0) {
+    return null;
+  }
+  // release-auto invokes verify_glibc_baseline.py twice -- once pre-staging on
+  // the built binary, once post-staging across the whole bundle. Returning the
+  // first would let the two drift apart with the installer silently following
+  // only one of them, which is the same order-dependence this function was
+  // written to remove.
+  const distinct = [...new Set(found)];
+  assert.strictEqual(
+    distinct.length,
+    1,
+    `release-auto.yml passes conflicting --max-glibc values to ${scriptName}: ` +
+      `${found.join(", ")}. They gate the same artifacts and must agree.`,
+  );
+  return distinct[0];
+}
+
+// Pin the anchoring itself: with the wheel invocation first, the binary
+// ceiling must still resolve to the binary ceiling.
+{
+  const reordered = [
+    "python3 .github/scripts/verify_wheel_glibc.py --max-glibc 2.17 dist/*.whl",
+    "python3 .github/scripts/verify_glibc_baseline.py --max-glibc 2.39 soldr",
+  ].join("\n");
+  assert.strictEqual(
+    glibcCeilingFor(reordered, "verify_glibc_baseline.py"),
+    "2.39",
+    "the binary ceiling must not be confused with the wheel ceiling",
+  );
+  assert.strictEqual(
+    glibcCeilingFor(reordered, "verify_wheel_glibc.py"),
+    "2.17",
+    "the wheel ceiling must resolve independently",
+  );
+  assert.strictEqual(glibcCeilingFor(reordered, "not_a_script.py"), null);
+
+  // Two invocations of the same script that agree resolve to that value...
+  const agreeing = [
+    "python3 .github/scripts/verify_glibc_baseline.py --max-glibc 2.39 soldr",
+    "python3 .github/scripts/verify_glibc_baseline.py --max-glibc 2.39 bundle",
+  ].join("\n");
+  assert.strictEqual(glibcCeilingFor(agreeing, "verify_glibc_baseline.py"), "2.39");
+
+  // ...and two that disagree are a hard error rather than a silent pick.
+  const conflicting = [
+    "python3 .github/scripts/verify_glibc_baseline.py --max-glibc 2.17 soldr",
+    "python3 .github/scripts/verify_glibc_baseline.py --max-glibc 2.39 bundle",
+  ].join("\n");
+  assert.throws(
+    () => glibcCeilingFor(conflicting, "verify_glibc_baseline.py"),
+    /conflicting --max-glibc/,
+    "two ceilings for the same script must not be silently reconciled",
+  );
+}
+
+const releaseWorkflow = fs.readFileSync(
+  path.join(root, ".github", "workflows", "release-auto.yml"),
+  "utf8",
+);
+const binaryCeiling = glibcCeilingFor(releaseWorkflow, "verify_glibc_baseline.py");
+assert(
+  binaryCeiling,
+  "release-auto.yml must pass --max-glibc to verify_glibc_baseline.py",
+);
+assert.strictEqual(
+  install.MIN_GLIBC_FOR_GNU,
+  binaryCeiling,
+  `install.js MIN_GLIBC_FOR_GNU (${install.MIN_GLIBC_FOR_GNU}) must match the ` +
+    `--max-glibc ceiling verify_glibc_baseline.py enforces in release-auto.yml ` +
+    `(${binaryCeiling})`,
+);
+
 assert.strictEqual(
   install.checksumFor(
     "abc123  soldr-v0.7.29-x86_64-unknown-linux-gnu.tar.zst\n",
@@ -123,6 +316,83 @@ assert.strictEqual(
   "abc123",
 );
 
+// The integrity check for everything this package installs
+// (docs/TRUST_BOUNDARIES.md). `checksumFor` was covered but the comparison
+// that uses it was inline in install() and untested, so deleting the
+// mismatch branch would have disabled verification with every test green.
+const crypto = require("crypto");
+const ARCHIVE_BYTES = Buffer.from("pretend this is a tar.zst");
+const ARCHIVE_NAME = "soldr-v9.9.9-x86_64-unknown-linux-musl.tar.zst";
+const ARCHIVE_SHA = crypto.createHash("sha256").update(ARCHIVE_BYTES).digest("hex");
+const SUMS = `${ARCHIVE_SHA}  ${ARCHIVE_NAME}
+`;
+
+// A matching digest returns it rather than throwing.
+assert.strictEqual(
+  install.verifyArchiveChecksum(ARCHIVE_BYTES, SUMS, ARCHIVE_NAME),
+  ARCHIVE_SHA,
+);
+
+// A tampered archive must throw. This is the case that had no coverage.
+assert.throws(
+  () =>
+    install.verifyArchiveChecksum(
+      Buffer.concat([ARCHIVE_BYTES, Buffer.from("tampered")]),
+      SUMS,
+      ARCHIVE_NAME,
+    ),
+  /checksum mismatch/,
+  "a tampered archive must be rejected",
+);
+
+// A digest for a DIFFERENT file must not be accepted for this one: the
+// lookup is by exact filename, so a sums file listing only some other
+// artifact fails closed rather than matching the first line it sees.
+assert.throws(
+  () =>
+    install.verifyArchiveChecksum(
+      ARCHIVE_BYTES,
+      `${ARCHIVE_SHA}  some-other-artifact.tar.zst
+`,
+      ARCHIVE_NAME,
+    ),
+  /checksum entry not found/,
+  "a sums file without this artifact must be rejected",
+);
+
+// An empty sums file is not a free pass.
+assert.throws(
+  () => install.verifyArchiveChecksum(ARCHIVE_BYTES, "", ARCHIVE_NAME),
+  /checksum entry not found/,
+  "an empty checksums file must be rejected",
+);
+
+// Real SHA256SUMS.txt files use two spaces and may carry CRLF; both must
+// parse. Verified against the published v0.8.29 file, which is
+// `<hash>  <name>` with 16 entries covering every release asset.
+assert.strictEqual(
+  install.verifyArchiveChecksum(
+    ARCHIVE_BYTES,
+    `deadbeef  unrelated.whl
+${ARCHIVE_SHA}  ${ARCHIVE_NAME}
+`,
+    ARCHIVE_NAME,
+  ),
+  ARCHIVE_SHA,
+);
+
+// Digests are compared case-insensitively on the manifest side: an
+// uppercase entry names the same bytes.
+assert.strictEqual(
+  install.verifyArchiveChecksum(
+    ARCHIVE_BYTES,
+    `${ARCHIVE_SHA.toUpperCase()}  ${ARCHIVE_NAME}
+`,
+    ARCHIVE_NAME,
+  ),
+  ARCHIVE_SHA,
+);
+
 assert.strictEqual(install.ARCHIVE_EXT, "tar.zst");
 assert.deepStrictEqual(
   install.BUNDLED_BINARIES,