jdx/mise · error

' ' depends on unknown

Error message

'{}' depends on unknown '{}'

What it means

When building the dependency graph, each edge's endpoints must already exist as nodes. If a dependency declares an edge to a key that was never registered as a node, the graph would be inconsistent, so `DepsGraph::new` bails naming the depending and missing keys.

Solutions

1. Fix the target key in the dependency declaration to match an existing node
2. Add the missing node so the edge target exists
3. Remove the stale dependency edge from the config

Example fix

// before (mise.toml)
[deps]
"app" depends-on "srev"   # typo: unknown node
// after
[deps]
"app" depends-on "serv"

let known: HashSet<&str> = nodes.iter().map(|n| n.key()).collect();
let bad: Vec<_> = edges.iter().filter(|(_, to)| !known.contains(to.as_str())).collect();
if !bad.is_empty() { eprintln!("edges targeting unknown nodes: {bad:?}"); }

When it happens

Trigger: Constructing `DepsGraph::new` from a node/edge list where an edge's `to_key` has no corresponding entry in `node_indices` (the `from` side is silently skipped if unknown; only unknown `to` targets are fatal).

Common situations: Deps config referencing a provider/package key with a typo; an edge added programmatically for a node filtered out earlier (e.g. skipped provider); stale cross-references after renaming a dep key.

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

• deps run command cannot be empty
• provider ' ' is inactive
• a provided source resolves to a path
• additional asset ' ' is not an archive
• agent ' ' `start_calendar_interval. ` must be between and

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

Appendix: source

Thrown at src/deps_graph.rs:66

        key_fn: fn(&N) -> K,
    ) -> Result<Self> {
        let mut graph = StableGraph::new();
        let mut node_indices = HashMap::new();

        for (key, node) in nodes {
            if node_indices.contains_key(&key) {
                continue;
            }
            let idx = graph.add_node(node);
            node_indices.insert(key, idx);
        }

        for (from_key, to_key) in edges {
            let Some(&from_idx) = node_indices.get(&from_key) else {
                continue;
            };
            let Some(&to_idx) = node_indices.get(&to_key) else {
                bail!("'{}' depends on unknown '{}'", from_key, to_key);
            };
            if from_key != to_key {
                graph.update_edge(from_idx, to_idx, ());
            }
        }

        let (tx, _) = mpsc::unbounded_channel();

        let mut deps = Self {
            graph,
            node_indices,
            sent: HashSet::new(),
            blocked: HashSet::new(),
            tx,
            key_fn,
        };

        deps.detect_and_block_cycles();

View on GitHub (pinned to 533346cc37)