dlin-cli 0.2.5__tar.gz → 0.2.6rc1__tar.gz

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/Cargo.lock

@@ -139,9 +139,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "clap"
-version = "4.6.6"
+version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca"
+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -149,9 +149,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.6.6"
+version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889"
+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -161,9 +161,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.6.4"
+version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061"
+checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -230,7 +230,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "dlin"
-version = "0.2.5"
+version = "0.2.6-rc.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "dlin-core"
-version = "0.2.5"
+version = "0.2.6-rc.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -402,9 +402,9 @@ dependencies = [
 
 [[package]]
 name = "globset"
-version = "0.4.19"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e47d37d2ae4464254884b60ab7071be2b876a9c35b696bd018ddcc76847309cd"
+checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"
 dependencies = [
  "aho-corasick",
  "bstr",
@@ -415,9 +415,9 @@ dependencies = [
 
 [[package]]
 name = "granit-parser"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ccd1be9ebf2bd5520dbfcfb72b70ef492f654061299a097056f3e73410e38ec"
+checksum = "e20f99e46474f56bd905c56e817ebddcf377a611f94c53ac4649e4d3fa3c0cd0"
 dependencies = [
  "arraydeque",
  "smallvec",
@@ -446,9 +446,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "indexmap"
-version = "2.14.0"
+version = "2.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
 dependencies = [
  "equivalent",
  "hashbrown 0.17.1",
@@ -696,9 +696,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.12.3"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -708,9 +708,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.14"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -719,9 +719,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rustix"
@@ -763,9 +763,9 @@ dependencies = [
 
 [[package]]
 name = "serde-saphyr"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ec1f5cac0eb96063c64b28705255a7ed6e7d77f95c1d25e9f8b8c928006ce1"
+checksum = "b8050abb251097357e24aff63ba2c52a6309ecb7d23a5474023df960a02694d8"
 dependencies = [
  "annotate-snippets",
  "base64",
@@ -949,18 +949,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.20"
+version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.20"
+version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
  "proc-macro2",
  "quote",

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "3"
 
 [workspace.package]
-version = "0.2.5"
+version = "0.2.6-rc.1"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/eitsupi/dlin"
@@ -38,7 +38,7 @@ insta = "1"
 serial_test = "4.0.1"
 
 # internal
-dlin-core = { version = "0.2.4-rc.3", path = "crates/dlin-core" }
+dlin-core = { version = "0.2.6-rc.1", path = "crates/dlin-core" }
 
 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dlin-cli
-Version: 0.2.5
+Version: 0.2.6rc1
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/crates/dlin/tests/integration/error_format.rs

@@ -1,5 +1,24 @@
 use super::*;
 
+fn setup_cyclic_project() -> tempfile::TempDir {
+    use std::fs;
+
+    let tmp = tempfile::tempdir().unwrap();
+    fs::create_dir_all(tmp.path().join("models")).unwrap();
+    fs::write(tmp.path().join("dbt_project.yml"), "name: cycle_test\n").unwrap();
+    fs::write(
+        tmp.path().join("models/a.sql"),
+        "select * from {{ ref('b') }}\n",
+    )
+    .unwrap();
+    fs::write(
+        tmp.path().join("models/b.sql"),
+        "select * from {{ ref('a') }}\n",
+    )
+    .unwrap();
+    tmp
+}
+
 #[test]
 fn test_error_format_json_on_error() {
     // Run impact on a nonexistent project to trigger an error
@@ -91,3 +110,54 @@ fn test_error_format_default_is_text() {
         "Expected text error, got: {stderr}"
     );
 }
+
+#[test]
+fn test_cycle_diagnostic_in_text_format_includes_unique_id_path() {
+    let project = setup_cyclic_project();
+    let output = std::process::Command::new(binary_path())
+        .args([
+            "--error-format",
+            "text",
+            "graph",
+            "-p",
+            project.path().to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to run binary");
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("cycle detected in lineage graph: model.a -> model.b -> model.a"),
+        "Expected the directed cycle path, got: {stderr}"
+    );
+}
+
+#[test]
+fn test_cycle_diagnostic_in_json_format_includes_unique_id_path() {
+    let project = setup_cyclic_project();
+    let output = std::process::Command::new(binary_path())
+        .args([
+            "--error-format",
+            "json",
+            "graph",
+            "-p",
+            project.path().to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to run binary");
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let parsed: serde_json::Value = serde_json::from_str(stderr.trim()).unwrap_or_else(|error| {
+        panic!("stderr is not valid JSON: {error}\nstderr: {stderr}");
+    });
+    assert_eq!(parsed["level"], "error");
+    assert!(
+        parsed["what"]
+            .as_str()
+            .unwrap()
+            .contains("model.a -> model.b -> model.a"),
+        "Expected the directed cycle path, got: {parsed}"
+    );
+}

dlin_cli-0.2.6rc1/crates/dlin/tests/integration/render_failure.rs

@@ -0,0 +1,255 @@
+use super::*;
+use std::process::Command;
+
+fn issue_199_project(model_sql: &str) -> tempfile::TempDir {
+    let tmp = tempfile::tempdir().unwrap();
+    std::fs::create_dir_all(tmp.path().join("models")).unwrap();
+    std::fs::create_dir_all(tmp.path().join("macros")).unwrap();
+    std::fs::write(
+        tmp.path().join("dbt_project.yml"),
+        "name: issue_199\nmodel-paths: [models]\nmacro-paths: [macros]\n",
+    )
+    .unwrap();
+    // The project macro is valid but unused; scanning the whole prefix adds a
+    // false self-edge in both the failed-render and runtime-macro scenarios.
+    std::fs::write(tmp.path().join("models/u.sql"), model_sql).unwrap();
+    std::fs::write(
+        tmp.path().join("models/downstream.sql"),
+        "select * from {{ ref('u') }}\n",
+    )
+    .unwrap();
+    std::fs::write(tmp.path().join("models/base.sql"), "select 1 as id\n").unwrap();
+    std::fs::write(
+        tmp.path().join("macros/unused.sql"),
+        "{% macro unused() %}{{ ref('u') }}{% endmacro %}\n",
+    )
+    .unwrap();
+    tmp
+}
+
+fn run_graph(project: &std::path::Path, cache_args: &[&str]) -> std::process::Output {
+    Command::new(binary_path())
+        .args(["graph", "--project-dir"])
+        .arg(project)
+        .args(["--output", "json"])
+        .args(cache_args)
+        .output()
+        .expect("failed to run graph")
+}
+
+#[test]
+fn test_issue_199_render_failure_does_not_create_self_cycle() {
+    let project = issue_199_project("select * from {{ ref('base') }}\n{{ missing_macro() }}\n");
+    assert_issue_project_has_no_false_self_edge(&project);
+
+    let impact = Command::new(binary_path())
+        .args(["impact", "u", "--project-dir"])
+        .arg(project.path())
+        .arg("--no-cache")
+        .output()
+        .expect("failed to run impact");
+    assert!(
+        impact.status.success(),
+        "impact failed: {}",
+        String::from_utf8_lossy(&impact.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&impact.stdout).contains("downstream"),
+        "impact should include downstream model: {}",
+        String::from_utf8_lossy(&impact.stdout)
+    );
+}
+
+#[test]
+fn test_issue_199_adapter_runtime_case_does_not_create_self_cycle() {
+    let project = issue_199_project(
+        "{% if is_incremental() %}select {{ gmid('d') }} from {{ ref('base') }}{% else %}select 1 from {{ ref('base') }}{% endif %}\n",
+    );
+    std::fs::write(
+        project.path().join("macros/gmid.sql"),
+        r#"
+            {% macro gmid(c) %}
+                {% if is_incremental() %}
+                    {% set r = adapter.get_relation(this.database, this.schema, this.identifier) %}
+                    {% if r %}{% set q = run_query('select 1') %}{% endif %}
+                {% endif %}
+                current_date()
+            {% endmacro %}
+        "#,
+    )
+    .unwrap();
+    assert_issue_project_has_no_false_self_edge(&project);
+
+    let impact = Command::new(binary_path())
+        .args(["impact", "u", "--project-dir"])
+        .arg(project.path())
+        .arg("--no-cache")
+        .output()
+        .expect("failed to run impact");
+    assert!(
+        impact.status.success(),
+        "adapter runtime impact failed: {}",
+        String::from_utf8_lossy(&impact.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&impact.stdout).contains("downstream"),
+        "impact should include downstream model: {}",
+        String::from_utf8_lossy(&impact.stdout)
+    );
+}
+
+#[test]
+fn test_runtime_macro_branches_recover_only_reachable_dependencies() {
+    let project = runtime_macro_branch_project();
+    let no_cache = run_graph(project.path(), &["--no-cache"]);
+    assert!(
+        no_cache.status.success(),
+        "uncached graph failed: {}",
+        String::from_utf8_lossy(&no_cache.stderr)
+    );
+    let no_cache_graph: serde_json::Value = serde_json::from_slice(&no_cache.stdout).unwrap();
+    assert_runtime_macro_edges(&no_cache_graph);
+
+    let cache_dir = project.path().join("dlin-cache");
+    let cache_dir_arg = cache_dir.to_str().unwrap();
+    let cold = run_graph(project.path(), &["--cache-dir", cache_dir_arg]);
+    assert!(
+        cold.status.success(),
+        "cold cached graph failed: {}",
+        String::from_utf8_lossy(&cold.stderr)
+    );
+    let warm = run_graph(project.path(), &["--cache-dir", cache_dir_arg]);
+    assert!(
+        warm.status.success(),
+        "warm cached graph failed: {}",
+        String::from_utf8_lossy(&warm.stderr)
+    );
+    let cold_graph: serde_json::Value = serde_json::from_slice(&cold.stdout).unwrap();
+    let warm_graph: serde_json::Value = serde_json::from_slice(&warm.stdout).unwrap();
+    assert_runtime_macro_edges(&cold_graph);
+    assert_runtime_macro_edges(&warm_graph);
+    assert_eq!(cold_graph, warm_graph, "cold and warm graph output differs");
+    assert_eq!(
+        no_cache_graph, cold_graph,
+        "cached and uncached graph output differs"
+    );
+}
+
+fn runtime_macro_branch_project() -> tempfile::TempDir {
+    let tmp = tempfile::tempdir().unwrap();
+    std::fs::create_dir_all(tmp.path().join("models")).unwrap();
+    std::fs::create_dir_all(tmp.path().join("macros")).unwrap();
+    std::fs::write(
+        tmp.path().join("dbt_project.yml"),
+        "name: runtime_macro_repro\nmodel-paths: [models]\nmacro-paths: [macros]\n",
+    )
+    .unwrap();
+    std::fs::write(
+        tmp.path().join("models/downstream.sql"),
+        "select {{ choose() }} as chosen\n",
+    )
+    .unwrap();
+    std::fs::write(tmp.path().join("models/yes_branch.sql"), "select 1 as id\n").unwrap();
+    std::fs::write(tmp.path().join("models/no_branch.sql"), "select 0 as id\n").unwrap();
+    std::fs::write(
+        tmp.path().join("models/schema.yml"),
+        "version: 2\nsources:\n  - name: unused\n    tables:\n      - name: tbl\n",
+    )
+    .unwrap();
+    std::fs::write(
+        tmp.path().join("macros/choose.sql"),
+        r#"
+            {% macro choose() %}
+                {% if adapter.get_relation(identifier='x') %}
+                    {{ ref('yes_branch') }}
+                {% else %}
+                    {{ ref('no_branch') }}
+                {% endif %}
+            {% endmacro %}
+
+            {% macro unused() %}{{ ref('downstream') }}{{ source('unused', 'tbl') }}{% endmacro %}
+        "#,
+    )
+    .unwrap();
+    tmp
+}
+
+fn assert_runtime_macro_edges(graph: &serde_json::Value) {
+    let edges = graph["edges"].as_array().unwrap();
+    for source in ["model.yes_branch", "model.no_branch"] {
+        assert!(
+            edges.iter().any(|edge| {
+                edge["source"].as_str() == Some(source)
+                    && edge["target"].as_str() == Some("model.downstream")
+                    && edge["edge_type"].as_str() == Some("ref")
+            }),
+            "missing {source} edge: {edges:?}"
+        );
+    }
+    assert!(
+        !edges.iter().any(|edge| {
+            edge["source"].as_str() == Some("model.downstream")
+                && edge["target"].as_str() == Some("model.downstream")
+        }),
+        "unused macro added downstream self-edge: {edges:?}"
+    );
+    assert!(
+        !edges.iter().any(|edge| {
+            edge["source"].as_str() == Some("source.unused.tbl")
+                && edge["target"].as_str() == Some("model.downstream")
+        }),
+        "unused macro source edge leaked into graph: {edges:?}"
+    );
+}
+
+fn assert_issue_project_has_no_false_self_edge(project: &tempfile::TempDir) {
+    let no_cache = run_graph(project.path(), &["--no-cache"]);
+    assert!(
+        no_cache.status.success(),
+        "uncached graph failed: {}",
+        String::from_utf8_lossy(&no_cache.stderr)
+    );
+    let no_cache_graph: serde_json::Value = serde_json::from_slice(&no_cache.stdout).unwrap();
+    assert_no_u_self_edge(&no_cache_graph);
+
+    let cache_dir = project.path().join("dlin-cache");
+    let cache_dir_arg = cache_dir.to_str().unwrap();
+    let cold = run_graph(project.path(), &["--cache-dir", cache_dir_arg]);
+    assert!(
+        cold.status.success(),
+        "cold cached graph failed: {}",
+        String::from_utf8_lossy(&cold.stderr)
+    );
+    let warm = run_graph(project.path(), &["--cache-dir", cache_dir_arg]);
+    assert!(
+        warm.status.success(),
+        "warm cached graph failed: {}",
+        String::from_utf8_lossy(&warm.stderr)
+    );
+    let cold_graph: serde_json::Value = serde_json::from_slice(&cold.stdout).unwrap();
+    let warm_graph: serde_json::Value = serde_json::from_slice(&warm.stdout).unwrap();
+    assert_no_u_self_edge(&cold_graph);
+    assert_no_u_self_edge(&warm_graph);
+    assert_eq!(cold_graph, warm_graph, "cold and warm graph output differs");
+    assert_eq!(
+        no_cache_graph, cold_graph,
+        "cached and uncached graph output differs"
+    );
+
+    for graph in [&no_cache_graph, &cold_graph, &warm_graph] {
+        assert!(graph["edges"].as_array().unwrap().iter().any(|edge| {
+            edge["source"].as_str() == Some("model.base")
+                && edge["target"].as_str() == Some("model.u")
+        }));
+    }
+}
+
+fn assert_no_u_self_edge(graph: &serde_json::Value) {
+    let edges = graph["edges"].as_array().unwrap();
+    assert!(
+        !edges.iter().any(|edge| {
+            edge["source"].as_str() == Some("model.u") && edge["target"].as_str() == Some("model.u")
+        }),
+        "unexpected model.u self-edge: {edges:?}"
+    );
+}

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/crates/dlin/tests/integration_test.rs

@@ -76,5 +76,7 @@ mod generic_test_metadata;
 mod manifest_only;
 #[path = "integration/parsing.rs"]
 mod parsing;
+#[path = "integration/render_failure.rs"]
+mod render_failure;
 #[path = "integration/sql_mode_test_warning.rs"]
 mod sql_mode_test_warning;

{dlin_cli-0.2.5 → dlin_cli-0.2.6rc1}/crates/dlin-core/src/graph/filter/mod.rs

@@ -275,7 +275,14 @@ pub fn filter_graph(
 ) -> Result<LineageGraph> {
     // Check for cycles
     if petgraph::algo::is_cyclic_directed(graph) {
-        return Err(DbtLineageError::CycleDetected.into());
+        let cycle = find_directed_cycle(graph)
+            .expect("petgraph reported a cycle but cycle path extraction found none");
+        return Err(
+            anyhow::Error::new(DbtLineageError::CycleDetected).context(format!(
+                "cycle detected in lineage graph: {}",
+                cycle.join(" -> ")
+            )),
+        );
     }
 
     let mut keep_nodes: HashSet<NodeIndex> = HashSet::new();
@@ -343,6 +350,97 @@ pub fn filter_graph(
     }
 }
 
+/// Find one real directed cycle, with its first node repeated at the end.
+///
+/// This runs only after the linear-time acyclic check has found a cycle. The
+/// iterative DFS avoids recursion depth limits on large lineage graphs, and
+/// sorted roots/neighbors make the reported path deterministic.
+fn find_directed_cycle(graph: &LineageGraph) -> Option<Vec<String>> {
+    struct Frame {
+        node: NodeIndex,
+        neighbors: Vec<NodeIndex>,
+        next_neighbor: usize,
+    }
+
+    let mut roots: Vec<_> = graph.node_indices().collect();
+    roots.sort_by(|left, right| {
+        graph[*left]
+            .unique_id
+            .cmp(&graph[*right].unique_id)
+            .then_with(|| left.index().cmp(&right.index()))
+    });
+
+    let mut color = HashMap::<NodeIndex, u8>::new();
+    let mut parent = HashMap::<NodeIndex, NodeIndex>::new();
+
+    for root in roots {
+        if color.get(&root).copied().unwrap_or(0) != 0 {
+            continue;
+        }
+        color.insert(root, 1);
+        let mut stack = vec![Frame {
+            node: root,
+            neighbors: sorted_successors(graph, root),
+            next_neighbor: 0,
+        }];
+
+        while let Some(frame) = stack.last_mut() {
+            if frame.next_neighbor == frame.neighbors.len() {
+                color.insert(frame.node, 2);
+                stack.pop();
+                continue;
+            }
+
+            let node = frame.node;
+            let next = frame.neighbors[frame.next_neighbor];
+            frame.next_neighbor += 1;
+            match color.get(&next).copied().unwrap_or(0) {
+                0 => {
+                    parent.insert(next, node);
+                    color.insert(next, 1);
+                    stack.push(Frame {
+                        node: next,
+                        neighbors: sorted_successors(graph, next),
+                        next_neighbor: 0,
+                    });
+                }
+                1 => {
+                    let mut cycle = vec![node];
+                    let mut cursor = node;
+                    while cursor != next {
+                        cursor = *parent.get(&cursor)?;
+                        cycle.push(cursor);
+                    }
+                    cycle.reverse();
+                    cycle.push(next);
+                    return Some(
+                        cycle
+                            .into_iter()
+                            .map(|index| graph[index].unique_id.clone())
+                            .collect(),
+                    );
+                }
+                _ => {}
+            }
+        }
+    }
+
+    None
+}
+
+fn sorted_successors(graph: &LineageGraph, node: NodeIndex) -> Vec<NodeIndex> {
+    let mut successors: Vec<_> = graph
+        .neighbors_directed(node, Direction::Outgoing)
+        .collect();
+    successors.sort_by(|left, right| {
+        graph[*left]
+            .unique_id
+            .cmp(&graph[*right].unique_id)
+            .then_with(|| left.index().cmp(&right.index()))
+    });
+    successors
+}
+
 /// Build a new graph containing only the specified nodes and their interconnecting edges.
 ///
 /// Edges between kept nodes that pass through filtered-out intermediaries are dropped.