Struct Graph 

pub struct Graph { /* private fields */ }

Graph builder for constructing graphs with implicit node connections

Implementations

impl Graph

pub fn new() -> Self

Create a new graph

Examples found in repository

examples/output_access_demo.rs (line 29)

fn demo_simple_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Pipeline Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 1: Generate initial data
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("initial_value".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("initial_value", "raw_data")])  // Maps initial_value → raw_data
    );
    
    // Node 2: Process the data
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("processed".to_string(), (value * 2).to_string());
            result
        },
        Some("Process"),
        Some(vec![("raw_data", "input")]),      // Maps raw_data → input
        Some(vec![("processed", "final_result")])  // Maps processed → final_result
    );
    
    // Build and execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Execution Context (all variables):");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🎯 Accessing specific outputs:");
    
    // Access by broadcast variable name (what's in the graph context)
    if let Some(raw_data) = context.get("raw_data") {
        println!("  raw_data: {}", raw_data);
    }
    
    if let Some(final_result) = context.get("final_result") {
        println!("  final_result: {}", final_result);
    }
    
    // Check if a variable exists
    if context.contains_key("final_result") {
        println!("\n✅ Final result is available in context");
    }
    
    println!();
}

fn demo_branch_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Branch Output Access (Parallel Paths)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "shared_data")])
    );
    
    // Branch A: Statistics computation
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("stats_output".to_string(), format!("Stats of {}", val));
            result
        },
        Some("Stats"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("stats_output", "statistics")])  // Branch A produces "statistics"
    );
    
    // Branch B: Model training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("model_output".to_string(), format!("Model trained on {}", val));
            result
        },
        Some("Train"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("model_output", "model")])  // Branch B produces "model"
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_output".to_string(), format!("Plot of {}", val));
            result
        },
        Some("Visualize"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("viz_output", "visualization")])  // Branch C produces "visualization"
    );
    
    // Add branches to main graph
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 All outputs from parallel branches:");
    
    // Access each branch's output
    if let Some(stats) = context.get("statistics") {
        println!("  Branch A (Statistics): {}", stats);
    }
    
    if let Some(model) = context.get("model") {
        println!("  Branch B (Model): {}", model);
    }
    
    if let Some(viz) = context.get("visualization") {
        println!("  Branch C (Visualization): {}", viz);
    }
    
    println!("\n🔍 All variables in context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!();
}

fn demo_variant_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Output Access (Parameter Sweep)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant nodes: scale by different factors
    // Factory function that creates a scaler for each factor
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled".to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled", "result")])  // Each variant produces "result"
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Variant outputs:");
    println!("  Note: Variants with same output name overwrite each other");
    println!("  The last variant (factor=5.0) writes to 'result'\n");
    
    // Access the result (will be from the last variant)
    if let Some(result) = context.get("result") {
        println!("  result = {} (from last variant: 10.0 * 5.0)", result);
    }
    
    println!("\n💡 Tip: To preserve all variant outputs, use unique output names:");
    println!("   Option 1: Map each variant to a different broadcast variable");
    println!("   Option 2: Collect results in merge node");
    println!("   Option 3: Use variant_params or closure capture to distinguish");
    
    // Better approach: unique output names per variant
    let mut graph2 = Graph::new();
    
    graph2.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant 1: 2x
    fn make_scaler_unique(label: &str, factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + '_ {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert(label.to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_2x", 2.0),
        vec!["2x"],
        Some("Scale2x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_2x", "result_2x")])
    );
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_3x", 3.0),
        vec!["3x"],
        Some("Scale3x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_3x", "result_3x")])
    );
    
    let dag2 = graph2.build();
    let context2 = dag2.execute(false, None);
    
    println!("\n✅ Better approach - unique output names:");
    if let Some(result_2x) = context2.get("result_2x") {
        println!("  result_2x = {}", result_2x);
    }
    if let Some(result_3x) = context2.get("result_3x") {
        println!("  result_3x = {}", result_3x);
    }
    
    println!();
}

fn demo_multiple_outputs() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Multiple Outputs from Single Node");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node that produces multiple outputs
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("mean".to_string(), "50.5".to_string());
            result.insert("median".to_string(), "48.0".to_string());
            result.insert("stddev".to_string(), "12.3".to_string());
            result.insert("count".to_string(), "100".to_string());
            result
        },
        Some("Statistics"),
        None,
        Some(vec![
            ("mean", "stat_mean"),
            ("median", "stat_median"),
            ("stddev", "stat_stddev"),
            ("count", "sample_count")
        ])
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📊 Multiple outputs from single node:");
    
    // Access each output individually
    println!("  Mean:   {}", context.get("stat_mean").unwrap());
    println!("  Median: {}", context.get("stat_median").unwrap());
    println!("  StdDev: {}", context.get("stat_stddev").unwrap());
    println!("  Count:  {}", context.get("sample_count").unwrap());
    
    println!("\n📋 Complete execution context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n💡 Summary:");
    println!("  ✓ dag.execute(false, None) returns HashMap<String, String>");
    println!("  ✓ Keys are broadcast variable names (from output mappings)");
    println!("  ✓ Use context.get(\"variable_name\") to access specific outputs");
    println!("  ✓ All outputs accumulate in the context throughout execution");
    
    println!();
}

examples/comprehensive_demo.rs (line 33)

fn demo_simple_pipeline() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Sequential Pipeline");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Data source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "42".to_string());
            result
        },
        Some("DataSource"),
        None,                                      // No inputs (source node)
        Some(vec![("value", "data")])              // (impl_var, broadcast_var)
    );
    
    // Processing node: multiply by 2
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("doubled".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Multiply"),
        Some(vec![("data", "x")]),                 // (broadcast_var, impl_var)
        Some(vec![("doubled", "result")])          // (impl_var, broadcast_var)
    );
    
    // Final processing: add 10
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("num").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("sum".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("AddTen"),
        Some(vec![("result", "num")]),
        Some(vec![("sum", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Input:  data = {}", context.get("data").unwrap());
    println!("  Step 1: result = {} (data * 2)", context.get("result").unwrap());
    println!("  Step 2: final = {} (result + 10)", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_branching() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Parallel Branching (Fan-Out)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Compute statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("stats".to_string(), format!("Mean: {}", val));
            }
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stats", "stats_result")])
    );
    
    // Branch B: Train model
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("model".to_string(), format!("Model trained on {}", val));
            }
            result
        },
        Some("MLModel"),
        Some(vec![("data", "input")]),
        Some(vec![("model", "model_result")])
    );
    
    // Branch C: Generate visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("plot".to_string(), format!("Plot of {}", val));
            }
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("plot", "viz_result")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A (Stats): {}", context.get("stats_result").unwrap());
    println!("  Branch B (Model): {}", context.get("model_result").unwrap());
    println!("  Branch C (Viz):   {}", context.get("viz_result").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All 3 branches can execute in parallel!");
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_merging() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Branching + Merging (Fan-Out + Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Branch A: Add 10
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("PathA (+10)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    // Branch B: Add 20
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 20).to_string());
            }
            result
        },
        Some("PathB (+20)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Merge node: Combine results from both branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let a = inputs.get("from_a").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let b = inputs.get("from_b").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            result.insert("combined".to_string(), format!("{} + {} = {}", a, b, a + b));
            result
        },
        Some("Merge"),
        vec![
            (branch_a_id, "result", "from_a"),  // Map branch A's "result" to merge fn's "from_a"
            (branch_b_id, "result", "from_b")   // Map branch B's "result" to merge fn's "from_b"
        ],
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A: 50 + 10 = 60");
    println!("  Branch B: 50 + 20 = 70");
    println!("  Merged: {}", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_graph() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 5: Complex Graph (All Features Combined)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // 1. Data ingestion
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw_data".to_string(), "1000".to_string());
            result
        },
        Some("Ingest"),
        None,
        Some(vec![("raw_data", "data")])
    );
    
    // 2. Preprocessing
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("raw").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("cleaned".to_string(), (val / 10).to_string());
            }
            result
        },
        Some("Preprocess"),
        Some(vec![("data", "raw")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    // 3. Branch for different analyses
    let mut stats_branch = Graph::new();
    stats_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("stats".to_string(), format!("Stats({})", val));
            }
            result
        },
        Some("Stats"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("stats", "statistics")])
    );
    
    let mut ml_branch = Graph::new();
    ml_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("prediction".to_string(), format!("Pred({})", val));
            }
            result
        },
        Some("ML"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("prediction", "ml_result")])
    );
    
    let stats_id = graph.branch(stats_branch);
    let ml_id = graph.branch(ml_branch);
    
    // 4. Merge branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let stats = inputs.get("stats_in").cloned().unwrap_or_default();
            let ml = inputs.get("ml_in").cloned().unwrap_or_default();
            result.insert("report".to_string(), format!("{} & {}", stats, ml));
            result
        },
        Some("Combine"),
        vec![
            (stats_id, "statistics", "stats_in"),
            (ml_id, "ml_result", "ml_in")
        ],
        Some(vec![("report", "final_report")])
    );
    
    // 5. Final output formatting
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(report) = inputs.get("report") {
                result.insert("formatted".to_string(), format!("[FINAL] {}", report));
            }
            result
        },
        Some("Format"),
        Some(vec![("final_report", "report")]),
        Some(vec![("formatted", "output")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Step 1: Ingest      → data = {}", context.get("data").unwrap());
    println!("  Step 2: Preprocess  → clean_data = {}", context.get("clean_data").unwrap());
    println!("  Step 3: Branch A    → statistics = {}", context.get("statistics").unwrap());
    println!("          Branch B    → ml_result = {}", context.get("ml_result").unwrap());
    println!("  Step 4: Merge       → final_report = {}", context.get("final_report").unwrap());
    println!("  Step 5: Format      → output = {}", context.get("output").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n📋 Execution Order:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        println!("  Level {}: {} nodes", level_idx, level.len());
        for &node_id in level {
            let node = dag.nodes().iter().find(|n| n.id == node_id).unwrap();
            println!("    - {}", node.display_name());
        }
    }
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
    
    println!("═══════════════════════════════════════════════════════════");
    println!("  Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/per_node_output_access.rs (line 29)

fn demo_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Per-Node Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 0: Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "initial_data")])
    );
    
    // Node 1: Double
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("doubled".to_string(), (value * 2).to_string());
            result
        },
        Some("Double"),
        Some(vec![("initial_data", "in")]),
        Some(vec![("doubled", "doubled_data")])
    );
    
    // Node 2: Add Ten
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("added".to_string(), (value + 10).to_string());
            result
        },
        Some("AddTen"),
        Some(vec![("doubled_data", "in")]),
        Some(vec![("added", "final_result")])
    );
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (all variables):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs:");
    println!("\nNode 0 (Source) outputs:");
    if let Some(outputs) = result.get_node_outputs(0) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 1 (Double) outputs:");
    if let Some(outputs) = result.get_node_outputs(1) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 2 (AddTen) outputs:");
    if let Some(outputs) = result.get_node_outputs(2) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific node outputs:");
    if let Some(value) = result.get_from_node(0, "initial_data") {
        println!("  Node 0 'initial_data': {}", value);
    }
    if let Some(value) = result.get_from_node(1, "doubled_data") {
        println!("  Node 1 'doubled_data': {}", value);
    }
    if let Some(value) = result.get_from_node(2, "final_result") {
        println!("  Node 2 'final_result': {}", value);
    }
    
    println!();
}

fn demo_per_branch_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Per-Branch Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Main graph: Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("stat_result".to_string(), format!("Mean of {}", value));
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stat_result", "statistics")])
    );
    
    // Branch B: Model Training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("model_result".to_string(), format!("Model trained on {}", value));
            result
        },
        Some("ModelTraining"),
        Some(vec![("data", "input")]),
        Some(vec![("model_result", "trained_model")])
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_result".to_string(), format!("Plot of {}", value));
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("viz_result", "plot")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    let branch_c_id = graph.branch(branch_c);
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context:");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🌿 Per-Branch Outputs:");
    
    println!("\nBranch {} (Statistics) outputs:", branch_a_id);
    if let Some(outputs) = result.get_branch_outputs(branch_a_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Model Training) outputs:", branch_b_id);
    if let Some(outputs) = result.get_branch_outputs(branch_b_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Visualization) outputs:", branch_c_id);
    if let Some(outputs) = result.get_branch_outputs(branch_c_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific branch outputs:");
    if let Some(value) = result.get_from_branch(branch_a_id, "statistics") {
        println!("  Branch {} 'statistics': {}", branch_a_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_b_id, "trained_model") {
        println!("  Branch {} 'trained_model': {}", branch_b_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_c_id, "plot") {
        println!("  Branch {} 'plot': {}", branch_c_id, value);
    }
    
    println!();
}

fn demo_variant_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Outputs with Per-Node Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory for scaling
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input_data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled_value".to_string(), (value * factor).to_string());
            result
        }
    }
    
    // Create variants with unique output names to preserve all results
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])  // Note: will overwrite in global context
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (note: 'result' contains last variant's output):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs (each variant tracked separately):");
    
    // Node 0 is the source
    // Nodes 1, 2, 3 are the variant nodes (2x, 3x, 5x scalers)
    for node_id in 1..=3 {
        println!("\nNode {} (Variant Scaler) outputs:", node_id);
        if let Some(outputs) = result.get_node_outputs(node_id) {
            for (key, value) in outputs {
                println!("  {} = {}", key, value);
            }
        }
    }
    
    println!("\n💡 Key Insight:");
    println!("  - Global context has 'result' = {} (last variant overwrites)", result.get("result").unwrap());
    println!("  - But per-node outputs preserve ALL variant results:");
    println!("    Node 1 (2x): result = {}", result.get_from_node(1, "result").unwrap());
    println!("    Node 2 (3x): result = {}", result.get_from_node(2, "result").unwrap());
    println!("    Node 3 (5x): result = {}", result.get_from_node(3, "result").unwrap());
    
    println!();
}

fn demo_execution_history_tracking() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Execution History Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Multi-stage pipeline
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "5".to_string());
            result
        },
        Some("Load"),
        None,
        Some(vec![("raw", "input")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("cleaned".to_string(), (value + 1).to_string());
            result
        },
        Some("Clean"),
        Some(vec![("input", "x")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("normalized".to_string(), (value * 10).to_string());
            result
        },
        Some("Normalize"),
        Some(vec![("clean_data", "x")]),
        Some(vec![("normalized", "norm_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("transformed".to_string(), format!("FINAL_{}", value));
            result
        },
        Some("Transform"),
        Some(vec![("norm_data", "x")]),
        Some(vec![("transformed", "output")])
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("📊 Execution History (Data Flow Tracking):");
    println!();
    println!("Step-by-step transformation:");
    println!("  1. Load:      input = {}", result.get_from_node(0, "input").unwrap());
    println!("  2. Clean:     clean_data = {}", result.get_from_node(1, "clean_data").unwrap());
    println!("  3. Normalize: norm_data = {}", result.get_from_node(2, "norm_data").unwrap());
    println!("  4. Transform: output = {}", result.get_from_node(3, "output").unwrap());
    
    println!("\n🔍 Debugging: Inspect any intermediate result:");
    println!("  Need to debug the normalization step?");
    println!("  Just check Node 2: {}", result.get_from_node(2, "norm_data").unwrap());
    
    println!("\n✅ Benefits of Per-Node Access:");
    println!("  ✓ Track data transformations step-by-step");
    println!("  ✓ Debug issues by inspecting intermediate values");
    println!("  ✓ Validate each processing stage independently");
    println!("  ✓ Preserve all variant outputs even with name collisions");
    
    println!();
}

examples/parallel_execution_demo.rs (line 37)

fn demo_sequential_vs_parallel() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Sequential vs Parallel Execution");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            result.insert("data".to_string(), "source_data".to_string());
            println!("    [{}ms] Source completed", start.elapsed().as_millis());
            result
        },
        Some("Source"),
        None,
        Some(vec![("data", "data")])
    );
    
    // Branch A: 100ms work
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch A completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchA[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_a")])
    );
    
    // Branch B: 100ms work
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch B completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchB[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_b")])
    );
    
    // Branch C: 100ms work
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch C completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchC[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_c")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    
    println!("\n📊 Sequential Execution (simulated):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let sequential_time = start.elapsed();
    println!("  Total time: {}ms", sequential_time.as_millis());
    
    println!("\n⚡ With Parallel Execution:");
    println!("  Expected time: ~100ms (all branches run simultaneously)");
    println!("  Speedup: ~3x faster than sequential");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("\n  Analysis:");
    println!("  - Level 0: 1 node  (Source)");
    println!("  - Level 1: 3 nodes (BranchA, BranchB, BranchC) ← Can run in parallel!");
    println!("  - Max parallelism: {} nodes can execute simultaneously", stats.max_parallelism);
    
    println!("\n🔍 Mermaid Visualization with Port Mappings:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_dependencies() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Complex Data Dependencies");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Two independent sources
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source1_data".to_string(), "100".to_string());
            result
        },
        Some("Source1"),
        None,
        Some(vec![("source1_data", "data1")])
    );
    
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source2_data".to_string(), "200".to_string());
            result
        },
        Some("Source2"),
        None,
        Some(vec![("source2_data", "data2")])
    );
    
    // Process each source independently (can run in parallel)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Process1[50ms]"),
        Some(vec![("data1", "in")]),
        Some(vec![("processed", "proc1")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 3).to_string());
            }
            result
        },
        Some("Process2[50ms]"),
        Some(vec![("data2", "in")]),
        Some(vec![("processed", "proc2")])
    );
    
    // Combine results (depends on both processors)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let v1 = inputs.get("p1").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let v2 = inputs.get("p2").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            thread::sleep(Duration::from_millis(30));
            result.insert("combined".to_string(), format!("{}", v1 + v2));
            result
        },
        Some("Combine[30ms]"),
        Some(vec![("proc1", "p1"), ("proc2", "p2")]),
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Execution with timing:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("  Source1: data1 = {}", context.get("data1").unwrap());
    println!("  Source2: data2 = {}", context.get("data2").unwrap());
    println!("  Process1: proc1 = {} (data1 * 2)", context.get("proc1").unwrap());
    println!("  Process2: proc2 = {} (data2 * 3)", context.get("proc2").unwrap());
    println!("  Combine: final = {} (proc1 + proc2)", context.get("final").unwrap());
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels (showing parallelism):");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
        if level.len() > 1 {
            println!("           ↑ {} nodes can execute in parallel!", level.len());
        }
    }
    
    println!("\n⚡ Parallel Execution Analysis:");
    println!("  Sequential time would be: 50+50+30 = 130ms");
    println!("  With parallelism: Level0→Level1(parallel)→Level2 = ~80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (shows data dependencies):");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variant_parallelism() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Parameter Sweep Parallelism");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "1000".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Variant factory with different multipliers
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                // Simulate 100ms of work
                thread::sleep(Duration::from_millis(100));
                result.insert("result".to_string(), format!("{:.1}", val * factor));
            }
            println!("    [{}ms] Variant (factor={}) completed", start.elapsed().as_millis(), factor);
            result
        }
    }
    
    // Create 5 variants
    graph.variant(
        make_multiplier,
        vec![0.5, 1.0, 1.5, 2.0, 2.5],
        Some("Multiply[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing 5 variants (each takes 100ms):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n⚡ Parallelism Analysis:");
    println!("  Sequential execution: 100 × 5 = 500ms");
    println!("  With parallel execution: ~100ms (all run simultaneously)");
    println!("  Speedup: 5x");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ↑ All {} variant nodes can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_diamond_pattern() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Diamond Pattern (Fan-Out → Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    println!("This pattern shows:");
    println!("  - One source splits into multiple parallel branches");
    println!("  - Branches are processed independently");
    println!("  - Results merge back into single output");
    
    let mut graph = Graph::new();
    
    // Top of diamond: Single source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "input_data".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("raw", "data")])
    );
    
    // Left branch: Transform A (50ms)
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformA", data));
            }
            println!("    [{}ms] Transform A completed", start.elapsed().as_millis());
            result
        },
        Some("TransformA[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    // Right branch: Transform B (50ms)
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformB", data));
            }
            println!("    [{}ms] Transform B completed", start.elapsed().as_millis());
            result
        },
        Some("TransformB[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Bottom of diamond: Merge (30ms)
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(30));
            let mut result = HashMap::new();
            let a = inputs.get("left").cloned().unwrap_or_default();
            let b = inputs.get("right").cloned().unwrap_or_default();
            result.insert("merged".to_string(), format!("[{}+{}]", a, b));
            println!("    [{}ms] Merge completed", start.elapsed().as_millis());
            result
        },
        Some("Merge[30ms]"),
        vec![
            (branch_a_id, "result", "left"),
            (branch_b_id, "result", "right")
        ],
        Some(vec![("merged", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing diamond pattern:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Result: {}", context.get("final").unwrap());
    println!("  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
    }
    
    println!("\n⚡ Timing Analysis:");
    println!("  Sequential: Source(0ms) + TransformA(50ms) + TransformB(50ms) + Merge(30ms) = 130ms");
    println!("  Parallel:   Source(0ms) → [TransformA + TransformB](50ms) → Merge(30ms) = 80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (Diamond Shape):");
    println!("{}", dag.to_mermaid());
    
    println!("\n  The visualization shows:");
    println!("  - Port mappings on edges (data→in, result→left, result→right)");
    println!("  - Data dependencies between nodes");
    println!("  - Parallel branches can execute simultaneously");
    
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Parallel Execution Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/tuple_api_demo.rs (line 14)

fn main() {
    println!("=== Tuple-Based API Demo ===\n");

    let mut graph = Graph::new();

    // Source node - no inputs, produces "dataset" in context
    fn data_source(_inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let mut outputs = HashMap::new();
        outputs.insert("raw".to_string(), "Sample Data".to_string());
        outputs
    }

    graph.add(
        data_source,
        Some("Source"),
        None,  // No inputs
        Some(vec![("raw", "dataset")])  // Function returns "raw", stored as "dataset" in context
    );

    println!("✓ Added source node");
    println!("  Output mapping: function's 'raw' → context's 'dataset'\n");

    // Process node - consumes "dataset" from context as "input_data", produces "processed_data" to context as "result"
    fn processor(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("input_data").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("processed_data".to_string(), format!("Processed: {}", data));
        outputs
    }

    graph.add(
        processor,
        Some("Process"),
        Some(vec![("dataset", "input_data")]),      // Context's "dataset" → function's "input_data"
        Some(vec![("processed_data", "result")])    // Function's "processed_data" → context's "result"
    );

    println!("✓ Added processor node");
    println!("  Input mapping: context's 'dataset' → function's 'input_data'");
    println!("  Output mapping: function's 'processed_data' → context's 'result'\n");

    // Create branches that both use the same variable names internally
    let mut branch_a = Graph::new();
    fn transform_a(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path A]", data));
        outputs
    }
    branch_a.add(
        transform_a,
        Some("Transform A"),
        Some(vec![("result", "x")]),  // Context's "result" → function's "x"
        Some(vec![("y", "output")])    // Function's "y" → context's "output"
    );

    let mut branch_b = Graph::new();
    fn transform_b(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path B]", data));
        outputs
    }
    branch_b.add(
        transform_b,
        Some("Transform B"),
        Some(vec![("result", "x")]),  // Same variable names as branch_a
        Some(vec![("y", "output")])    // Same variable names as branch_a
    );

    println!("✓ Created two branches");
    println!("  Both branches use same internal variable names (x, y)");
    println!("  Both map 'result' → 'x' and 'y' → 'output'\n");

    // Branch from the processor
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);

    println!("✓ Added branches to graph");
    println!("  Branch A ID: {}", branch_a_id);
    println!("  Branch B ID: {}\n", branch_b_id);

    // Merge branches with branch-specific variable resolution
    fn combine(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let a = inputs.get("from_a").unwrap_or(&default);
        let b = inputs.get("from_b").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("merged".to_string(), format!("Combined: {} + {}", a, b));
        outputs
    }

    graph.merge(
        combine,
        Some("Combine"),
        vec![
            (branch_a_id, "output", "from_a"),  // Branch A's "output" → merge function's "from_a"
            (branch_b_id, "output", "from_b")   // Branch B's "output" → merge function's "from_b"
        ],
        Some(vec![("merged", "final_result")])  // Merge function's "merged" → context's "final_result"
    );

    println!("✓ Added merge node");
    println!("  Branch-specific input mapping:");
    println!("    Branch {} 'output' → merge function's 'from_a'", branch_a_id);
    println!("    Branch {} 'output' → merge function's 'from_b'", branch_b_id);
    println!("  Output mapping: merge function's 'merged' → context's 'final_result'\n");

    // Variant example with factory pattern
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs, _variant| {
            let default = "1.0".to_string();
            let data = inputs.get("value").unwrap_or(&default);
            if let Ok(val) = data.parse::<f64>() {
                let mut outputs = HashMap::new();
                outputs.insert("scaled".to_string(), (val * factor).to_string());
                outputs
            } else {
                HashMap::new()
            }
        }
    }

    graph.variant(
        make_multiplier,
        vec![2.0, 3.0, 5.0],
        Some("Multiply"),
        Some(vec![("final_result", "value")]),  // Context's "final_result" → function's "value"
        Some(vec![("scaled", "multiplied")])    // Function's "scaled" → context's "multiplied"
    );

    println!("✓ Added variant nodes with parameter sweep");
    println!("  Three variants: factor = 2.0, 3.0, 5.0");
    println!("  Input mapping: context's 'final_result' → function's 'value'");
    println!("  Output mapping: function's 'scaled' → context's 'multiplied'\n");

    println!("=== Summary ===");
    println!("The tuple-based API provides clear separation between:");
    println!("1. Context variable names (broadcast vars) - shared across the graph");
    println!("2. Function parameter names (impl vars) - internal to each function");
    println!("\nThis allows:");
    println!("- Branches to use consistent internal naming (x, y)");
    println!("- Merge to distinguish branch outputs using branch IDs");
    println!("- Clear data flow visualization and debugging");
}

examples/variant_demo_full.rs (line 155)

fn main() {
    println!("═══════════════════════════════════════════════════════════");
    println!("  Variant Pattern Demo (sigexec-style)");
    println!("  Full Actual Syntax Examples");
    println!("═══════════════════════════════════════════════════════════\n");

    // =========================================================================
    // Demo 1: Single Variant - Basic Factory Pattern
    // =========================================================================
    println!("Demo 1: Single Variant with Factory Function");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_scaler(factor: f64) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"input_data\").unwrap().parse::<f64>().unwrap();");
    println!("        let scaled = value * factor;");
    println!("        outputs.insert(\"scaled_value\", scaled.to_string());");
    println!("    }}");
    println!("}}");
    println!();
    println!("let mut graph = Graph::new();");
    println!("graph.add(data_source, Some(\"Source\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(");
    println!("    make_scaler,              // Factory function");
    println!("    vec![2.0, 3.0, 5.0],      // Parameter values to sweep");
    println!("    Some(\"Scale\"),            // Label");
    println!("    Some(vec![(\"data\", \"input_data\")]),  // Input mapping");
    println!("    Some(vec![(\"scaled_value\", \"result\")])  // Output mapping");
    println!(");");
    println!("```\n");

    let mut graph1 = Graph::new();
    graph1.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph1.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag1 = graph1.build();
    println!("🎯 What happens:");
    println!("  • Factory creates 3 nodes: Scale_2.0, Scale_3.0, Scale_5.0");
    println!("  • Each node multiplies input by its factor");
    println!("  • All variants can execute in parallel");
    println!();
    
    let stats1 = dag1.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats1.node_count);
    println!("  - Depth: {} levels", stats1.depth);
    println!("  - Max parallelism: {} nodes can run simultaneously", stats1.max_parallelism);
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag1.to_mermaid());
    println!();

    // =========================================================================
    // Demo 2: Multiple Variants - Cartesian Product
    // =========================================================================
    println!("\nDemo 2: Multiple Variants (Cartesian Product)");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("graph.add(data_source, Some(\"Generate\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(make_scaler, vec![2.0, 3.0], Some(\"Scale\"), ...);");
    println!("graph.variant(make_offsetter, vec![10, 20], Some(\"Offset\"), ...);");
    println!("graph.add(stats_node, Some(\"Stats\"), Some(vec![(\"result\", \"result\")]), None);");
    println!("```\n");
    
    let mut graph2 = Graph::new();
    graph2.add(
        data_source,
        Some("Generate"),
        None,
        Some(vec![("value", "data")])
    );
    graph2.variant(
        make_scaler,
        vec![2.0, 3.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    graph2.variant(
        make_offsetter,
        vec![10, 20],
        Some("Offset"),
        Some(vec![("result", "number")]),
        Some(vec![("offset_result", "result")])
    );
    graph2.add(
        stats_node,
        Some("Stats"),
        Some(vec![("result", "result")]),
        Some(vec![("summary", "final")])
    );
    
    let dag2 = graph2.build();
    println!("🎯 What happens:");
    println!("  • Scale creates 2 variants: x2.0, x3.0");
    println!("  • Offset creates 2 variants: +10, +20");
    println!("  • Total combinations: 2 × 2 = 4 execution paths");
    println!("  • Each path: Generate → Scale[variant] → Offset[variant] → Stats");
    println!();
    
    let stats2 = dag2.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats2.node_count);
    println!("  - Depth: {} levels", stats2.depth);
    println!("  - Execution paths: 4 (2 scales × 2 offsets)");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag2.to_mermaid());
    println!();

    // =========================================================================
    // Demo 3: Complex Factory - Struct Configuration
    // =========================================================================
    println!("\nDemo 3: Complex Factory with Struct Configuration");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("#[derive(Clone)]");
    println!("struct FilterConfig {{");
    println!("    cutoff: f64,");
    println!("    mode: String,");
    println!("}}");
    println!();
    println!("fn make_filter(config: FilterConfig) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"data\").unwrap().parse::<f64>().unwrap();");
    println!("        let filtered = match config.mode.as_str() {{");
    println!("            \"lowpass\" => value * config.cutoff,");
    println!("            \"highpass\" => value * (1.0 - config.cutoff),");
    println!("            _ => value,");
    println!("        }};");
    println!("    }}");
    println!("}}");
    println!();
    println!("let configs = vec![");
    println!("    FilterConfig {{ cutoff: 0.5, mode: \"lowpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.3, mode: \"highpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.7, mode: \"lowpass\".to_string() }},");
    println!("];");
    println!("graph.variant(make_filter, configs, Some(\"Filter\"), ...);");
    println!("```\n");

    let configs = vec![
        FilterConfig { cutoff: 0.5, mode: "lowpass".to_string() },
        FilterConfig { cutoff: 0.3, mode: "highpass".to_string() },
        FilterConfig { cutoff: 0.7, mode: "lowpass".to_string() },
    ];
    
    let mut graph3 = Graph::new();
    graph3.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph3.variant(
        make_filter,
        configs,
        Some("Filter"),
        Some(vec![("data", "data")]),
        Some(vec![("filtered", "result")])
    );
    
    let dag3 = graph3.build();
    println!("🎯 What happens:");
    println!("  • 3 filter variants created with different configurations");
    println!("  • Each variant uses its own FilterConfig struct");
    println!("  • Demonstrates passing complex types to factory");
    println!();
    
    let stats3 = dag3.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats3.node_count);
    println!("  - Filter variants: 3");
    println!("  - Max parallelism: {} nodes", stats3.max_parallelism);
    println!();

    // =========================================================================
    // Demo 4: String Processing Variants
    // =========================================================================
    println!("\nDemo 4: String Processing Variants");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_processor(prefix: &'static str) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let text = inputs.get(\"text\").unwrap();");
    println!("        let processed = format!(\"[{{}}] {{}}\", prefix, text);");
    println!("        outputs.insert(\"processed_text\", processed);");
    println!("    }}");
    println!("}}");
    println!();
    println!("graph.variant(");
    println!("    make_processor,");
    println!("    vec![\"INFO\", \"WARN\", \"ERROR\"],");
    println!("    Some(\"LogLevel\"),");
    println!("    Some(vec![(\"message\", \"text\")]),");
    println!("    Some(vec![(\"processed_text\", \"log\")])");
    println!(");");
    println!("```\n");

    let mut graph4 = Graph::new();
    graph4.add(
        text_source,
        Some("Source"),
        None,
        Some(vec![("message", "message")])
    );
    graph4.variant(
        make_processor,
        vec!["INFO", "WARN", "ERROR"],
        Some("LogLevel"),
        Some(vec![("message", "text")]),
        Some(vec![("processed_text", "log")])
    );
    
    let dag4 = graph4.build();
    println!("🎯 What happens:");
    println!("  • 3 log level variants: INFO, WARN, ERROR");
    println!("  • Each prefixes the message with its log level");
    println!("  • Demonstrates string/static str parameters");
    println!();
    
    let stats4 = dag4.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats4.node_count);
    println!("  - Log variants: 3");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag4.to_mermaid());
    println!();

    // =========================================================================
    // Summary
    // =========================================================================
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Summary: Key Variant Pattern Features");
    println!("═══════════════════════════════════════════════════════════\n");
    
    println!("✅ Factory Function Pattern:");
    println!("   • Factory takes parameter(s), returns closure");
    println!("   • Closure captures parameters in its environment");
    println!("   • Same signature as regular node functions");
    println!();
    
    println!("✅ Parameter Flexibility:");
    println!("   • Primitives: f64, i32, &str");
    println!("   • Structs: Custom configuration objects");
    println!("   • Arrays/Vectors: Multiple values at once");
    println!();
    
    println!("✅ Cartesian Products:");
    println!("   • Multiple .variant() calls create all combinations");
    println!("   • Example: 2 scales × 3 filters = 6 execution paths");
    println!();
    
    println!("✅ Port Mapping:");
    println!("   • Variants use same tuple-based syntax");
    println!("   • (broadcast_var, impl_var) for inputs");
    println!("   • (impl_var, broadcast_var) for outputs");
    println!();
    
    println!("✅ Parallel Execution:");
    println!("   • All variants at same level can run in parallel");
    println!("   • DAG analysis identifies parallelization opportunities");
    println!();
}

pub fn add<F>( &mut self, function_handle: F, label: Option<&str>, inputs: Option<Vec<(&str, &str)>>, outputs: Option<Vec<(&str, &str)>>, ) -> &mut Self

where F: Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + Send + Sync + 'static,

Add a node to the graph with implicit connections

Arguments

• function_handle - The function to execute for this node
• label - Optional label for visualization
• inputs - Optional list of (broadcast_var, impl_var) tuples for inputs
• outputs - Optional list of (impl_var, broadcast_var) tuples for outputs

Implicit Connection Behavior

• The first node added has no dependencies
• Subsequent nodes automatically depend on the previous node
• This creates a natural sequential flow unless .branch() is used

Function Signature

Functions receive two parameters:

• inputs: &HashMap<String, String> - Mapped input variables (impl_var names)
• variant_params: &HashMap<String, String> - Variant parameter values

Functions return outputs using impl_var names, which get mapped to broadcast_var names.

Example

// Function sees "input_data", context has "data"
// Function returns "output_value", gets stored as "result" in context
graph.add(
    process_fn,
    Some("Process"),
    Some(vec![("data", "input_data")]),     // (broadcast, impl)
    Some(vec![("output_value", "result")])  // (impl, broadcast)
);

Examples found in repository

examples/output_access_demo.rs (lines 32-41)

fn demo_simple_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Pipeline Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 1: Generate initial data
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("initial_value".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("initial_value", "raw_data")])  // Maps initial_value → raw_data
    );
    
    // Node 2: Process the data
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("processed".to_string(), (value * 2).to_string());
            result
        },
        Some("Process"),
        Some(vec![("raw_data", "input")]),      // Maps raw_data → input
        Some(vec![("processed", "final_result")])  // Maps processed → final_result
    );
    
    // Build and execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Execution Context (all variables):");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🎯 Accessing specific outputs:");
    
    // Access by broadcast variable name (what's in the graph context)
    if let Some(raw_data) = context.get("raw_data") {
        println!("  raw_data: {}", raw_data);
    }
    
    if let Some(final_result) = context.get("final_result") {
        println!("  final_result: {}", final_result);
    }
    
    // Check if a variable exists
    if context.contains_key("final_result") {
        println!("\n✅ Final result is available in context");
    }
    
    println!();
}

fn demo_branch_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Branch Output Access (Parallel Paths)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "shared_data")])
    );
    
    // Branch A: Statistics computation
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("stats_output".to_string(), format!("Stats of {}", val));
            result
        },
        Some("Stats"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("stats_output", "statistics")])  // Branch A produces "statistics"
    );
    
    // Branch B: Model training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("model_output".to_string(), format!("Model trained on {}", val));
            result
        },
        Some("Train"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("model_output", "model")])  // Branch B produces "model"
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_output".to_string(), format!("Plot of {}", val));
            result
        },
        Some("Visualize"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("viz_output", "visualization")])  // Branch C produces "visualization"
    );
    
    // Add branches to main graph
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 All outputs from parallel branches:");
    
    // Access each branch's output
    if let Some(stats) = context.get("statistics") {
        println!("  Branch A (Statistics): {}", stats);
    }
    
    if let Some(model) = context.get("model") {
        println!("  Branch B (Model): {}", model);
    }
    
    if let Some(viz) = context.get("visualization") {
        println!("  Branch C (Visualization): {}", viz);
    }
    
    println!("\n🔍 All variables in context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!();
}

fn demo_variant_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Output Access (Parameter Sweep)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant nodes: scale by different factors
    // Factory function that creates a scaler for each factor
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled".to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled", "result")])  // Each variant produces "result"
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Variant outputs:");
    println!("  Note: Variants with same output name overwrite each other");
    println!("  The last variant (factor=5.0) writes to 'result'\n");
    
    // Access the result (will be from the last variant)
    if let Some(result) = context.get("result") {
        println!("  result = {} (from last variant: 10.0 * 5.0)", result);
    }
    
    println!("\n💡 Tip: To preserve all variant outputs, use unique output names:");
    println!("   Option 1: Map each variant to a different broadcast variable");
    println!("   Option 2: Collect results in merge node");
    println!("   Option 3: Use variant_params or closure capture to distinguish");
    
    // Better approach: unique output names per variant
    let mut graph2 = Graph::new();
    
    graph2.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant 1: 2x
    fn make_scaler_unique(label: &str, factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + '_ {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert(label.to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_2x", 2.0),
        vec!["2x"],
        Some("Scale2x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_2x", "result_2x")])
    );
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_3x", 3.0),
        vec!["3x"],
        Some("Scale3x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_3x", "result_3x")])
    );
    
    let dag2 = graph2.build();
    let context2 = dag2.execute(false, None);
    
    println!("\n✅ Better approach - unique output names:");
    if let Some(result_2x) = context2.get("result_2x") {
        println!("  result_2x = {}", result_2x);
    }
    if let Some(result_3x) = context2.get("result_3x") {
        println!("  result_3x = {}", result_3x);
    }
    
    println!();
}

fn demo_multiple_outputs() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Multiple Outputs from Single Node");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node that produces multiple outputs
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("mean".to_string(), "50.5".to_string());
            result.insert("median".to_string(), "48.0".to_string());
            result.insert("stddev".to_string(), "12.3".to_string());
            result.insert("count".to_string(), "100".to_string());
            result
        },
        Some("Statistics"),
        None,
        Some(vec![
            ("mean", "stat_mean"),
            ("median", "stat_median"),
            ("stddev", "stat_stddev"),
            ("count", "sample_count")
        ])
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📊 Multiple outputs from single node:");
    
    // Access each output individually
    println!("  Mean:   {}", context.get("stat_mean").unwrap());
    println!("  Median: {}", context.get("stat_median").unwrap());
    println!("  StdDev: {}", context.get("stat_stddev").unwrap());
    println!("  Count:  {}", context.get("sample_count").unwrap());
    
    println!("\n📋 Complete execution context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n💡 Summary:");
    println!("  ✓ dag.execute(false, None) returns HashMap<String, String>");
    println!("  ✓ Keys are broadcast variable names (from output mappings)");
    println!("  ✓ Use context.get(\"variable_name\") to access specific outputs");
    println!("  ✓ All outputs accumulate in the context throughout execution");
    
    println!();
}

examples/comprehensive_demo.rs (lines 36-45)

fn demo_simple_pipeline() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Sequential Pipeline");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Data source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "42".to_string());
            result
        },
        Some("DataSource"),
        None,                                      // No inputs (source node)
        Some(vec![("value", "data")])              // (impl_var, broadcast_var)
    );
    
    // Processing node: multiply by 2
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("doubled".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Multiply"),
        Some(vec![("data", "x")]),                 // (broadcast_var, impl_var)
        Some(vec![("doubled", "result")])          // (impl_var, broadcast_var)
    );
    
    // Final processing: add 10
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("num").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("sum".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("AddTen"),
        Some(vec![("result", "num")]),
        Some(vec![("sum", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Input:  data = {}", context.get("data").unwrap());
    println!("  Step 1: result = {} (data * 2)", context.get("result").unwrap());
    println!("  Step 2: final = {} (result + 10)", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_branching() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Parallel Branching (Fan-Out)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Compute statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("stats".to_string(), format!("Mean: {}", val));
            }
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stats", "stats_result")])
    );
    
    // Branch B: Train model
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("model".to_string(), format!("Model trained on {}", val));
            }
            result
        },
        Some("MLModel"),
        Some(vec![("data", "input")]),
        Some(vec![("model", "model_result")])
    );
    
    // Branch C: Generate visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("plot".to_string(), format!("Plot of {}", val));
            }
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("plot", "viz_result")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A (Stats): {}", context.get("stats_result").unwrap());
    println!("  Branch B (Model): {}", context.get("model_result").unwrap());
    println!("  Branch C (Viz):   {}", context.get("viz_result").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All 3 branches can execute in parallel!");
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_merging() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Branching + Merging (Fan-Out + Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Branch A: Add 10
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("PathA (+10)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    // Branch B: Add 20
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 20).to_string());
            }
            result
        },
        Some("PathB (+20)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Merge node: Combine results from both branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let a = inputs.get("from_a").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let b = inputs.get("from_b").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            result.insert("combined".to_string(), format!("{} + {} = {}", a, b, a + b));
            result
        },
        Some("Merge"),
        vec![
            (branch_a_id, "result", "from_a"),  // Map branch A's "result" to merge fn's "from_a"
            (branch_b_id, "result", "from_b")   // Map branch B's "result" to merge fn's "from_b"
        ],
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A: 50 + 10 = 60");
    println!("  Branch B: 50 + 20 = 70");
    println!("  Merged: {}", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_graph() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 5: Complex Graph (All Features Combined)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // 1. Data ingestion
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw_data".to_string(), "1000".to_string());
            result
        },
        Some("Ingest"),
        None,
        Some(vec![("raw_data", "data")])
    );
    
    // 2. Preprocessing
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("raw").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("cleaned".to_string(), (val / 10).to_string());
            }
            result
        },
        Some("Preprocess"),
        Some(vec![("data", "raw")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    // 3. Branch for different analyses
    let mut stats_branch = Graph::new();
    stats_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("stats".to_string(), format!("Stats({})", val));
            }
            result
        },
        Some("Stats"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("stats", "statistics")])
    );
    
    let mut ml_branch = Graph::new();
    ml_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("prediction".to_string(), format!("Pred({})", val));
            }
            result
        },
        Some("ML"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("prediction", "ml_result")])
    );
    
    let stats_id = graph.branch(stats_branch);
    let ml_id = graph.branch(ml_branch);
    
    // 4. Merge branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let stats = inputs.get("stats_in").cloned().unwrap_or_default();
            let ml = inputs.get("ml_in").cloned().unwrap_or_default();
            result.insert("report".to_string(), format!("{} & {}", stats, ml));
            result
        },
        Some("Combine"),
        vec![
            (stats_id, "statistics", "stats_in"),
            (ml_id, "ml_result", "ml_in")
        ],
        Some(vec![("report", "final_report")])
    );
    
    // 5. Final output formatting
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(report) = inputs.get("report") {
                result.insert("formatted".to_string(), format!("[FINAL] {}", report));
            }
            result
        },
        Some("Format"),
        Some(vec![("final_report", "report")]),
        Some(vec![("formatted", "output")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Step 1: Ingest      → data = {}", context.get("data").unwrap());
    println!("  Step 2: Preprocess  → clean_data = {}", context.get("clean_data").unwrap());
    println!("  Step 3: Branch A    → statistics = {}", context.get("statistics").unwrap());
    println!("          Branch B    → ml_result = {}", context.get("ml_result").unwrap());
    println!("  Step 4: Merge       → final_report = {}", context.get("final_report").unwrap());
    println!("  Step 5: Format      → output = {}", context.get("output").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n📋 Execution Order:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        println!("  Level {}: {} nodes", level_idx, level.len());
        for &node_id in level {
            let node = dag.nodes().iter().find(|n| n.id == node_id).unwrap();
            println!("    - {}", node.display_name());
        }
    }
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
    
    println!("═══════════════════════════════════════════════════════════");
    println!("  Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/per_node_output_access.rs (lines 32-41)

fn demo_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Per-Node Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 0: Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "initial_data")])
    );
    
    // Node 1: Double
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("doubled".to_string(), (value * 2).to_string());
            result
        },
        Some("Double"),
        Some(vec![("initial_data", "in")]),
        Some(vec![("doubled", "doubled_data")])
    );
    
    // Node 2: Add Ten
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("added".to_string(), (value + 10).to_string());
            result
        },
        Some("AddTen"),
        Some(vec![("doubled_data", "in")]),
        Some(vec![("added", "final_result")])
    );
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (all variables):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs:");
    println!("\nNode 0 (Source) outputs:");
    if let Some(outputs) = result.get_node_outputs(0) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 1 (Double) outputs:");
    if let Some(outputs) = result.get_node_outputs(1) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 2 (AddTen) outputs:");
    if let Some(outputs) = result.get_node_outputs(2) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific node outputs:");
    if let Some(value) = result.get_from_node(0, "initial_data") {
        println!("  Node 0 'initial_data': {}", value);
    }
    if let Some(value) = result.get_from_node(1, "doubled_data") {
        println!("  Node 1 'doubled_data': {}", value);
    }
    if let Some(value) = result.get_from_node(2, "final_result") {
        println!("  Node 2 'final_result': {}", value);
    }
    
    println!();
}

fn demo_per_branch_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Per-Branch Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Main graph: Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("stat_result".to_string(), format!("Mean of {}", value));
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stat_result", "statistics")])
    );
    
    // Branch B: Model Training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("model_result".to_string(), format!("Model trained on {}", value));
            result
        },
        Some("ModelTraining"),
        Some(vec![("data", "input")]),
        Some(vec![("model_result", "trained_model")])
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_result".to_string(), format!("Plot of {}", value));
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("viz_result", "plot")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    let branch_c_id = graph.branch(branch_c);
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context:");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🌿 Per-Branch Outputs:");
    
    println!("\nBranch {} (Statistics) outputs:", branch_a_id);
    if let Some(outputs) = result.get_branch_outputs(branch_a_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Model Training) outputs:", branch_b_id);
    if let Some(outputs) = result.get_branch_outputs(branch_b_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Visualization) outputs:", branch_c_id);
    if let Some(outputs) = result.get_branch_outputs(branch_c_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific branch outputs:");
    if let Some(value) = result.get_from_branch(branch_a_id, "statistics") {
        println!("  Branch {} 'statistics': {}", branch_a_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_b_id, "trained_model") {
        println!("  Branch {} 'trained_model': {}", branch_b_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_c_id, "plot") {
        println!("  Branch {} 'plot': {}", branch_c_id, value);
    }
    
    println!();
}

fn demo_variant_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Outputs with Per-Node Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory for scaling
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input_data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled_value".to_string(), (value * factor).to_string());
            result
        }
    }
    
    // Create variants with unique output names to preserve all results
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])  // Note: will overwrite in global context
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (note: 'result' contains last variant's output):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs (each variant tracked separately):");
    
    // Node 0 is the source
    // Nodes 1, 2, 3 are the variant nodes (2x, 3x, 5x scalers)
    for node_id in 1..=3 {
        println!("\nNode {} (Variant Scaler) outputs:", node_id);
        if let Some(outputs) = result.get_node_outputs(node_id) {
            for (key, value) in outputs {
                println!("  {} = {}", key, value);
            }
        }
    }
    
    println!("\n💡 Key Insight:");
    println!("  - Global context has 'result' = {} (last variant overwrites)", result.get("result").unwrap());
    println!("  - But per-node outputs preserve ALL variant results:");
    println!("    Node 1 (2x): result = {}", result.get_from_node(1, "result").unwrap());
    println!("    Node 2 (3x): result = {}", result.get_from_node(2, "result").unwrap());
    println!("    Node 3 (5x): result = {}", result.get_from_node(3, "result").unwrap());
    
    println!();
}

fn demo_execution_history_tracking() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Execution History Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Multi-stage pipeline
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "5".to_string());
            result
        },
        Some("Load"),
        None,
        Some(vec![("raw", "input")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("cleaned".to_string(), (value + 1).to_string());
            result
        },
        Some("Clean"),
        Some(vec![("input", "x")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("normalized".to_string(), (value * 10).to_string());
            result
        },
        Some("Normalize"),
        Some(vec![("clean_data", "x")]),
        Some(vec![("normalized", "norm_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("transformed".to_string(), format!("FINAL_{}", value));
            result
        },
        Some("Transform"),
        Some(vec![("norm_data", "x")]),
        Some(vec![("transformed", "output")])
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("📊 Execution History (Data Flow Tracking):");
    println!();
    println!("Step-by-step transformation:");
    println!("  1. Load:      input = {}", result.get_from_node(0, "input").unwrap());
    println!("  2. Clean:     clean_data = {}", result.get_from_node(1, "clean_data").unwrap());
    println!("  3. Normalize: norm_data = {}", result.get_from_node(2, "norm_data").unwrap());
    println!("  4. Transform: output = {}", result.get_from_node(3, "output").unwrap());
    
    println!("\n🔍 Debugging: Inspect any intermediate result:");
    println!("  Need to debug the normalization step?");
    println!("  Just check Node 2: {}", result.get_from_node(2, "norm_data").unwrap());
    
    println!("\n✅ Benefits of Per-Node Access:");
    println!("  ✓ Track data transformations step-by-step");
    println!("  ✓ Debug issues by inspecting intermediate values");
    println!("  ✓ Validate each processing stage independently");
    println!("  ✓ Preserve all variant outputs even with name collisions");
    
    println!();
}

examples/parallel_execution_demo.rs (lines 40-51)

fn demo_sequential_vs_parallel() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Sequential vs Parallel Execution");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            result.insert("data".to_string(), "source_data".to_string());
            println!("    [{}ms] Source completed", start.elapsed().as_millis());
            result
        },
        Some("Source"),
        None,
        Some(vec![("data", "data")])
    );
    
    // Branch A: 100ms work
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch A completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchA[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_a")])
    );
    
    // Branch B: 100ms work
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch B completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchB[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_b")])
    );
    
    // Branch C: 100ms work
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch C completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchC[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_c")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    
    println!("\n📊 Sequential Execution (simulated):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let sequential_time = start.elapsed();
    println!("  Total time: {}ms", sequential_time.as_millis());
    
    println!("\n⚡ With Parallel Execution:");
    println!("  Expected time: ~100ms (all branches run simultaneously)");
    println!("  Speedup: ~3x faster than sequential");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("\n  Analysis:");
    println!("  - Level 0: 1 node  (Source)");
    println!("  - Level 1: 3 nodes (BranchA, BranchB, BranchC) ← Can run in parallel!");
    println!("  - Max parallelism: {} nodes can execute simultaneously", stats.max_parallelism);
    
    println!("\n🔍 Mermaid Visualization with Port Mappings:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_dependencies() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Complex Data Dependencies");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Two independent sources
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source1_data".to_string(), "100".to_string());
            result
        },
        Some("Source1"),
        None,
        Some(vec![("source1_data", "data1")])
    );
    
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source2_data".to_string(), "200".to_string());
            result
        },
        Some("Source2"),
        None,
        Some(vec![("source2_data", "data2")])
    );
    
    // Process each source independently (can run in parallel)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Process1[50ms]"),
        Some(vec![("data1", "in")]),
        Some(vec![("processed", "proc1")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 3).to_string());
            }
            result
        },
        Some("Process2[50ms]"),
        Some(vec![("data2", "in")]),
        Some(vec![("processed", "proc2")])
    );
    
    // Combine results (depends on both processors)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let v1 = inputs.get("p1").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let v2 = inputs.get("p2").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            thread::sleep(Duration::from_millis(30));
            result.insert("combined".to_string(), format!("{}", v1 + v2));
            result
        },
        Some("Combine[30ms]"),
        Some(vec![("proc1", "p1"), ("proc2", "p2")]),
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Execution with timing:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("  Source1: data1 = {}", context.get("data1").unwrap());
    println!("  Source2: data2 = {}", context.get("data2").unwrap());
    println!("  Process1: proc1 = {} (data1 * 2)", context.get("proc1").unwrap());
    println!("  Process2: proc2 = {} (data2 * 3)", context.get("proc2").unwrap());
    println!("  Combine: final = {} (proc1 + proc2)", context.get("final").unwrap());
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels (showing parallelism):");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
        if level.len() > 1 {
            println!("           ↑ {} nodes can execute in parallel!", level.len());
        }
    }
    
    println!("\n⚡ Parallel Execution Analysis:");
    println!("  Sequential time would be: 50+50+30 = 130ms");
    println!("  With parallelism: Level0→Level1(parallel)→Level2 = ~80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (shows data dependencies):");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variant_parallelism() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Parameter Sweep Parallelism");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "1000".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Variant factory with different multipliers
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                // Simulate 100ms of work
                thread::sleep(Duration::from_millis(100));
                result.insert("result".to_string(), format!("{:.1}", val * factor));
            }
            println!("    [{}ms] Variant (factor={}) completed", start.elapsed().as_millis(), factor);
            result
        }
    }
    
    // Create 5 variants
    graph.variant(
        make_multiplier,
        vec![0.5, 1.0, 1.5, 2.0, 2.5],
        Some("Multiply[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing 5 variants (each takes 100ms):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n⚡ Parallelism Analysis:");
    println!("  Sequential execution: 100 × 5 = 500ms");
    println!("  With parallel execution: ~100ms (all run simultaneously)");
    println!("  Speedup: 5x");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ↑ All {} variant nodes can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_diamond_pattern() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Diamond Pattern (Fan-Out → Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    println!("This pattern shows:");
    println!("  - One source splits into multiple parallel branches");
    println!("  - Branches are processed independently");
    println!("  - Results merge back into single output");
    
    let mut graph = Graph::new();
    
    // Top of diamond: Single source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "input_data".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("raw", "data")])
    );
    
    // Left branch: Transform A (50ms)
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformA", data));
            }
            println!("    [{}ms] Transform A completed", start.elapsed().as_millis());
            result
        },
        Some("TransformA[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    // Right branch: Transform B (50ms)
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformB", data));
            }
            println!("    [{}ms] Transform B completed", start.elapsed().as_millis());
            result
        },
        Some("TransformB[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Bottom of diamond: Merge (30ms)
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(30));
            let mut result = HashMap::new();
            let a = inputs.get("left").cloned().unwrap_or_default();
            let b = inputs.get("right").cloned().unwrap_or_default();
            result.insert("merged".to_string(), format!("[{}+{}]", a, b));
            println!("    [{}ms] Merge completed", start.elapsed().as_millis());
            result
        },
        Some("Merge[30ms]"),
        vec![
            (branch_a_id, "result", "left"),
            (branch_b_id, "result", "right")
        ],
        Some(vec![("merged", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing diamond pattern:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Result: {}", context.get("final").unwrap());
    println!("  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
    }
    
    println!("\n⚡ Timing Analysis:");
    println!("  Sequential: Source(0ms) + TransformA(50ms) + TransformB(50ms) + Merge(30ms) = 130ms");
    println!("  Parallel:   Source(0ms) → [TransformA + TransformB](50ms) → Merge(30ms) = 80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (Diamond Shape):");
    println!("{}", dag.to_mermaid());
    
    println!("\n  The visualization shows:");
    println!("  - Port mappings on edges (data→in, result→left, result→right)");
    println!("  - Data dependencies between nodes");
    println!("  - Parallel branches can execute simultaneously");
    
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Parallel Execution Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/tuple_api_demo.rs (lines 23-28)

fn main() {
    println!("=== Tuple-Based API Demo ===\n");

    let mut graph = Graph::new();

    // Source node - no inputs, produces "dataset" in context
    fn data_source(_inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let mut outputs = HashMap::new();
        outputs.insert("raw".to_string(), "Sample Data".to_string());
        outputs
    }

    graph.add(
        data_source,
        Some("Source"),
        None,  // No inputs
        Some(vec![("raw", "dataset")])  // Function returns "raw", stored as "dataset" in context
    );

    println!("✓ Added source node");
    println!("  Output mapping: function's 'raw' → context's 'dataset'\n");

    // Process node - consumes "dataset" from context as "input_data", produces "processed_data" to context as "result"
    fn processor(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("input_data").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("processed_data".to_string(), format!("Processed: {}", data));
        outputs
    }

    graph.add(
        processor,
        Some("Process"),
        Some(vec![("dataset", "input_data")]),      // Context's "dataset" → function's "input_data"
        Some(vec![("processed_data", "result")])    // Function's "processed_data" → context's "result"
    );

    println!("✓ Added processor node");
    println!("  Input mapping: context's 'dataset' → function's 'input_data'");
    println!("  Output mapping: function's 'processed_data' → context's 'result'\n");

    // Create branches that both use the same variable names internally
    let mut branch_a = Graph::new();
    fn transform_a(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path A]", data));
        outputs
    }
    branch_a.add(
        transform_a,
        Some("Transform A"),
        Some(vec![("result", "x")]),  // Context's "result" → function's "x"
        Some(vec![("y", "output")])    // Function's "y" → context's "output"
    );

    let mut branch_b = Graph::new();
    fn transform_b(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path B]", data));
        outputs
    }
    branch_b.add(
        transform_b,
        Some("Transform B"),
        Some(vec![("result", "x")]),  // Same variable names as branch_a
        Some(vec![("y", "output")])    // Same variable names as branch_a
    );

    println!("✓ Created two branches");
    println!("  Both branches use same internal variable names (x, y)");
    println!("  Both map 'result' → 'x' and 'y' → 'output'\n");

    // Branch from the processor
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);

    println!("✓ Added branches to graph");
    println!("  Branch A ID: {}", branch_a_id);
    println!("  Branch B ID: {}\n", branch_b_id);

    // Merge branches with branch-specific variable resolution
    fn combine(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let a = inputs.get("from_a").unwrap_or(&default);
        let b = inputs.get("from_b").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("merged".to_string(), format!("Combined: {} + {}", a, b));
        outputs
    }

    graph.merge(
        combine,
        Some("Combine"),
        vec![
            (branch_a_id, "output", "from_a"),  // Branch A's "output" → merge function's "from_a"
            (branch_b_id, "output", "from_b")   // Branch B's "output" → merge function's "from_b"
        ],
        Some(vec![("merged", "final_result")])  // Merge function's "merged" → context's "final_result"
    );

    println!("✓ Added merge node");
    println!("  Branch-specific input mapping:");
    println!("    Branch {} 'output' → merge function's 'from_a'", branch_a_id);
    println!("    Branch {} 'output' → merge function's 'from_b'", branch_b_id);
    println!("  Output mapping: merge function's 'merged' → context's 'final_result'\n");

    // Variant example with factory pattern
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs, _variant| {
            let default = "1.0".to_string();
            let data = inputs.get("value").unwrap_or(&default);
            if let Ok(val) = data.parse::<f64>() {
                let mut outputs = HashMap::new();
                outputs.insert("scaled".to_string(), (val * factor).to_string());
                outputs
            } else {
                HashMap::new()
            }
        }
    }

    graph.variant(
        make_multiplier,
        vec![2.0, 3.0, 5.0],
        Some("Multiply"),
        Some(vec![("final_result", "value")]),  // Context's "final_result" → function's "value"
        Some(vec![("scaled", "multiplied")])    // Function's "scaled" → context's "multiplied"
    );

    println!("✓ Added variant nodes with parameter sweep");
    println!("  Three variants: factor = 2.0, 3.0, 5.0");
    println!("  Input mapping: context's 'final_result' → function's 'value'");
    println!("  Output mapping: function's 'scaled' → context's 'multiplied'\n");

    println!("=== Summary ===");
    println!("The tuple-based API provides clear separation between:");
    println!("1. Context variable names (broadcast vars) - shared across the graph");
    println!("2. Function parameter names (impl vars) - internal to each function");
    println!("\nThis allows:");
    println!("- Branches to use consistent internal naming (x, y)");
    println!("- Merge to distinguish branch outputs using branch IDs");
    println!("- Clear data flow visualization and debugging");
}

examples/variant_demo_full.rs (lines 156-161)

fn main() {
    println!("═══════════════════════════════════════════════════════════");
    println!("  Variant Pattern Demo (sigexec-style)");
    println!("  Full Actual Syntax Examples");
    println!("═══════════════════════════════════════════════════════════\n");

    // =========================================================================
    // Demo 1: Single Variant - Basic Factory Pattern
    // =========================================================================
    println!("Demo 1: Single Variant with Factory Function");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_scaler(factor: f64) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"input_data\").unwrap().parse::<f64>().unwrap();");
    println!("        let scaled = value * factor;");
    println!("        outputs.insert(\"scaled_value\", scaled.to_string());");
    println!("    }}");
    println!("}}");
    println!();
    println!("let mut graph = Graph::new();");
    println!("graph.add(data_source, Some(\"Source\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(");
    println!("    make_scaler,              // Factory function");
    println!("    vec![2.0, 3.0, 5.0],      // Parameter values to sweep");
    println!("    Some(\"Scale\"),            // Label");
    println!("    Some(vec![(\"data\", \"input_data\")]),  // Input mapping");
    println!("    Some(vec![(\"scaled_value\", \"result\")])  // Output mapping");
    println!(");");
    println!("```\n");

    let mut graph1 = Graph::new();
    graph1.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph1.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag1 = graph1.build();
    println!("🎯 What happens:");
    println!("  • Factory creates 3 nodes: Scale_2.0, Scale_3.0, Scale_5.0");
    println!("  • Each node multiplies input by its factor");
    println!("  • All variants can execute in parallel");
    println!();
    
    let stats1 = dag1.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats1.node_count);
    println!("  - Depth: {} levels", stats1.depth);
    println!("  - Max parallelism: {} nodes can run simultaneously", stats1.max_parallelism);
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag1.to_mermaid());
    println!();

    // =========================================================================
    // Demo 2: Multiple Variants - Cartesian Product
    // =========================================================================
    println!("\nDemo 2: Multiple Variants (Cartesian Product)");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("graph.add(data_source, Some(\"Generate\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(make_scaler, vec![2.0, 3.0], Some(\"Scale\"), ...);");
    println!("graph.variant(make_offsetter, vec![10, 20], Some(\"Offset\"), ...);");
    println!("graph.add(stats_node, Some(\"Stats\"), Some(vec![(\"result\", \"result\")]), None);");
    println!("```\n");
    
    let mut graph2 = Graph::new();
    graph2.add(
        data_source,
        Some("Generate"),
        None,
        Some(vec![("value", "data")])
    );
    graph2.variant(
        make_scaler,
        vec![2.0, 3.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    graph2.variant(
        make_offsetter,
        vec![10, 20],
        Some("Offset"),
        Some(vec![("result", "number")]),
        Some(vec![("offset_result", "result")])
    );
    graph2.add(
        stats_node,
        Some("Stats"),
        Some(vec![("result", "result")]),
        Some(vec![("summary", "final")])
    );
    
    let dag2 = graph2.build();
    println!("🎯 What happens:");
    println!("  • Scale creates 2 variants: x2.0, x3.0");
    println!("  • Offset creates 2 variants: +10, +20");
    println!("  • Total combinations: 2 × 2 = 4 execution paths");
    println!("  • Each path: Generate → Scale[variant] → Offset[variant] → Stats");
    println!();
    
    let stats2 = dag2.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats2.node_count);
    println!("  - Depth: {} levels", stats2.depth);
    println!("  - Execution paths: 4 (2 scales × 2 offsets)");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag2.to_mermaid());
    println!();

    // =========================================================================
    // Demo 3: Complex Factory - Struct Configuration
    // =========================================================================
    println!("\nDemo 3: Complex Factory with Struct Configuration");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("#[derive(Clone)]");
    println!("struct FilterConfig {{");
    println!("    cutoff: f64,");
    println!("    mode: String,");
    println!("}}");
    println!();
    println!("fn make_filter(config: FilterConfig) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"data\").unwrap().parse::<f64>().unwrap();");
    println!("        let filtered = match config.mode.as_str() {{");
    println!("            \"lowpass\" => value * config.cutoff,");
    println!("            \"highpass\" => value * (1.0 - config.cutoff),");
    println!("            _ => value,");
    println!("        }};");
    println!("    }}");
    println!("}}");
    println!();
    println!("let configs = vec![");
    println!("    FilterConfig {{ cutoff: 0.5, mode: \"lowpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.3, mode: \"highpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.7, mode: \"lowpass\".to_string() }},");
    println!("];");
    println!("graph.variant(make_filter, configs, Some(\"Filter\"), ...);");
    println!("```\n");

    let configs = vec![
        FilterConfig { cutoff: 0.5, mode: "lowpass".to_string() },
        FilterConfig { cutoff: 0.3, mode: "highpass".to_string() },
        FilterConfig { cutoff: 0.7, mode: "lowpass".to_string() },
    ];
    
    let mut graph3 = Graph::new();
    graph3.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph3.variant(
        make_filter,
        configs,
        Some("Filter"),
        Some(vec![("data", "data")]),
        Some(vec![("filtered", "result")])
    );
    
    let dag3 = graph3.build();
    println!("🎯 What happens:");
    println!("  • 3 filter variants created with different configurations");
    println!("  • Each variant uses its own FilterConfig struct");
    println!("  • Demonstrates passing complex types to factory");
    println!();
    
    let stats3 = dag3.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats3.node_count);
    println!("  - Filter variants: 3");
    println!("  - Max parallelism: {} nodes", stats3.max_parallelism);
    println!();

    // =========================================================================
    // Demo 4: String Processing Variants
    // =========================================================================
    println!("\nDemo 4: String Processing Variants");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_processor(prefix: &'static str) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let text = inputs.get(\"text\").unwrap();");
    println!("        let processed = format!(\"[{{}}] {{}}\", prefix, text);");
    println!("        outputs.insert(\"processed_text\", processed);");
    println!("    }}");
    println!("}}");
    println!();
    println!("graph.variant(");
    println!("    make_processor,");
    println!("    vec![\"INFO\", \"WARN\", \"ERROR\"],");
    println!("    Some(\"LogLevel\"),");
    println!("    Some(vec![(\"message\", \"text\")]),");
    println!("    Some(vec![(\"processed_text\", \"log\")])");
    println!(");");
    println!("```\n");

    let mut graph4 = Graph::new();
    graph4.add(
        text_source,
        Some("Source"),
        None,
        Some(vec![("message", "message")])
    );
    graph4.variant(
        make_processor,
        vec!["INFO", "WARN", "ERROR"],
        Some("LogLevel"),
        Some(vec![("message", "text")]),
        Some(vec![("processed_text", "log")])
    );
    
    let dag4 = graph4.build();
    println!("🎯 What happens:");
    println!("  • 3 log level variants: INFO, WARN, ERROR");
    println!("  • Each prefixes the message with its log level");
    println!("  • Demonstrates string/static str parameters");
    println!();
    
    let stats4 = dag4.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats4.node_count);
    println!("  - Log variants: 3");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag4.to_mermaid());
    println!();

    // =========================================================================
    // Summary
    // =========================================================================
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Summary: Key Variant Pattern Features");
    println!("═══════════════════════════════════════════════════════════\n");
    
    println!("✅ Factory Function Pattern:");
    println!("   • Factory takes parameter(s), returns closure");
    println!("   • Closure captures parameters in its environment");
    println!("   • Same signature as regular node functions");
    println!();
    
    println!("✅ Parameter Flexibility:");
    println!("   • Primitives: f64, i32, &str");
    println!("   • Structs: Custom configuration objects");
    println!("   • Arrays/Vectors: Multiple values at once");
    println!();
    
    println!("✅ Cartesian Products:");
    println!("   • Multiple .variant() calls create all combinations");
    println!("   • Example: 2 scales × 3 filters = 6 execution paths");
    println!();
    
    println!("✅ Port Mapping:");
    println!("   • Variants use same tuple-based syntax");
    println!("   • (broadcast_var, impl_var) for inputs");
    println!("   • (impl_var, broadcast_var) for outputs");
    println!();
    
    println!("✅ Parallel Execution:");
    println!("   • All variants at same level can run in parallel");
    println!("   • DAG analysis identifies parallelization opportunities");
    println!();
}

pub fn branch(&mut self, subgraph: Graph) -> usize

Insert a branching subgraph

Implicit Branching Behavior

• Sequential .branch() calls without .add() between them implicitly branch from the same node
• This allows creating multiple parallel execution paths easily

Arguments

• subgraph - A configured Graph representing the branch

Returns

Returns the branch ID for use in merge operations

Examples found in repository

examples/comprehensive_demo.rs (line 156)

fn demo_branching() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Parallel Branching (Fan-Out)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Compute statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("stats".to_string(), format!("Mean: {}", val));
            }
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stats", "stats_result")])
    );
    
    // Branch B: Train model
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("model".to_string(), format!("Model trained on {}", val));
            }
            result
        },
        Some("MLModel"),
        Some(vec![("data", "input")]),
        Some(vec![("model", "model_result")])
    );
    
    // Branch C: Generate visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("plot".to_string(), format!("Plot of {}", val));
            }
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("plot", "viz_result")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A (Stats): {}", context.get("stats_result").unwrap());
    println!("  Branch B (Model): {}", context.get("model_result").unwrap());
    println!("  Branch C (Viz):   {}", context.get("viz_result").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All 3 branches can execute in parallel!");
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_merging() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Branching + Merging (Fan-Out + Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Branch A: Add 10
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("PathA (+10)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    // Branch B: Add 20
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 20).to_string());
            }
            result
        },
        Some("PathB (+20)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Merge node: Combine results from both branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let a = inputs.get("from_a").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let b = inputs.get("from_b").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            result.insert("combined".to_string(), format!("{} + {} = {}", a, b, a + b));
            result
        },
        Some("Merge"),
        vec![
            (branch_a_id, "result", "from_a"),  // Map branch A's "result" to merge fn's "from_a"
            (branch_b_id, "result", "from_b")   // Map branch B's "result" to merge fn's "from_b"
        ],
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A: 50 + 10 = 60");
    println!("  Branch B: 50 + 20 = 70");
    println!("  Merged: {}", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_graph() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 5: Complex Graph (All Features Combined)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // 1. Data ingestion
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw_data".to_string(), "1000".to_string());
            result
        },
        Some("Ingest"),
        None,
        Some(vec![("raw_data", "data")])
    );
    
    // 2. Preprocessing
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("raw").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("cleaned".to_string(), (val / 10).to_string());
            }
            result
        },
        Some("Preprocess"),
        Some(vec![("data", "raw")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    // 3. Branch for different analyses
    let mut stats_branch = Graph::new();
    stats_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("stats".to_string(), format!("Stats({})", val));
            }
            result
        },
        Some("Stats"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("stats", "statistics")])
    );
    
    let mut ml_branch = Graph::new();
    ml_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("prediction".to_string(), format!("Pred({})", val));
            }
            result
        },
        Some("ML"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("prediction", "ml_result")])
    );
    
    let stats_id = graph.branch(stats_branch);
    let ml_id = graph.branch(ml_branch);
    
    // 4. Merge branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let stats = inputs.get("stats_in").cloned().unwrap_or_default();
            let ml = inputs.get("ml_in").cloned().unwrap_or_default();
            result.insert("report".to_string(), format!("{} & {}", stats, ml));
            result
        },
        Some("Combine"),
        vec![
            (stats_id, "statistics", "stats_in"),
            (ml_id, "ml_result", "ml_in")
        ],
        Some(vec![("report", "final_report")])
    );
    
    // 5. Final output formatting
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(report) = inputs.get("report") {
                result.insert("formatted".to_string(), format!("[FINAL] {}", report));
            }
            result
        },
        Some("Format"),
        Some(vec![("final_report", "report")]),
        Some(vec![("formatted", "output")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Step 1: Ingest      → data = {}", context.get("data").unwrap());
    println!("  Step 2: Preprocess  → clean_data = {}", context.get("clean_data").unwrap());
    println!("  Step 3: Branch A    → statistics = {}", context.get("statistics").unwrap());
    println!("          Branch B    → ml_result = {}", context.get("ml_result").unwrap());
    println!("  Step 4: Merge       → final_report = {}", context.get("final_report").unwrap());
    println!("  Step 5: Format      → output = {}", context.get("output").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n📋 Execution Order:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        println!("  Level {}: {} nodes", level_idx, level.len());
        for &node_id in level {
            let node = dag.nodes().iter().find(|n| n.id == node_id).unwrap();
            println!("    - {}", node.display_name());
        }
    }
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
    
    println!("═══════════════════════════════════════════════════════════");
    println!("  Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/output_access_demo.rs (line 146)

fn demo_branch_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Branch Output Access (Parallel Paths)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "shared_data")])
    );
    
    // Branch A: Statistics computation
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("stats_output".to_string(), format!("Stats of {}", val));
            result
        },
        Some("Stats"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("stats_output", "statistics")])  // Branch A produces "statistics"
    );
    
    // Branch B: Model training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("model_output".to_string(), format!("Model trained on {}", val));
            result
        },
        Some("Train"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("model_output", "model")])  // Branch B produces "model"
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_output".to_string(), format!("Plot of {}", val));
            result
        },
        Some("Visualize"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("viz_output", "visualization")])  // Branch C produces "visualization"
    );
    
    // Add branches to main graph
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 All outputs from parallel branches:");
    
    // Access each branch's output
    if let Some(stats) = context.get("statistics") {
        println!("  Branch A (Statistics): {}", stats);
    }
    
    if let Some(model) = context.get("model") {
        println!("  Branch B (Model): {}", model);
    }
    
    if let Some(viz) = context.get("visualization") {
        println!("  Branch C (Visualization): {}", viz);
    }
    
    println!("\n🔍 All variables in context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!();
}

examples/parallel_execution_demo.rs (line 107)

fn demo_sequential_vs_parallel() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Sequential vs Parallel Execution");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            result.insert("data".to_string(), "source_data".to_string());
            println!("    [{}ms] Source completed", start.elapsed().as_millis());
            result
        },
        Some("Source"),
        None,
        Some(vec![("data", "data")])
    );
    
    // Branch A: 100ms work
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch A completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchA[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_a")])
    );
    
    // Branch B: 100ms work
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch B completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchB[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_b")])
    );
    
    // Branch C: 100ms work
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch C completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchC[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_c")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    
    println!("\n📊 Sequential Execution (simulated):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let sequential_time = start.elapsed();
    println!("  Total time: {}ms", sequential_time.as_millis());
    
    println!("\n⚡ With Parallel Execution:");
    println!("  Expected time: ~100ms (all branches run simultaneously)");
    println!("  Speedup: ~3x faster than sequential");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("\n  Analysis:");
    println!("  - Level 0: 1 node  (Source)");
    println!("  - Level 1: 3 nodes (BranchA, BranchB, BranchC) ← Can run in parallel!");
    println!("  - Max parallelism: {} nodes can execute simultaneously", stats.max_parallelism);
    
    println!("\n🔍 Mermaid Visualization with Port Mappings:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_dependencies() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Complex Data Dependencies");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Two independent sources
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source1_data".to_string(), "100".to_string());
            result
        },
        Some("Source1"),
        None,
        Some(vec![("source1_data", "data1")])
    );
    
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source2_data".to_string(), "200".to_string());
            result
        },
        Some("Source2"),
        None,
        Some(vec![("source2_data", "data2")])
    );
    
    // Process each source independently (can run in parallel)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Process1[50ms]"),
        Some(vec![("data1", "in")]),
        Some(vec![("processed", "proc1")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 3).to_string());
            }
            result
        },
        Some("Process2[50ms]"),
        Some(vec![("data2", "in")]),
        Some(vec![("processed", "proc2")])
    );
    
    // Combine results (depends on both processors)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let v1 = inputs.get("p1").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let v2 = inputs.get("p2").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            thread::sleep(Duration::from_millis(30));
            result.insert("combined".to_string(), format!("{}", v1 + v2));
            result
        },
        Some("Combine[30ms]"),
        Some(vec![("proc1", "p1"), ("proc2", "p2")]),
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Execution with timing:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("  Source1: data1 = {}", context.get("data1").unwrap());
    println!("  Source2: data2 = {}", context.get("data2").unwrap());
    println!("  Process1: proc1 = {} (data1 * 2)", context.get("proc1").unwrap());
    println!("  Process2: proc2 = {} (data2 * 3)", context.get("proc2").unwrap());
    println!("  Combine: final = {} (proc1 + proc2)", context.get("final").unwrap());
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels (showing parallelism):");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
        if level.len() > 1 {
            println!("           ↑ {} nodes can execute in parallel!", level.len());
        }
    }
    
    println!("\n⚡ Parallel Execution Analysis:");
    println!("  Sequential time would be: 50+50+30 = 130ms");
    println!("  With parallelism: Level0→Level1(parallel)→Level2 = ~80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (shows data dependencies):");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variant_parallelism() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Parameter Sweep Parallelism");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "1000".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Variant factory with different multipliers
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                // Simulate 100ms of work
                thread::sleep(Duration::from_millis(100));
                result.insert("result".to_string(), format!("{:.1}", val * factor));
            }
            println!("    [{}ms] Variant (factor={}) completed", start.elapsed().as_millis(), factor);
            result
        }
    }
    
    // Create 5 variants
    graph.variant(
        make_multiplier,
        vec![0.5, 1.0, 1.5, 2.0, 2.5],
        Some("Multiply[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing 5 variants (each takes 100ms):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n⚡ Parallelism Analysis:");
    println!("  Sequential execution: 100 × 5 = 500ms");
    println!("  With parallel execution: ~100ms (all run simultaneously)");
    println!("  Speedup: 5x");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ↑ All {} variant nodes can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_diamond_pattern() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Diamond Pattern (Fan-Out → Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    println!("This pattern shows:");
    println!("  - One source splits into multiple parallel branches");
    println!("  - Branches are processed independently");
    println!("  - Results merge back into single output");
    
    let mut graph = Graph::new();
    
    // Top of diamond: Single source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "input_data".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("raw", "data")])
    );
    
    // Left branch: Transform A (50ms)
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformA", data));
            }
            println!("    [{}ms] Transform A completed", start.elapsed().as_millis());
            result
        },
        Some("TransformA[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    // Right branch: Transform B (50ms)
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformB", data));
            }
            println!("    [{}ms] Transform B completed", start.elapsed().as_millis());
            result
        },
        Some("TransformB[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Bottom of diamond: Merge (30ms)
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(30));
            let mut result = HashMap::new();
            let a = inputs.get("left").cloned().unwrap_or_default();
            let b = inputs.get("right").cloned().unwrap_or_default();
            result.insert("merged".to_string(), format!("[{}+{}]", a, b));
            println!("    [{}ms] Merge completed", start.elapsed().as_millis());
            result
        },
        Some("Merge[30ms]"),
        vec![
            (branch_a_id, "result", "left"),
            (branch_b_id, "result", "right")
        ],
        Some(vec![("merged", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing diamond pattern:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Result: {}", context.get("final").unwrap());
    println!("  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
    }
    
    println!("\n⚡ Timing Analysis:");
    println!("  Sequential: Source(0ms) + TransformA(50ms) + TransformB(50ms) + Merge(30ms) = 130ms");
    println!("  Parallel:   Source(0ms) → [TransformA + TransformB](50ms) → Merge(30ms) = 80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (Diamond Shape):");
    println!("{}", dag.to_mermaid());
    
    println!("\n  The visualization shows:");
    println!("  - Port mappings on edges (data→in, result→left, result→right)");
    println!("  - Data dependencies between nodes");
    println!("  - Parallel branches can execute simultaneously");
    
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Parallel Execution Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/per_node_output_access.rs (line 175)

fn demo_per_branch_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Per-Branch Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Main graph: Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("stat_result".to_string(), format!("Mean of {}", value));
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stat_result", "statistics")])
    );
    
    // Branch B: Model Training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("model_result".to_string(), format!("Model trained on {}", value));
            result
        },
        Some("ModelTraining"),
        Some(vec![("data", "input")]),
        Some(vec![("model_result", "trained_model")])
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_result".to_string(), format!("Plot of {}", value));
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("viz_result", "plot")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    let branch_c_id = graph.branch(branch_c);
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context:");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🌿 Per-Branch Outputs:");
    
    println!("\nBranch {} (Statistics) outputs:", branch_a_id);
    if let Some(outputs) = result.get_branch_outputs(branch_a_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Model Training) outputs:", branch_b_id);
    if let Some(outputs) = result.get_branch_outputs(branch_b_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Visualization) outputs:", branch_c_id);
    if let Some(outputs) = result.get_branch_outputs(branch_c_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific branch outputs:");
    if let Some(value) = result.get_from_branch(branch_a_id, "statistics") {
        println!("  Branch {} 'statistics': {}", branch_a_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_b_id, "trained_model") {
        println!("  Branch {} 'trained_model': {}", branch_b_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_c_id, "plot") {
        println!("  Branch {} 'plot': {}", branch_c_id, value);
    }
    
    println!();
}

examples/tuple_api_demo.rs (line 89)

fn main() {
    println!("=== Tuple-Based API Demo ===\n");

    let mut graph = Graph::new();

    // Source node - no inputs, produces "dataset" in context
    fn data_source(_inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let mut outputs = HashMap::new();
        outputs.insert("raw".to_string(), "Sample Data".to_string());
        outputs
    }

    graph.add(
        data_source,
        Some("Source"),
        None,  // No inputs
        Some(vec![("raw", "dataset")])  // Function returns "raw", stored as "dataset" in context
    );

    println!("✓ Added source node");
    println!("  Output mapping: function's 'raw' → context's 'dataset'\n");

    // Process node - consumes "dataset" from context as "input_data", produces "processed_data" to context as "result"
    fn processor(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("input_data").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("processed_data".to_string(), format!("Processed: {}", data));
        outputs
    }

    graph.add(
        processor,
        Some("Process"),
        Some(vec![("dataset", "input_data")]),      // Context's "dataset" → function's "input_data"
        Some(vec![("processed_data", "result")])    // Function's "processed_data" → context's "result"
    );

    println!("✓ Added processor node");
    println!("  Input mapping: context's 'dataset' → function's 'input_data'");
    println!("  Output mapping: function's 'processed_data' → context's 'result'\n");

    // Create branches that both use the same variable names internally
    let mut branch_a = Graph::new();
    fn transform_a(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path A]", data));
        outputs
    }
    branch_a.add(
        transform_a,
        Some("Transform A"),
        Some(vec![("result", "x")]),  // Context's "result" → function's "x"
        Some(vec![("y", "output")])    // Function's "y" → context's "output"
    );

    let mut branch_b = Graph::new();
    fn transform_b(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path B]", data));
        outputs
    }
    branch_b.add(
        transform_b,
        Some("Transform B"),
        Some(vec![("result", "x")]),  // Same variable names as branch_a
        Some(vec![("y", "output")])    // Same variable names as branch_a
    );

    println!("✓ Created two branches");
    println!("  Both branches use same internal variable names (x, y)");
    println!("  Both map 'result' → 'x' and 'y' → 'output'\n");

    // Branch from the processor
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);

    println!("✓ Added branches to graph");
    println!("  Branch A ID: {}", branch_a_id);
    println!("  Branch B ID: {}\n", branch_b_id);

    // Merge branches with branch-specific variable resolution
    fn combine(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let a = inputs.get("from_a").unwrap_or(&default);
        let b = inputs.get("from_b").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("merged".to_string(), format!("Combined: {} + {}", a, b));
        outputs
    }

    graph.merge(
        combine,
        Some("Combine"),
        vec![
            (branch_a_id, "output", "from_a"),  // Branch A's "output" → merge function's "from_a"
            (branch_b_id, "output", "from_b")   // Branch B's "output" → merge function's "from_b"
        ],
        Some(vec![("merged", "final_result")])  // Merge function's "merged" → context's "final_result"
    );

    println!("✓ Added merge node");
    println!("  Branch-specific input mapping:");
    println!("    Branch {} 'output' → merge function's 'from_a'", branch_a_id);
    println!("    Branch {} 'output' → merge function's 'from_b'", branch_b_id);
    println!("  Output mapping: merge function's 'merged' → context's 'final_result'\n");

    // Variant example with factory pattern
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs, _variant| {
            let default = "1.0".to_string();
            let data = inputs.get("value").unwrap_or(&default);
            if let Ok(val) = data.parse::<f64>() {
                let mut outputs = HashMap::new();
                outputs.insert("scaled".to_string(), (val * factor).to_string());
                outputs
            } else {
                HashMap::new()
            }
        }
    }

    graph.variant(
        make_multiplier,
        vec![2.0, 3.0, 5.0],
        Some("Multiply"),
        Some(vec![("final_result", "value")]),  // Context's "final_result" → function's "value"
        Some(vec![("scaled", "multiplied")])    // Function's "scaled" → context's "multiplied"
    );

    println!("✓ Added variant nodes with parameter sweep");
    println!("  Three variants: factor = 2.0, 3.0, 5.0");
    println!("  Input mapping: context's 'final_result' → function's 'value'");
    println!("  Output mapping: function's 'scaled' → context's 'multiplied'\n");

    println!("=== Summary ===");
    println!("The tuple-based API provides clear separation between:");
    println!("1. Context variable names (broadcast vars) - shared across the graph");
    println!("2. Function parameter names (impl vars) - internal to each function");
    println!("\nThis allows:");
    println!("- Branches to use consistent internal naming (x, y)");
    println!("- Merge to distinguish branch outputs using branch IDs");
    println!("- Clear data flow visualization and debugging");
}

pub fn variant<F, P, NF>( &mut self, factory: F, param_values: Vec<P>, label: Option<&str>, inputs: Option<Vec<(&str, &str)>>, outputs: Option<Vec<(&str, &str)>>, ) -> &mut Self

where F: Fn(P) -> NF, P: ToString + Clone, NF: Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + Send + Sync + 'static,

Create configuration sweep variants using a factory function (sigexec-style)

Takes a factory function and an array of parameter values. The factory is called with each parameter value to create a node function for that variant.

Arguments

• factory - Function that takes a parameter value and returns a node function
• param_values - Array of parameter values to sweep over
• label - Optional label for visualization (default: None)
• inputs - Optional list of (broadcast_var, impl_var) tuples for inputs
• outputs - Optional list of (impl_var, broadcast_var) tuples for outputs

Example

fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
    move |inputs, _variant_params| {
        let mut outputs = HashMap::new();
        if let Some(val) = inputs.get("x").and_then(|s| s.parse::<f64>().ok()) {
            outputs.insert("scaled_x".to_string(), (val * factor).to_string());
        }
        outputs
    }
}

graph.variant(
    make_scaler,
    vec![2.0, 3.0, 5.0],
    Some("Scale"),
    Some(vec![("data", "x")]),          // (broadcast, impl)
    Some(vec![("scaled_x", "result")])  // (impl, broadcast)
);

Behavior

• Creates one node per parameter value
• Each node is created by calling factory(param_value)
• Nodes still receive both regular inputs and variant_params
• All variants branch from the same point and can execute in parallel

Examples found in repository

examples/comprehensive_demo.rs (lines 298-304)

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

examples/parallel_execution_demo.rs (lines 281-287)

fn demo_variant_parallelism() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Parameter Sweep Parallelism");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "1000".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Variant factory with different multipliers
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                // Simulate 100ms of work
                thread::sleep(Duration::from_millis(100));
                result.insert("result".to_string(), format!("{:.1}", val * factor));
            }
            println!("    [{}ms] Variant (factor={}) completed", start.elapsed().as_millis(), factor);
            result
        }
    }
    
    // Create 5 variants
    graph.variant(
        make_multiplier,
        vec![0.5, 1.0, 1.5, 2.0, 2.5],
        Some("Multiply[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing 5 variants (each takes 100ms):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n⚡ Parallelism Analysis:");
    println!("  Sequential execution: 100 × 5 = 500ms");
    println!("  With parallel execution: ~100ms (all run simultaneously)");
    println!("  Speedup: 5x");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ↑ All {} variant nodes can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

examples/per_node_output_access.rs (lines 255-261)

fn demo_variant_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Outputs with Per-Node Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory for scaling
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input_data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled_value".to_string(), (value * factor).to_string());
            result
        }
    }
    
    // Create variants with unique output names to preserve all results
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])  // Note: will overwrite in global context
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (note: 'result' contains last variant's output):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs (each variant tracked separately):");
    
    // Node 0 is the source
    // Nodes 1, 2, 3 are the variant nodes (2x, 3x, 5x scalers)
    for node_id in 1..=3 {
        println!("\nNode {} (Variant Scaler) outputs:", node_id);
        if let Some(outputs) = result.get_node_outputs(node_id) {
            for (key, value) in outputs {
                println!("  {} = {}", key, value);
            }
        }
    }
    
    println!("\n💡 Key Insight:");
    println!("  - Global context has 'result' = {} (last variant overwrites)", result.get("result").unwrap());
    println!("  - But per-node outputs preserve ALL variant results:");
    println!("    Node 1 (2x): result = {}", result.get_from_node(1, "result").unwrap());
    println!("    Node 2 (3x): result = {}", result.get_from_node(2, "result").unwrap());
    println!("    Node 3 (5x): result = {}", result.get_from_node(3, "result").unwrap());
    
    println!();
}

examples/output_access_demo.rs (lines 207-213)

fn demo_variant_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Output Access (Parameter Sweep)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant nodes: scale by different factors
    // Factory function that creates a scaler for each factor
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled".to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled", "result")])  // Each variant produces "result"
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Variant outputs:");
    println!("  Note: Variants with same output name overwrite each other");
    println!("  The last variant (factor=5.0) writes to 'result'\n");
    
    // Access the result (will be from the last variant)
    if let Some(result) = context.get("result") {
        println!("  result = {} (from last variant: 10.0 * 5.0)", result);
    }
    
    println!("\n💡 Tip: To preserve all variant outputs, use unique output names:");
    println!("   Option 1: Map each variant to a different broadcast variable");
    println!("   Option 2: Collect results in merge node");
    println!("   Option 3: Use variant_params or closure capture to distinguish");
    
    // Better approach: unique output names per variant
    let mut graph2 = Graph::new();
    
    graph2.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant 1: 2x
    fn make_scaler_unique(label: &str, factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + '_ {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert(label.to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_2x", 2.0),
        vec!["2x"],
        Some("Scale2x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_2x", "result_2x")])
    );
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_3x", 3.0),
        vec!["3x"],
        Some("Scale3x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_3x", "result_3x")])
    );
    
    let dag2 = graph2.build();
    let context2 = dag2.execute(false, None);
    
    println!("\n✅ Better approach - unique output names:");
    if let Some(result_2x) = context2.get("result_2x") {
        println!("  result_2x = {}", result_2x);
    }
    if let Some(result_3x) = context2.get("result_3x") {
        println!("  result_3x = {}", result_3x);
    }
    
    println!();
}

examples/tuple_api_demo.rs (lines 137-143)

fn main() {
    println!("=== Tuple-Based API Demo ===\n");

    let mut graph = Graph::new();

    // Source node - no inputs, produces "dataset" in context
    fn data_source(_inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let mut outputs = HashMap::new();
        outputs.insert("raw".to_string(), "Sample Data".to_string());
        outputs
    }

    graph.add(
        data_source,
        Some("Source"),
        None,  // No inputs
        Some(vec![("raw", "dataset")])  // Function returns "raw", stored as "dataset" in context
    );

    println!("✓ Added source node");
    println!("  Output mapping: function's 'raw' → context's 'dataset'\n");

    // Process node - consumes "dataset" from context as "input_data", produces "processed_data" to context as "result"
    fn processor(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("input_data").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("processed_data".to_string(), format!("Processed: {}", data));
        outputs
    }

    graph.add(
        processor,
        Some("Process"),
        Some(vec![("dataset", "input_data")]),      // Context's "dataset" → function's "input_data"
        Some(vec![("processed_data", "result")])    // Function's "processed_data" → context's "result"
    );

    println!("✓ Added processor node");
    println!("  Input mapping: context's 'dataset' → function's 'input_data'");
    println!("  Output mapping: function's 'processed_data' → context's 'result'\n");

    // Create branches that both use the same variable names internally
    let mut branch_a = Graph::new();
    fn transform_a(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path A]", data));
        outputs
    }
    branch_a.add(
        transform_a,
        Some("Transform A"),
        Some(vec![("result", "x")]),  // Context's "result" → function's "x"
        Some(vec![("y", "output")])    // Function's "y" → context's "output"
    );

    let mut branch_b = Graph::new();
    fn transform_b(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path B]", data));
        outputs
    }
    branch_b.add(
        transform_b,
        Some("Transform B"),
        Some(vec![("result", "x")]),  // Same variable names as branch_a
        Some(vec![("y", "output")])    // Same variable names as branch_a
    );

    println!("✓ Created two branches");
    println!("  Both branches use same internal variable names (x, y)");
    println!("  Both map 'result' → 'x' and 'y' → 'output'\n");

    // Branch from the processor
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);

    println!("✓ Added branches to graph");
    println!("  Branch A ID: {}", branch_a_id);
    println!("  Branch B ID: {}\n", branch_b_id);

    // Merge branches with branch-specific variable resolution
    fn combine(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let a = inputs.get("from_a").unwrap_or(&default);
        let b = inputs.get("from_b").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("merged".to_string(), format!("Combined: {} + {}", a, b));
        outputs
    }

    graph.merge(
        combine,
        Some("Combine"),
        vec![
            (branch_a_id, "output", "from_a"),  // Branch A's "output" → merge function's "from_a"
            (branch_b_id, "output", "from_b")   // Branch B's "output" → merge function's "from_b"
        ],
        Some(vec![("merged", "final_result")])  // Merge function's "merged" → context's "final_result"
    );

    println!("✓ Added merge node");
    println!("  Branch-specific input mapping:");
    println!("    Branch {} 'output' → merge function's 'from_a'", branch_a_id);
    println!("    Branch {} 'output' → merge function's 'from_b'", branch_b_id);
    println!("  Output mapping: merge function's 'merged' → context's 'final_result'\n");

    // Variant example with factory pattern
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs, _variant| {
            let default = "1.0".to_string();
            let data = inputs.get("value").unwrap_or(&default);
            if let Ok(val) = data.parse::<f64>() {
                let mut outputs = HashMap::new();
                outputs.insert("scaled".to_string(), (val * factor).to_string());
                outputs
            } else {
                HashMap::new()
            }
        }
    }

    graph.variant(
        make_multiplier,
        vec![2.0, 3.0, 5.0],
        Some("Multiply"),
        Some(vec![("final_result", "value")]),  // Context's "final_result" → function's "value"
        Some(vec![("scaled", "multiplied")])    // Function's "scaled" → context's "multiplied"
    );

    println!("✓ Added variant nodes with parameter sweep");
    println!("  Three variants: factor = 2.0, 3.0, 5.0");
    println!("  Input mapping: context's 'final_result' → function's 'value'");
    println!("  Output mapping: function's 'scaled' → context's 'multiplied'\n");

    println!("=== Summary ===");
    println!("The tuple-based API provides clear separation between:");
    println!("1. Context variable names (broadcast vars) - shared across the graph");
    println!("2. Function parameter names (impl vars) - internal to each function");
    println!("\nThis allows:");
    println!("- Branches to use consistent internal naming (x, y)");
    println!("- Merge to distinguish branch outputs using branch IDs");
    println!("- Clear data flow visualization and debugging");
}

examples/variant_demo_full.rs (lines 162-168)

fn main() {
    println!("═══════════════════════════════════════════════════════════");
    println!("  Variant Pattern Demo (sigexec-style)");
    println!("  Full Actual Syntax Examples");
    println!("═══════════════════════════════════════════════════════════\n");

    // =========================================================================
    // Demo 1: Single Variant - Basic Factory Pattern
    // =========================================================================
    println!("Demo 1: Single Variant with Factory Function");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_scaler(factor: f64) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"input_data\").unwrap().parse::<f64>().unwrap();");
    println!("        let scaled = value * factor;");
    println!("        outputs.insert(\"scaled_value\", scaled.to_string());");
    println!("    }}");
    println!("}}");
    println!();
    println!("let mut graph = Graph::new();");
    println!("graph.add(data_source, Some(\"Source\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(");
    println!("    make_scaler,              // Factory function");
    println!("    vec![2.0, 3.0, 5.0],      // Parameter values to sweep");
    println!("    Some(\"Scale\"),            // Label");
    println!("    Some(vec![(\"data\", \"input_data\")]),  // Input mapping");
    println!("    Some(vec![(\"scaled_value\", \"result\")])  // Output mapping");
    println!(");");
    println!("```\n");

    let mut graph1 = Graph::new();
    graph1.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph1.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag1 = graph1.build();
    println!("🎯 What happens:");
    println!("  • Factory creates 3 nodes: Scale_2.0, Scale_3.0, Scale_5.0");
    println!("  • Each node multiplies input by its factor");
    println!("  • All variants can execute in parallel");
    println!();
    
    let stats1 = dag1.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats1.node_count);
    println!("  - Depth: {} levels", stats1.depth);
    println!("  - Max parallelism: {} nodes can run simultaneously", stats1.max_parallelism);
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag1.to_mermaid());
    println!();

    // =========================================================================
    // Demo 2: Multiple Variants - Cartesian Product
    // =========================================================================
    println!("\nDemo 2: Multiple Variants (Cartesian Product)");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("graph.add(data_source, Some(\"Generate\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(make_scaler, vec![2.0, 3.0], Some(\"Scale\"), ...);");
    println!("graph.variant(make_offsetter, vec![10, 20], Some(\"Offset\"), ...);");
    println!("graph.add(stats_node, Some(\"Stats\"), Some(vec![(\"result\", \"result\")]), None);");
    println!("```\n");
    
    let mut graph2 = Graph::new();
    graph2.add(
        data_source,
        Some("Generate"),
        None,
        Some(vec![("value", "data")])
    );
    graph2.variant(
        make_scaler,
        vec![2.0, 3.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    graph2.variant(
        make_offsetter,
        vec![10, 20],
        Some("Offset"),
        Some(vec![("result", "number")]),
        Some(vec![("offset_result", "result")])
    );
    graph2.add(
        stats_node,
        Some("Stats"),
        Some(vec![("result", "result")]),
        Some(vec![("summary", "final")])
    );
    
    let dag2 = graph2.build();
    println!("🎯 What happens:");
    println!("  • Scale creates 2 variants: x2.0, x3.0");
    println!("  • Offset creates 2 variants: +10, +20");
    println!("  • Total combinations: 2 × 2 = 4 execution paths");
    println!("  • Each path: Generate → Scale[variant] → Offset[variant] → Stats");
    println!();
    
    let stats2 = dag2.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats2.node_count);
    println!("  - Depth: {} levels", stats2.depth);
    println!("  - Execution paths: 4 (2 scales × 2 offsets)");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag2.to_mermaid());
    println!();

    // =========================================================================
    // Demo 3: Complex Factory - Struct Configuration
    // =========================================================================
    println!("\nDemo 3: Complex Factory with Struct Configuration");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("#[derive(Clone)]");
    println!("struct FilterConfig {{");
    println!("    cutoff: f64,");
    println!("    mode: String,");
    println!("}}");
    println!();
    println!("fn make_filter(config: FilterConfig) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"data\").unwrap().parse::<f64>().unwrap();");
    println!("        let filtered = match config.mode.as_str() {{");
    println!("            \"lowpass\" => value * config.cutoff,");
    println!("            \"highpass\" => value * (1.0 - config.cutoff),");
    println!("            _ => value,");
    println!("        }};");
    println!("    }}");
    println!("}}");
    println!();
    println!("let configs = vec![");
    println!("    FilterConfig {{ cutoff: 0.5, mode: \"lowpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.3, mode: \"highpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.7, mode: \"lowpass\".to_string() }},");
    println!("];");
    println!("graph.variant(make_filter, configs, Some(\"Filter\"), ...);");
    println!("```\n");

    let configs = vec![
        FilterConfig { cutoff: 0.5, mode: "lowpass".to_string() },
        FilterConfig { cutoff: 0.3, mode: "highpass".to_string() },
        FilterConfig { cutoff: 0.7, mode: "lowpass".to_string() },
    ];
    
    let mut graph3 = Graph::new();
    graph3.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph3.variant(
        make_filter,
        configs,
        Some("Filter"),
        Some(vec![("data", "data")]),
        Some(vec![("filtered", "result")])
    );
    
    let dag3 = graph3.build();
    println!("🎯 What happens:");
    println!("  • 3 filter variants created with different configurations");
    println!("  • Each variant uses its own FilterConfig struct");
    println!("  • Demonstrates passing complex types to factory");
    println!();
    
    let stats3 = dag3.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats3.node_count);
    println!("  - Filter variants: 3");
    println!("  - Max parallelism: {} nodes", stats3.max_parallelism);
    println!();

    // =========================================================================
    // Demo 4: String Processing Variants
    // =========================================================================
    println!("\nDemo 4: String Processing Variants");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_processor(prefix: &'static str) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let text = inputs.get(\"text\").unwrap();");
    println!("        let processed = format!(\"[{{}}] {{}}\", prefix, text);");
    println!("        outputs.insert(\"processed_text\", processed);");
    println!("    }}");
    println!("}}");
    println!();
    println!("graph.variant(");
    println!("    make_processor,");
    println!("    vec![\"INFO\", \"WARN\", \"ERROR\"],");
    println!("    Some(\"LogLevel\"),");
    println!("    Some(vec![(\"message\", \"text\")]),");
    println!("    Some(vec![(\"processed_text\", \"log\")])");
    println!(");");
    println!("```\n");

    let mut graph4 = Graph::new();
    graph4.add(
        text_source,
        Some("Source"),
        None,
        Some(vec![("message", "message")])
    );
    graph4.variant(
        make_processor,
        vec!["INFO", "WARN", "ERROR"],
        Some("LogLevel"),
        Some(vec![("message", "text")]),
        Some(vec![("processed_text", "log")])
    );
    
    let dag4 = graph4.build();
    println!("🎯 What happens:");
    println!("  • 3 log level variants: INFO, WARN, ERROR");
    println!("  • Each prefixes the message with its log level");
    println!("  • Demonstrates string/static str parameters");
    println!();
    
    let stats4 = dag4.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats4.node_count);
    println!("  - Log variants: 3");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag4.to_mermaid());
    println!();

    // =========================================================================
    // Summary
    // =========================================================================
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Summary: Key Variant Pattern Features");
    println!("═══════════════════════════════════════════════════════════\n");
    
    println!("✅ Factory Function Pattern:");
    println!("   • Factory takes parameter(s), returns closure");
    println!("   • Closure captures parameters in its environment");
    println!("   • Same signature as regular node functions");
    println!();
    
    println!("✅ Parameter Flexibility:");
    println!("   • Primitives: f64, i32, &str");
    println!("   • Structs: Custom configuration objects");
    println!("   • Arrays/Vectors: Multiple values at once");
    println!();
    
    println!("✅ Cartesian Products:");
    println!("   • Multiple .variant() calls create all combinations");
    println!("   • Example: 2 scales × 3 filters = 6 execution paths");
    println!();
    
    println!("✅ Port Mapping:");
    println!("   • Variants use same tuple-based syntax");
    println!("   • (broadcast_var, impl_var) for inputs");
    println!("   • (impl_var, broadcast_var) for outputs");
    println!();
    
    println!("✅ Parallel Execution:");
    println!("   • All variants at same level can run in parallel");
    println!("   • DAG analysis identifies parallelization opportunities");
    println!();
}

pub fn merge<F>( &mut self, merge_fn: F, label: Option<&str>, inputs: Vec<(usize, &str, &str)>, outputs: Option<Vec<(&str, &str)>>, ) -> &mut Self

where F: Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + Send + Sync + 'static,

Merge multiple branches back together with a merge function

After branching, use .merge() to bring parallel paths back to a single point. The merge function receives outputs from all specified branches and combines them.

Arguments

• merge_fn - Function that combines outputs from all branches
• label - Optional label for visualization
• inputs - List of (branch_id, broadcast_var, impl_var) tuples specifying which branch outputs to merge
• outputs - Optional list of (impl_var, broadcast_var) tuples for outputs

Example

graph.add(source_fn, Some("Source"), None, Some(vec![("src_out", "data")]));
 
let mut branch_a = Graph::new();
branch_a.add(process_a, Some("Process A"), Some(vec![("data", "input")]), Some(vec![("output", "result")]));
 
let mut branch_b = Graph::new();
branch_b.add(process_b, Some("Process B"), Some(vec![("data", "input")]), Some(vec![("output", "result")]));
 
let branch_a_id = graph.branch(branch_a);
let branch_b_id = graph.branch(branch_b);
 
// Merge function combines results from both branches
// Branches can use same output name "result", merge maps them distinctly
graph.merge(
    combine_fn,
    Some("Combine"),
    vec![
        (branch_a_id, "result", "a_result"),    // (branch, broadcast, impl)
        (branch_b_id, "result", "b_result")
    ],
    Some(vec![("combined", "final")])            // (impl, broadcast)
);

Examples found in repository

examples/comprehensive_demo.rs (lines 232-246)

fn demo_merging() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Branching + Merging (Fan-Out + Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Branch A: Add 10
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("PathA (+10)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    // Branch B: Add 20
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 20).to_string());
            }
            result
        },
        Some("PathB (+20)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Merge node: Combine results from both branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let a = inputs.get("from_a").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let b = inputs.get("from_b").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            result.insert("combined".to_string(), format!("{} + {} = {}", a, b, a + b));
            result
        },
        Some("Merge"),
        vec![
            (branch_a_id, "result", "from_a"),  // Map branch A's "result" to merge fn's "from_a"
            (branch_b_id, "result", "from_b")   // Map branch B's "result" to merge fn's "from_b"
        ],
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A: 50 + 10 = 60");
    println!("  Branch B: 50 + 20 = 70");
    println!("  Merged: {}", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_graph() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 5: Complex Graph (All Features Combined)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // 1. Data ingestion
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw_data".to_string(), "1000".to_string());
            result
        },
        Some("Ingest"),
        None,
        Some(vec![("raw_data", "data")])
    );
    
    // 2. Preprocessing
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("raw").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("cleaned".to_string(), (val / 10).to_string());
            }
            result
        },
        Some("Preprocess"),
        Some(vec![("data", "raw")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    // 3. Branch for different analyses
    let mut stats_branch = Graph::new();
    stats_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("stats".to_string(), format!("Stats({})", val));
            }
            result
        },
        Some("Stats"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("stats", "statistics")])
    );
    
    let mut ml_branch = Graph::new();
    ml_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("prediction".to_string(), format!("Pred({})", val));
            }
            result
        },
        Some("ML"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("prediction", "ml_result")])
    );
    
    let stats_id = graph.branch(stats_branch);
    let ml_id = graph.branch(ml_branch);
    
    // 4. Merge branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let stats = inputs.get("stats_in").cloned().unwrap_or_default();
            let ml = inputs.get("ml_in").cloned().unwrap_or_default();
            result.insert("report".to_string(), format!("{} & {}", stats, ml));
            result
        },
        Some("Combine"),
        vec![
            (stats_id, "statistics", "stats_in"),
            (ml_id, "ml_result", "ml_in")
        ],
        Some(vec![("report", "final_report")])
    );
    
    // 5. Final output formatting
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(report) = inputs.get("report") {
                result.insert("formatted".to_string(), format!("[FINAL] {}", report));
            }
            result
        },
        Some("Format"),
        Some(vec![("final_report", "report")]),
        Some(vec![("formatted", "output")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Step 1: Ingest      → data = {}", context.get("data").unwrap());
    println!("  Step 2: Preprocess  → clean_data = {}", context.get("clean_data").unwrap());
    println!("  Step 3: Branch A    → statistics = {}", context.get("statistics").unwrap());
    println!("          Branch B    → ml_result = {}", context.get("ml_result").unwrap());
    println!("  Step 4: Merge       → final_report = {}", context.get("final_report").unwrap());
    println!("  Step 5: Format      → output = {}", context.get("output").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n📋 Execution Order:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        println!("  Level {}: {} nodes", level_idx, level.len());
        for &node_id in level {
            let node = dag.nodes().iter().find(|n| n.id == node_id).unwrap();
            println!("    - {}", node.display_name());
        }
    }
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
    
    println!("═══════════════════════════════════════════════════════════");
    println!("  Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/parallel_execution_demo.rs (lines 376-393)

fn demo_diamond_pattern() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Diamond Pattern (Fan-Out → Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    println!("This pattern shows:");
    println!("  - One source splits into multiple parallel branches");
    println!("  - Branches are processed independently");
    println!("  - Results merge back into single output");
    
    let mut graph = Graph::new();
    
    // Top of diamond: Single source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "input_data".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("raw", "data")])
    );
    
    // Left branch: Transform A (50ms)
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformA", data));
            }
            println!("    [{}ms] Transform A completed", start.elapsed().as_millis());
            result
        },
        Some("TransformA[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    // Right branch: Transform B (50ms)
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformB", data));
            }
            println!("    [{}ms] Transform B completed", start.elapsed().as_millis());
            result
        },
        Some("TransformB[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Bottom of diamond: Merge (30ms)
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(30));
            let mut result = HashMap::new();
            let a = inputs.get("left").cloned().unwrap_or_default();
            let b = inputs.get("right").cloned().unwrap_or_default();
            result.insert("merged".to_string(), format!("[{}+{}]", a, b));
            println!("    [{}ms] Merge completed", start.elapsed().as_millis());
            result
        },
        Some("Merge[30ms]"),
        vec![
            (branch_a_id, "result", "left"),
            (branch_b_id, "result", "right")
        ],
        Some(vec![("merged", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing diamond pattern:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Result: {}", context.get("final").unwrap());
    println!("  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
    }
    
    println!("\n⚡ Timing Analysis:");
    println!("  Sequential: Source(0ms) + TransformA(50ms) + TransformB(50ms) + Merge(30ms) = 130ms");
    println!("  Parallel:   Source(0ms) → [TransformA + TransformB](50ms) → Merge(30ms) = 80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (Diamond Shape):");
    println!("{}", dag.to_mermaid());
    
    println!("\n  The visualization shows:");
    println!("  - Port mappings on edges (data→in, result→left, result→right)");
    println!("  - Data dependencies between nodes");
    println!("  - Parallel branches can execute simultaneously");
    
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Parallel Execution Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/tuple_api_demo.rs (lines 106-114)

fn main() {
    println!("=== Tuple-Based API Demo ===\n");

    let mut graph = Graph::new();

    // Source node - no inputs, produces "dataset" in context
    fn data_source(_inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let mut outputs = HashMap::new();
        outputs.insert("raw".to_string(), "Sample Data".to_string());
        outputs
    }

    graph.add(
        data_source,
        Some("Source"),
        None,  // No inputs
        Some(vec![("raw", "dataset")])  // Function returns "raw", stored as "dataset" in context
    );

    println!("✓ Added source node");
    println!("  Output mapping: function's 'raw' → context's 'dataset'\n");

    // Process node - consumes "dataset" from context as "input_data", produces "processed_data" to context as "result"
    fn processor(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("input_data").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("processed_data".to_string(), format!("Processed: {}", data));
        outputs
    }

    graph.add(
        processor,
        Some("Process"),
        Some(vec![("dataset", "input_data")]),      // Context's "dataset" → function's "input_data"
        Some(vec![("processed_data", "result")])    // Function's "processed_data" → context's "result"
    );

    println!("✓ Added processor node");
    println!("  Input mapping: context's 'dataset' → function's 'input_data'");
    println!("  Output mapping: function's 'processed_data' → context's 'result'\n");

    // Create branches that both use the same variable names internally
    let mut branch_a = Graph::new();
    fn transform_a(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path A]", data));
        outputs
    }
    branch_a.add(
        transform_a,
        Some("Transform A"),
        Some(vec![("result", "x")]),  // Context's "result" → function's "x"
        Some(vec![("y", "output")])    // Function's "y" → context's "output"
    );

    let mut branch_b = Graph::new();
    fn transform_b(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let data = inputs.get("x").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("y".to_string(), format!("{} [Path B]", data));
        outputs
    }
    branch_b.add(
        transform_b,
        Some("Transform B"),
        Some(vec![("result", "x")]),  // Same variable names as branch_a
        Some(vec![("y", "output")])    // Same variable names as branch_a
    );

    println!("✓ Created two branches");
    println!("  Both branches use same internal variable names (x, y)");
    println!("  Both map 'result' → 'x' and 'y' → 'output'\n");

    // Branch from the processor
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);

    println!("✓ Added branches to graph");
    println!("  Branch A ID: {}", branch_a_id);
    println!("  Branch B ID: {}\n", branch_b_id);

    // Merge branches with branch-specific variable resolution
    fn combine(inputs: &HashMap<String, String>, _variant: &HashMap<String, String>) -> HashMap<String, String> {
        let default = String::new();
        let a = inputs.get("from_a").unwrap_or(&default);
        let b = inputs.get("from_b").unwrap_or(&default);
        let mut outputs = HashMap::new();
        outputs.insert("merged".to_string(), format!("Combined: {} + {}", a, b));
        outputs
    }

    graph.merge(
        combine,
        Some("Combine"),
        vec![
            (branch_a_id, "output", "from_a"),  // Branch A's "output" → merge function's "from_a"
            (branch_b_id, "output", "from_b")   // Branch B's "output" → merge function's "from_b"
        ],
        Some(vec![("merged", "final_result")])  // Merge function's "merged" → context's "final_result"
    );

    println!("✓ Added merge node");
    println!("  Branch-specific input mapping:");
    println!("    Branch {} 'output' → merge function's 'from_a'", branch_a_id);
    println!("    Branch {} 'output' → merge function's 'from_b'", branch_b_id);
    println!("  Output mapping: merge function's 'merged' → context's 'final_result'\n");

    // Variant example with factory pattern
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs, _variant| {
            let default = "1.0".to_string();
            let data = inputs.get("value").unwrap_or(&default);
            if let Ok(val) = data.parse::<f64>() {
                let mut outputs = HashMap::new();
                outputs.insert("scaled".to_string(), (val * factor).to_string());
                outputs
            } else {
                HashMap::new()
            }
        }
    }

    graph.variant(
        make_multiplier,
        vec![2.0, 3.0, 5.0],
        Some("Multiply"),
        Some(vec![("final_result", "value")]),  // Context's "final_result" → function's "value"
        Some(vec![("scaled", "multiplied")])    // Function's "scaled" → context's "multiplied"
    );

    println!("✓ Added variant nodes with parameter sweep");
    println!("  Three variants: factor = 2.0, 3.0, 5.0");
    println!("  Input mapping: context's 'final_result' → function's 'value'");
    println!("  Output mapping: function's 'scaled' → context's 'multiplied'\n");

    println!("=== Summary ===");
    println!("The tuple-based API provides clear separation between:");
    println!("1. Context variable names (broadcast vars) - shared across the graph");
    println!("2. Function parameter names (impl vars) - internal to each function");
    println!("\nThis allows:");
    println!("- Branches to use consistent internal naming (x, y)");
    println!("- Merge to distinguish branch outputs using branch IDs");
    println!("- Clear data flow visualization and debugging");
}

pub fn build(self) -> Dag

Build the final DAG from the graph builder

This performs the implicit inspection phase:

• Full graph traversal
• Execution path optimization
• Data flow connection determination
• Identification of parallelizable operations

Examples found in repository

examples/output_access_demo.rs (line 57)

fn demo_simple_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Pipeline Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 1: Generate initial data
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("initial_value".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("initial_value", "raw_data")])  // Maps initial_value → raw_data
    );
    
    // Node 2: Process the data
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("processed".to_string(), (value * 2).to_string());
            result
        },
        Some("Process"),
        Some(vec![("raw_data", "input")]),      // Maps raw_data → input
        Some(vec![("processed", "final_result")])  // Maps processed → final_result
    );
    
    // Build and execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Execution Context (all variables):");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🎯 Accessing specific outputs:");
    
    // Access by broadcast variable name (what's in the graph context)
    if let Some(raw_data) = context.get("raw_data") {
        println!("  raw_data: {}", raw_data);
    }
    
    if let Some(final_result) = context.get("final_result") {
        println!("  final_result: {}", final_result);
    }
    
    // Check if a variable exists
    if context.contains_key("final_result") {
        println!("\n✅ Final result is available in context");
    }
    
    println!();
}

fn demo_branch_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Branch Output Access (Parallel Paths)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "shared_data")])
    );
    
    // Branch A: Statistics computation
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("stats_output".to_string(), format!("Stats of {}", val));
            result
        },
        Some("Stats"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("stats_output", "statistics")])  // Branch A produces "statistics"
    );
    
    // Branch B: Model training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("model_output".to_string(), format!("Model trained on {}", val));
            result
        },
        Some("Train"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("model_output", "model")])  // Branch B produces "model"
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let val = inputs.get("data").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_output".to_string(), format!("Plot of {}", val));
            result
        },
        Some("Visualize"),
        Some(vec![("shared_data", "data")]),
        Some(vec![("viz_output", "visualization")])  // Branch C produces "visualization"
    );
    
    // Add branches to main graph
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 All outputs from parallel branches:");
    
    // Access each branch's output
    if let Some(stats) = context.get("statistics") {
        println!("  Branch A (Statistics): {}", stats);
    }
    
    if let Some(model) = context.get("model") {
        println!("  Branch B (Model): {}", model);
    }
    
    if let Some(viz) = context.get("visualization") {
        println!("  Branch C (Visualization): {}", viz);
    }
    
    println!("\n🔍 All variables in context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!();
}

fn demo_variant_output_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Output Access (Parameter Sweep)");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant nodes: scale by different factors
    // Factory function that creates a scaler for each factor
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled".to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled", "result")])  // Each variant produces "result"
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📦 Variant outputs:");
    println!("  Note: Variants with same output name overwrite each other");
    println!("  The last variant (factor=5.0) writes to 'result'\n");
    
    // Access the result (will be from the last variant)
    if let Some(result) = context.get("result") {
        println!("  result = {} (from last variant: 10.0 * 5.0)", result);
    }
    
    println!("\n💡 Tip: To preserve all variant outputs, use unique output names:");
    println!("   Option 1: Map each variant to a different broadcast variable");
    println!("   Option 2: Collect results in merge node");
    println!("   Option 3: Use variant_params or closure capture to distinguish");
    
    // Better approach: unique output names per variant
    let mut graph2 = Graph::new();
    
    graph2.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "input_data")])
    );
    
    // Variant 1: 2x
    fn make_scaler_unique(label: &str, factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> + '_ {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert(label.to_string(), (value * factor).to_string());
            result
        }
    }
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_2x", 2.0),
        vec!["2x"],
        Some("Scale2x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_2x", "result_2x")])
    );
    
    graph2.variant(
        |_x: &str| make_scaler_unique("scaled_3x", 3.0),
        vec!["3x"],
        Some("Scale3x"),
        Some(vec![("input_data", "data")]),
        Some(vec![("scaled_3x", "result_3x")])
    );
    
    let dag2 = graph2.build();
    let context2 = dag2.execute(false, None);
    
    println!("\n✅ Better approach - unique output names:");
    if let Some(result_2x) = context2.get("result_2x") {
        println!("  result_2x = {}", result_2x);
    }
    if let Some(result_3x) = context2.get("result_3x") {
        println!("  result_3x = {}", result_3x);
    }
    
    println!();
}

fn demo_multiple_outputs() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Multiple Outputs from Single Node");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node that produces multiple outputs
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("mean".to_string(), "50.5".to_string());
            result.insert("median".to_string(), "48.0".to_string());
            result.insert("stddev".to_string(), "12.3".to_string());
            result.insert("count".to_string(), "100".to_string());
            result
        },
        Some("Statistics"),
        None,
        Some(vec![
            ("mean", "stat_mean"),
            ("median", "stat_median"),
            ("stddev", "stat_stddev"),
            ("count", "sample_count")
        ])
    );
    
    // Execute
    let dag = graph.build();
    let context = dag.execute(false, None);
    
    println!("📊 Multiple outputs from single node:");
    
    // Access each output individually
    println!("  Mean:   {}", context.get("stat_mean").unwrap());
    println!("  Median: {}", context.get("stat_median").unwrap());
    println!("  StdDev: {}", context.get("stat_stddev").unwrap());
    println!("  Count:  {}", context.get("sample_count").unwrap());
    
    println!("\n📋 Complete execution context:");
    for (key, value) in &context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n💡 Summary:");
    println!("  ✓ dag.execute(false, None) returns HashMap<String, String>");
    println!("  ✓ Keys are broadcast variable names (from output mappings)");
    println!("  ✓ Use context.get(\"variable_name\") to access specific outputs");
    println!("  ✓ All outputs accumulate in the context throughout execution");
    
    println!();
}

examples/comprehensive_demo.rs (line 75)

fn demo_simple_pipeline() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Simple Sequential Pipeline");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Data source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "42".to_string());
            result
        },
        Some("DataSource"),
        None,                                      // No inputs (source node)
        Some(vec![("value", "data")])              // (impl_var, broadcast_var)
    );
    
    // Processing node: multiply by 2
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("doubled".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Multiply"),
        Some(vec![("data", "x")]),                 // (broadcast_var, impl_var)
        Some(vec![("doubled", "result")])          // (impl_var, broadcast_var)
    );
    
    // Final processing: add 10
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("num").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("sum".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("AddTen"),
        Some(vec![("result", "num")]),
        Some(vec![("sum", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Input:  data = {}", context.get("data").unwrap());
    println!("  Step 1: result = {} (data * 2)", context.get("result").unwrap());
    println!("  Step 2: final = {} (result + 10)", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_branching() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Parallel Branching (Fan-Out)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Compute statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("stats".to_string(), format!("Mean: {}", val));
            }
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stats", "stats_result")])
    );
    
    // Branch B: Train model
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("model".to_string(), format!("Model trained on {}", val));
            }
            result
        },
        Some("MLModel"),
        Some(vec![("data", "input")]),
        Some(vec![("model", "model_result")])
    );
    
    // Branch C: Generate visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input") {
                result.insert("plot".to_string(), format!("Plot of {}", val));
            }
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("plot", "viz_result")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A (Stats): {}", context.get("stats_result").unwrap());
    println!("  Branch B (Model): {}", context.get("model_result").unwrap());
    println!("  Branch C (Viz):   {}", context.get("viz_result").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All 3 branches can execute in parallel!");
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_merging() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Branching + Merging (Fan-Out + Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "50".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Branch A: Add 10
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 10).to_string());
            }
            result
        },
        Some("PathA (+10)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    // Branch B: Add 20
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("x").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("output".to_string(), (val + 20).to_string());
            }
            result
        },
        Some("PathB (+20)"),
        Some(vec![("data", "x")]),
        Some(vec![("output", "result")])  // Both branches use same output name!
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Merge node: Combine results from both branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let a = inputs.get("from_a").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let b = inputs.get("from_b").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            result.insert("combined".to_string(), format!("{} + {} = {}", a, b, a + b));
            result
        },
        Some("Merge"),
        vec![
            (branch_a_id, "result", "from_a"),  // Map branch A's "result" to merge fn's "from_a"
            (branch_b_id, "result", "from_b")   // Map branch B's "result" to merge fn's "from_b"
        ],
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Branch A: 50 + 10 = 60");
    println!("  Branch B: 50 + 20 = 70");
    println!("  Merged: {}", context.get("final").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variants() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Parameter Sweep with Variants");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10.0".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory: Scale by different learning rates
    fn make_scaler(learning_rate: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                let scaled = val * learning_rate;
                result.insert("scaled_value".to_string(), format!("{:.2}", scaled));
            }
            result
        }
    }
    
    // Create variants using Linspace for learning rate sweep
    graph.variant(
        make_scaler,
        vec![0.001, 0.01, 0.1, 1.0],
        Some("ScaleLR"),
        Some(vec![("data", "input")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Source: data = {}", context.get("data").unwrap());
    println!("  Variants created for learning rates: [0.001, 0.01, 0.1, 1.0]");
    println!("  (Each variant computes: data * learning_rate)");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ⚡ All {} variants can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_graph() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 5: Complex Graph (All Features Combined)");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // 1. Data ingestion
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw_data".to_string(), "1000".to_string());
            result
        },
        Some("Ingest"),
        None,
        Some(vec![("raw_data", "data")])
    );
    
    // 2. Preprocessing
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("raw").and_then(|s| s.parse::<i32>().ok()) {
                result.insert("cleaned".to_string(), (val / 10).to_string());
            }
            result
        },
        Some("Preprocess"),
        Some(vec![("data", "raw")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    // 3. Branch for different analyses
    let mut stats_branch = Graph::new();
    stats_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("stats".to_string(), format!("Stats({})", val));
            }
            result
        },
        Some("Stats"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("stats", "statistics")])
    );
    
    let mut ml_branch = Graph::new();
    ml_branch.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("data") {
                result.insert("prediction".to_string(), format!("Pred({})", val));
            }
            result
        },
        Some("ML"),
        Some(vec![("clean_data", "data")]),
        Some(vec![("prediction", "ml_result")])
    );
    
    let stats_id = graph.branch(stats_branch);
    let ml_id = graph.branch(ml_branch);
    
    // 4. Merge branches
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let stats = inputs.get("stats_in").cloned().unwrap_or_default();
            let ml = inputs.get("ml_in").cloned().unwrap_or_default();
            result.insert("report".to_string(), format!("{} & {}", stats, ml));
            result
        },
        Some("Combine"),
        vec![
            (stats_id, "statistics", "stats_in"),
            (ml_id, "ml_result", "ml_in")
        ],
        Some(vec![("report", "final_report")])
    );
    
    // 5. Final output formatting
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(report) = inputs.get("report") {
                result.insert("formatted".to_string(), format!("[FINAL] {}", report));
            }
            result
        },
        Some("Format"),
        Some(vec![("final_report", "report")]),
        Some(vec![("formatted", "output")])
    );
    
    let dag = graph.build();
    println!("\n📊 Execution:");
    let context = dag.execute(false, None);
    
    println!("  Step 1: Ingest      → data = {}", context.get("data").unwrap());
    println!("  Step 2: Preprocess  → clean_data = {}", context.get("clean_data").unwrap());
    println!("  Step 3: Branch A    → statistics = {}", context.get("statistics").unwrap());
    println!("          Branch B    → ml_result = {}", context.get("ml_result").unwrap());
    println!("  Step 4: Merge       → final_report = {}", context.get("final_report").unwrap());
    println!("  Step 5: Format      → output = {}", context.get("output").unwrap());
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    
    println!("\n📋 Execution Order:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        println!("  Level {}: {} nodes", level_idx, level.len());
        for &node_id in level {
            let node = dag.nodes().iter().find(|n| n.id == node_id).unwrap();
            println!("    - {}", node.display_name());
        }
    }
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
    
    println!("═══════════════════════════════════════════════════════════");
    println!("  Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/per_node_output_access.rs (line 70)

fn demo_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Per-Node Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Node 0: Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("value", "initial_data")])
    );
    
    // Node 1: Double
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("doubled".to_string(), (value * 2).to_string());
            result
        },
        Some("Double"),
        Some(vec![("initial_data", "in")]),
        Some(vec![("doubled", "doubled_data")])
    );
    
    // Node 2: Add Ten
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("in").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("added".to_string(), (value + 10).to_string());
            result
        },
        Some("AddTen"),
        Some(vec![("doubled_data", "in")]),
        Some(vec![("added", "final_result")])
    );
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (all variables):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs:");
    println!("\nNode 0 (Source) outputs:");
    if let Some(outputs) = result.get_node_outputs(0) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 1 (Double) outputs:");
    if let Some(outputs) = result.get_node_outputs(1) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nNode 2 (AddTen) outputs:");
    if let Some(outputs) = result.get_node_outputs(2) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific node outputs:");
    if let Some(value) = result.get_from_node(0, "initial_data") {
        println!("  Node 0 'initial_data': {}", value);
    }
    if let Some(value) = result.get_from_node(1, "doubled_data") {
        println!("  Node 1 'doubled_data': {}", value);
    }
    if let Some(value) = result.get_from_node(2, "final_result") {
        println!("  Node 2 'final_result': {}", value);
    }
    
    println!();
}

fn demo_per_branch_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Per-Branch Output Access");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Main graph: Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("dataset".to_string(), "100".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("dataset", "data")])
    );
    
    // Branch A: Statistics
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("stat_result".to_string(), format!("Mean of {}", value));
            result
        },
        Some("Statistics"),
        Some(vec![("data", "input")]),
        Some(vec![("stat_result", "statistics")])
    );
    
    // Branch B: Model Training
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("model_result".to_string(), format!("Model trained on {}", value));
            result
        },
        Some("ModelTraining"),
        Some(vec![("data", "input")]),
        Some(vec![("model_result", "trained_model")])
    );
    
    // Branch C: Visualization
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input").unwrap();
            let mut result = HashMap::new();
            result.insert("viz_result".to_string(), format!("Plot of {}", value));
            result
        },
        Some("Visualization"),
        Some(vec![("data", "input")]),
        Some(vec![("viz_result", "plot")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    let branch_c_id = graph.branch(branch_c);
    
    // Execute and get detailed results
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context:");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n🌿 Per-Branch Outputs:");
    
    println!("\nBranch {} (Statistics) outputs:", branch_a_id);
    if let Some(outputs) = result.get_branch_outputs(branch_a_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Model Training) outputs:", branch_b_id);
    if let Some(outputs) = result.get_branch_outputs(branch_b_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\nBranch {} (Visualization) outputs:", branch_c_id);
    if let Some(outputs) = result.get_branch_outputs(branch_c_id) {
        for (key, value) in outputs {
            println!("  {} = {}", key, value);
        }
    }
    
    println!("\n🎯 Accessing specific branch outputs:");
    if let Some(value) = result.get_from_branch(branch_a_id, "statistics") {
        println!("  Branch {} 'statistics': {}", branch_a_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_b_id, "trained_model") {
        println!("  Branch {} 'trained_model': {}", branch_b_id, value);
    }
    if let Some(value) = result.get_from_branch(branch_c_id, "plot") {
        println!("  Branch {} 'plot': {}", branch_c_id, value);
    }
    
    println!();
}

fn demo_variant_per_node_access() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Outputs with Per-Node Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("base_value".to_string(), "10".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("base_value", "data")])
    );
    
    // Variant factory for scaling
    fn make_scaler(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("input_data").unwrap().parse::<f64>().unwrap();
            let mut result = HashMap::new();
            result.insert("scaled_value".to_string(), (value * factor).to_string());
            result
        }
    }
    
    // Create variants with unique output names to preserve all results
    graph.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])  // Note: will overwrite in global context
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("🌍 Global Context (note: 'result' contains last variant's output):");
    for (key, value) in &result.context {
        println!("  {} = {}", key, value);
    }
    
    println!("\n📦 Per-Node Outputs (each variant tracked separately):");
    
    // Node 0 is the source
    // Nodes 1, 2, 3 are the variant nodes (2x, 3x, 5x scalers)
    for node_id in 1..=3 {
        println!("\nNode {} (Variant Scaler) outputs:", node_id);
        if let Some(outputs) = result.get_node_outputs(node_id) {
            for (key, value) in outputs {
                println!("  {} = {}", key, value);
            }
        }
    }
    
    println!("\n💡 Key Insight:");
    println!("  - Global context has 'result' = {} (last variant overwrites)", result.get("result").unwrap());
    println!("  - But per-node outputs preserve ALL variant results:");
    println!("    Node 1 (2x): result = {}", result.get_from_node(1, "result").unwrap());
    println!("    Node 2 (3x): result = {}", result.get_from_node(2, "result").unwrap());
    println!("    Node 3 (5x): result = {}", result.get_from_node(3, "result").unwrap());
    
    println!();
}

fn demo_execution_history_tracking() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Execution History Tracking");
    println!("─────────────────────────────────────────────────────────\n");
    
    let mut graph = Graph::new();
    
    // Multi-stage pipeline
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "5".to_string());
            result
        },
        Some("Load"),
        None,
        Some(vec![("raw", "input")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("cleaned".to_string(), (value + 1).to_string());
            result
        },
        Some("Clean"),
        Some(vec![("input", "x")]),
        Some(vec![("cleaned", "clean_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("normalized".to_string(), (value * 10).to_string());
            result
        },
        Some("Normalize"),
        Some(vec![("clean_data", "x")]),
        Some(vec![("normalized", "norm_data")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let value = inputs.get("x").unwrap().parse::<i32>().unwrap();
            let mut result = HashMap::new();
            result.insert("transformed".to_string(), format!("FINAL_{}", value));
            result
        },
        Some("Transform"),
        Some(vec![("norm_data", "x")]),
        Some(vec![("transformed", "output")])
    );
    
    let dag = graph.build();
    let result = dag.execute_detailed(false, None);
    
    println!("📊 Execution History (Data Flow Tracking):");
    println!();
    println!("Step-by-step transformation:");
    println!("  1. Load:      input = {}", result.get_from_node(0, "input").unwrap());
    println!("  2. Clean:     clean_data = {}", result.get_from_node(1, "clean_data").unwrap());
    println!("  3. Normalize: norm_data = {}", result.get_from_node(2, "norm_data").unwrap());
    println!("  4. Transform: output = {}", result.get_from_node(3, "output").unwrap());
    
    println!("\n🔍 Debugging: Inspect any intermediate result:");
    println!("  Need to debug the normalization step?");
    println!("  Just check Node 2: {}", result.get_from_node(2, "norm_data").unwrap());
    
    println!("\n✅ Benefits of Per-Node Access:");
    println!("  ✓ Track data transformations step-by-step");
    println!("  ✓ Debug issues by inspecting intermediate values");
    println!("  ✓ Validate each processing stage independently");
    println!("  ✓ Preserve all variant outputs even with name collisions");
    
    println!();
}

examples/parallel_execution_demo.rs (line 111)

fn demo_sequential_vs_parallel() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 1: Sequential vs Parallel Execution");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source node
    graph.add(
        |_: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            result.insert("data".to_string(), "source_data".to_string());
            println!("    [{}ms] Source completed", start.elapsed().as_millis());
            result
        },
        Some("Source"),
        None,
        Some(vec![("data", "data")])
    );
    
    // Branch A: 100ms work
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch A completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchA[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_a")])
    );
    
    // Branch B: 100ms work
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch B completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchB[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_b")])
    );
    
    // Branch C: 100ms work
    let mut branch_c = Graph::new();
    branch_c.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("input") {
                let processed = simulate_work(100, data);
                result.insert("result".to_string(), processed);
            }
            println!("    [{}ms] Branch C completed (100ms work)", start.elapsed().as_millis());
            result
        },
        Some("BranchC[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result_c")])
    );
    
    graph.branch(branch_a);
    graph.branch(branch_b);
    graph.branch(branch_c);
    
    let dag = graph.build();
    
    println!("\n📊 Sequential Execution (simulated):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let sequential_time = start.elapsed();
    println!("  Total time: {}ms", sequential_time.as_millis());
    
    println!("\n⚡ With Parallel Execution:");
    println!("  Expected time: ~100ms (all branches run simultaneously)");
    println!("  Speedup: ~3x faster than sequential");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("\n  Analysis:");
    println!("  - Level 0: 1 node  (Source)");
    println!("  - Level 1: 3 nodes (BranchA, BranchB, BranchC) ← Can run in parallel!");
    println!("  - Max parallelism: {} nodes can execute simultaneously", stats.max_parallelism);
    
    println!("\n🔍 Mermaid Visualization with Port Mappings:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_complex_dependencies() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 2: Complex Data Dependencies");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Two independent sources
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source1_data".to_string(), "100".to_string());
            result
        },
        Some("Source1"),
        None,
        Some(vec![("source1_data", "data1")])
    );
    
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("source2_data".to_string(), "200".to_string());
            result
        },
        Some("Source2"),
        None,
        Some(vec![("source2_data", "data2")])
    );
    
    // Process each source independently (can run in parallel)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 2).to_string());
            }
            result
        },
        Some("Process1[50ms]"),
        Some(vec![("data1", "in")]),
        Some(vec![("processed", "proc1")])
    );
    
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("in").and_then(|s| s.parse::<i32>().ok()) {
                thread::sleep(Duration::from_millis(50));
                result.insert("processed".to_string(), (val * 3).to_string());
            }
            result
        },
        Some("Process2[50ms]"),
        Some(vec![("data2", "in")]),
        Some(vec![("processed", "proc2")])
    );
    
    // Combine results (depends on both processors)
    graph.add(
        |inputs: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            let v1 = inputs.get("p1").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            let v2 = inputs.get("p2").and_then(|s| s.parse::<i32>().ok()).unwrap_or(0);
            thread::sleep(Duration::from_millis(30));
            result.insert("combined".to_string(), format!("{}", v1 + v2));
            result
        },
        Some("Combine[30ms]"),
        Some(vec![("proc1", "p1"), ("proc2", "p2")]),
        Some(vec![("combined", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Execution with timing:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("  Source1: data1 = {}", context.get("data1").unwrap());
    println!("  Source2: data2 = {}", context.get("data2").unwrap());
    println!("  Process1: proc1 = {} (data1 * 2)", context.get("proc1").unwrap());
    println!("  Process2: proc2 = {} (data2 * 3)", context.get("proc2").unwrap());
    println!("  Combine: final = {} (proc1 + proc2)", context.get("final").unwrap());
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels (showing parallelism):");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
        if level.len() > 1 {
            println!("           ↑ {} nodes can execute in parallel!", level.len());
        }
    }
    
    println!("\n⚡ Parallel Execution Analysis:");
    println!("  Sequential time would be: 50+50+30 = 130ms");
    println!("  With parallelism: Level0→Level1(parallel)→Level2 = ~80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (shows data dependencies):");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_variant_parallelism() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 3: Variant Parameter Sweep Parallelism");
    println!("─────────────────────────────────────────────────────────");
    
    let mut graph = Graph::new();
    
    // Source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("value".to_string(), "1000".to_string());
            result
        },
        Some("DataSource"),
        None,
        Some(vec![("value", "data")])
    );
    
    // Variant factory with different multipliers
    fn make_multiplier(factor: f64) -> impl Fn(&HashMap<String, String>, &HashMap<String, String>) -> HashMap<String, String> {
        move |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            let mut result = HashMap::new();
            if let Some(val) = inputs.get("input").and_then(|s| s.parse::<f64>().ok()) {
                // Simulate 100ms of work
                thread::sleep(Duration::from_millis(100));
                result.insert("result".to_string(), format!("{:.1}", val * factor));
            }
            println!("    [{}ms] Variant (factor={}) completed", start.elapsed().as_millis(), factor);
            result
        }
    }
    
    // Create 5 variants
    graph.variant(
        make_multiplier,
        vec![0.5, 1.0, 1.5, 2.0, 2.5],
        Some("Multiply[100ms]"),
        Some(vec![("data", "input")]),
        Some(vec![("result", "result")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing 5 variants (each takes 100ms):");
    let start = Instant::now();
    let _ = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n⚡ Parallelism Analysis:");
    println!("  Sequential execution: 100 × 5 = 500ms");
    println!("  With parallel execution: ~100ms (all run simultaneously)");
    println!("  Speedup: 5x");
    
    println!("\n📈 DAG Statistics:");
    let stats = dag.stats();
    println!("{}", stats.summary());
    println!("  ↑ All {} variant nodes can execute in parallel!", stats.variant_count);
    
    println!("\n🔍 Mermaid Visualization:");
    println!("{}", dag.to_mermaid());
    println!();
}

fn demo_diamond_pattern() {
    println!("─────────────────────────────────────────────────────────");
    println!("Demo 4: Diamond Pattern (Fan-Out → Fan-In)");
    println!("─────────────────────────────────────────────────────────");
    println!("This pattern shows:");
    println!("  - One source splits into multiple parallel branches");
    println!("  - Branches are processed independently");
    println!("  - Results merge back into single output");
    
    let mut graph = Graph::new();
    
    // Top of diamond: Single source
    graph.add(
        |_: &HashMap<String, String>, _| {
            let mut result = HashMap::new();
            result.insert("raw".to_string(), "input_data".to_string());
            result
        },
        Some("Source"),
        None,
        Some(vec![("raw", "data")])
    );
    
    // Left branch: Transform A (50ms)
    let mut branch_a = Graph::new();
    branch_a.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformA", data));
            }
            println!("    [{}ms] Transform A completed", start.elapsed().as_millis());
            result
        },
        Some("TransformA[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    // Right branch: Transform B (50ms)
    let mut branch_b = Graph::new();
    branch_b.add(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(50));
            let mut result = HashMap::new();
            if let Some(data) = inputs.get("in") {
                result.insert("out".to_string(), format!("{}_transformB", data));
            }
            println!("    [{}ms] Transform B completed", start.elapsed().as_millis());
            result
        },
        Some("TransformB[50ms]"),
        Some(vec![("data", "in")]),
        Some(vec![("out", "result")])
    );
    
    let branch_a_id = graph.branch(branch_a);
    let branch_b_id = graph.branch(branch_b);
    
    // Bottom of diamond: Merge (30ms)
    graph.merge(
        |inputs: &HashMap<String, String>, _| {
            let start = Instant::now();
            thread::sleep(Duration::from_millis(30));
            let mut result = HashMap::new();
            let a = inputs.get("left").cloned().unwrap_or_default();
            let b = inputs.get("right").cloned().unwrap_or_default();
            result.insert("merged".to_string(), format!("[{}+{}]", a, b));
            println!("    [{}ms] Merge completed", start.elapsed().as_millis());
            result
        },
        Some("Merge[30ms]"),
        vec![
            (branch_a_id, "result", "left"),
            (branch_b_id, "result", "right")
        ],
        Some(vec![("merged", "final")])
    );
    
    let dag = graph.build();
    
    println!("\n📊 Executing diamond pattern:");
    let start = Instant::now();
    let context = dag.execute(false, None);
    let total_time = start.elapsed();
    
    println!("\n  Result: {}", context.get("final").unwrap());
    println!("  Total execution time: {}ms", total_time.as_millis());
    
    println!("\n📈 Execution Levels:");
    for (level_idx, level) in dag.execution_levels().iter().enumerate() {
        print!("  Level {}: ", level_idx);
        let node_names: Vec<String> = level.iter()
            .map(|&node_id| dag.nodes().iter().find(|n| n.id == node_id).unwrap().display_name())
            .collect();
        println!("{}", node_names.join(", "));
    }
    
    println!("\n⚡ Timing Analysis:");
    println!("  Sequential: Source(0ms) + TransformA(50ms) + TransformB(50ms) + Merge(30ms) = 130ms");
    println!("  Parallel:   Source(0ms) → [TransformA + TransformB](50ms) → Merge(30ms) = 80ms");
    println!("  Speedup: 1.6x");
    
    println!("\n🔍 Mermaid Visualization (Diamond Shape):");
    println!("{}", dag.to_mermaid());
    
    println!("\n  The visualization shows:");
    println!("  - Port mappings on edges (data→in, result→left, result→right)");
    println!("  - Data dependencies between nodes");
    println!("  - Parallel branches can execute simultaneously");
    
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Parallel Execution Demo Complete!");
    println!("═══════════════════════════════════════════════════════════");
}

examples/variant_demo_full.rs (line 170)

fn main() {
    println!("═══════════════════════════════════════════════════════════");
    println!("  Variant Pattern Demo (sigexec-style)");
    println!("  Full Actual Syntax Examples");
    println!("═══════════════════════════════════════════════════════════\n");

    // =========================================================================
    // Demo 1: Single Variant - Basic Factory Pattern
    // =========================================================================
    println!("Demo 1: Single Variant with Factory Function");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_scaler(factor: f64) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"input_data\").unwrap().parse::<f64>().unwrap();");
    println!("        let scaled = value * factor;");
    println!("        outputs.insert(\"scaled_value\", scaled.to_string());");
    println!("    }}");
    println!("}}");
    println!();
    println!("let mut graph = Graph::new();");
    println!("graph.add(data_source, Some(\"Source\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(");
    println!("    make_scaler,              // Factory function");
    println!("    vec![2.0, 3.0, 5.0],      // Parameter values to sweep");
    println!("    Some(\"Scale\"),            // Label");
    println!("    Some(vec![(\"data\", \"input_data\")]),  // Input mapping");
    println!("    Some(vec![(\"scaled_value\", \"result\")])  // Output mapping");
    println!(");");
    println!("```\n");

    let mut graph1 = Graph::new();
    graph1.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph1.variant(
        make_scaler,
        vec![2.0, 3.0, 5.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    
    let dag1 = graph1.build();
    println!("🎯 What happens:");
    println!("  • Factory creates 3 nodes: Scale_2.0, Scale_3.0, Scale_5.0");
    println!("  • Each node multiplies input by its factor");
    println!("  • All variants can execute in parallel");
    println!();
    
    let stats1 = dag1.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats1.node_count);
    println!("  - Depth: {} levels", stats1.depth);
    println!("  - Max parallelism: {} nodes can run simultaneously", stats1.max_parallelism);
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag1.to_mermaid());
    println!();

    // =========================================================================
    // Demo 2: Multiple Variants - Cartesian Product
    // =========================================================================
    println!("\nDemo 2: Multiple Variants (Cartesian Product)");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("graph.add(data_source, Some(\"Generate\"), None, Some(vec![(\"value\", \"data\")]));");
    println!("graph.variant(make_scaler, vec![2.0, 3.0], Some(\"Scale\"), ...);");
    println!("graph.variant(make_offsetter, vec![10, 20], Some(\"Offset\"), ...);");
    println!("graph.add(stats_node, Some(\"Stats\"), Some(vec![(\"result\", \"result\")]), None);");
    println!("```\n");
    
    let mut graph2 = Graph::new();
    graph2.add(
        data_source,
        Some("Generate"),
        None,
        Some(vec![("value", "data")])
    );
    graph2.variant(
        make_scaler,
        vec![2.0, 3.0],
        Some("Scale"),
        Some(vec![("data", "input_data")]),
        Some(vec![("scaled_value", "result")])
    );
    graph2.variant(
        make_offsetter,
        vec![10, 20],
        Some("Offset"),
        Some(vec![("result", "number")]),
        Some(vec![("offset_result", "result")])
    );
    graph2.add(
        stats_node,
        Some("Stats"),
        Some(vec![("result", "result")]),
        Some(vec![("summary", "final")])
    );
    
    let dag2 = graph2.build();
    println!("🎯 What happens:");
    println!("  • Scale creates 2 variants: x2.0, x3.0");
    println!("  • Offset creates 2 variants: +10, +20");
    println!("  • Total combinations: 2 × 2 = 4 execution paths");
    println!("  • Each path: Generate → Scale[variant] → Offset[variant] → Stats");
    println!();
    
    let stats2 = dag2.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats2.node_count);
    println!("  - Depth: {} levels", stats2.depth);
    println!("  - Execution paths: 4 (2 scales × 2 offsets)");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag2.to_mermaid());
    println!();

    // =========================================================================
    // Demo 3: Complex Factory - Struct Configuration
    // =========================================================================
    println!("\nDemo 3: Complex Factory with Struct Configuration");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("#[derive(Clone)]");
    println!("struct FilterConfig {{");
    println!("    cutoff: f64,");
    println!("    mode: String,");
    println!("}}");
    println!();
    println!("fn make_filter(config: FilterConfig) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let value = inputs.get(\"data\").unwrap().parse::<f64>().unwrap();");
    println!("        let filtered = match config.mode.as_str() {{");
    println!("            \"lowpass\" => value * config.cutoff,");
    println!("            \"highpass\" => value * (1.0 - config.cutoff),");
    println!("            _ => value,");
    println!("        }};");
    println!("    }}");
    println!("}}");
    println!();
    println!("let configs = vec![");
    println!("    FilterConfig {{ cutoff: 0.5, mode: \"lowpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.3, mode: \"highpass\".to_string() }},");
    println!("    FilterConfig {{ cutoff: 0.7, mode: \"lowpass\".to_string() }},");
    println!("];");
    println!("graph.variant(make_filter, configs, Some(\"Filter\"), ...);");
    println!("```\n");

    let configs = vec![
        FilterConfig { cutoff: 0.5, mode: "lowpass".to_string() },
        FilterConfig { cutoff: 0.3, mode: "highpass".to_string() },
        FilterConfig { cutoff: 0.7, mode: "lowpass".to_string() },
    ];
    
    let mut graph3 = Graph::new();
    graph3.add(
        data_source,
        Some("Source"),
        None,
        Some(vec![("value", "data")])
    );
    graph3.variant(
        make_filter,
        configs,
        Some("Filter"),
        Some(vec![("data", "data")]),
        Some(vec![("filtered", "result")])
    );
    
    let dag3 = graph3.build();
    println!("🎯 What happens:");
    println!("  • 3 filter variants created with different configurations");
    println!("  • Each variant uses its own FilterConfig struct");
    println!("  • Demonstrates passing complex types to factory");
    println!();
    
    let stats3 = dag3.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats3.node_count);
    println!("  - Filter variants: 3");
    println!("  - Max parallelism: {} nodes", stats3.max_parallelism);
    println!();

    // =========================================================================
    // Demo 4: String Processing Variants
    // =========================================================================
    println!("\nDemo 4: String Processing Variants");
    println!("─────────────────────────────────────────────────────────\n");
    
    println!("📝 Code:");
    println!("```rust");
    println!("fn make_processor(prefix: &'static str) -> impl Fn(...) -> ... {{");
    println!("    move |inputs, _| {{");
    println!("        let text = inputs.get(\"text\").unwrap();");
    println!("        let processed = format!(\"[{{}}] {{}}\", prefix, text);");
    println!("        outputs.insert(\"processed_text\", processed);");
    println!("    }}");
    println!("}}");
    println!();
    println!("graph.variant(");
    println!("    make_processor,");
    println!("    vec![\"INFO\", \"WARN\", \"ERROR\"],");
    println!("    Some(\"LogLevel\"),");
    println!("    Some(vec![(\"message\", \"text\")]),");
    println!("    Some(vec![(\"processed_text\", \"log\")])");
    println!(");");
    println!("```\n");

    let mut graph4 = Graph::new();
    graph4.add(
        text_source,
        Some("Source"),
        None,
        Some(vec![("message", "message")])
    );
    graph4.variant(
        make_processor,
        vec!["INFO", "WARN", "ERROR"],
        Some("LogLevel"),
        Some(vec![("message", "text")]),
        Some(vec![("processed_text", "log")])
    );
    
    let dag4 = graph4.build();
    println!("🎯 What happens:");
    println!("  • 3 log level variants: INFO, WARN, ERROR");
    println!("  • Each prefixes the message with its log level");
    println!("  • Demonstrates string/static str parameters");
    println!();
    
    let stats4 = dag4.stats();
    println!("📈 DAG Statistics:");
    println!("  - Total nodes: {}", stats4.node_count);
    println!("  - Log variants: 3");
    println!();
    
    println!("🔍 Mermaid Visualization:");
    println!("{}", dag4.to_mermaid());
    println!();

    // =========================================================================
    // Summary
    // =========================================================================
    println!("\n═══════════════════════════════════════════════════════════");
    println!("  Summary: Key Variant Pattern Features");
    println!("═══════════════════════════════════════════════════════════\n");
    
    println!("✅ Factory Function Pattern:");
    println!("   • Factory takes parameter(s), returns closure");
    println!("   • Closure captures parameters in its environment");
    println!("   • Same signature as regular node functions");
    println!();
    
    println!("✅ Parameter Flexibility:");
    println!("   • Primitives: f64, i32, &str");
    println!("   • Structs: Custom configuration objects");
    println!("   • Arrays/Vectors: Multiple values at once");
    println!();
    
    println!("✅ Cartesian Products:");
    println!("   • Multiple .variant() calls create all combinations");
    println!("   • Example: 2 scales × 3 filters = 6 execution paths");
    println!();
    
    println!("✅ Port Mapping:");
    println!("   • Variants use same tuple-based syntax");
    println!("   • (broadcast_var, impl_var) for inputs");
    println!("   • (impl_var, broadcast_var) for outputs");
    println!();
    
    println!("✅ Parallel Execution:");
    println!("   • All variants at same level can run in parallel");
    println!("   • DAG analysis identifies parallelization opportunities");
    println!();
}

Trait Implementations

impl Default for Graph

fn default() -> Self

Returns the “default value” for a type.