no checksum entry found for

Error message

no checksum entry found for {filename} in checksum file

What it means

Aqua checksum files list `digest filename` lines. When a file_pattern-based lookup is configured, the backend regex-matches lines to find the entry whose captured filename equals the artifact's filename; if no line's captured name matches, it throws this error because the artifact's checksum cannot be located.

Solutions

Inspect the downloaded checksum file and update the `file` regex pattern so its capture group exactly matches the artifact filename as it appears in the file
Check for upstream format changes for this version and update the checksum config accordingly
Confirm you downloaded the checksum file corresponding to the right release/platform
If lines include path prefixes, adjust the pattern to capture just the basename or match the full path

Example fix

# before (pattern no longer matches format)
[checksum]
file = 'checksums-(.*).txt'
# after: capture group must equal the artifact filename
# checksums.txt line: "abc123  darwin-arm64/sometool"
[checksum]
file_pattern = '^[0-9a-f]{64}\s+(.+)$'

Defensive patterns

Strategy: validation

Validate before calling

let re = regex::Regex::new(&cfg.file_pattern)?;
let matched = checksum_file.lines().any(|l| {
    re.captures(l).map(|c| c[1].to_string()) == Some(artifact_filename.to_string())
});
if !matched {
    eprintln!("checksum file has no entry for {artifact_filename}; fix the file_pattern before verifying");
}

Try / catch

match parse_checksum_entry(&checksum_file, &pattern, &filename) {
    Err(e) if e.to_string().contains("no checksum entry found") => {
        eprintln!("artifact {filename} missing from checksum file; check upstream format changes");
    }
    r => r?,
}

Prevention

After upgrading a tool, re-check that its checksum file regex patterns still match the current file format
Download the checksum file from the same release/platform as the artifact
Inspect a sample checksum file line and confirm the pattern's capture group yields exactly the artifact filename (watch for ./ or path prefixes)
Pin the checksum file source URL alongside the artifact to avoid mixing releases

When it happens

Trigger: Verifying an aqua artifact whose checksum config specifies a `file` regex pattern, but the downloaded checksums file contains no line whose captured group (c[1]) equals the artifact filename — e.g. the regex captures a different part of the line or the file lists checksums under different names.

Common situations: Upstream changed the checksums file format or naming convention between releases; the `file` pattern in the package config no longer matches the current format; downloading the wrong checksum file (e.g. for another platform) that doesn't include this artifact; path prefixes (./, subdirectory) in the checksum lines that break exact filename equality.

Understand the failure class

Background: Record Not Found Errors: "not found", RecordNotFound, and "was not found" — what they mean and how to fix them — this error's family across 28 libraries.

Related errors

AI-assisted analysis of jdx/mise@533346cc37 (2026-09-17). Data as JSON: /api/errors/c8faf0f54943d3c0. Report an issue: GitHub.

Appendix: source

Thrown at src/backend/aqua.rs:2501

    /// Parse a checksum from checksum file content for a specific filename.
    fn parse_checksum_from_content(
        &self,
        content: &str,
        checksum_config: &AquaChecksum,
        filename: &str,
    ) -> Result<String> {
        let mut checksum_file = content.to_string();

        if checksum_config.file_format() == "regexp" {
            let pattern = checksum_config.pattern();
            if let Some(file_pattern) = &pattern.file {
                let re = regex::Regex::new(file_pattern.as_str())?;
                let Some(line) = checksum_file
                    .lines()
                    .find(|l| re.captures(l).is_some_and(|c| c[1].to_string() == filename))
                else {
                    bail!("no checksum entry found for {filename} in checksum file");
                };
                checksum_file = line.to_string();
            }
            let re = regex::Regex::new(pattern.checksum.as_str())?;
            if let Some(caps) = re.captures(checksum_file.as_str()) {
                checksum_file = caps[1].to_string();
            } else {
                debug!(
                    "no checksum found matching {} in checksum file",
                    pattern.checksum
                );
            }
        }

        // Standard format: "<hash>  <filename>" or "<hash> *<filename>"
        let entries = checksum_file
            .lines()
            .filter_map(|l| {

View on GitHub (pinned to 533346cc37)