Struct Kiln 

pub struct Kiln { /* private fields */ }

The kiln — the runtime that fires tasks and cools them to detect patterns.

Like a pottery kiln, this runtime has two distinct phases:

1. Firing: Tasks execute (fire()), producing outputs and metrics. This is the hot phase — the work gets done.

2. Cooling: After all tasks have fired, the runtime examines the completed tasks for emergent patterns. The crackle glaze forms in the cooling, not the firing.

Example

use crackle_runtime::{CrackleTask, Kiln, ThermalProfile, TaskOutput};

struct MyTask { x: f64 }
impl CrackleTask for MyTask {
    type Output = f64;
    fn fire(&self) -> TaskOutput<Self::Output> {
        TaskOutput::new(self.x, vec![("value".into(), self.x)])
    }
}

let mut kiln = Kiln::new(ThermalProfile::default());
kiln.fire_task(MyTask { x: 1.0 })?;
kiln.fire_task(MyTask { x: 2.0 })?;
kiln.fire_task(MyTask { x: 3.0 })?;

let patterns = kiln.cool();

Implementations

impl Kiln

pub fn new(profile: ThermalProfile) -> Self

Create a new kiln with the given thermal profile.

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::fast_cooling());

        kiln.fire_and_record(NumberTask { value: 2.0, name: "a".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.1, name: "b".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 9.8, name: "c".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 10.0, name: "d".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.2, name: "e".into() }).unwrap();

    println!("Tasks in kiln: {}", kiln.task_count());

    let patterns = kiln.cool();
    println!("\nDetected {} pattern(s):\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  tasks: {:?}\n", p.involved_tasks());
    }
}

examples/ci_patterns.rs (line 31)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // Normal builds
    kiln.fire_and_record(CiBuild { duration_secs: 45.0, test_count: 200.0, branch: "feature/auth".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 42.0, test_count: 195.0, branch: "fix/typo".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 48.0, test_count: 210.0, branch: "feature/ui".into() }).unwrap();

    // Something changed — builds got slower
    kiln.fire_and_record(CiBuild { duration_secs: 95.0, test_count: 200.0, branch: "feature/cache".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 102.0, test_count: 198.0, branch: "chore/deps".into() }).unwrap();

    let patterns = kiln.cool();
    println!("CI Build Pattern Analysis");
    println!("=========================\n");

    for p in &patterns {
        println!("[{}] {}", p.kind().to_string().to_uppercase(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  branches: {:?}\n", p.involved_tasks());
    }

    // Check for phase transition in build duration
    let phase_shifts: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "phase transition")
        .collect();

    if !phase_shifts.is_empty() {
        println!("⚠️  Build duration shifted significantly — investigate recent changes!");
    }
}

examples/api_monitoring.rs (line 33)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // /api/users — fast, small responses
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 45.0, status: 200, response_bytes: 1200.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 48.0, status: 200, response_bytes: 1150.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 52.0, status: 200, response_bytes: 1300.0 }).unwrap();

    // /api/reports — slow, large responses (correlated with bytes)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 350.0, status: 200, response_bytes: 55000.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 380.0, status: 200, response_bytes: 62000.0 }).unwrap();

    // /api/health — tiny, always fast (conservation candidate)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 3.0, status: 200, response_bytes: 15.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 4.0, status: 200, response_bytes: 15.0 }).unwrap();

    let patterns = kiln.cool();
    println!("API Monitoring — Pattern Report");
    println!("================================\n");
    println!("{} patterns detected:\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        if !p.involved_tasks().is_empty() {
            println!("  endpoints: {:?}", p.involved_tasks());
        }
        println!();
    }

    // Highlight correlations between latency and response size
    let correlations: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "correlation")
        .collect();

    if !correlations.is_empty() {
        println!("📊 Latency and response size are correlated — consider pagination or caching.");
    }
}

examples/event_stream_processor.rs (lines 113-115)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn default_profile() -> Self

Create a kiln with default thermal profile.

pub fn fire_task<T: CrackleTask>( &self, task: T, ) -> Result<TaskOutput<T::Output>>

Fire a single task and return its output (without recording).

Returns the task’s output value.

Errors

Returns CrackleError::KilnCooled if called after cool().

pub fn fire_and_record<T: CrackleTask>( &mut self, task: T, ) -> Result<TaskOutput<T::Output>>

Fire a task and record it in the kiln for later cooling.

This stores the task’s metrics internally so patterns can be detected during the cooling phase.

Errors

Returns CrackleError::KilnCooled if called after cool().

Examples found in repository

examples/basic.rs (line 32)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::fast_cooling());

        kiln.fire_and_record(NumberTask { value: 2.0, name: "a".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.1, name: "b".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 9.8, name: "c".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 10.0, name: "d".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.2, name: "e".into() }).unwrap();

    println!("Tasks in kiln: {}", kiln.task_count());

    let patterns = kiln.cool();
    println!("\nDetected {} pattern(s):\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  tasks: {:?}\n", p.involved_tasks());
    }
}

examples/ci_patterns.rs (line 34)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // Normal builds
    kiln.fire_and_record(CiBuild { duration_secs: 45.0, test_count: 200.0, branch: "feature/auth".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 42.0, test_count: 195.0, branch: "fix/typo".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 48.0, test_count: 210.0, branch: "feature/ui".into() }).unwrap();

    // Something changed — builds got slower
    kiln.fire_and_record(CiBuild { duration_secs: 95.0, test_count: 200.0, branch: "feature/cache".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 102.0, test_count: 198.0, branch: "chore/deps".into() }).unwrap();

    let patterns = kiln.cool();
    println!("CI Build Pattern Analysis");
    println!("=========================\n");

    for p in &patterns {
        println!("[{}] {}", p.kind().to_string().to_uppercase(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  branches: {:?}\n", p.involved_tasks());
    }

    // Check for phase transition in build duration
    let phase_shifts: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "phase transition")
        .collect();

    if !phase_shifts.is_empty() {
        println!("⚠️  Build duration shifted significantly — investigate recent changes!");
    }
}

examples/api_monitoring.rs (line 36)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // /api/users — fast, small responses
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 45.0, status: 200, response_bytes: 1200.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 48.0, status: 200, response_bytes: 1150.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 52.0, status: 200, response_bytes: 1300.0 }).unwrap();

    // /api/reports — slow, large responses (correlated with bytes)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 350.0, status: 200, response_bytes: 55000.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 380.0, status: 200, response_bytes: 62000.0 }).unwrap();

    // /api/health — tiny, always fast (conservation candidate)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 3.0, status: 200, response_bytes: 15.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 4.0, status: 200, response_bytes: 15.0 }).unwrap();

    let patterns = kiln.cool();
    println!("API Monitoring — Pattern Report");
    println!("================================\n");
    println!("{} patterns detected:\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        if !p.involved_tasks().is_empty() {
            println!("  endpoints: {:?}", p.involved_tasks());
        }
        println!();
    }

    // Highlight correlations between latency and response size
    let correlations: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "correlation")
        .collect();

    if !correlations.is_empty() {
        println!("📊 Latency and response size are correlated — consider pagination or caching.");
    }
}

examples/event_stream_processor.rs (line 121)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn fire_all<T: CrackleTask>( &mut self, tasks: Vec<T>, ) -> Result<Vec<TaskOutput<T::Output>>>

Fire multiple tasks in sequence and record them all.

Errors

Returns the first error encountered. Already-fired tasks are still recorded.

pub fn add_entry( &mut self, label: impl Into<String>, metrics: Vec<(String, f64)>, )

Add a pre-computed task entry directly (useful for testing).

pub fn task_count(&self) -> usize

The number of tasks currently in the kiln.

Examples found in repository

examples/basic.rs (line 38)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::fast_cooling());

        kiln.fire_and_record(NumberTask { value: 2.0, name: "a".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.1, name: "b".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 9.8, name: "c".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 10.0, name: "d".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.2, name: "e".into() }).unwrap();

    println!("Tasks in kiln: {}", kiln.task_count());

    let patterns = kiln.cool();
    println!("\nDetected {} pattern(s):\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  tasks: {:?}\n", p.involved_tasks());
    }
}

pub fn entries(&self) -> &[TaskEntry]

Get all task entries.

pub fn cool(&mut self) -> Vec<CracklePattern>

Cool the kiln: run pattern detection across all completed tasks.

This is where the beauty emerges. Just as a pottery kiln’s crackle glaze forms during cooling, the patterns that crackle-runtime detects are only visible after the heat of execution has passed.

Returns all detected patterns.

Examples found in repository

examples/basic.rs (line 40)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::fast_cooling());

        kiln.fire_and_record(NumberTask { value: 2.0, name: "a".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.1, name: "b".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 9.8, name: "c".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 10.0, name: "d".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.2, name: "e".into() }).unwrap();

    println!("Tasks in kiln: {}", kiln.task_count());

    let patterns = kiln.cool();
    println!("\nDetected {} pattern(s):\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  tasks: {:?}\n", p.involved_tasks());
    }
}

examples/ci_patterns.rs (line 42)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // Normal builds
    kiln.fire_and_record(CiBuild { duration_secs: 45.0, test_count: 200.0, branch: "feature/auth".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 42.0, test_count: 195.0, branch: "fix/typo".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 48.0, test_count: 210.0, branch: "feature/ui".into() }).unwrap();

    // Something changed — builds got slower
    kiln.fire_and_record(CiBuild { duration_secs: 95.0, test_count: 200.0, branch: "feature/cache".into() }).unwrap();
    kiln.fire_and_record(CiBuild { duration_secs: 102.0, test_count: 198.0, branch: "chore/deps".into() }).unwrap();

    let patterns = kiln.cool();
    println!("CI Build Pattern Analysis");
    println!("=========================\n");

    for p in &patterns {
        println!("[{}] {}", p.kind().to_string().to_uppercase(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  branches: {:?}\n", p.involved_tasks());
    }

    // Check for phase transition in build duration
    let phase_shifts: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "phase transition")
        .collect();

    if !phase_shifts.is_empty() {
        println!("⚠️  Build duration shifted significantly — investigate recent changes!");
    }
}

examples/api_monitoring.rs (line 48)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::default());

    // /api/users — fast, small responses
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 45.0, status: 200, response_bytes: 1200.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 48.0, status: 200, response_bytes: 1150.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/users".into(), latency_ms: 52.0, status: 200, response_bytes: 1300.0 }).unwrap();

    // /api/reports — slow, large responses (correlated with bytes)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 350.0, status: 200, response_bytes: 55000.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/reports".into(), latency_ms: 380.0, status: 200, response_bytes: 62000.0 }).unwrap();

    // /api/health — tiny, always fast (conservation candidate)
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 3.0, status: 200, response_bytes: 15.0 }).unwrap();
    kiln.fire_and_record(ApiRequest { endpoint: "GET /api/health".into(), latency_ms: 4.0, status: 200, response_bytes: 15.0 }).unwrap();

    let patterns = kiln.cool();
    println!("API Monitoring — Pattern Report");
    println!("================================\n");
    println!("{} patterns detected:\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        if !p.involved_tasks().is_empty() {
            println!("  endpoints: {:?}", p.involved_tasks());
        }
        println!();
    }

    // Highlight correlations between latency and response size
    let correlations: Vec<_> = patterns.iter()
        .filter(|p| format!("{}", p.kind()) == "correlation")
        .collect();

    if !correlations.is_empty() {
        println!("📊 Latency and response size are correlated — consider pagination or caching.");
    }
}

examples/event_stream_processor.rs (line 130)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn is_cooled(&self) -> bool

Check if the kiln has been cooled.

pub fn profile(&self) -> &ThermalProfile

Get the thermal profile.

pub fn reset(&mut self)

Reset the kiln for a new firing cycle.

pub fn mi_matrix(&self, bins: usize) -> Vec<Vec<f64>>

Compute the full mutual information matrix for all metric pairs.

Returns a symmetric matrix where entry (i,j) is the mutual information between metric i and metric j. Captures non-linear dependencies that Pearson correlation misses.

Arguments

• bins - Number of bins for discretization (typically 10)

Panics

Panics if there are no metric names (empty kiln).

Examples found in repository

examples/event_stream_processor.rs (line 242)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn distribution_shift(&self, bins: usize) -> Vec<(String, f64)>

Compute KL divergence between first-half and second-half metric distributions.

Principled replacement for the old “phase transition” heuristic. Returns the KL divergence for each metric name.

Examples found in repository

examples/event_stream_processor.rs (line 136)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn jsd_shift(&self, bins: usize) -> Vec<(String, f64)>

Compute Jensen-Shannon divergence between first-half and second-half metric distributions.

Symmetric version of KL divergence. Returns JSD for each metric name.

Examples found in repository

examples/event_stream_processor.rs (line 175)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn permutation_entropies(&self, order: usize) -> Vec<(String, f64)>

Compute permutation entropy for each metric’s time series.

Captures temporal structure in metric values.

Examples found in repository

examples/event_stream_processor.rs (line 182)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}