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.

pub fn default_profile() -> Self

Create a kiln with default thermal profile.

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

Fire a single task and record its output.

Returns the task’s output value.

Panics

Panics if called after cool().

pub fn fire_and_record<T: CrackleTask>( &mut self, task: T, ) -> 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.

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

Fire multiple tasks in sequence and record them all.

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.

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.

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.