published a stamp list for before (sequence ) but now…

Error message

{host} published a stamp list for {project} before (sequence {last}) but now answers 404 at {url}; refusing to treat that as no list, since it would drop the yanks that list carried

What it means

Raised by packslip_stamps::missing_list_in when the host previously published a stamp list for the project (a sequence number is recorded in the local per-host state) but the list URL now returns 404. Treating the 404 as 'no list exists' would silently discard the yanks carried by the previously accepted list, so mise refuses instead.

Solutions

Verify the list URL is correct and the host still publishes the list; restore or re-publish the list on the host.
Use a different/mirror host for this project that still serves the stamp list.
If the list was deliberately removed and you accept dropping its yanks, clear the local per-host stamp state for this project (explicitly, not implicitly) after confirming with the publisher.
Check for proxy/CDN misconfigurations that return 404 for valid URLs.

Example fix

// before: host moved the list but state still records sequence 7
// after: point configuration at the new host/URL that serves the list,
// or restore the list at the original URL
mise packslip refresh --host mirrors.example.com  # fetch from a host that serves it

Defensive patterns

Strategy: retry

Validate before calling

// before treating a 404 as 'no list', check local accepted state
const state = readHostState(dir, host);
if (state.sequences && state.sequences[project] !== undefined) {
  // a 404 here is NOT 'no list' — surface it loudly
  throw new Error(`${host} previously published a list for ${project}; 404 must not be ignored`);
}

Type guard

function hadPublishedList(state, project) {
  return typeof state?.sequences?.[project] === "number";
}

Try / catch

try {
  fetchStampList(host, project);
} catch (e) {
  if (String(e).includes("answers 404")) {
    // verify out-of-band with the publisher; do not silently drop yanks
    console.error(`List vanished from ${host}; restore it or explicitly clear state after confirmation.`);
    process.exitCode = 1;
  } else throw e;
}

Prevention

Pin mirror/proxy configs so valid list URLs cannot be answered with 404s by a CDN.
Monitor stamp-list URLs with uptime checks so vanishing lists are caught before installs fail.
When a publisher moves a list, update client config before decommissioning the old URL.

When it happens

Trigger: Calling missing_list (or missing_list_in) during a stamp-list refresh when read_state shows a stored sequence for this host+project, yet the HTTP fetch of the list URL got a 404.

Common situations: The host deleted or moved the project's stamp list; a mirror/proxy is serving stale 404s; a network middlebox or wrong URL rewrite turns real requests into 404s; a registry reorganization removed the project path.

Understand the failure class

Background: 'Could not be found', 'does not exist', 'not found in database': the resource-not-found family when an ID, slug, key, or URI lookup comes back empty — this error's family across 20 libraries.

Related errors

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

Appendix: source

Thrown at src/packslip_stamps.rs:241

fn check_sequence(host: &str, project: &str, list: &ReleaseListStatement) -> Result<()> {
    let dir = state_dir();
    let _lock = locked(&dir, host)?;
    check_sequence_in(&dir, host, project, list)
}

/// A host that answered 404 for a project it had a list for before is not
/// "no list": it would drop that list's yanks and let another host's stamp
/// stand alone. Refuse until the host publishes again.
fn missing_list(host: &str, project: &str, url: &str) -> Result<()> {
    let dir = state_dir();
    let _lock = locked(&dir, host)?;
    missing_list_in(&dir, host, project, url)
}

fn missing_list_in(dir: &Path, host: &str, project: &str, url: &str) -> Result<()> {
    let state = read_state(dir, host)?;
    if let Some(last) = state.sequences.get(project) {
        bail!(
            "{host} published a stamp list for {project} before (sequence {last}) but now answers 404 at {url}; refusing to treat that as no list, since it would drop the yanks that list carried"
        );
    }
    Ok(())
}

fn check_sequence_in(
    dir: &Path,
    host: &str,
    project: &str,
    list: &ReleaseListStatement,
) -> Result<()> {
    let mut state = read_state(dir, host)?;
    let sequence = list.predicate.sequence;
    if let Some(&last) = state.sequences.get(project)
        && sequence < last
    {
        bail!(

View on GitHub (pinned to 533346cc37)