jdx/mise · error

unsupported number in aube lockfile

Error message

unsupported number in aube lockfile

What it means

Thrown in the YAML->TOML conversion of the aube lockfile when a numeric value is neither an i64 nor an f64 (e.g. arbitrary-precision or overflow numbers outside both ranges). TOML can only hold integers and floats, so the value is unsupported.

Solutions

1. Correct the offending number to fit within 64-bit integer/float range
2. Restore mise.lock from git
3. Delete and regenerate the lockfile
4. Fix the generator writing oversized numbers into the lock

Example fix

// before
big: 99999999999999999999999999
// after
big: 9999999999

# check numbers fit in 64-bit before committing the lock
yq '[.. | numbers] | map(select(. > 9223372036854775807)) | length == 0' mise.lock

When it happens

Trigger: mise.lock's aube YAML contains a huge integer beyond i64 range or a number format serde_yaml maps to neither i64 nor f64.

Common situations: Hand-edited lockfile with an extremely large number; another tool writing YAML numbers that overflow 64-bit; corrupted lockfile.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

• non-finite numbers cannot be represented in mise.lock
• aube lockfile mapping keys must be strings
• null values cannot be represented in mise.lock
• additional_artifacts must be an array in lockfile
• aube lockfile must contain a mapping

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

Appendix: source

Thrown at src/lockfile.rs:177

            }
        }
    }
}

fn yaml_to_toml(value: serde_yaml::Value) -> Result<toml::Value> {
    use serde_yaml::Value;
    Ok(match value {
        Value::Bool(value) => toml::Value::Boolean(value),
        Value::Number(value) => {
            if let Some(value) = value.as_i64() {
                toml::Value::Integer(value)
            } else if let Some(value) = value.as_f64() {
                if !value.is_finite() {
                    bail!("non-finite numbers cannot be represented in mise.lock")
                }
                toml::Value::Float(value)
            } else {
                bail!("unsupported number in aube lockfile")
            }
        }
        Value::String(value) => toml::Value::String(value),
        Value::Sequence(values) => toml::Value::Array(
            values
                .into_iter()
                .map(yaml_to_toml)
                .collect::<Result<_>>()?,
        ),
        Value::Mapping(values) => {
            let mut table = toml::Table::new();
            for (key, value) in values {
                let Value::String(key) = key else {
                    bail!("aube lockfile mapping keys must be strings")
                };
                table.insert(key, yaml_to_toml(value)?);
            }
            toml::Value::Table(table)

View on GitHub (pinned to 533346cc37)