jdx/mise · error

brew bottles are only published for a formula's current vers

Error message

brew bottles are only published for a formula's current version ('{p}'): pin via the formula name instead (e.g. "brew:postgresql@17")

What it means

mise's brew bootstrap installs Homebrew bottles via pour, and bottles are only built by Homebrew for a formula's current version. Any PackageRequest with an explicit version cannot be satisfied by a bottle, so install_via_pour rejects the batch up front and tells you to encode the version in the formula name (e.g. "brew:postgresql@17").

Source

Thrown at src/system/packages/brew/mod.rs:88

        for request in pkgs {
            let name = request_formula_name(&request.name);
            let state = linked_package_state(&request.version, pour::linked_state(name));
            if matches!(state, PackageState::NeedsRepair { .. })
                && pour::repair_link_record(name, opts.dry_run)?
            {
                repaired.push(request.clone());
            }
        }
        Ok(repaired)
    }

    /// Prefetch bottles concurrently, then install the closure in dependency order.
    async fn install_via_pour(&self, pkgs: &[PackageRequest], opts: &InstallOpts) -> Result<()> {
        // bottles only exist for a formula's current version — versioning is
        // expressed in the formula name itself (postgresql@17); the CLI
        // filters pinned requests out before calling
        if let Some(p) = pkgs.iter().find(|p| p.version.is_some()) {
            bail!(
                "brew bottles are only published for a formula's current version ('{p}'): \
                 pin via the formula name instead (e.g. \"brew:postgresql@17\")"
            );
        }
        let roots: Vec<String> = pkgs.iter().map(|p| p.name.clone()).collect();
        let closure = resolve::resolve_closure_with_taps(pkgs, !opts.dry_run).await?;
        for rf in &closure {
            if rf.on_request
                && !roots.contains(&rf.formula.name)
                && let Some(alias) = roots.iter().find(|r| rf.formula.aliases.contains(r))
            {
                warn!(
                    "'{alias}' is an alias of '{}' — use the canonical name in [bootstrap.packages] \
                     so `mise bootstrap packages status` can track it",
                    rf.formula.name
                );
            }
        }

View on GitHub (pinned to afd2eddd3a)

Solutions

  1. Remove the version field and use the versioned formula name instead, e.g. brew:postgresql@17
  2. Check the formula exists with that name: `brew info postgresql@17`
  3. If you truly need an arbitrary old version, use a different backend or a brew tap/versioned formula

Example fix

# before
[tools]
postgresql = { backend = 'brew', version = '17.4' }
# after
[tools]
'brew:postgresql@17' = 'latest'
Defensive patterns

Strategy: validation

Validate before calling

const reqs = pkgs.filter(p => p.backend === 'brew' && p.version);
if (reqs.length) throw new Error(`brew does not support version pins: ${reqs.map(p=>p.name).join(', ')} — use formula name like brew:postgresql@17`);

Type guard

const isPinned = (p) => typeof p.version === 'string' && p.version.length > 0;

Prevention

When it happens

Trigger: Calling `mise bootstrap packages apply` (or install/upgrade) with a brew package request carrying a version pin, e.g. `brew:postgresql@17.4` or a mise.toml entry like `brew = { version = '9.6' }`. The CLI filters pinned requests, but any that slip through hit this bail.

Common situations: Copy-pasting version pins from other backends into brew: tool config; trying to pin an older formula version the way you would with cargo/npm; upgrading a config that previously used the version-pinned syntax.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors


AI-assisted analysis of jdx/mise@afd2eddd3a (2026-09-09). Data as JSON: /api/errors/69b87bcfedc90290. Report an issue: GitHub.