Struct ServiceBuilder 

pub struct ServiceBuilder { /* private fields */ }

Builder for creating optimization services with registered type evaluators. Handles morphology registration and evaluator type erasure.

Implementations

impl ServiceBuilder

pub async fn register<T, E>(self, evaluator: E) -> Result<Self, Error>

where T: Encodeable + 'static, E: Evaluator<T::Phenotype> + Send + Sync + 'static,

Registers a problem type and its fitness evaluator with the optimization service.

This is the core method for connecting your domain-specific problems to the genetic algorithm engine. It establishes the relationship between your data structures, their genetic encoding, and the fitness evaluation logic.

Core Concepts

Type Registration Process

1. Morphology Creation: Automatically creates and stores the search space definition
2. Type Erasure: Converts your specific evaluator into a type-erased form for internal storage
3. Hash Mapping: Associates your type’s hash with its evaluator for efficient lookup
4. Database Integration: Ensures the type’s morphology exists in persistent storage

Required Trait Implementations

• Encodeable: Defines how your type maps to/from genetic representation
• Evaluator: Provides the fitness function that guides evolution

Parameters

• evaluator - Your fitness evaluator implementing Evaluator<T::Phenotype>

Type Parameters

• T: Encodeable - Your problem type that can be encoded as genes
• E: Evaluator<T::Phenotype> - Your fitness evaluator for decoded phenotypes

Encodeable Implementation Requirements

Your type must implement Encodeable with:

• NAME: Unique string identifier for your type
• Phenotype: The decoded form passed to evaluators
• morphology(): Defines the search space bounds and structure
• encode(): Converts instances to genetic representation
• decode(): Converts genes back to phenotypes for evaluation

Evaluator Implementation Requirements

Your evaluator must implement Evaluator<T::Phenotype> with:

• fitness(): Async function returning fitness scores (any finite f64 values)
• Support for early termination via the Terminated trait
• Error handling for failed evaluations

Common Registration Patterns

Simple Numerical Optimization

use fx_durable_ga::models::*;

#[derive(Debug, Clone)]
struct Parameters {
    learning_rate: f64,
    batch_size: i64,
    layers: i64,
}

impl Encodeable for Parameters {
    const NAME: &'static str = "Parameters";
    type Phenotype = Parameters;

    fn morphology() -> Vec<GeneBounds> {
        vec![
            GeneBounds::decimal(0.001, 1.0, 1000, 3).unwrap(),  // learning_rate
            GeneBounds::integer(8, 512, 32).unwrap(),            // batch_size
            GeneBounds::integer(1, 10, 10).unwrap(),             // layers
        ]
    }

    fn encode(&self) -> Vec<i64> {
        let bounds = Self::morphology();
        vec![
            bounds[0].from_sample(self.learning_rate / 1.0),
            bounds[1].from_sample((self.batch_size - 8) as f64 / (512 - 8) as f64),
            bounds[2].from_sample((self.layers - 1) as f64 / 9.0),
        ]
    }

    fn decode(genes: &[i64]) -> Self::Phenotype {
        let bounds = Self::morphology();
        Parameters {
            learning_rate: bounds[0].decode_f64(genes[0]),
            batch_size: (bounds[1].decode_f64(genes[1]) * (512 - 8) as f64 + 8.0) as i64,
            layers: (bounds[2].decode_f64(genes[2]) * 9.0 + 1.0) as i64,
        }
    }
}

struct ModelEvaluator;

impl Evaluator<Parameters> for ModelEvaluator {
    fn fitness<'a>(
        &self,
        _genotype_id: uuid::Uuid,
        params: Parameters,
        _request: &Request,
        _terminated: &'a Box<dyn Terminated>,
    ) -> BoxFuture<'a, Result<f64, anyhow::Error>> {
        Box::pin(async move {
            // Train model with parameters and return accuracy
            let accuracy = train_model(params.learning_rate, params.batch_size, params.layers).await?;
            Ok(accuracy)
        })
    }
}

let builder = builder.register::<Parameters, _>(ModelEvaluator).await?;

Geometric/Spatial Problems

use fx_durable_ga::models::*;

#[derive(Debug, Clone)]
struct Point3D {
    x: f64,
    y: f64,
    z: f64,
}

impl Encodeable for Point3D {
    const NAME: &'static str = "Point3D";
    type Phenotype = Point3D;

    fn morphology() -> Vec<GeneBounds> {
        vec![
            GeneBounds::decimal(-10.0, 10.0, 2000, 3).unwrap(),  // x: -10.0 to 10.0
            GeneBounds::decimal(-10.0, 10.0, 2000, 3).unwrap(),  // y: -10.0 to 10.0
            GeneBounds::decimal(0.0, 20.0, 2000, 3).unwrap(),    // z: 0.0 to 20.0
        ]
    }

    fn encode(&self) -> Vec<i64> {
        let bounds = Self::morphology();
        vec![
            bounds[0].from_sample((self.x + 10.0) / 20.0),
            bounds[1].from_sample((self.y + 10.0) / 20.0),
            bounds[2].from_sample(self.z / 20.0),
        ]
    }

    fn decode(genes: &[i64]) -> Self::Phenotype {
        let bounds = Self::morphology();
        Point3D {
            x: bounds[0].decode_f64(genes[0]) * 20.0 - 10.0,
            y: bounds[1].decode_f64(genes[1]) * 20.0 - 10.0,
            z: bounds[2].decode_f64(genes[2]) * 20.0,
        }
    }
}

struct DistanceEvaluator {
    target: Point3D,
}

impl Evaluator<Point3D> for DistanceEvaluator {
    fn fitness<'a>(
        &self,
        _genotype_id: uuid::Uuid,
        point: Point3D,
        _request: &Request,
        terminated: &'a Box<dyn Terminated>,
    ) -> BoxFuture<'a, Result<f64, anyhow::Error>> {
        let target = self.target.clone();
        Box::pin(async move {
            // Check for early termination
            if terminated.is_terminated().await {
                return Err(anyhow::anyhow!("Evaluation terminated"));
            }

            let dx = point.x - target.x;
            let dy = point.y - target.y;
            let dz = point.z - target.z;
            let distance = (dx*dx + dy*dy + dz*dz).sqrt();

            // Convert distance to fitness (closer = higher fitness)
            let fitness = 1.0 / (1.0 + distance);
            Ok(fitness)
        })
    }
}

let evaluator = DistanceEvaluator {
    target: Point3D { x: 5.0, y: -2.0, z: 10.0 }
};
let builder = builder.register::<Point3D, _>(evaluator).await?;

Combinatorial/Discrete Problems

use fx_durable_ga::models::*;

#[derive(Debug, Clone)]
struct Schedule {
    assignments: Vec<i64>,  // job assignments to workers
}

impl Encodeable for Schedule {
    const NAME: &'static str = "Schedule";
    type Phenotype = Schedule;

    fn morphology() -> Vec<GeneBounds> {
        // 10 jobs, each can be assigned to 5 workers (0-4)
        (0..10)
            .map(|_| GeneBounds::integer(0, 4, 5).unwrap())
            .collect()
    }

    fn encode(&self) -> Vec<i64> {
        self.assignments.clone()
    }

    fn decode(genes: &[i64]) -> Self::Phenotype {
        Schedule {
            assignments: genes.to_vec()
        }
    }
}

struct ScheduleEvaluator {
    job_costs: Vec<Vec<f64>>,  // job_costs[job][worker] = cost
}

impl Evaluator<Schedule> for ScheduleEvaluator {
    fn fitness<'a>(
        &self,
        _genotype_id: uuid::Uuid,
        schedule: Schedule,
        _request: &Request,
        _terminated: &'a Box<dyn Terminated>,
    ) -> BoxFuture<'a, Result<f64, anyhow::Error>> {
        let costs = self.job_costs.clone();
        Box::pin(async move {
            let total_cost: f64 = schedule.assignments
                .iter()
                .enumerate()
                .map(|(job, &worker)| costs[job][worker as usize])
                .sum();

            // Lower cost = higher fitness
            let max_possible_cost = 1000.0;
            let fitness = (max_possible_cost - total_cost) / max_possible_cost;
            Ok(fitness.max(0.0))
        })
    }
}

let evaluator = ScheduleEvaluator {
    job_costs: vec![vec![10.0, 20.0, 15.0, 25.0, 12.0]; 10]
};
let builder = builder.register::<Schedule, _>(evaluator).await?;

Best Practices

Morphology Design

• Use appropriate bounds: Match your problem’s natural constraints
• Balance precision vs. search space: More precision = larger search space
• Consider gene interactions: Related parameters should be adjacent when possible
• Use meaningful step sizes: Align with your problem’s natural granularity

Fitness Function Design

• Use natural value ranges: Return raw values like loss, accuracy, cost, profit
• Handle edge cases gracefully: Return appropriate default values for invalid solutions
• Check termination regularly: Use terminated.is_terminated() in long evaluations
• Avoid fitness cliffs: Gradual fitness landscapes converge better than binary ones
• Return errors for true failures: Let the system handle evaluation failures

Performance Considerations

• Minimize evaluation cost: Fitness evaluation is the bottleneck
• Use caching when appropriate: Cache expensive computations
• Parallelize evaluations: The system handles concurrent fitness evaluations
• Profile your evaluator: Identify and optimize slow paths

Registration Order

Multiple types can be registered with the same service:

let service = builder
    .register::<TypeA, _>(EvaluatorA).await?
    .register::<TypeB, _>(EvaluatorB).await?
    .build();

Returns

Returns Ok(Self) if registration succeeds, allowing method chaining. The morphology is created in the database if it doesn’t exist.

Errors

• Database connection or transaction failures
• Morphology creation failures (invalid gene bounds)
• Type hash collisions (extremely rare with different type names)

Example Usage

use fx_durable_ga::{bootstrap, models::*};

#[derive(Debug, Clone)]
struct OptimizationTarget {
    value: f64,
}

impl Encodeable for OptimizationTarget {
    const NAME: &'static str = "OptimizationTarget";
    type Phenotype = OptimizationTarget;

    fn morphology() -> Vec<GeneBounds> {
        vec![GeneBounds::decimal(-100.0, 100.0, 10000, 4).unwrap()]
    }

    fn encode(&self) -> Vec<i64> {
        let bounds = Self::morphology();
        vec![bounds[0].from_sample((self.value + 100.0) / 200.0)]
    }

    fn decode(genes: &[i64]) -> Self::Phenotype {
        let bounds = Self::morphology();
        OptimizationTarget {
            value: bounds[0].decode_f64(genes[0]) * 200.0 - 100.0
        }
    }
}

struct QuadraticEvaluator;

impl Evaluator<OptimizationTarget> for QuadraticEvaluator {
    fn fitness<'a>(
        &self,
        _genotype_id: uuid::Uuid,
        target: OptimizationTarget,
        _request: &Request,
        _terminated: &'a Box<dyn Terminated>,
    ) -> BoxFuture<'a, Result<f64, anyhow::Error>> {
        Box::pin(async move {
            // Maximize -(x-10)^2 + 100, so optimal x = 10
            let fitness = -(target.value - 10.0).powi(2) + 100.0;
            Ok(fitness)  // Return raw fitness value
        })
    }
}

let service = bootstrap(pool)
    .await?
    .register::<OptimizationTarget, _>(QuadraticEvaluator)
    .await?
    .build();

Examples found in repository

examples/regression_model.rs (line 215)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();
    tracing_subscriber::fmt()
        .pretty()
        .with_thread_ids(true)
        .with_max_level(Level::INFO)
        .init();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&database_url)
        .await?;

    // Run all default migrations
    fx_durable_ga::migrations::run_default_migrations(&pool).await?;

    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<NeuralArchitecture, _>(ArchitectureEvaluator)
            .await?
            .build(),
    );

    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    tokio::spawn(async move { listener.listen(None).await });

    let host_id = Uuid::parse_str("00000000-0000-0000-0000-123456789abc")?;
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        WORKERS,
        host_id,
        Duration::from_secs(600),
    )
    .await?;
    tokio::spawn(async move { jobs_listener.listen().await });

    service
        .new_optimization_request(
            NeuralArchitecture::NAME,
            NeuralArchitecture::HASH,
            FitnessGoal::minimize(FITNESS_TARGET)?,
            Schedule::generational(10, 10),
            Selector::tournament(5, 15)?,
            Mutagen::new(Temperature::constant(0.8)?, MutationRate::constant(0.4)?),
            Crossover::uniform(0.5)?,
            Distribution::latin_hypercube(15),
            None::<()>,
        )
        .await?;

    tokio::time::sleep(Duration::from_secs(3600)).await;
    Ok(())
}

examples/point_search.rs (line 158)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();

    // Initialize logging to see optimization progress
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    // Database setup - genetic algorithms need persistent storage for populations
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(50)
        .connect(&database_url)
        .await?;

    fx_event_bus::run_migrations(&pool).await?;
    fx_mq_jobs::run_migrations(&pool, fx_mq_jobs::FX_MQ_JOBS_SCHEMA_NAME).await?;

    // Bootstrap the optimization service and register our problem type
    let target_point = Point {
        x: 1.0,
        y: 1.5,
        z: 2.5,
    }; // Target point to find
    let evaluator = PointDistanceEvaluator { target_point };
    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<Point, _>(evaluator)
            .await?
            .build(),
    );

    // setup event handling and spawn an event handling agent
    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    let _events_handle = tokio::spawn(async move {
        listener.listen(None).await?;
        Ok::<(), sqlx::Error>(())
    });

    // setup job handling and initiate workers
    let host_id = Uuid::parse_str("ba3a4752-c4ce-4129-aa1d-55a0b2107e68").expect("valid uuid");
    let hold_for = Duration::from_secs(TIMEOUT_SECONDS);
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        8,
        host_id,
        hold_for,
    )
    .await?;
    let _jobs_handle = tokio::spawn(async move {
        jobs_listener.listen().await?;
        Ok::<(), anyhow::Error>(())
    });

    // Create multiple optimization requests with different genetic algorithm parameters
    for _ in 0..1 {
        service
            .new_optimization_request(
                Point::NAME,
                Point::HASH,
                FitnessGoal::minimize(0.01)?, // Stop when distance ≤ 0.01
                Schedule::generational(200, 30),
                Selector::tournament(7, 100)?,
                Mutagen::new(Temperature::constant(0.7)?, MutationRate::constant(0.3)?),
                Crossover::uniform(0.5)?,
                Distribution::latin_hypercube(1000),
                None::<()>,
            )
            .await?;
    }

    let timeout_duration = Duration::from_secs(TIMEOUT_SECONDS);
    let start_time = std::time::Instant::now();

    loop {
        tokio::time::sleep(Duration::from_secs(1)).await;

        // Check if we've exceeded the timeout
        if start_time.elapsed() >= timeout_duration {
            println!(
                "Timeout reached after {} seconds. Stopping optimization.",
                timeout_duration.as_secs()
            );
            break;
        }
    }

    Ok(())
}

examples/feature_engineering.rs (line 397)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();
    tracing_subscriber::fmt()
        .pretty()
        .with_thread_ids(true)
        .with_max_level(Level::INFO)
        .init();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&database_url)
        .await?;

    // Run all default migrations
    fx_durable_ga::migrations::run_default_migrations(&pool).await?;

    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<FeatureConfig, _>(FeatureEvaluator)
            .await?
            .build(),
    );

    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    tokio::spawn(async move { listener.listen(None).await });

    let host_id = Uuid::parse_str("00000000-0000-0000-0000-123456789abc")?;
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        WORKERS,
        host_id,
        Duration::from_secs(600),
    )
    .await?;
    tokio::spawn(async move { jobs_listener.listen().await });

    let request_id = service
        .new_optimization_request(
            FeatureConfig::NAME,
            FeatureConfig::HASH,
            FitnessGoal::minimize(FITNESS_TARGET)?,
            Schedule::generational(40, 10),
            Selector::tournament(5, 45)?,
            Mutagen::new(Temperature::constant(0.7)?, MutationRate::constant(0.35)?),
            Crossover::uniform(0.5)?,
            Distribution::latin_hypercube(40),
            None::<()>,
        )
        .await?;

    // Poll for completion every 15 seconds (timeout after 1 hour)
    let timeout = Duration::from_secs(7200);
    let poll_interval = Duration::from_secs(15);
    let start = std::time::Instant::now();

    loop {
        if service.is_request_concluded(request_id).await? {
            println!("\nOptimization completed!");
            break;
        }

        if start.elapsed() > timeout {
            println!("\nOptimization timed out after 1 hour.");
            break;
        }

        tokio::time::sleep(poll_interval).await;
    }

    // Get and print the best configuration
    if let Some((genotype, fitness)) = service.get_best_genotype(request_id).await? {
        let config = FeatureConfig::decode(&genotype.genome());
        println!("\n=== Best Configuration ===");
        println!("Fitness (MSE): {:.6}", fitness);
        println!("RMSE: {:.6}°C", fitness.sqrt());
        println!("\nHyperparameters:");
        println!("  Hidden Size: {}", config.hidden_size);
        println!("  Learning Rate: {}", config.learning_rate);
        println!("  Sequence Length: {}", config.sequence_length);
        println!("\nFeatures:");
        for (i, feature) in config.features.iter().enumerate() {
            let pipeline = feature
                .transforms
                .iter()
                .map(|t| t.to_string())
                .collect::<Vec<_>>()
                .join(" → ");
            if pipeline.is_empty() {
                println!("  feat_{}: {}", i, feature.source);
            } else {
                println!("  feat_{}: {} → {}", i, feature.source, pipeline);
            }
        }
    } else {
        println!("No genotypes were evaluated.");
    }

    Ok(())
}

pub fn with_max_deduplication_attempts(self, attempts: i32) -> Self

Sets the maximum number of deduplication attempts when breeding genotypes.

pub fn build(self) -> Service

Builds the optimization service with all registered evaluators.

Examples found in repository

examples/regression_model.rs (line 217)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();
    tracing_subscriber::fmt()
        .pretty()
        .with_thread_ids(true)
        .with_max_level(Level::INFO)
        .init();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&database_url)
        .await?;

    // Run all default migrations
    fx_durable_ga::migrations::run_default_migrations(&pool).await?;

    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<NeuralArchitecture, _>(ArchitectureEvaluator)
            .await?
            .build(),
    );

    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    tokio::spawn(async move { listener.listen(None).await });

    let host_id = Uuid::parse_str("00000000-0000-0000-0000-123456789abc")?;
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        WORKERS,
        host_id,
        Duration::from_secs(600),
    )
    .await?;
    tokio::spawn(async move { jobs_listener.listen().await });

    service
        .new_optimization_request(
            NeuralArchitecture::NAME,
            NeuralArchitecture::HASH,
            FitnessGoal::minimize(FITNESS_TARGET)?,
            Schedule::generational(10, 10),
            Selector::tournament(5, 15)?,
            Mutagen::new(Temperature::constant(0.8)?, MutationRate::constant(0.4)?),
            Crossover::uniform(0.5)?,
            Distribution::latin_hypercube(15),
            None::<()>,
        )
        .await?;

    tokio::time::sleep(Duration::from_secs(3600)).await;
    Ok(())
}

examples/point_search.rs (line 160)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();

    // Initialize logging to see optimization progress
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .init();

    // Database setup - genetic algorithms need persistent storage for populations
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(50)
        .connect(&database_url)
        .await?;

    fx_event_bus::run_migrations(&pool).await?;
    fx_mq_jobs::run_migrations(&pool, fx_mq_jobs::FX_MQ_JOBS_SCHEMA_NAME).await?;

    // Bootstrap the optimization service and register our problem type
    let target_point = Point {
        x: 1.0,
        y: 1.5,
        z: 2.5,
    }; // Target point to find
    let evaluator = PointDistanceEvaluator { target_point };
    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<Point, _>(evaluator)
            .await?
            .build(),
    );

    // setup event handling and spawn an event handling agent
    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    let _events_handle = tokio::spawn(async move {
        listener.listen(None).await?;
        Ok::<(), sqlx::Error>(())
    });

    // setup job handling and initiate workers
    let host_id = Uuid::parse_str("ba3a4752-c4ce-4129-aa1d-55a0b2107e68").expect("valid uuid");
    let hold_for = Duration::from_secs(TIMEOUT_SECONDS);
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        8,
        host_id,
        hold_for,
    )
    .await?;
    let _jobs_handle = tokio::spawn(async move {
        jobs_listener.listen().await?;
        Ok::<(), anyhow::Error>(())
    });

    // Create multiple optimization requests with different genetic algorithm parameters
    for _ in 0..1 {
        service
            .new_optimization_request(
                Point::NAME,
                Point::HASH,
                FitnessGoal::minimize(0.01)?, // Stop when distance ≤ 0.01
                Schedule::generational(200, 30),
                Selector::tournament(7, 100)?,
                Mutagen::new(Temperature::constant(0.7)?, MutationRate::constant(0.3)?),
                Crossover::uniform(0.5)?,
                Distribution::latin_hypercube(1000),
                None::<()>,
            )
            .await?;
    }

    let timeout_duration = Duration::from_secs(TIMEOUT_SECONDS);
    let start_time = std::time::Instant::now();

    loop {
        tokio::time::sleep(Duration::from_secs(1)).await;

        // Check if we've exceeded the timeout
        if start_time.elapsed() >= timeout_duration {
            println!(
                "Timeout reached after {} seconds. Stopping optimization.",
                timeout_duration.as_secs()
            );
            break;
        }
    }

    Ok(())
}

examples/feature_engineering.rs (line 399)

async fn main() -> Result<()> {
    dotenv::from_filename(".env.local").ok();
    tracing_subscriber::fmt()
        .pretty()
        .with_thread_ids(true)
        .with_max_level(Level::INFO)
        .init();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&database_url)
        .await?;

    // Run all default migrations
    fx_durable_ga::migrations::run_default_migrations(&pool).await?;

    let service = Arc::new(
        bootstrap(pool.clone())
            .await?
            .register::<FeatureConfig, _>(FeatureEvaluator)
            .await?
            .build(),
    );

    let mut registry = fx_event_bus::EventHandlerRegistry::new();
    register_event_handlers(
        Arc::new(Queries::new(FX_MQ_JOBS_SCHEMA_NAME)),
        service.clone(),
        &mut registry,
    );
    let mut listener = fx_event_bus::Listener::new(pool.clone(), registry);
    tokio::spawn(async move { listener.listen(None).await });

    let host_id = Uuid::parse_str("00000000-0000-0000-0000-123456789abc")?;
    let mut jobs_listener = fx_mq_jobs::Listener::new(
        pool.clone(),
        register_job_handlers(&service, fx_mq_jobs::RegistryBuilder::new()),
        WORKERS,
        host_id,
        Duration::from_secs(600),
    )
    .await?;
    tokio::spawn(async move { jobs_listener.listen().await });

    let request_id = service
        .new_optimization_request(
            FeatureConfig::NAME,
            FeatureConfig::HASH,
            FitnessGoal::minimize(FITNESS_TARGET)?,
            Schedule::generational(40, 10),
            Selector::tournament(5, 45)?,
            Mutagen::new(Temperature::constant(0.7)?, MutationRate::constant(0.35)?),
            Crossover::uniform(0.5)?,
            Distribution::latin_hypercube(40),
            None::<()>,
        )
        .await?;

    // Poll for completion every 15 seconds (timeout after 1 hour)
    let timeout = Duration::from_secs(7200);
    let poll_interval = Duration::from_secs(15);
    let start = std::time::Instant::now();

    loop {
        if service.is_request_concluded(request_id).await? {
            println!("\nOptimization completed!");
            break;
        }

        if start.elapsed() > timeout {
            println!("\nOptimization timed out after 1 hour.");
            break;
        }

        tokio::time::sleep(poll_interval).await;
    }

    // Get and print the best configuration
    if let Some((genotype, fitness)) = service.get_best_genotype(request_id).await? {
        let config = FeatureConfig::decode(&genotype.genome());
        println!("\n=== Best Configuration ===");
        println!("Fitness (MSE): {:.6}", fitness);
        println!("RMSE: {:.6}°C", fitness.sqrt());
        println!("\nHyperparameters:");
        println!("  Hidden Size: {}", config.hidden_size);
        println!("  Learning Rate: {}", config.learning_rate);
        println!("  Sequence Length: {}", config.sequence_length);
        println!("\nFeatures:");
        for (i, feature) in config.features.iter().enumerate() {
            let pipeline = feature
                .transforms
                .iter()
                .map(|t| t.to_string())
                .collect::<Vec<_>>()
                .join(" → ");
            if pipeline.is_empty() {
                println!("  feat_{}: {}", i, feature.source);
            } else {
                println!("  feat_{}: {} → {}", i, feature.source, pipeline);
            }
        }
    } else {
        println!("No genotypes were evaluated.");
    }

    Ok(())
}