feat(core): scale Bergamo routing model

Split the oversized Rust seed, route-metric, and solver-service modules into focused files so every Rust source remains below the 300-line limit.

Scale the LARGE demo to 48 visits over the Bergamo service-location catalog while keeping generated routes initially unassigned. The route seed data now uses broader technician capability and full-day visit windows so the larger generated plan can become feasible during construction and local search.

src/constraints/mod.rs

@@ -8,7 +8,10 @@ use solverforge::prelude::*;
 
 pub use self::assemble::create_constraints;
 
+mod route_constraint;
 pub mod route_metrics;
+#[cfg(test)]
+mod route_metrics_tests;
 
 // @solverforge:begin constraint-modules
 mod assigned_visits;

src/constraints/route_constraint.rs

@@ -0,0 +1,88 @@
+use crate::domain::{FieldServicePlan, TechnicianRoute};
+use solverforge::prelude::*;
+use solverforge::IncrementalConstraint;
+
+pub struct RouteConstraint {
+    name: &'static str,
+    hard: bool,
+    weight: HardSoftScore,
+    scorer: fn(&FieldServicePlan, &TechnicianRoute) -> HardSoftScore,
+}
+
+impl RouteConstraint {
+    pub const fn new(
+        name: &'static str,
+        hard: bool,
+        weight: HardSoftScore,
+        scorer: fn(&FieldServicePlan, &TechnicianRoute) -> HardSoftScore,
+    ) -> Self {
+        Self {
+            name,
+            hard,
+            weight,
+            scorer,
+        }
+    }
+
+    fn route_score(&self, solution: &FieldServicePlan, entity_index: usize) -> HardSoftScore {
+        solution
+            .technician_routes
+            .get(entity_index)
+            .map(|route| (self.scorer)(solution, route))
+            .unwrap_or(HardSoftScore::ZERO)
+    }
+}
+
+impl IncrementalConstraint<FieldServicePlan, HardSoftScore> for RouteConstraint {
+    fn evaluate(&self, solution: &FieldServicePlan) -> HardSoftScore {
+        solution
+            .technician_routes
+            .iter()
+            .map(|route| (self.scorer)(solution, route))
+            .fold(HardSoftScore::ZERO, |total, score| total + score)
+    }
+
+    fn match_count(&self, solution: &FieldServicePlan) -> usize {
+        solution
+            .technician_routes
+            .iter()
+            .filter(|route| (self.scorer)(solution, route) != HardSoftScore::ZERO)
+            .count()
+    }
+
+    fn initialize(&mut self, solution: &FieldServicePlan) -> HardSoftScore {
+        self.evaluate(solution)
+    }
+
+    fn on_insert(
+        &mut self,
+        solution: &FieldServicePlan,
+        entity_index: usize,
+        _descriptor_index: usize,
+    ) -> HardSoftScore {
+        self.route_score(solution, entity_index)
+    }
+
+    fn on_retract(
+        &mut self,
+        solution: &FieldServicePlan,
+        entity_index: usize,
+        _descriptor_index: usize,
+    ) -> HardSoftScore {
+        -self.route_score(solution, entity_index)
+    }
+
+    fn reset(&mut self) {}
+
+    fn name(&self) -> &str {
+        self.name
+    }
+
+    fn is_hard(&self) -> bool {
+        self.hard
+    }
+
+    fn weight(&self) -> HardSoftScore {
+        self.weight
+    }
+}

src/constraints/route_metrics.rs

@@ -1,91 +1,7 @@
 use crate::domain::{FieldServicePlan, ServiceVisit, TechnicianRoute, TravelLeg};
 use solverforge::prelude::*;
-use solverforge::IncrementalConstraint;
 
-pub struct RouteConstraint {
-    name: &'static str,
-    hard: bool,
-    weight: HardSoftScore,
-    scorer: fn(&FieldServicePlan, &TechnicianRoute) -> HardSoftScore,
-}
-
-impl RouteConstraint {
-    pub const fn new(
-        name: &'static str,
-        hard: bool,
-        weight: HardSoftScore,
-        scorer: fn(&FieldServicePlan, &TechnicianRoute) -> HardSoftScore,
-    ) -> Self {
-        Self {
-            name,
-            hard,
-            weight,
-            scorer,
-        }
-    }
-
-    fn route_score(&self, solution: &FieldServicePlan, entity_index: usize) -> HardSoftScore {
-        solution
-            .technician_routes
-            .get(entity_index)
-            .map(|route| (self.scorer)(solution, route))
-            .unwrap_or(HardSoftScore::ZERO)
-    }
-}
-
-impl IncrementalConstraint<FieldServicePlan, HardSoftScore> for RouteConstraint {
-    fn evaluate(&self, solution: &FieldServicePlan) -> HardSoftScore {
-        solution
-            .technician_routes
-            .iter()
-            .map(|route| (self.scorer)(solution, route))
-            .fold(HardSoftScore::ZERO, |total, score| total + score)
-    }
-
-    fn match_count(&self, solution: &FieldServicePlan) -> usize {
-        solution
-            .technician_routes
-            .iter()
-            .filter(|route| (self.scorer)(solution, route) != HardSoftScore::ZERO)
-            .count()
-    }
-
-    fn initialize(&mut self, solution: &FieldServicePlan) -> HardSoftScore {
-        self.evaluate(solution)
-    }
-
-    fn on_insert(
-        &mut self,
-        solution: &FieldServicePlan,
-        entity_index: usize,
-        _descriptor_index: usize,
-    ) -> HardSoftScore {
-        self.route_score(solution, entity_index)
-    }
-
-    fn on_retract(
-        &mut self,
-        solution: &FieldServicePlan,
-        entity_index: usize,
-        _descriptor_index: usize,
-    ) -> HardSoftScore {
-        -self.route_score(solution, entity_index)
-    }
-
-    fn reset(&mut self) {}
-
-    fn name(&self) -> &str {
-        self.name
-    }
-
-    fn is_hard(&self) -> bool {
-        self.hard
-    }
-
-    fn weight(&self) -> HardSoftScore {
-        self.weight
-    }
-}
+pub use super::route_constraint::RouteConstraint;
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct RouteStats {
@@ -296,140 +212,3 @@ fn div_ceil(value: i64, divisor: i64) -> i64 {
         (value + divisor - 1) / divisor
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::domain::{
-        FieldServicePlan, Location, ServiceVisit, ServiceVisitInit, TechnicianRoute,
-        TechnicianRouteInit, TravelLeg, TravelLegInit,
-    };
-    use solverforge::ConstraintSet;
-
-    #[test]
-    fn route_stats_accounts_for_travel_service_and_lateness() {
-        let plan = sample_plan(vec![0, 1]);
-        let stats = route_stats(&plan, &plan.technician_routes[0]);
-
-        assert_eq!(stats.travel_seconds, 1_800);
-        assert_eq!(stats.service_minutes, 75);
-        assert_eq!(stats.late_minutes, 0);
-        assert_eq!(stats.route_minutes, 125);
-        assert_eq!(stats.overtime_minutes, 55);
-        assert_eq!(stats.missing_skill_visits, 0);
-        assert_eq!(stats.missing_part_visits, 1);
-    }
-
-    #[test]
-    fn travel_leg_lookup_prefers_row_major_contract() {
-        let plan = sample_plan(vec![0]);
-        let leg = leg_for(&plan, 0, 1).expect("leg should exist");
-
-        assert_eq!(leg.id, "leg-0-1");
-        assert!(leg.reachable);
-    }
-
-    #[test]
-    fn full_constraint_set_reports_expected_hard_penalties() {
-        let constraints = crate::constraints::create_constraints();
-        let score = constraints.evaluate_all(&sample_plan(vec![0, 1]));
-
-        assert_eq!(score.hard(), -56);
-        assert!(score.soft() < 0);
-    }
-
-    fn sample_plan(visits: Vec<usize>) -> FieldServicePlan {
-        let locations = vec![
-            Location::new(
-                "loc-0",
-                "Hub",
-                "Hub".to_string(),
-                45_700_000,
-                9_670_000,
-                "depot".to_string(),
-            ),
-            Location::new(
-                "loc-1",
-                "Customer 1",
-                "Customer 1".to_string(),
-                45_710_000,
-                9_680_000,
-                "customer".to_string(),
-            ),
-            Location::new(
-                "loc-2",
-                "Customer 2",
-                "Customer 2".to_string(),
-                45_720_000,
-                9_690_000,
-                "customer".to_string(),
-            ),
-        ];
-        let service_visits = vec![
-            ServiceVisit::new(ServiceVisitInit {
-                id: "visit-0".to_string(),
-                name: "Boiler".to_string(),
-                customer: "Customer 1".to_string(),
-                location_idx: 1,
-                duration_minutes: 30,
-                earliest_minute: 510,
-                latest_minute: 540,
-                required_skill_mask: 0b001,
-                required_parts_mask: 0b010,
-                priority: 3,
-                territory: "center".to_string(),
-            }),
-            ServiceVisit::new(ServiceVisitInit {
-                id: "visit-1".to_string(),
-                name: "Lift".to_string(),
-                customer: "Customer 2".to_string(),
-                location_idx: 2,
-                duration_minutes: 45,
-                earliest_minute: 540,
-                latest_minute: 570,
-                required_skill_mask: 0b001,
-                required_parts_mask: 0b100,
-                priority: 2,
-                territory: "center".to_string(),
-            }),
-        ];
-        let travel_legs = row_major_legs(3);
-        let mut route = TechnicianRoute::new(TechnicianRouteInit {
-            id: "route-0".to_string(),
-            technician_id: "tech-0".to_string(),
-            technician_name: "Ada".to_string(),
-            color: "#2563eb".to_string(),
-            start_location_idx: 0,
-            end_location_idx: 0,
-            shift_start_minute: 480,
-            shift_end_minute: 585,
-            max_route_minutes: 90,
-            skill_mask: 0b001,
-            inventory_mask: 0b010,
-            territory: "center".to_string(),
-        });
-        route.visits = visits;
-
-        FieldServicePlan::new(locations, service_visits, travel_legs, vec![route])
-    }
-
-    fn row_major_legs(width: usize) -> Vec<TravelLeg> {
-        (0..width)
-            .flat_map(|from| {
-                (0..width).map(move |to| {
-                    let same = from == to;
-                    TravelLeg::new(TravelLegInit {
-                        id: format!("leg-{from}-{to}"),
-                        name: format!("leg-{from}-{to}"),
-                        from_location_idx: from,
-                        to_location_idx: to,
-                        duration_seconds: if same { 0 } else { 600 },
-                        distance_meters: if same { 0 } else { 2_000 },
-                        encoded_polyline: String::new(),
-                        reachable: true,
-                    })
-                })
-            })
-            .collect()
-    }
-}

src/constraints/route_metrics_tests.rs

@@ -0,0 +1,133 @@
+use super::route_metrics::{leg_for, route_stats};
+use crate::domain::{
+    FieldServicePlan, Location, ServiceVisit, ServiceVisitInit, TechnicianRoute,
+    TechnicianRouteInit, TravelLeg, TravelLegInit,
+};
+use solverforge::ConstraintSet;
+
+#[test]
+fn route_stats_accounts_for_travel_service_and_lateness() {
+    let plan = sample_plan(vec![0, 1]);
+    let stats = route_stats(&plan, &plan.technician_routes[0]);
+
+    assert_eq!(stats.travel_seconds, 1_800);
+    assert_eq!(stats.service_minutes, 75);
+    assert_eq!(stats.late_minutes, 0);
+    assert_eq!(stats.route_minutes, 125);
+    assert_eq!(stats.overtime_minutes, 55);
+    assert_eq!(stats.missing_skill_visits, 0);
+    assert_eq!(stats.missing_part_visits, 1);
+}
+
+#[test]
+fn travel_leg_lookup_prefers_row_major_contract() {
+    let plan = sample_plan(vec![0]);
+    let leg = leg_for(&plan, 0, 1).expect("leg should exist");
+
+    assert_eq!(leg.id, "leg-0-1");
+    assert!(leg.reachable);
+}
+
+#[test]
+fn full_constraint_set_reports_expected_hard_penalties() {
+    let constraints = crate::constraints::create_constraints();
+    let score = constraints.evaluate_all(&sample_plan(vec![0, 1]));
+
+    assert_eq!(score.hard(), -56);
+    assert!(score.soft() < 0);
+}
+
+fn sample_plan(visits: Vec<usize>) -> FieldServicePlan {
+    let locations = vec![
+        Location::new(
+            "loc-0",
+            "Hub",
+            "Hub".to_string(),
+            45_700_000,
+            9_670_000,
+            "depot".to_string(),
+        ),
+        Location::new(
+            "loc-1",
+            "Customer 1",
+            "Customer 1".to_string(),
+            45_710_000,
+            9_680_000,
+            "customer".to_string(),
+        ),
+        Location::new(
+            "loc-2",
+            "Customer 2",
+            "Customer 2".to_string(),
+            45_720_000,
+            9_690_000,
+            "customer".to_string(),
+        ),
+    ];
+    let service_visits = vec![
+        ServiceVisit::new(ServiceVisitInit {
+            id: "visit-0".to_string(),
+            name: "Boiler".to_string(),
+            customer: "Customer 1".to_string(),
+            location_idx: 1,
+            duration_minutes: 30,
+            earliest_minute: 510,
+            latest_minute: 540,
+            required_skill_mask: 0b001,
+            required_parts_mask: 0b010,
+            priority: 3,
+            territory: "center".to_string(),
+        }),
+        ServiceVisit::new(ServiceVisitInit {
+            id: "visit-1".to_string(),
+            name: "Lift".to_string(),
+            customer: "Customer 2".to_string(),
+            location_idx: 2,
+            duration_minutes: 45,
+            earliest_minute: 540,
+            latest_minute: 570,
+            required_skill_mask: 0b001,
+            required_parts_mask: 0b100,
+            priority: 2,
+            territory: "center".to_string(),
+        }),
+    ];
+    let travel_legs = row_major_legs(3);
+    let mut route = TechnicianRoute::new(TechnicianRouteInit {
+        id: "route-0".to_string(),
+        technician_id: "tech-0".to_string(),
+        technician_name: "Ada".to_string(),
+        color: "#2563eb".to_string(),
+        start_location_idx: 0,
+        end_location_idx: 0,
+        shift_start_minute: 480,
+        shift_end_minute: 585,
+        max_route_minutes: 90,
+        skill_mask: 0b001,
+        inventory_mask: 0b010,
+        territory: "center".to_string(),
+    });
+    route.visits = visits;
+
+    FieldServicePlan::new(locations, service_visits, travel_legs, vec![route])
+}
+
+fn row_major_legs(width: usize) -> Vec<TravelLeg> {
+    (0..width)
+        .flat_map(|from| {
+            (0..width).map(move |to| {
+                let same = from == to;
+                TravelLeg::new(TravelLegInit {
+                    id: format!("leg-{from}-{to}"),
+                    name: format!("leg-{from}-{to}"),
+                    from_location_idx: from,
+                    to_location_idx: to,
+                    duration_seconds: if same { 0 } else { 600 },
+                    distance_meters: if same { 0 } else { 2_000 },
+                    encoded_polyline: String::new(),
+                    reachable: true,
+                })
+            })
+        })
+        .collect()
+}

src/data/bergamo_catalog.rs

@@ -0,0 +1,60 @@
+use crate::domain::Location;
+
+#[derive(Clone, Copy)]
+pub(super) struct LocationSeed {
+    pub id: &'static str,
+    pub label: &'static str,
+    pub lat: f64,
+    pub lng: f64,
+    pub territory: &'static str,
+}
+
+impl LocationSeed {
+    pub(super) fn to_location(self, kind: &'static str) -> Location {
+        Location::new(
+            self.id,
+            self.label,
+            self.label.to_string(),
+            coord_e6(self.lat),
+            coord_e6(self.lng),
+            kind.to_string(),
+        )
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct VisitProfile {
+    pub name: &'static str,
+    pub duration_minutes: i32,
+    pub earliest_minute: i32,
+    pub latest_minute: i32,
+    pub required_skill_mask: i64,
+    pub required_parts_mask: i64,
+    pub priority: i32,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct TechnicianSeed {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub color: &'static str,
+    pub start_location_idx: usize,
+    pub end_location_idx: usize,
+    pub skill_mask: i64,
+    pub inventory_mask: i64,
+    pub territory: &'static str,
+}
+
+pub(super) const SKILL_HVAC: i64 = 0b0001;
+pub(super) const SKILL_ELECTRICAL: i64 = 0b0010;
+pub(super) const SKILL_PLUMBING: i64 = 0b0100;
+pub(super) const SKILL_ELEVATOR: i64 = 0b1000;
+
+pub(super) const PART_FILTERS: i64 = 0b0001;
+pub(super) const PART_RELAYS: i64 = 0b0010;
+pub(super) const PART_VALVES: i64 = 0b0100;
+pub(super) const PART_SENSORS: i64 = 0b1000;
+
+fn coord_e6(value: f64) -> i32 {
+    (value * 1_000_000.0).round() as i32
+}

src/data/bergamo_locations.rs

@@ -0,0 +1,189 @@
+use super::bergamo_catalog::LocationSeed;
+
+pub(super) const DEPOTS: &[LocationSeed] = &[
+    LocationSeed {
+        id: "depot-ops",
+        label: "Bergamo Operations Hub",
+        lat: 45.6954,
+        lng: 9.6703,
+        territory: "center",
+    },
+    LocationSeed {
+        id: "depot-east",
+        label: "Seriate Parts Locker",
+        lat: 45.6835,
+        lng: 9.7210,
+        territory: "east",
+    },
+];
+
+pub(super) const SERVICE_LOCATIONS: &[LocationSeed] = &[
+    LocationSeed {
+        id: "loc-citta-alta",
+        label: "Citta Alta heating fault",
+        lat: 45.7036,
+        lng: 9.6627,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-borgo-palazzo",
+        label: "Borgo Palazzo refrigeration",
+        lat: 45.6903,
+        lng: 9.6909,
+        territory: "east",
+    },
+    LocationSeed {
+        id: "loc-stazione",
+        label: "Station kiosk power",
+        lat: 45.6900,
+        lng: 9.6750,
+        territory: "center",
+    },
+    LocationSeed {
+        id: "loc-longuelo",
+        label: "Longuelo pump service",
+        lat: 45.6982,
+        lng: 9.6377,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-redona",
+        label: "Redona lift inspection",
+        lat: 45.7107,
+        lng: 9.6999,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-celadina",
+        label: "Celadina controls alarm",
+        lat: 45.6815,
+        lng: 9.7056,
+        territory: "east",
+    },
+    LocationSeed {
+        id: "loc-valtesse",
+        label: "Valtesse boiler reset",
+        lat: 45.7202,
+        lng: 9.6736,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-colognola",
+        label: "Colognola valve leak",
+        lat: 45.6767,
+        lng: 9.6469,
+        territory: "south",
+    },
+    LocationSeed {
+        id: "loc-malpensata",
+        label: "Malpensata sensor swap",
+        lat: 45.6840,
+        lng: 9.6687,
+        territory: "south",
+    },
+    LocationSeed {
+        id: "loc-seriate",
+        label: "Seriate medical cooler",
+        lat: 45.6856,
+        lng: 9.7242,
+        territory: "east",
+    },
+    LocationSeed {
+        id: "loc-gorle",
+        label: "Gorle access control",
+        lat: 45.7014,
+        lng: 9.7138,
+        territory: "east",
+    },
+    LocationSeed {
+        id: "loc-treviglio-road",
+        label: "Azzano workshop air unit",
+        lat: 45.6579,
+        lng: 9.6734,
+        territory: "south",
+    },
+    LocationSeed {
+        id: "loc-monterosso",
+        label: "Monterosso lift callout",
+        lat: 45.7161,
+        lng: 9.6905,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-loreto",
+        label: "Loreto electrical board",
+        lat: 45.6995,
+        lng: 9.6517,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-stezzano",
+        label: "Stezzano retail HVAC",
+        lat: 45.6508,
+        lng: 9.6534,
+        territory: "south",
+    },
+    LocationSeed {
+        id: "loc-grumello",
+        label: "Grumello pressure issue",
+        lat: 45.6888,
+        lng: 9.6275,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-orio",
+        label: "Orio terminal chiller",
+        lat: 45.6689,
+        lng: 9.7044,
+        territory: "south",
+    },
+    LocationSeed {
+        id: "loc-ranica",
+        label: "Ranica municipal lift",
+        lat: 45.7241,
+        lng: 9.7133,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-torre-boldone",
+        label: "Torre Boldone boiler",
+        lat: 45.7178,
+        lng: 9.7075,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-villaggio-sposi",
+        label: "Villaggio Sposi pump",
+        lat: 45.6901,
+        lng: 9.6365,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-dalmine",
+        label: "Dalmine line sensor",
+        lat: 45.6482,
+        lng: 9.6061,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-alzano",
+        label: "Alzano Lombardo relay",
+        lat: 45.7362,
+        lng: 9.7271,
+        territory: "north",
+    },
+    LocationSeed {
+        id: "loc-ponte-san-pietro",
+        label: "Ponte San Pietro valve",
+        lat: 45.7001,
+        lng: 9.5908,
+        territory: "west",
+    },
+    LocationSeed {
+        id: "loc-scanzo",
+        label: "Scanzorosciate cooler",
+        lat: 45.7105,
+        lng: 9.7354,
+        territory: "east",
+    },
+];

src/data/bergamo_profiles.rs

@@ -0,0 +1,61 @@
+use super::bergamo_catalog::{
+    VisitProfile, PART_RELAYS, PART_SENSORS, PART_VALVES, SKILL_ELECTRICAL, SKILL_ELEVATOR,
+    SKILL_HVAC, SKILL_PLUMBING,
+};
+
+pub(super) const VISIT_PROFILES: &[VisitProfile] = &[
+    VisitProfile {
+        name: "Boiler restart",
+        duration_minutes: 35,
+        earliest_minute: 8 * 60,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_HVAC,
+        required_parts_mask: PART_SENSORS,
+        priority: 4,
+    },
+    VisitProfile {
+        name: "Refrigeration diagnosis",
+        duration_minutes: 45,
+        earliest_minute: 9 * 60,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_HVAC | SKILL_ELECTRICAL,
+        required_parts_mask: PART_RELAYS,
+        priority: 5,
+    },
+    VisitProfile {
+        name: "Electrical board check",
+        duration_minutes: 30,
+        earliest_minute: 8 * 60 + 30,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_ELECTRICAL,
+        required_parts_mask: PART_RELAYS,
+        priority: 3,
+    },
+    VisitProfile {
+        name: "Pump service",
+        duration_minutes: 50,
+        earliest_minute: 10 * 60,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_PLUMBING,
+        required_parts_mask: PART_VALVES,
+        priority: 3,
+    },
+    VisitProfile {
+        name: "Lift safety inspection",
+        duration_minutes: 60,
+        earliest_minute: 11 * 60,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_ELEVATOR | SKILL_ELECTRICAL,
+        required_parts_mask: PART_SENSORS,
+        priority: 4,
+    },
+    VisitProfile {
+        name: "Controls alarm reset",
+        duration_minutes: 25,
+        earliest_minute: 13 * 60,
+        latest_minute: 18 * 60,
+        required_skill_mask: SKILL_ELECTRICAL,
+        required_parts_mask: PART_SENSORS,
+        priority: 2,
+    },
+];

src/data/bergamo_technicians.rs

@@ -0,0 +1,70 @@
+use super::bergamo_catalog::{
+    TechnicianSeed, PART_FILTERS, PART_RELAYS, PART_SENSORS, PART_VALVES, SKILL_ELECTRICAL,
+    SKILL_ELEVATOR, SKILL_HVAC, SKILL_PLUMBING,
+};
+
+pub(super) const TECHNICIANS: &[TechnicianSeed] = &[
+    TechnicianSeed {
+        id: "tech-ada",
+        name: "Ada Romano",
+        color: "#2563eb",
+        start_location_idx: 0,
+        end_location_idx: 0,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "center",
+    },
+    TechnicianSeed {
+        id: "tech-marco",
+        name: "Marco Bianchi",
+        color: "#059669",
+        start_location_idx: 1,
+        end_location_idx: 1,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "east",
+    },
+    TechnicianSeed {
+        id: "tech-elena",
+        name: "Elena Conti",
+        color: "#d97706",
+        start_location_idx: 0,
+        end_location_idx: 0,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "north",
+    },
+    TechnicianSeed {
+        id: "tech-paolo",
+        name: "Paolo Gatti",
+        color: "#be123c",
+        start_location_idx: 0,
+        end_location_idx: 0,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "west",
+    },
+    TechnicianSeed {
+        id: "tech-sara",
+        name: "Sara Ferri",
+        color: "#7c3aed",
+        start_location_idx: 1,
+        end_location_idx: 1,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "south",
+    },
+    TechnicianSeed {
+        id: "tech-luca",
+        name: "Luca Moretti",
+        color: "#0f766e",
+        start_location_idx: 0,
+        end_location_idx: 0,
+        skill_mask: ALL_SKILLS,
+        inventory_mask: ALL_PARTS,
+        territory: "east",
+    },
+];
+
+const ALL_SKILLS: i64 = SKILL_ELECTRICAL | SKILL_ELEVATOR | SKILL_HVAC | SKILL_PLUMBING;
+const ALL_PARTS: i64 = PART_FILTERS | PART_RELAYS | PART_SENSORS | PART_VALVES;

src/data/data_seed.rs

@@ -7,6 +7,9 @@ use solverforge_maps::{
     encode_polyline, BoundingBox, Coord, NetworkConfig, RoadNetwork, RoutingError, UNREACHABLE,
 };
 
+use super::bergamo_locations::{DEPOTS, SERVICE_LOCATIONS};
+use super::bergamo_profiles::VISIT_PROFILES;
+use super::bergamo_technicians::TECHNICIANS;
 use crate::domain::{
     FieldServicePlan, Location, ServiceVisit, ServiceVisitInit, TechnicianRoute,
     TechnicianRouteInit, TravelLeg, TravelLegInit,
@@ -87,7 +90,7 @@ impl DemoData {
         match self {
             Self::Small => 6,
             Self::Standard => 14,
-            Self::Large => SERVICE_LOCATIONS.len(),
+            Self::Large => SERVICE_LOCATIONS.len() * 2,
         }
     }
 }
@@ -135,30 +138,30 @@ fn network_config() -> NetworkConfig {
 }
 
 fn build_locations(demo: DemoData) -> Vec<Location> {
+    let service_location_count = demo.visit_count().min(SERVICE_LOCATIONS.len());
+
     DEPOTS
         .iter()
         .map(|seed| seed.to_location("depot"))
         .chain(
             SERVICE_LOCATIONS
                 .iter()
-                .take(demo.visit_count())
+                .take(service_location_count)
                 .map(|seed| seed.to_location("customer")),
         )
         .collect()
 }
 
 fn build_service_visits(demo: DemoData) -> Vec<ServiceVisit> {
-    SERVICE_LOCATIONS
-        .iter()
-        .take(demo.visit_count())
-        .enumerate()
-        .map(|(idx, seed)| {
+    (0..demo.visit_count())
+        .map(|idx| {
+            let seed = &SERVICE_LOCATIONS[idx % SERVICE_LOCATIONS.len()];
             let profile = VISIT_PROFILES[idx % VISIT_PROFILES.len()];
             ServiceVisit::new(ServiceVisitInit {
                 id: format!("visit-{idx:02}"),
                 name: profile.name.to_string(),
                 customer: seed.label.to_string(),
-                location_idx: DEPOTS.len() + idx,
+                location_idx: DEPOTS.len() + (idx % SERVICE_LOCATIONS.len()),
                 duration_minutes: profile.duration_minutes,
                 earliest_minute: profile.earliest_minute,
                 latest_minute: profile.latest_minute,
@@ -185,8 +188,8 @@ fn build_technician_routes(demo: DemoData) -> Vec<TechnicianRoute> {
                 start_location_idx: seed.start_location_idx,
                 end_location_idx: seed.end_location_idx,
                 shift_start_minute: 8 * 60,
-                shift_end_minute: 17 * 60,
-                max_route_minutes: 8 * 60,
+                shift_end_minute: 18 * 60,
+                max_route_minutes: 10 * 60,
                 skill_mask: seed.skill_mask,
                 inventory_mask: seed.inventory_mask,
                 territory: seed.territory.to_string(),
@@ -245,373 +248,6 @@ fn build_travel_legs(
     legs
 }
 
-#[derive(Clone, Copy)]
-struct LocationSeed {
-    id: &'static str,
-    label: &'static str,
-    lat: f64,
-    lng: f64,
-    territory: &'static str,
-}
-
-impl LocationSeed {
-    fn to_location(self, kind: &'static str) -> Location {
-        Location::new(
-            self.id,
-            self.label,
-            self.label.to_string(),
-            coord_e6(self.lat),
-            coord_e6(self.lng),
-            kind.to_string(),
-        )
-    }
-}
-
-fn coord_e6(value: f64) -> i32 {
-    (value * 1_000_000.0).round() as i32
-}
-
-#[derive(Clone, Copy)]
-struct VisitProfile {
-    name: &'static str,
-    duration_minutes: i32,
-    earliest_minute: i32,
-    latest_minute: i32,
-    required_skill_mask: i64,
-    required_parts_mask: i64,
-    priority: i32,
-}
-
-#[derive(Clone, Copy)]
-struct TechnicianSeed {
-    id: &'static str,
-    name: &'static str,
-    color: &'static str,
-    start_location_idx: usize,
-    end_location_idx: usize,
-    skill_mask: i64,
-    inventory_mask: i64,
-    territory: &'static str,
-}
-
-const SKILL_HVAC: i64 = 0b0001;
-const SKILL_ELECTRICAL: i64 = 0b0010;
-const SKILL_PLUMBING: i64 = 0b0100;
-const SKILL_ELEVATOR: i64 = 0b1000;
-
-const PART_FILTERS: i64 = 0b0001;
-const PART_RELAYS: i64 = 0b0010;
-const PART_VALVES: i64 = 0b0100;
-const PART_SENSORS: i64 = 0b1000;
-
-const DEPOTS: &[LocationSeed] = &[
-    LocationSeed {
-        id: "depot-ops",
-        label: "Bergamo Operations Hub",
-        lat: 45.6954,
-        lng: 9.6703,
-        territory: "center",
-    },
-    LocationSeed {
-        id: "depot-east",
-        label: "Seriate Parts Locker",
-        lat: 45.6835,
-        lng: 9.7210,
-        territory: "east",
-    },
-];
-
-const SERVICE_LOCATIONS: &[LocationSeed] = &[
-    LocationSeed {
-        id: "loc-citta-alta",
-        label: "Citta Alta heating fault",
-        lat: 45.7036,
-        lng: 9.6627,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-borgo-palazzo",
-        label: "Borgo Palazzo refrigeration",
-        lat: 45.6903,
-        lng: 9.6909,
-        territory: "east",
-    },
-    LocationSeed {
-        id: "loc-stazione",
-        label: "Station kiosk power",
-        lat: 45.6900,
-        lng: 9.6750,
-        territory: "center",
-    },
-    LocationSeed {
-        id: "loc-longuelo",
-        label: "Longuelo pump service",
-        lat: 45.6982,
-        lng: 9.6377,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-redona",
-        label: "Redona lift inspection",
-        lat: 45.7107,
-        lng: 9.6999,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-celadina",
-        label: "Celadina controls alarm",
-        lat: 45.6815,
-        lng: 9.7056,
-        territory: "east",
-    },
-    LocationSeed {
-        id: "loc-valtesse",
-        label: "Valtesse boiler reset",
-        lat: 45.7202,
-        lng: 9.6736,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-colognola",
-        label: "Colognola valve leak",
-        lat: 45.6767,
-        lng: 9.6469,
-        territory: "south",
-    },
-    LocationSeed {
-        id: "loc-malpensata",
-        label: "Malpensata sensor swap",
-        lat: 45.6840,
-        lng: 9.6687,
-        territory: "south",
-    },
-    LocationSeed {
-        id: "loc-seriate",
-        label: "Seriate medical cooler",
-        lat: 45.6856,
-        lng: 9.7242,
-        territory: "east",
-    },
-    LocationSeed {
-        id: "loc-gorle",
-        label: "Gorle access control",
-        lat: 45.7014,
-        lng: 9.7138,
-        territory: "east",
-    },
-    LocationSeed {
-        id: "loc-treviglio-road",
-        label: "Azzano workshop air unit",
-        lat: 45.6579,
-        lng: 9.6734,
-        territory: "south",
-    },
-    LocationSeed {
-        id: "loc-monterosso",
-        label: "Monterosso lift callout",
-        lat: 45.7161,
-        lng: 9.6905,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-loreto",
-        label: "Loreto electrical board",
-        lat: 45.6995,
-        lng: 9.6517,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-stezzano",
-        label: "Stezzano retail HVAC",
-        lat: 45.6508,
-        lng: 9.6534,
-        territory: "south",
-    },
-    LocationSeed {
-        id: "loc-grumello",
-        label: "Grumello pressure issue",
-        lat: 45.6888,
-        lng: 9.6275,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-orio",
-        label: "Orio terminal chiller",
-        lat: 45.6689,
-        lng: 9.7044,
-        territory: "south",
-    },
-    LocationSeed {
-        id: "loc-ranica",
-        label: "Ranica municipal lift",
-        lat: 45.7241,
-        lng: 9.7133,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-torre-boldone",
-        label: "Torre Boldone boiler",
-        lat: 45.7178,
-        lng: 9.7075,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-villaggio-sposi",
-        label: "Villaggio Sposi pump",
-        lat: 45.6901,
-        lng: 9.6365,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-dalmine",
-        label: "Dalmine line sensor",
-        lat: 45.6482,
-        lng: 9.6061,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-alzano",
-        label: "Alzano Lombardo relay",
-        lat: 45.7362,
-        lng: 9.7271,
-        territory: "north",
-    },
-    LocationSeed {
-        id: "loc-ponte-san-pietro",
-        label: "Ponte San Pietro valve",
-        lat: 45.7001,
-        lng: 9.5908,
-        territory: "west",
-    },
-    LocationSeed {
-        id: "loc-scanzo",
-        label: "Scanzorosciate cooler",
-        lat: 45.7105,
-        lng: 9.7354,
-        territory: "east",
-    },
-];
-
-const VISIT_PROFILES: &[VisitProfile] = &[
-    VisitProfile {
-        name: "Boiler restart",
-        duration_minutes: 35,
-        earliest_minute: 8 * 60,
-        latest_minute: 10 * 60,
-        required_skill_mask: SKILL_HVAC,
-        required_parts_mask: PART_SENSORS,
-        priority: 4,
-    },
-    VisitProfile {
-        name: "Refrigeration diagnosis",
-        duration_minutes: 45,
-        earliest_minute: 9 * 60,
-        latest_minute: 12 * 60,
-        required_skill_mask: SKILL_HVAC | SKILL_ELECTRICAL,
-        required_parts_mask: PART_RELAYS,
-        priority: 5,
-    },
-    VisitProfile {
-        name: "Electrical board check",
-        duration_minutes: 30,
-        earliest_minute: 8 * 60 + 30,
-        latest_minute: 13 * 60,
-        required_skill_mask: SKILL_ELECTRICAL,
-        required_parts_mask: PART_RELAYS,
-        priority: 3,
-    },
-    VisitProfile {
-        name: "Pump service",
-        duration_minutes: 50,
-        earliest_minute: 10 * 60,
-        latest_minute: 15 * 60,
-        required_skill_mask: SKILL_PLUMBING,
-        required_parts_mask: PART_VALVES,
-        priority: 3,
-    },
-    VisitProfile {
-        name: "Lift safety inspection",
-        duration_minutes: 60,
-        earliest_minute: 11 * 60,
-        latest_minute: 16 * 60,
-        required_skill_mask: SKILL_ELEVATOR | SKILL_ELECTRICAL,
-        required_parts_mask: PART_SENSORS,
-        priority: 4,
-    },
-    VisitProfile {
-        name: "Controls alarm reset",
-        duration_minutes: 25,
-        earliest_minute: 13 * 60,
-        latest_minute: 17 * 60,
-        required_skill_mask: SKILL_ELECTRICAL,
-        required_parts_mask: PART_SENSORS,
-        priority: 2,
-    },
-];
-
-const TECHNICIANS: &[TechnicianSeed] = &[
-    TechnicianSeed {
-        id: "tech-ada",
-        name: "Ada Romano",
-        color: "#2563eb",
-        start_location_idx: 0,
-        end_location_idx: 0,
-        skill_mask: SKILL_HVAC | SKILL_ELECTRICAL,
-        inventory_mask: PART_FILTERS | PART_RELAYS | PART_SENSORS,
-        territory: "center",
-    },
-    TechnicianSeed {
-        id: "tech-marco",
-        name: "Marco Bianchi",
-        color: "#059669",
-        start_location_idx: 1,
-        end_location_idx: 1,
-        skill_mask: SKILL_PLUMBING | SKILL_HVAC,
-        inventory_mask: PART_VALVES | PART_FILTERS | PART_SENSORS,
-        territory: "east",
-    },
-    TechnicianSeed {
-        id: "tech-elena",
-        name: "Elena Conti",
-        color: "#d97706",
-        start_location_idx: 0,
-        end_location_idx: 0,
-        skill_mask: SKILL_ELEVATOR | SKILL_ELECTRICAL,
-        inventory_mask: PART_RELAYS | PART_SENSORS,
-        territory: "north",
-    },
-    TechnicianSeed {
-        id: "tech-paolo",
-        name: "Paolo Gatti",
-        color: "#be123c",
-        start_location_idx: 0,
-        end_location_idx: 0,
-        skill_mask: SKILL_PLUMBING | SKILL_ELECTRICAL | SKILL_HVAC,
-        inventory_mask: PART_VALVES | PART_RELAYS | PART_FILTERS,
-        territory: "west",
-    },
-    TechnicianSeed {
-        id: "tech-sara",
-        name: "Sara Ferri",
-        color: "#7c3aed",
-        start_location_idx: 1,
-        end_location_idx: 1,
-        skill_mask: SKILL_HVAC | SKILL_ELECTRICAL | SKILL_ELEVATOR,
-        inventory_mask: PART_RELAYS | PART_SENSORS | PART_FILTERS,
-        territory: "south",
-    },
-    TechnicianSeed {
-        id: "tech-luca",
-        name: "Luca Moretti",
-        color: "#0f766e",
-        start_location_idx: 0,
-        end_location_idx: 0,
-        skill_mask: SKILL_PLUMBING | SKILL_HVAC | SKILL_ELECTRICAL,
-        inventory_mask: PART_VALVES | PART_RELAYS | PART_SENSORS | PART_FILTERS,
-        territory: "east",
-    },
-];
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/data/mod.rs

@@ -1,3 +1,7 @@
+mod bergamo_catalog;
+mod bergamo_locations;
+mod bergamo_profiles;
+mod bergamo_technicians;
 mod data_seed;
 
 pub use data_seed::{available_demo_data, default_demo_data, generate, DemoData, DemoDataError};

src/solver/event_payload.rs

@@ -0,0 +1,199 @@
+use serde::Serialize;
+use std::time::Duration;
+
+use solverforge::{
+    HardSoftScore, SolverEventMetadata, SolverLifecycleState, SolverSnapshot, SolverStatus,
+    SolverTelemetry, SolverTerminalReason,
+};
+
+use crate::api::PlanDto;
+use crate::domain::FieldServicePlan;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct TelemetryPayload {
+    elapsed_ms: u64,
+    step_count: u64,
+    moves_generated: u64,
+    moves_evaluated: u64,
+    moves_accepted: u64,
+    score_calculations: u64,
+    generation_ms: u64,
+    evaluation_ms: u64,
+    moves_per_second: u64,
+    acceptance_rate: f64,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct JobEventPayload {
+    id: String,
+    job_id: String,
+    event_type: &'static str,
+    event_sequence: u64,
+    lifecycle_state: &'static str,
+    terminal_reason: Option<&'static str>,
+    telemetry: TelemetryPayload,
+    current_score: Option<String>,
+    best_score: Option<String>,
+    snapshot_revision: Option<u64>,
+    solution: Option<PlanDto>,
+    error: Option<String>,
+}
+
+pub(super) fn status_event_payload(
+    job_id: usize,
+    event_type: &'static str,
+    status: &SolverStatus<HardSoftScore>,
+) -> String {
+    serialize_payload(JobEventPayload {
+        id: job_id.to_string(),
+        job_id: job_id.to_string(),
+        event_type,
+        event_sequence: status.event_sequence,
+        lifecycle_state: lifecycle_state_label(status.lifecycle_state),
+        terminal_reason: status.terminal_reason.map(terminal_reason_label),
+        telemetry: telemetry_payload(&status.telemetry),
+        current_score: status.current_score.map(|score| score.to_string()),
+        best_score: status.best_score.map(|score| score.to_string()),
+        snapshot_revision: status.latest_snapshot_revision,
+        solution: None,
+        error: None,
+    })
+}
+
+pub(super) fn snapshot_status_event_payload(
+    job_id: usize,
+    event_type: &'static str,
+    status: &SolverStatus<HardSoftScore>,
+    snapshot: &SolverSnapshot<FieldServicePlan>,
+) -> String {
+    serialize_payload(JobEventPayload {
+        id: job_id.to_string(),
+        job_id: job_id.to_string(),
+        event_type,
+        event_sequence: status.event_sequence,
+        lifecycle_state: lifecycle_state_label(status.lifecycle_state),
+        terminal_reason: status.terminal_reason.map(terminal_reason_label),
+        telemetry: telemetry_payload(&status.telemetry),
+        current_score: status
+            .current_score
+            .or(snapshot.current_score)
+            .map(|score| score.to_string()),
+        best_score: status
+            .best_score
+            .or(snapshot.best_score)
+            .map(|score| score.to_string()),
+        snapshot_revision: Some(snapshot.snapshot_revision),
+        solution: Some(PlanDto::from_plan(&snapshot.solution)),
+        error: None,
+    })
+}
+
+pub(super) fn event_payload(
+    job_id: usize,
+    event_type: &'static str,
+    metadata: &SolverEventMetadata<HardSoftScore>,
+    solution: Option<&FieldServicePlan>,
+    error: Option<&str>,
+) -> String {
+    serialize_payload(JobEventPayload {
+        id: job_id.to_string(),
+        job_id: job_id.to_string(),
+        event_type,
+        event_sequence: metadata.event_sequence,
+        lifecycle_state: lifecycle_state_label(metadata.lifecycle_state),
+        terminal_reason: metadata.terminal_reason.map(terminal_reason_label),
+        telemetry: telemetry_payload(&metadata.telemetry),
+        current_score: metadata.current_score.map(|score| score.to_string()),
+        best_score: metadata.best_score.map(|score| score.to_string()),
+        snapshot_revision: metadata.snapshot_revision,
+        solution: solution.map(PlanDto::from_plan),
+        error: error.map(ToOwned::to_owned),
+    })
+}
+
+pub(super) fn bootstrap_event_type(state: SolverLifecycleState) -> &'static str {
+    match state {
+        SolverLifecycleState::Solving => "progress",
+        SolverLifecycleState::PauseRequested => "pause_requested",
+        SolverLifecycleState::Paused => "paused",
+        SolverLifecycleState::Completed => "completed",
+        SolverLifecycleState::Cancelled => "cancelled",
+        SolverLifecycleState::Failed => "failed",
+    }
+}
+
+pub(super) fn bootstrap_snapshot_event_type(state: SolverLifecycleState) -> &'static str {
+    match state {
+        SolverLifecycleState::Solving => "best_solution",
+        other => bootstrap_event_type(other),
+    }
+}
+
+fn serialize_payload(payload: JobEventPayload) -> String {
+    serde_json::to_string(&payload).expect("failed to serialize solver lifecycle payload")
+}
+
+fn telemetry_payload(telemetry: &SolverTelemetry) -> TelemetryPayload {
+    TelemetryPayload {
+        elapsed_ms: duration_to_millis(telemetry.elapsed),
+        step_count: telemetry.step_count,
+        moves_generated: telemetry.moves_generated,
+        moves_evaluated: telemetry.moves_evaluated,
+        moves_accepted: telemetry.moves_accepted,
+        score_calculations: telemetry.score_calculations,
+        generation_ms: duration_to_millis(telemetry.generation_time),
+        evaluation_ms: duration_to_millis(telemetry.evaluation_time),
+        moves_per_second: whole_units_per_second(telemetry.moves_evaluated, telemetry.elapsed),
+        acceptance_rate: derive_acceptance_rate(
+            telemetry.moves_accepted,
+            telemetry.moves_evaluated,
+        ),
+    }
+}
+
+fn lifecycle_state_label(state: SolverLifecycleState) -> &'static str {
+    match state {
+        SolverLifecycleState::Solving => "SOLVING",
+        SolverLifecycleState::PauseRequested => "PAUSE_REQUESTED",
+        SolverLifecycleState::Paused => "PAUSED",
+        SolverLifecycleState::Completed => "COMPLETED",
+        SolverLifecycleState::Cancelled => "CANCELLED",
+        SolverLifecycleState::Failed => "FAILED",
+    }
+}
+
+fn terminal_reason_label(reason: SolverTerminalReason) -> &'static str {
+    match reason {
+        SolverTerminalReason::Completed => "completed",
+        SolverTerminalReason::TerminatedByConfig => "terminated_by_config",
+        SolverTerminalReason::Cancelled => "cancelled",
+        SolverTerminalReason::Failed => "failed",
+    }
+}
+
+fn duration_to_millis(duration: Duration) -> u64 {
+    duration.as_millis().min(u128::from(u64::MAX)) as u64
+}
+
+fn whole_units_per_second(count: u64, elapsed: Duration) -> u64 {
+    let nanos = elapsed.as_nanos();
+    if nanos == 0 {
+        0
+    } else {
+        let per_second = u128::from(count)
+            .saturating_mul(1_000_000_000)
+            .checked_div(nanos)
+            .unwrap_or(0);
+        per_second.min(u128::from(u64::MAX)) as u64
+    }
+}
+
+fn derive_acceptance_rate(moves_accepted: u64, moves_evaluated: u64) -> f64 {
+    if moves_evaluated == 0 {
+        0.0
+    } else {
+        moves_accepted as f64 / moves_evaluated as f64
+    }
+}

src/solver/mod.rs

@@ -1,3 +1,4 @@
+mod event_payload;
 mod service;
 
 pub use service::SolverService;

src/solver/service.rs

@@ -1,54 +1,22 @@
 use parking_lot::RwLock;
-use serde::Serialize;
 use std::collections::HashMap;
 use std::sync::Arc;
-use std::time::Duration;
 use tokio::sync::{broadcast, mpsc};
 
 use solverforge::{
-    HardSoftScore, SolverEvent, SolverEventMetadata, SolverLifecycleState, SolverManager,
-    SolverManagerError, SolverSnapshot, SolverSnapshotAnalysis, SolverStatus, SolverTelemetry,
-    SolverTerminalReason,
+    HardSoftScore, SolverEvent, SolverManager, SolverManagerError, SolverSnapshot,
+    SolverSnapshotAnalysis, SolverStatus,
 };
 
-use crate::api::PlanDto;
+use super::event_payload::{
+    bootstrap_event_type, bootstrap_snapshot_event_type, event_payload,
+    snapshot_status_event_payload, status_event_payload,
+};
 use crate::domain::FieldServicePlan;
 
 // Static manager — must be 'static for retained job execution.
 static MANAGER: SolverManager<FieldServicePlan> = SolverManager::new();
 
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct TelemetryPayload {
-    elapsed_ms: u64,
-    step_count: u64,
-    moves_generated: u64,
-    moves_evaluated: u64,
-    moves_accepted: u64,
-    score_calculations: u64,
-    generation_ms: u64,
-    evaluation_ms: u64,
-    moves_per_second: u64,
-    acceptance_rate: f64,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct JobEventPayload {
-    id: String,
-    job_id: String,
-    event_type: &'static str,
-    event_sequence: u64,
-    lifecycle_state: &'static str,
-    terminal_reason: Option<&'static str>,
-    telemetry: TelemetryPayload,
-    current_score: Option<String>,
-    best_score: Option<String>,
-    snapshot_revision: Option<u64>,
-    solution: Option<PlanDto>,
-    error: Option<String>,
-}
-
 struct JobState {
     sse_tx: broadcast::Sender<String>,
 }
@@ -200,165 +168,8 @@ fn parse_job_id(id: &str) -> Result<usize, SolverManagerError> {
         .map_err(|_| SolverManagerError::JobNotFound { job_id: usize::MAX })
 }
 
-fn status_event_payload(
-    job_id: usize,
-    event_type: &'static str,
-    status: &SolverStatus<HardSoftScore>,
-) -> String {
-    serialize_payload(JobEventPayload {
-        id: job_id.to_string(),
-        job_id: job_id.to_string(),
-        event_type,
-        event_sequence: status.event_sequence,
-        lifecycle_state: lifecycle_state_label(status.lifecycle_state),
-        terminal_reason: status.terminal_reason.map(terminal_reason_label),
-        telemetry: telemetry_payload(&status.telemetry),
-        current_score: status.current_score.map(|score| score.to_string()),
-        best_score: status.best_score.map(|score| score.to_string()),
-        snapshot_revision: status.latest_snapshot_revision,
-        solution: None,
-        error: None,
-    })
-}
-
-fn snapshot_status_event_payload(
-    job_id: usize,
-    event_type: &'static str,
-    status: &SolverStatus<HardSoftScore>,
-    snapshot: &SolverSnapshot<FieldServicePlan>,
-) -> String {
-    serialize_payload(JobEventPayload {
-        id: job_id.to_string(),
-        job_id: job_id.to_string(),
-        event_type,
-        event_sequence: status.event_sequence,
-        lifecycle_state: lifecycle_state_label(status.lifecycle_state),
-        terminal_reason: status.terminal_reason.map(terminal_reason_label),
-        telemetry: telemetry_payload(&status.telemetry),
-        current_score: status
-            .current_score
-            .or(snapshot.current_score)
-            .map(|score| score.to_string()),
-        best_score: status
-            .best_score
-            .or(snapshot.best_score)
-            .map(|score| score.to_string()),
-        snapshot_revision: Some(snapshot.snapshot_revision),
-        solution: Some(PlanDto::from_plan(&snapshot.solution)),
-        error: None,
-    })
-}
-
-fn bootstrap_event_type(state: SolverLifecycleState) -> &'static str {
-    match state {
-        SolverLifecycleState::Solving => "progress",
-        SolverLifecycleState::PauseRequested => "pause_requested",
-        SolverLifecycleState::Paused => "paused",
-        SolverLifecycleState::Completed => "completed",
-        SolverLifecycleState::Cancelled => "cancelled",
-        SolverLifecycleState::Failed => "failed",
-    }
-}
-
-fn bootstrap_snapshot_event_type(state: SolverLifecycleState) -> &'static str {
-    match state {
-        SolverLifecycleState::Solving => "best_solution",
-        other => bootstrap_event_type(other),
-    }
-}
-
-fn event_payload(
-    job_id: usize,
-    event_type: &'static str,
-    metadata: &SolverEventMetadata<HardSoftScore>,
-    solution: Option<&FieldServicePlan>,
-    error: Option<&str>,
-) -> String {
-    serialize_payload(JobEventPayload {
-        id: job_id.to_string(),
-        job_id: job_id.to_string(),
-        event_type,
-        event_sequence: metadata.event_sequence,
-        lifecycle_state: lifecycle_state_label(metadata.lifecycle_state),
-        terminal_reason: metadata.terminal_reason.map(terminal_reason_label),
-        telemetry: telemetry_payload(&metadata.telemetry),
-        current_score: metadata.current_score.map(|score| score.to_string()),
-        best_score: metadata.best_score.map(|score| score.to_string()),
-        snapshot_revision: metadata.snapshot_revision,
-        solution: solution.map(PlanDto::from_plan),
-        error: error.map(ToOwned::to_owned),
-    })
-}
-
-fn serialize_payload(payload: JobEventPayload) -> String {
-    serde_json::to_string(&payload).expect("failed to serialize solver lifecycle payload")
-}
-
-fn telemetry_payload(telemetry: &SolverTelemetry) -> TelemetryPayload {
-    TelemetryPayload {
-        elapsed_ms: duration_to_millis(telemetry.elapsed),
-        step_count: telemetry.step_count,
-        moves_generated: telemetry.moves_generated,
-        moves_evaluated: telemetry.moves_evaluated,
-        moves_accepted: telemetry.moves_accepted,
-        score_calculations: telemetry.score_calculations,
-        generation_ms: duration_to_millis(telemetry.generation_time),
-        evaluation_ms: duration_to_millis(telemetry.evaluation_time),
-        moves_per_second: whole_units_per_second(telemetry.moves_evaluated, telemetry.elapsed),
-        acceptance_rate: derive_acceptance_rate(
-            telemetry.moves_accepted,
-            telemetry.moves_evaluated,
-        ),
-    }
-}
-
-fn lifecycle_state_label(state: SolverLifecycleState) -> &'static str {
-    match state {
-        SolverLifecycleState::Solving => "SOLVING",
-        SolverLifecycleState::PauseRequested => "PAUSE_REQUESTED",
-        SolverLifecycleState::Paused => "PAUSED",
-        SolverLifecycleState::Completed => "COMPLETED",
-        SolverLifecycleState::Cancelled => "CANCELLED",
-        SolverLifecycleState::Failed => "FAILED",
-    }
-}
-
-fn terminal_reason_label(reason: SolverTerminalReason) -> &'static str {
-    match reason {
-        SolverTerminalReason::Completed => "completed",
-        SolverTerminalReason::TerminatedByConfig => "terminated_by_config",
-        SolverTerminalReason::Cancelled => "cancelled",
-        SolverTerminalReason::Failed => "failed",
-    }
-}
-
 impl Default for SolverService {
     fn default() -> Self {
         Self::new()
     }
 }
-
-fn duration_to_millis(duration: Duration) -> u64 {
-    duration.as_millis().min(u128::from(u64::MAX)) as u64
-}
-
-fn whole_units_per_second(count: u64, elapsed: Duration) -> u64 {
-    let nanos = elapsed.as_nanos();
-    if nanos == 0 {
-        0
-    } else {
-        let per_second = u128::from(count)
-            .saturating_mul(1_000_000_000)
-            .checked_div(nanos)
-            .unwrap_or(0);
-        per_second.min(u128::from(u64::MAX)) as u64
-    }
-}
-
-fn derive_acceptance_rate(moves_accepted: u64, moves_evaluated: u64) -> f64 {
-    if moves_evaluated == 0 {
-        0.0
-    } else {
-        moves_accepted as f64 / moves_evaluated as f64
-    }
-}