fixed discov

added Winder mock

cargo_run_linux.sh

@@ -15,7 +15,7 @@ if [[ "$1" == "release" ]]; then
     cargo build --release
 else
     echo "Building Debug Code"
-    cargo build $FEATURE
+    cargo build $FEATURE --features development-build
 fi
 
 # Only setcap if not building with mock-machine

control-core/src/ethercat/interface_discovery.rs

@@ -92,9 +92,6 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
     let mut interface: Option<&str> = None;
 
     for i in 0..interfaces.len() {
-        // Avoid NetworkManager hangups
-        set_interface_managed(&interfaces[i].name, false);
-
         match test_interface(&interfaces[i].name) {
             Ok(_) => {
                 // if interface found with ethercat Exit early, we expect only one interface with ethercat
@@ -107,6 +104,7 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
 
     for i in 0..interfaces.len() {
         if interface.is_some() && interface.unwrap() == &interfaces[i].name {
+            set_interface_managed(&interfaces[i].name, false);
             continue;
         } else {
             set_interface_managed(&interfaces[i].name, true);

control-core/src/machines/connection.rs

@@ -102,7 +102,7 @@ pub struct MachineCrossConnection<
                                                        // to an unknown type. See also https://github.com/qitechgmbh/control/pull/625#discussion_r2379566315
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct MachineCrossConnectionState {
     /// Connected Machine
     pub machine_identification_unique: Option<MachineIdentificationUnique>,

control-core/src/serial/mod.rs

@@ -1,13 +1,10 @@
 use std::{any::Any, sync::Arc};
 
-use smol::{channel::Sender, lock::RwLock};
+use smol::lock::RwLock;
 use std::fmt::Debug;
 
-use crate::{
-    machines::identification::DeviceIdentification, serial::serial_detection::SerialDeviceRemoval,
-};
+use crate::machines::identification::DeviceIdentification;
 
-pub mod panic;
 pub mod registry;
 pub mod serial_detection;
 
@@ -27,10 +24,9 @@ pub trait SerialDeviceThread {
 
 pub struct SerialDeviceNewParams {
     pub path: String,
-    pub device_thread_panic_tx: Sender<SerialDeviceRemoval<String>>,
 }
 
-#[derive(PartialEq, Eq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug, Hash)]
 pub struct SerialDeviceIdentification {
     pub vendor_id: u16,
     pub product_id: u16,

control-core/src/serial/panic.rs

@@ -1,53 +0,0 @@
-use smol::channel::Sender;
-
-use crate::serial::serial_detection::SerialDeviceRemoval;
-
-/// Device-level panic handler for individual device crashes
-/// Sends device identifier and error information for cleanup
-/// Used by serial devices and other individual components that need to be removed on panic
-pub fn send_serial_device_panic<T>(
-    device_identifier: T,
-    thread_panic_tx: Sender<SerialDeviceRemoval<T>>,
-) where
-    T: Send + Sync + Clone + 'static,
-{
-    // Ensure backtrace is enabled for panics
-    if std::env::var("RUST_BACKTRACE").is_err() {
-        unsafe {
-            std::env::set_var("RUST_BACKTRACE", "full");
-        }
-    }
-
-    std::panic::set_hook(Box::new(move |panic_info| {
-        let thread_name = std::thread::current()
-            .name()
-            .unwrap_or("unnamed")
-            .to_string();
-        let location = panic_info.location().map_or("unknown".to_string(), |loc| {
-            format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
-        });
-        let message = panic_info
-            .payload()
-            .downcast_ref::<&str>()
-            .unwrap_or(&"Box<dyn Any>")
-            .to_string();
-
-        let panic_message = format!(
-            "Device panicked in thread '{}' at {}: {}",
-            thread_name, location, message
-        );
-
-        // Send device panic info through channel
-        smol::block_on(async {
-            let _ = thread_panic_tx
-                .send(SerialDeviceRemoval::Error(
-                    device_identifier.clone(),
-                    anyhow::anyhow!("{}", panic_message),
-                ))
-                .await;
-        });
-
-        // Note: We don't call old_hook to avoid duplicate logging
-        // All logging is handled in the main thread when receiving panic details
-    }));
-}

control-core/src/serial/serial_detection.rs

@@ -7,194 +7,70 @@
 */
 
 use serialport::{SerialPortInfo, SerialPortType, UsbPortInfo};
-use smol::{
-    channel::{Receiver, Sender, unbounded},
-    lock::RwLock,
-};
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
 
-use crate::{
-    helpers::compare_lists::compare_lists, machines::identification::DeviceIdentification,
-};
+use super::SerialDeviceIdentification;
+/// Handles scanning and caching of connected USB serial devices.
+pub struct SerialDetection {}
 
-use super::{
-    SerialDevice, SerialDeviceIdentification, SerialDeviceNewParams, registry::SerialDeviceRegistry,
-};
-
-pub enum SerialDeviceRemoval<T> {
-    Disconnect(T),
-    Error(T, anyhow::Error),
-}
-
-pub struct SerialDetection<'serialdeviceregistry> {
-    pub serial_device_registry: &'serialdeviceregistry SerialDeviceRegistry,
-    pub ports: HashMap<
-        String,
-        (
-            UsbPortInfo,
-            DeviceIdentification,
-            Arc<RwLock<dyn SerialDevice>>,
-        ),
-    >,
-    pub device_removal_signal_rx: Receiver<SerialDeviceRemoval<String>>,
-    pub device_removal_signal_tx: Sender<SerialDeviceRemoval<String>>,
-}
-
-impl<'serialdeviceregistry> SerialDetection<'serialdeviceregistry> {
-    pub fn new(serial_device_registry: &'serialdeviceregistry SerialDeviceRegistry) -> Self {
-        let (device_removal_signal_tx, device_removal_signal_rx) = unbounded();
-        SerialDetection {
-            serial_device_registry,
-            ports: HashMap::new(),
-            device_removal_signal_rx,
-            device_removal_signal_tx,
+impl SerialDetection {
+    /// Returns all serial ports on the system (minus macOS "cu" noise).
+    fn get_ports() -> Vec<SerialPortInfo> {
+        match serialport::available_ports() {
+            Ok(ports) => ports
+                .into_iter()
+                .filter(|port| !port.port_name.contains("cu"))
+                .collect(),
+            Err(_) => Vec::new(),
         }
     }
 
-    /*
-     *@return: Option::None if there are no available ports on device
-     *@return: Option::Some(Vec) with all available ports
-     *
-     *@description: detects all available ports and returns them as list
-     */
-    fn get_ports() -> Vec<SerialPortInfo> {
-        let all = match serialport::available_ports() {
-            Ok(ports) => ports,
-            Err(_) => return Vec::new(),
-        };
-
-        // exclude ports that contai "cu" in their name
-        all.into_iter()
-            .filter(|port| !port.port_name.contains("cu"))
-            .collect::<Vec<_>>()
-    }
-
-    /* @param: port_list -> list of available ports
-     *
-     * @return: Vec<(String, UsbPortInfo)> -> list of ports with their names and usb information
-     *
-     * @description: This function extracts the USB serial devices from the given list of ports.
-     */
-    fn extract_usb_serial_devices(
-        &self,
-        port_list: Vec<SerialPortInfo>,
-    ) -> Vec<(String, UsbPortInfo)> {
-        let mut usb_ports: Vec<(String, UsbPortInfo)> = Vec::new();
+    /// Extracts only USB serial devices from the port list.
+    fn extract_usb_serial_devices(port_list: Vec<SerialPortInfo>) -> HashMap<String, UsbPortInfo> {
+        let mut map = HashMap::new();
 
         for port in port_list {
-            if let SerialPortType::UsbPort(usb_info) = &port.port_type {
-                usb_ports.push((port.port_name.to_string(), usb_info.clone()));
-            };
+            if let SerialPortType::UsbPort(usb_info) = port.port_type {
+                map.insert(port.port_name, usb_info);
+            }
         }
-
-        usb_ports
+        map
     }
 
-    pub async fn check_ports(&mut self) -> CheckPortsResult {
-        // get available ports
+    /// Scans for connected USB serial devices and updates the internal map.
+    /// Returns a clone of the map for quick access.
+    pub fn detect_devices() -> HashMap<String, UsbPortInfo> {
         let ports = Self::get_ports();
-
-        // extract all ports that are usb ports
-        let usb_ports = self.extract_usb_serial_devices(ports);
-
-        let last_usb_ports = self
-            .ports
-            .iter()
-            .map(|last_usb_port| (last_usb_port.0.clone(), last_usb_port.1.0.clone()))
-            .collect::<Vec<_>>();
-
-        let usb_ports_diff = compare_lists(&last_usb_ports, &usb_ports);
-
-        let mut result = CheckPortsResult {
-            added: Vec::new(),
-            removed: Vec::new(),
-        };
-
-        // reamove ports
-        for removed in usb_ports_diff.removed {
-            if let Some((_, device_identification, _)) = self.ports.remove(&removed.0) {
-                result.removed.push(device_identification);
-            }
-
-            tracing::trace!("Removed port: {}", removed.0);
-        }
-
-        // add new ports
-        for added in usb_ports_diff.added {
-            // add the port to the list
-            let serial_device_identification = SerialDeviceIdentification {
-                vendor_id: added.1.vid,
-                product_id: added.1.pid,
-            };
-
-            let device_result = self.serial_device_registry.new_serial_device(
-                &SerialDeviceNewParams {
-                    path: added.0.clone(),
-                    device_thread_panic_tx: self.device_removal_signal_tx.clone(),
-                },
-                &serial_device_identification,
-            );
-
-            // only if created device driver sucessfully
-            if let Ok((device_identification, device)) = device_result {
-                // add the device to the ports list
-                self.ports.insert(
-                    added.0.clone(),
-                    (
-                        added.1.clone(),
-                        device_identification.clone(),
-                        device.clone(),
-                    ),
-                );
-
-                // add to result list
-                result.added.push((device_identification, device.clone()));
-
-                tracing::trace!("Added port: {}", added.0);
-            }
-        }
-
-        result
+        let usb_devices = Self::extract_usb_serial_devices(ports);
+        usb_devices
     }
 
-    pub async fn check_remove_signals(&mut self) -> Vec<DeviceIdentification> {
-        let mut removed_signals: Vec<DeviceIdentification> = Vec::new();
+    pub fn device_port_exists(device_path: &str) -> bool {
+        let ports = Self::get_ports();
+        return ports.iter().any(|p| p.port_name == device_path);
+    }
 
-        let mut add_removal_signal = |path: &String| {
-            if let Some(info) = self.ports.get(path) {
-                removed_signals.push(info.1.clone());
-            };
-            self.ports.remove(path);
-        };
-
-        if self.device_removal_signal_rx.is_empty() {
-            return removed_signals;
-        }
-
-        let removal = self
-            .device_removal_signal_rx
-            .recv()
-            .await
-            .expect("Failed to receive removal signals");
-
-        match removal {
-            SerialDeviceRemoval::Disconnect(path) => {
-                add_removal_signal(&path);
-                tracing::trace!("Removed serial device after disconnect: {:?}", path);
-            }
-
-            SerialDeviceRemoval::Error(path, error) => {
-                add_removal_signal(&path);
-                tracing::error!("Removed erroring serial device: {:?}: {}", path, error);
+    pub fn device_id_exists(sdevid: SerialDeviceIdentification) -> bool {
+        let ports = Self::get_ports();
+        for port in ports {
+            if let SerialPortType::UsbPort(usb_info) = port.port_type {
+                if usb_info.vid == sdevid.vendor_id && usb_info.pid == sdevid.product_id {
+                    return true;
+                }
             }
         }
+        return false;
+    }
 
-        removed_signals
+    pub fn get_path_by_id(
+        sdevid: SerialDeviceIdentification,
+        map: HashMap<String, UsbPortInfo>,
+    ) -> Option<String> {
+        for (port, usbport) in map.iter() {
+            if usbport.vid == sdevid.vendor_id && usbport.pid == sdevid.product_id {
+                return Some(port.clone());
+            }
+        }
+        return None;
     }
 }
-
-#[derive(Debug)]
-pub struct CheckPortsResult {
-    pub added: Vec<(DeviceIdentification, Arc<RwLock<dyn SerialDevice>>)>,
-    pub removed: Vec<DeviceIdentification>,
-}

control-core/src/socketio/namespace.rs

@@ -76,7 +76,7 @@ impl Namespace {
 
         // Sort by event count (ascending - lowest count first)
         event_groups.sort_by(|a, b| a.1.len().cmp(&b.1.len()));
-
+        tracing::info!("reemit: {:?}", self.events);
         // Emit events in order of lowest count first
         for (_event_name, events) in event_groups {
             for event in events {
@@ -118,7 +118,6 @@ impl Namespace {
     ) {
         // cache the event
         self.cache(event.clone(), buffer_fn);
-
         // emit the event - inlined from emit function
         // Send to global queue for each socket in the namespace
         for socket in self.sockets.clone() {

electron/package-lock.json

@@ -70,7 +70,7 @@
         "@electron/fuses": "^2.0.0",
         "@eslint/compat": "^1.2.6",
         "@eslint/js": "^9.18.0",
-        "@playwright/test": "^1.50.1",
+        "@playwright/test": "^1.56.1",
         "@tailwindcss/postcss": "^4.0.6",
         "@testing-library/jest-dom": "^6.6.3",
         "@testing-library/react": "^16.3.0",
@@ -97,7 +97,7 @@
         "ts-node": "^10.9.2",
         "typescript": "^5.7.3",
         "typescript-eslint": "^8.24.1",
-        "vite": "^6.3.6",
+        "vite": "^6.4.1",
         "vitest": "^3.0.6"
       }
     },
@@ -175,7 +175,6 @@
       "version": "7.28.0",
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.0.tgz",
       "integrity": "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ==",
-      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.2.0",
         "@babel/code-frame": "^7.27.1",
@@ -639,7 +638,6 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
-      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -662,7 +660,6 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
-      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1105,7 +1102,6 @@
       "integrity": "sha512-lyb1zK3YHeWUjaz7yiK0GnxSPduwASKMyiDbCtbn3spP6EEt+UWtktggWehG0icFrXAk3GwvcJ4nCrJO0N9IhQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "electron-fuses": "dist/bin.js"
       },
@@ -2282,12 +2278,13 @@
       }
     },
     "node_modules/@playwright/test": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.54.2.tgz",
-      "integrity": "sha512-A+znathYxPf+72riFd1r1ovOLqsIIB0jKIoPjyK2kqEIe30/6jF6BC7QNluHuwUmsD2tv1XZVugN8GqfTMOxsA==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.56.1.tgz",
+      "integrity": "sha512-vSMYtL/zOcFpvJCW71Q/OEGQb7KYBPAdKh35WNSkaZA75JlAO8ED8UN6GUNTm3drWomcbcqRPFqQbLae8yBTdg==",
       "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "playwright": "1.54.2"
+        "playwright": "1.56.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -4032,7 +4029,6 @@
       "resolved": "https://registry.npmjs.org/@tanstack/react-router/-/react-router-1.130.17.tgz",
       "integrity": "sha512-F1tyMEbX7PJclnA25hAFXhLKq4jqeODvvaogsd0/NX02Kmz3QoT9GV+rgpv2TxamU6RwjRgihSH06Dn5hM6SOw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/react-store": "^0.7.0",
@@ -4114,7 +4110,6 @@
       "resolved": "https://registry.npmjs.org/@tanstack/router-core/-/router-core-1.130.17.tgz",
       "integrity": "sha512-0AH4s/52X2shYLifr9hR+6R6NpGsBp1M3LyjBTZm6Jlkud+nOhkkRxKxYS7l+JErRlffdxVHxMdoTnKcQ+duiQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@tanstack/history": "1.130.12",
         "@tanstack/store": "^0.7.0",
@@ -4348,7 +4343,8 @@
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
       "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
-      "dev": true
+      "dev": true,
+      "peer": true
     },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
@@ -4505,7 +4501,6 @@
       "integrity": "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ==",
       "devOptional": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~7.10.0"
       }
@@ -4522,7 +4517,6 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.16.tgz",
       "integrity": "sha512-WBM/nDbEZmDUORKnh5i1bTnAz6vTohUf9b8esSMu+b24+srbaxa04UbJgWx78CVfNXA20sNu0odEIluZDFdCog==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "csstype": "^3.0.2"
       }
@@ -4532,7 +4526,6 @@
       "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.1.7.tgz",
       "integrity": "sha512-i5ZzwYpqjmrKenzkoLM2Ibzt6mAsM7pxB6BCIouEVVmgiqaMj1TjaK7hnA36hbW5aZv20kx7Lw6hWzPWg0Rurw==",
       "devOptional": true,
-      "peer": true,
       "peerDependencies": {
         "@types/react": "^19.0.0"
       }
@@ -4615,7 +4608,6 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.38.0.tgz",
       "integrity": "sha512-Zhy8HCvBUEfBECzIl1PKqF4p11+d0aUJS1GeUiuqK9WmOug8YCmC4h4bjyBvMyAMI9sbRczmrYL5lKg/YMbrcQ==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.38.0",
         "@typescript-eslint/types": "8.38.0",
@@ -4970,7 +4962,6 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -5418,7 +5409,6 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
-      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001726",
         "electron-to-chromium": "^1.5.173",
@@ -6111,8 +6101,7 @@
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
-      "peer": true
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="
     },
     "node_modules/data-urls": {
       "version": "5.0.0",
@@ -6385,7 +6374,8 @@
       "version": "0.5.16",
       "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
-      "dev": true
+      "dev": true,
+      "peer": true
     },
     "node_modules/dom-helpers": {
       "version": "5.2.1",
@@ -7385,7 +7375,6 @@
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.32.0.tgz",
       "integrity": "sha512-LSehfdpgMeWcTZkWZVIJl+tkZ2nuSkyyB9C27MZqFWXuph7DvaowgcTvKqxvpLW1JZIk8PN7hFY3Rj9LQ7m7lg==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -7446,7 +7435,6 @@
       "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz",
       "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
       "dev": true,
-      "peer": true,
       "bin": {
         "eslint-config-prettier": "bin/cli.js"
       },
@@ -8753,7 +8741,6 @@
           "url": "https://www.i18next.com/how-to/faq#i18next-is-awesome.-how-can-i-support-the-project"
         }
       ],
-      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.27.6"
       },
@@ -8816,7 +8803,6 @@
       "version": "10.1.1",
       "resolved": "https://registry.npmjs.org/immer/-/immer-10.1.1.tgz",
       "integrity": "sha512-s2MPrmjovJcoMaHtx6K11Ra7oD05NT97w1IC5zpMkT6Atjr7H8LjaDd81iIxUYpMKSRRNMJE703M1Fhr/TctHw==",
-      "peer": true,
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/immer"
@@ -9491,7 +9477,6 @@
       "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
       "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
       "dev": true,
-      "peer": true,
       "dependencies": {
         "cssstyle": "^4.2.1",
         "data-urls": "^5.0.0",
@@ -10057,6 +10042,7 @@
       "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
+      "peer": true,
       "bin": {
         "lz-string": "bin/bin.js"
       }
@@ -11882,12 +11868,13 @@
       }
     },
     "node_modules/playwright": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.54.2.tgz",
-      "integrity": "sha512-Hu/BMoA1NAdRUuulyvQC0pEqZ4vQbGfn8f7wPXcnqQmM+zct9UliKxsIkLNmz/ku7LElUNqmaiv1TG/aL5ACsw==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.56.1.tgz",
+      "integrity": "sha512-aFi5B0WovBHTEvpM3DzXTUaeN6eN0qWnTkKx4NQaH4Wvcmc153PdaY2UBdSYKaGYw+UyWXSVyxDUg5DoPEttjw==",
       "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "playwright-core": "1.54.2"
+        "playwright-core": "1.56.1"
       },
       "bin": {
         "playwright": "cli.js"
@@ -11900,10 +11887,11 @@
       }
     },
     "node_modules/playwright-core": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.54.2.tgz",
-      "integrity": "sha512-n5r4HFbMmWsB4twG7tJLDN9gmBUeSPcsBZiWSE4DnYz9mJMAFqr2ID7+eGC9kpEnxExJ1epttwR59LEWCk8mtA==",
+      "version": "1.56.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.56.1.tgz",
+      "integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==",
       "dev": true,
+      "license": "Apache-2.0",
       "bin": {
         "playwright-core": "cli.js"
       },
@@ -11999,7 +11987,6 @@
       "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz",
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
-      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -12113,6 +12100,7 @@
       "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "ansi-regex": "^5.0.1",
         "ansi-styles": "^5.0.0",
@@ -12127,6 +12115,7 @@
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
       "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -12255,7 +12244,6 @@
       "version": "19.1.1",
       "resolved": "https://registry.npmjs.org/react/-/react-19.1.1.tgz",
       "integrity": "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ==",
-      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -12264,7 +12252,6 @@
       "version": "19.1.1",
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.1.1.tgz",
       "integrity": "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==",
-      "peer": true,
       "dependencies": {
         "scheduler": "^0.26.0"
       },
@@ -12276,7 +12263,6 @@
       "version": "7.62.0",
       "resolved": "https://registry.npmjs.org/react-hook-form/-/react-hook-form-7.62.0.tgz",
       "integrity": "sha512-7KWFejc98xqG/F4bAxpL41NB3o1nnvQO1RWZT3TqRZYL8RryQETGfEdVnJN2fy1crCiBLLjkRBVK05j24FxJGA==",
-      "peer": true,
       "engines": {
         "node": ">=18.0.0"
       },
@@ -12317,7 +12303,8 @@
       "version": "17.0.2",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
       "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
-      "dev": true
+      "dev": true,
+      "peer": true
     },
     "node_modules/react-lifecycles-compat": {
       "version": "3.0.4",
@@ -13068,7 +13055,6 @@
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/seroval/-/seroval-1.3.2.tgz",
       "integrity": "sha512-RbcPH1n5cfwKrru7v7+zrZvjLurgHhGyso3HTyGtRivGWgYjbOmGuivCQaORNELjNONoK35nj28EoWul9sb1zQ==",
-      "peer": true,
       "engines": {
         "node": ">=10"
       }
@@ -13858,8 +13844,7 @@
     "node_modules/tailwindcss": {
       "version": "4.1.11",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.11.tgz",
-      "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA==",
-      "peer": true
+      "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA=="
     },
     "node_modules/tailwindcss-animate": {
       "version": "1.0.7",
@@ -13961,8 +13946,7 @@
     "node_modules/tiny-invariant": {
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
-      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
-      "peer": true
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="
     },
     "node_modules/tiny-warning": {
       "version": "1.0.3",
@@ -14013,7 +13997,6 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -14325,7 +14308,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
       "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "devOptional": true,
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -14683,11 +14665,10 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.3.6",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.6.tgz",
-      "integrity": "sha512-0msEVHJEScQbhkbVTb/4iHZdJ6SXp/AvxL2sjwYQFfBqleHtnCqv1J3sa9zbWz/6kW1m9Tfzn92vW+kZ1WV6QA==",
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.25.0",
         "fdir": "^6.4.4",
@@ -14809,7 +14790,6 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -15353,7 +15333,6 @@
       "version": "3.25.76",
       "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
       "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
-      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }

electron/package.json

@@ -34,7 +34,7 @@
     "@electron/fuses": "^2.0.0",
     "@eslint/compat": "^1.2.6",
     "@eslint/js": "^9.18.0",
-    "@playwright/test": "^1.50.1",
+    "@playwright/test": "^1.56.1",
     "@tailwindcss/postcss": "^4.0.6",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
@@ -61,7 +61,7 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.1",
-    "vite": "^6.3.6",
+    "vite": "^6.4.1",
     "vitest": "^3.0.6"
   },
   "dependencies": {

electron/src/client/socketioStore.ts

@@ -386,7 +386,7 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
 
     // check if the namespace exists
     const namespace = get().namespaces[namespace_path];
-    if (namespace) {
+    /*if (namespace) {
       set(
         produce((state: SocketioStore) => {
           // decrement the count
@@ -430,7 +430,7 @@ const useSocketioStore = create<SocketioStore>()((set, get) => ({
           }
         }),
       );
-    }
+    }*/
   },
 }));
 

server/Cargo.toml

@@ -55,10 +55,6 @@ opentelemetry-otlp = { version = "0.30.0", features = [
 ], optional = true }
 tonic = { version = "0.13.1", optional = true }
 
-#[target.'cfg(not(target_env = "msvc"))'.dependencies]
-#tikv-jemallocator = { version = "0.6", features = ["profiling", "stats"] }
-#tikv-jemalloc-ctl = "0.6"
-
 [dev-dependencies]
 approx = "0.5.1"
 textplots = "0.8.7"

server/src/app_state.rs

@@ -6,7 +6,6 @@ use crate::socketio::namespaces::Namespaces;
 use control_core::machines::Machine;
 use control_core::machines::identification::{DeviceIdentification, MachineIdentificationUnique};
 use control_core::machines::manager::MachineManager;
-use control_core::serial::serial_detection::SerialDetection;
 use control_core::socketio::event::GenericEvent;
 use ethercat_hal::devices::EthercatDevice;
 use ethercrab::{MainDevice, SubDeviceGroup, subdevice_group::Op};
@@ -25,7 +24,7 @@ pub struct SocketioSetup {
 }
 
 pub struct SerialSetup {
-    pub serial_detection: SerialDetection<'static>,
+    pub serial_registry: &'static SERIAL_DEVICE_REGISTRY,
 }
 
 pub struct AppState {
@@ -85,7 +84,7 @@ impl AppState {
             },
             ethercat_setup: Arc::new(RwLock::new(None)),
             serial_setup: Arc::new(RwLock::new(SerialSetup {
-                serial_detection: SerialDetection::new(&SERIAL_DEVICE_REGISTRY),
+                serial_registry: &SERIAL_DEVICE_REGISTRY,
             })),
             machines: Arc::new(RwLock::new(MachineManager::new())),
             performance_metrics: Arc::new(RwLock::new(EthercatPerformanceMetrics::new())),

server/src/ethercat/ethercat_discovery_info.rs

@@ -0,0 +1,38 @@
+use std::sync::Arc;
+
+use control_core::socketio::namespace::NamespaceCacheingLogic;
+
+use crate::{
+    app_state::AppState,
+    socketio::main_namespace::{
+        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
+    },
+};
+
+pub async fn send_ethercat_discovering(app_state: Arc<AppState>) {
+    {
+        let main_namespace = &mut app_state
+            .socketio_setup
+            .namespaces
+            .write()
+            .await
+            .main_namespace;
+        let event = EthercatInterfaceDiscoveryEvent::Discovering(true).build();
+        main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
+    }
+}
+pub async fn send_ethercat_found(app_state: Arc<AppState>, interface: &str) {
+    // Notify client via socketio
+    let interface = interface.to_string();
+    let app_state_socketio = app_state.clone();
+    smol::block_on(async move {
+        let main_namespace = &mut app_state_socketio
+            .socketio_setup
+            .namespaces
+            .write()
+            .await
+            .main_namespace;
+        let event = EthercatInterfaceDiscoveryEvent::Done(interface).build();
+        main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
+    });
+}

server/src/ethercat/init.rs

@@ -1,70 +1,23 @@
-use super::setup::setup_loop;
-use crate::{
-    app_state::AppState,
-    socketio::main_namespace::{
-        MainNamespaceEvents, ethercat_interface_discovery_event::EthercatInterfaceDiscoveryEvent,
-    },
-};
-use control_core::{
-    ethercat::interface_discovery::discover_ethercat_interface,
-    socketio::namespace::NamespaceCacheingLogic,
-};
-use std::sync::Arc;
+use control_core::ethercat::interface_discovery::discover_ethercat_interface;
+use smol::{Task, Timer};
+use std::time::Duration;
 
-pub fn init_ethercat(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
-    let app_state_clone = app_state;
-
-    std::thread::Builder::new()
-        .name("init_ethercat".to_string())
-        .spawn(move || {
-            // Notify client via socketio
-            let app_state_socketio = app_state_clone.clone();
-            smol::block_on(async move {
-                let main_namespace = &mut app_state_socketio
-                    .socketio_setup
-                    .namespaces
-                    .write()
-                    .await
-                    .main_namespace;
-                let event = EthercatInterfaceDiscoveryEvent::Discovering(true).build();
-                main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
-            });
-
-            // tries to find a suitable interface in a loop
-            let interface = smol::block_on(async {
-                loop {
-                    match discover_ethercat_interface().await {
-                        Ok(interface) => {
-                            tracing::info!("Found working interface: {}", interface);
-                            break interface;
-                        }
-                        Err(_) => {
-                            tracing::warn!("No working interface found, retrying...");
-                            // wait 1 seconds before retrying
-                            smol::Timer::after(std::time::Duration::from_secs(1)).await;
-                        }
-                    }
-                }
-            });
-
-            // Notify client via socketio
-            let interface_clone = interface.clone();
-            let app_state_socketio = app_state_clone.clone();
-            smol::block_on(async move {
-                let main_namespace = &mut app_state_socketio
-                    .socketio_setup
-                    .namespaces
-                    .write()
-                    .await
-                    .main_namespace;
-                let event = EthercatInterfaceDiscoveryEvent::Done(interface_clone).build();
-                main_namespace.emit(MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event));
-            });
-
-            if let Err(e) = smol::block_on(setup_loop(&interface, app_state_clone)) {
-                tracing::error!("EtherCAT setup failed: {:?}", e);
+pub async fn find_ethercat_interface() -> Result<String, anyhow::Error> {
+    loop {
+        match discover_ethercat_interface().await {
+            Ok(interface) => {
+                tracing::info!("Found EtherCAT Interface at: {}", interface);
+                return Ok(interface);
             }
-        })?;
+            Err(e) => {
+                tracing::warn!("No working interface found: {}. Retrying...", e);
+                Timer::after(Duration::from_secs(1)).await;
+            }
+        }
+    }
+}
 
-    Ok(())
+// Returns a Future to the interface
+pub fn start_interface_discovery() -> Task<Result<String, anyhow::Error>> {
+    smol::spawn(find_ethercat_interface())
 }

server/src/ethercat/mod.rs

@@ -1,3 +1,4 @@
 pub mod config;
+pub mod ethercat_discovery_info;
 pub mod init;
 pub mod setup;

server/src/ethercat/setup.rs

@@ -52,6 +52,7 @@ pub async fn setup_loop(interface: &str, app_state: Arc<AppState>) -> Result<(),
             let _ = set_core_affinity(3);
 
             // Set the thread to real-time priority
+            #[cfg(not(feature = "development-build"))]
             let _ = set_realtime_priority();
 
             #[cfg(not(all(target_os = "linux", feature = "io-uring")))]
@@ -85,13 +86,13 @@ pub async fn setup_loop(interface: &str, app_state: Arc<AppState>) -> Result<(),
             // Default 30_000us
             pdu: Duration::from_micros(30_000),
             // Default 10ms
-            eeprom: Duration::from_millis(100),
+            eeprom: Duration::from_millis(10),
             // Default 0ms
             wait_loop_delay: Duration::from_millis(0),
             // Default 100ms
-            mailbox_echo: Duration::from_millis(1000),
+            mailbox_echo: Duration::from_millis(100),
             // Default 1000ms
-            mailbox_response: Duration::from_millis(10000),
+            mailbox_response: Duration::from_millis(1000),
         },
         MainDeviceConfig {
             // Default RetryBehaviour::None

server/src/loop.rs

@@ -1,55 +1,81 @@
-use crate::app_state::AppState;
+use crate::{app_state::AppState, ethercat::setup::setup_loop};
 use bitvec::prelude::*;
 use control_core::machines::connection::MachineConnection;
-use control_core::realtime::{set_core_affinity, set_realtime_priority};
+use control_core::realtime::set_core_affinity;
+#[cfg(not(feature = "development-build"))]
+use control_core::realtime::set_realtime_priority;
 use std::sync::Arc;
 use std::time::Instant;
 use tracing::{instrument, trace_span};
 
-pub fn init_loop(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
+pub fn start_loop_thread(
+    interface: &str,
+    app_state: Arc<AppState>,
+) -> Result<std::thread::JoinHandle<()>, std::io::Error> {
+    let res = smol::block_on(async { setup_loop(interface, app_state.clone()).await });
+    match res {
+        Ok(_) => tracing::info!("Successfully initialized EtherCAT network"),
+        Err(e) => {
+            tracing::error!(
+                "[{}::init_loop] Failed to initialize EtherCAT network \n{:?}",
+                module_path!(),
+                e
+            );
+        }
+    }
     // Start control loop
-    std::thread::Builder::new()
+    let res = std::thread::Builder::new()
         .name("loop".to_owned())
         .spawn(move || {
-            let rt = smol::LocalExecutor::new();
-
-            // Set core affinity to third core
             let _ = set_core_affinity(2);
-
-            // Set the thread to real-time priority
+            #[cfg(not(feature = "development-build"))]
             if let Err(e) = set_realtime_priority() {
                 tracing::error!(
-                    "[{}::init_loop] Failed to set real-time priority \n{:?}",
+                    "[{}::init_loop] Failed to set thread to real-time priority \n{:?}",
                     module_path!(),
                     e
                 );
             } else {
                 tracing::info!(
-                    "[{}::init_loop] Real-time priority set successfully",
+                    "[{}::init_loop] Real-time priority set successfully for current thread",
                     module_path!()
                 );
             }
 
-            loop {
-                let res = smol::block_on(rt.run(async { loop_once(app_state.clone()).await }));
+            let rt = smol::LocalExecutor::new();
+            // Instead of creating a NEW async task every iteration of our realtime txrx loop, create it ONCE
+            smol::block_on(async {
+                rt.run(async {
+                    loop {
+                        if let Err(e) = loop_once(app_state.clone()).await {
+                            tracing::error!("Loop failed\n{:?}", e);
+                            std::process::exit(1);
+                        }
+                    }
+                })
+                .await;
+            });
 
-                if let Err(err) = res {
-                    tracing::error!("Loop failed\n{:?}", err);
-                    break;
+            /*
+                // If timeouts keep happenning do a spin_sleep, better then thread_sleep and allows for more deterministic timing
+                let elapsed = start.elapsed();
+                if elapsed < target_cycle {
+                    spin_sleep::sleep(target_cycle - elapsed);
                 }
-            }
-            // Exit the entire program if the Loop fails (gets restarted by systemd if running on NixOS)
-            std::process::exit(1);
-        })
-        .map_err(|e| {
-            anyhow::anyhow!(
-                "[{}::init_loop] Failed to spawn loop thread\n{:?}",
-                module_path!(),
-                e
-            )
-        })?;
+            */
 
-    Ok(())
+            if let Some(last_loop_start) = app_state
+                .performance_metrics
+                .read_arc_blocking()
+                .last_loop_start
+            {
+                tracing::info!("Failing Loop Took {:?}", last_loop_start.elapsed());
+            }
+            // Exit the entire program if the Loop fails
+            // gets restarted by systemd if running on NixOS, or different distro wtih the same sysd service
+            std::process::exit(1);
+        });
+    return res;
 }
 
 #[instrument(skip(app_state))]

server/src/machines/aquapath1/api.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 
 use super::{AquaPathV1, AquaPathV1Mode};
 use control_core::{
@@ -6,8 +6,7 @@ use control_core::{
     socketio::{
         event::{Event, GenericEvent},
         namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_first_and_last_event,
+            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_first_and_last_event,
         },
     },
 };
@@ -116,11 +115,10 @@ impl CacheableEvents<AquaPathV1Events> for AquaPathV1Events {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_first_and_last = cache_first_and_last_event();
 
         match self {
-            AquaPathV1Events::LiveValues(_) => cache_one_hour,
+            AquaPathV1Events::LiveValues(_) => cache_first_and_last,
             AquaPathV1Events::State(_) => cache_first_and_last,
         }
     }

server/src/machines/buffer1/api.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 
 use super::{BufferV1, BufferV1Mode};
 use control_core::{
@@ -8,10 +8,7 @@ use control_core::{
     },
     socketio::{
         event::{Event, GenericEvent},
-        namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_one_event,
-        },
+        namespace::{CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_one_event},
     },
 };
 use serde::{Deserialize, Serialize};
@@ -103,11 +100,10 @@ impl CacheableEvents<Self> for BufferV1Events {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_one = cache_one_event();
 
         match self {
-            Self::LiveValues(_) => cache_one_hour,
+            Self::LiveValues(_) => cache_one,
             Self::State(_) => cache_one,
         }
     }

server/src/machines/buffer1/mod.rs

@@ -3,6 +3,8 @@ pub mod api;
 pub mod buffer_tower_controller;
 pub mod new;
 
+#[cfg(not(feature = "mock-machine"))]
+use crate::machines::{MACHINE_BUFFER_V1, VENDOR_QITECH, winder2::Winder2};
 use api::{Buffer1Namespace, BufferV1Events, LiveValuesEvent, ModeState, StateEvent};
 use buffer_tower_controller::BufferTowerController;
 use control_core::machines::connection::{CrossConnectableMachine, MachineCrossConnection};
@@ -18,8 +20,6 @@ use serde::{Deserialize, Serialize};
 use smol::lock::RwLock;
 use std::{sync::Weak, time::Instant};
 
-use crate::machines::{MACHINE_BUFFER_V1, VENDOR_QITECH, winder2::Winder2};
-
 #[derive(Debug, Machine)]
 pub struct BufferV1 {
     // controllers

server/src/machines/extruder1/api.rs

@@ -11,8 +11,8 @@ use control_core::machines::api::MachineApi;
 use control_core::socketio::{
     event::{Event, GenericEvent},
     namespace::{
-        CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-        cache_first_and_last_event,
+        CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_first_and_last_event,
+        cache_one_event,
     },
 };
 use control_core_derive::BuildEvent;
@@ -20,7 +20,7 @@ use serde::{Deserialize, Serialize};
 #[cfg(not(feature = "mock-machine"))]
 use serde_json::Value;
 use smol::lock::Mutex;
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 use tracing::instrument;
 use uom::si::{
     angular_velocity::revolution_per_minute, electric_current::ampere, electric_potential::volt,
@@ -263,11 +263,9 @@ impl CacheableEvents<Self> for ExtruderV2Events {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_first_and_last = cache_first_and_last_event();
-
         match self {
-            Self::LiveValues(_) => cache_one_hour,
+            Self::LiveValues(_) => cache_one_event(),
             Self::State(_) => cache_first_and_last,
         }
     }

server/src/machines/laser/api.rs

@@ -4,8 +4,8 @@ use control_core::{
     socketio::{
         event::{Event, GenericEvent},
         namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_first_and_last_event,
+            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic,
+            cache_first_and_last_event, cache_one_event,
         },
     },
 };
@@ -13,7 +13,7 @@ use control_core_derive::BuildEvent;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use smol::lock::Mutex;
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 use tracing::instrument;
 
 #[derive(Serialize, Debug, Clone, Default)]
@@ -73,11 +73,9 @@ impl CacheableEvents<Self> for LaserEvents {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_first_and_last = cache_first_and_last_event();
-
         match self {
-            Self::LiveValues(_) => cache_one_hour,
+            Self::LiveValues(_) => cache_one_event(),
             Self::State(_) => cache_first_and_last,
         }
     }

server/src/machines/mock/api.rs

@@ -1,11 +1,11 @@
 use super::MockMachine;
+use control_core::socketio::namespace::cache_one_event;
 use control_core::{
     machines::api::MachineApi,
     socketio::{
         event::{Event, GenericEvent},
         namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_first_and_last_event,
+            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_first_and_last_event,
         },
     },
 };
@@ -13,9 +13,8 @@ use control_core_derive::BuildEvent;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use smol::lock::Mutex;
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 use tracing::instrument;
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 pub enum Mode {
     Standby,
@@ -72,11 +71,9 @@ impl CacheableEvents<Self> for MockEvents {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_first_and_last = cache_first_and_last_event();
-
         match self {
-            Self::LiveValues(_) => cache_one_hour,
+            Self::LiveValues(_) => cache_one_event(),
             Self::State(_) => cache_first_and_last,
         }
     }

server/src/machines/mod.rs

@@ -14,7 +14,10 @@ use ethercrab::{SubDevice, SubDeviceRef};
 use smol::lock::RwLock;
 
 pub mod aquapath1;
+
+#[cfg(not(feature = "mock-machine"))]
 pub mod buffer1;
+
 pub mod extruder1;
 pub mod laser;
 pub mod mock;
@@ -26,9 +29,11 @@ pub const MACHINE_WINDER_V1: u16 = 0x0002;
 pub const MACHINE_EXTRUDER_V1: u16 = 0x0004;
 pub const MACHINE_LASER_V1: u16 = 0x0006;
 pub const MACHINE_MOCK: u16 = 0x0007;
-pub const MACHINE_BUFFER_V1: u16 = 0x0008;
 pub const MACHINE_AQUAPATH_V1: u16 = 0x0009;
 
+#[cfg(not(feature = "mock-machine"))]
+pub const MACHINE_BUFFER_V1: u16 = 0x0008;
+
 async fn get_device_ident<
     'maindevice,
     'subdevices,

server/src/machines/registry.rs

@@ -1,12 +1,12 @@
 #[cfg(feature = "mock-machine")]
-use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine};
+use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine, winder2::mock::Winder2};
 
 #[cfg(not(feature = "mock-machine"))]
-use crate::machines::extruder1::ExtruderV2;
-
 use crate::machines::{
-    aquapath1::AquaPathV1, buffer1::BufferV1, laser::LaserMachine, winder2::Winder2,
+    aquapath1::AquaPathV1, buffer1::BufferV1, extruder1::ExtruderV2, laser::LaserMachine,
+    winder2::Winder2,
 };
+
 use control_core::machines::registry::MachineRegistry;
 use lazy_static::lazy_static;
 
@@ -14,11 +14,18 @@ lazy_static! {
     pub static ref MACHINE_REGISTRY: MachineRegistry = {
         let mut mc = MachineRegistry::new();
         mc.register::<Winder2>(Winder2::MACHINE_IDENTIFICATION);
-        mc.register::<LaserMachine>(LaserMachine::MACHINE_IDENTIFICATION);
         mc.register::<ExtruderV2>(ExtruderV2::MACHINE_IDENTIFICATION);
+
         #[cfg(feature = "mock-machine")]
         mc.register::<MockMachine>(MockMachine::MACHINE_IDENTIFICATION);
+
+        #[cfg(not(feature = "mock-machine"))]
+        mc.register::<LaserMachine>(LaserMachine::MACHINE_IDENTIFICATION);
+
+        #[cfg(not(feature = "mock-machine"))]
         mc.register::<BufferV1>(BufferV1::MACHINE_IDENTIFICATION);
+
+        #[cfg(not(feature = "mock-machine"))]
         mc.register::<AquaPathV1>(AquaPathV1::MACHINE_IDENTIFICATION);
         mc
     };

server/src/machines/winder2/act.rs

@@ -1,7 +1,11 @@
+#[cfg(not(feature = "mock-machine"))]
 use super::Winder2;
+#[cfg(not(feature = "mock-machine"))]
 use control_core::machines::new::MachineAct;
+#[cfg(not(feature = "mock-machine"))]
 use std::time::{Duration, Instant};
 
+#[cfg(not(feature = "mock-machine"))]
 impl MachineAct for Winder2 {
     fn act(&mut self, now: Instant) {
         // sync the spool speed

server/src/machines/winder2/api.rs

@@ -1,31 +1,64 @@
-use super::puller_speed_controller::GearRatio;
-use super::{Winder2, Winder2Mode, puller_speed_controller::PullerRegulationMode};
-use control_core::{
-    machines::{
-        api::MachineApi, connection::MachineCrossConnectionState,
-        identification::MachineIdentificationUnique,
-    },
-    socketio::{
-        event::{Event, GenericEvent},
-        namespace::{
-            CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
-            cache_first_and_last_event,
+#[cfg(feature = "mock-machine")]
+mod winder2_imports {
+    pub use super::super::Winder2Mode;
+    pub use super::super::puller_speed_controller::{GearRatio, PullerRegulationMode};
+    pub use serde::Deserialize;
+    pub use serde::Serialize;
+
+    pub use std::{sync::Arc, time::Duration};
+
+    pub use control_core::{
+        machines::{
+            connection::MachineCrossConnectionState, identification::MachineIdentificationUnique,
         },
-    },
-};
+        socketio::{
+            event::{Event, GenericEvent},
+            namespace::{
+                CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
+                cache_first_and_last_event,
+            },
+        },
+    };
+    pub use control_core_derive::BuildEvent;
+    pub use smol::lock::Mutex;
+    pub use tracing::instrument;
+}
 
-use control_core_derive::BuildEvent;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use smol::lock::Mutex;
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use tracing::instrument;
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::puller_speed_controller::{GearRatio, PullerRegulationMode};
+    pub use super::super::{Winder2, Winder2Mode};
+    pub use control_core::{
+        machines::{
+            api::MachineApi, connection::MachineCrossConnectionState,
+            identification::MachineIdentificationUnique,
+        },
+        socketio::{
+            event::{Event, GenericEvent},
+            namespace::{
+                CacheFn, CacheableEvents, Namespace, NamespaceCacheingLogic, cache_duration,
+                cache_first_and_last_event,
+            },
+        },
+    };
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+    pub use control_core_derive::BuildEvent;
+    pub use serde::{Deserialize, Serialize};
+    pub use serde_json::Value;
+    pub use smol::lock::Mutex;
+    pub use std::{
+        sync::Arc,
+        time::{Duration, Instant},
+    };
+    pub use tracing::instrument;
+}
+
+use control_core::socketio::namespace::cache_one_event;
+pub use winder2_imports::*;
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub enum Mode {
+    #[default]
     Standby,
     Hold,
     Pull,
@@ -55,7 +88,7 @@ impl From<Mode> for Winder2Mode {
 }
 
 #[derive(Deserialize, Serialize)]
-enum Mutation {
+pub enum Mutation {
     // Traverse
     /// Position in mm from home point
     SetTraverseLimitOuter(f64),
@@ -149,7 +182,7 @@ pub struct StateEvent {
     pub connected_machine_state: MachineCrossConnectionState,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct TraverseState {
     /// min position in mm
     pub limit_inner: f64,
@@ -183,7 +216,7 @@ pub struct TraverseState {
     pub can_go_home: bool,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct PullerState {
     /// regulation type
     pub regulation: PullerRegulationMode,
@@ -197,20 +230,21 @@ pub struct PullerState {
     pub gear_ratio: GearRatio,
 }
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Deserialize, Serialize, Debug, Clone, Default)]
 pub enum SpoolAutomaticActionMode {
+    #[default]
     NoAction,
     Pull,
     Hold,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct SpoolAutomaticActionState {
     pub spool_required_meters: f64,
     pub spool_automatic_action_mode: SpoolAutomaticActionMode,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct ModeState {
     /// mode
     pub mode: Mode,
@@ -218,13 +252,13 @@ pub struct ModeState {
     pub can_wind: bool,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct TensionArmState {
     /// is zeroed
     pub zeroed: bool,
 }
 
-#[derive(Serialize, Debug, Clone)]
+#[derive(Serialize, Debug, Clone, Default)]
 pub struct SpoolSpeedControllerState {
     /// regulation mode
     pub regulation_mode: super::spool_speed_controller::SpoolSpeedControllerType,
@@ -276,16 +310,15 @@ impl CacheableEvents<Self> for Winder2Events {
     }
 
     fn event_cache_fn(&self) -> CacheFn {
-        let cache_one_hour = cache_duration(Duration::from_secs(60 * 60), Duration::from_secs(1));
         let cache_first_and_last = cache_first_and_last_event();
-
         match self {
-            Self::LiveValues(_) => cache_one_hour,
+            Self::LiveValues(_) => cache_one_event(),
             Self::State(_) => cache_first_and_last,
         }
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl MachineApi for Winder2 {
     fn api_mutate(&mut self, request_body: Value) -> Result<(), anyhow::Error> {
         let mutation: Mutation = serde_json::from_value(request_body)?;

server/src/machines/winder2/emit.rs

@@ -1,26 +1,33 @@
-use std::time::Instant;
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::puller_speed_controller::PullerRegulationMode;
 
-use crate::machines::buffer1::BufferV1;
+    pub use super::super::{TraverseMode, Winder2, Winder2Mode, api, spool_speed_controller};
+    pub use crate::machines::buffer1::BufferV1;
 
-use super::puller_speed_controller::PullerRegulationMode;
-use super::{TraverseMode, Winder2, Winder2Mode, api, spool_speed_controller};
-use api::{
-    LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode, SpoolAutomaticActionState,
-    SpoolSpeedControllerState, StateEvent, TensionArmState, TraverseState, Winder2Events,
-};
-use control_core::socketio::event::BuildEvent;
-use control_core::{
-    machines::identification::MachineIdentificationUnique,
-    socketio::namespace::NamespaceCacheingLogic, uom_extensions::velocity::meter_per_minute,
-};
+    pub use api::{
+        LiveValuesEvent, ModeState, PullerState, SpoolAutomaticActionMode,
+        SpoolAutomaticActionState, SpoolSpeedControllerState, StateEvent, TensionArmState,
+        TraverseState, Winder2Events,
+    };
+    pub use control_core::socketio::event::BuildEvent;
+    pub use control_core::{
+        machines::identification::MachineIdentificationUnique,
+        socketio::namespace::NamespaceCacheingLogic, uom_extensions::velocity::meter_per_minute,
+    };
+    pub use std::time::Instant;
+    pub use uom::si::{
+        angle::degree,
+        angular_velocity::revolution_per_minute,
+        f64::{Length, Velocity},
+        length::{meter, millimeter},
+    };
+}
 
-use uom::si::{
-    angle::degree,
-    angular_velocity::revolution_per_minute,
-    f64::{Length, Velocity},
-    length::{meter, millimeter},
-};
+#[cfg(not(feature = "mock-machine"))]
+pub use winder2_imports::*;
 
+#[cfg(not(feature = "mock-machine"))]
 impl Winder2 {
     /// Implement Spool
     /// called by `act`

server/src/machines/winder2/mock/act.rs

@@ -0,0 +1,13 @@
+use crate::machines::winder2::mock::Winder2;
+use control_core::machines::new::MachineAct;
+use std::time::{Duration, Instant};
+
+impl MachineAct for Winder2 {
+    fn act(&mut self, now: Instant) {
+        // more than 33ms have passed since last emit (30 "fps" target)
+        if now.duration_since(self.last_measurement_emit) > Duration::from_secs_f64(1.0 / 30.0) {
+            self.emit_live_values();
+            self.last_measurement_emit = now;
+        }
+    }
+}

server/src/machines/winder2/mock/api.rs

@@ -0,0 +1,67 @@
+use std::{sync::Arc, time::Instant};
+
+use control_core::{machines::api::MachineApi, socketio::namespace::Namespace};
+use serde_json::Value;
+use smol::lock::Mutex;
+
+use crate::machines::winder2::api::Mutation;
+
+use super::Winder2;
+
+impl MachineApi for Winder2 {
+    fn api_mutate(&mut self, request_body: Value) -> Result<(), anyhow::Error> {
+        let mutation: Mutation = serde_json::from_value(request_body)?;
+        match mutation {
+            Mutation::EnableTraverseLaserpointer(enable) => self.set_laser(enable),
+            Mutation::SetMode(mode) => self.set_mode(&mode.into()),
+            Mutation::SetTraverseLimitOuter(limit) => self.traverse_set_limit_outer(limit),
+            Mutation::SetTraverseLimitInner(limit) => self.traverse_set_limit_inner(limit),
+            Mutation::SetTraverseStepSize(size) => self.traverse_set_step_size(size),
+            Mutation::SetTraversePadding(padding) => self.traverse_set_padding(padding),
+            Mutation::GotoTraverseLimitOuter => self.traverse_goto_limit_outer(),
+            Mutation::GotoTraverseLimitInner => self.traverse_goto_limit_inner(),
+            Mutation::GotoTraverseHome => self.traverse_goto_home(),
+            Mutation::SetPullerRegulationMode(regulation) => self.puller_set_regulation(regulation),
+            Mutation::SetPullerTargetSpeed(value) => self.puller_set_target_speed(value),
+            Mutation::SetPullerTargetDiameter(_) => todo!(),
+            Mutation::SetPullerForward(value) => self.puller_set_forward(value),
+            Mutation::SetPullerGearRatio(gear_ratio) => self.puller_set_gear_ratio(gear_ratio),
+            Mutation::SetSpoolRegulationMode(mode) => self.spool_set_regulation_mode(mode),
+            Mutation::SetSpoolMinMaxMinSpeed(speed) => self.spool_set_minmax_min_speed(speed),
+            Mutation::SetSpoolMinMaxMaxSpeed(speed) => self.spool_set_minmax_max_speed(speed),
+            Mutation::SetSpoolForward(value) => self.spool_set_forward(value),
+            Mutation::SetSpoolAdaptiveTensionTarget(value) => {
+                self.spool_set_adaptive_tension_target(value)
+            }
+            Mutation::SetSpoolAdaptiveRadiusLearningRate(value) => {
+                self.spool_set_adaptive_radius_learning_rate(value)
+            }
+            Mutation::SetSpoolAdaptiveMaxSpeedMultiplier(value) => {
+                self.spool_set_adaptive_max_speed_multiplier(value)
+            }
+            Mutation::SetSpoolAdaptiveAccelerationFactor(value) => {
+                self.spool_set_adaptive_acceleration_factor(value)
+            }
+            Mutation::SetSpoolAdaptiveDeaccelerationUrgencyMultiplier(value) => {
+                self.spool_set_adaptive_deacceleration_urgency_multiplier(value)
+            }
+            Mutation::SetSpoolAutomaticRequiredMeters(meters) => {
+                self.set_spool_automatic_required_meters(meters)
+            }
+            Mutation::SetSpoolAutomaticAction(mode) => self.set_spool_automatic_mode(mode),
+            Mutation::ResetSpoolProgress => self.stop_or_pull_spool_reset(Instant::now()),
+            Mutation::ZeroTensionArmAngle => self.tension_arm_zero(),
+            Mutation::SetConnectedMachine(machine_identification_unique) => {
+                self.set_connected_buffer(machine_identification_unique)
+            }
+            Mutation::DisconnectMachine(machine_identification_unique) => {
+                self.disconnect_buffer(machine_identification_unique)
+            }
+        }
+        Ok(())
+    }
+
+    fn api_event_namespace(&mut self) -> Arc<Mutex<Namespace>> {
+        self.namespace.namespace.clone()
+    }
+}

server/src/machines/winder2/mock/mock_emit.rs

@@ -0,0 +1,242 @@
+use std::time::Instant;
+
+use crate::machines::winder2::Winder2Mode;
+use crate::machines::winder2::api::LiveValuesEvent;
+use crate::machines::winder2::api::{
+    ModeState, SpoolAutomaticActionMode, StateEvent, Winder2Events,
+};
+use crate::machines::winder2::puller_speed_controller::{GearRatio, PullerRegulationMode};
+use crate::machines::winder2::spool_speed_controller::SpoolSpeedControllerType;
+use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH};
+use control_core::machines::identification::{MachineIdentification, MachineIdentificationUnique};
+use control_core::socketio::event::BuildEvent;
+use control_core::socketio::namespace::NamespaceCacheingLogic;
+
+use super::Winder2;
+
+impl Winder2 {
+    pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
+        vendor: VENDOR_QITECH,
+        machine: MACHINE_WINDER_V1,
+    };
+
+    pub fn stop_or_pull_spool_reset(&mut self, now: Instant) {}
+    /// Implement Mode
+    pub fn set_mode(&mut self, mode: &Winder2Mode) {
+        self.mode_state = ModeState {
+            mode: mode.clone().into(),
+            can_wind: true,
+        };
+        self.emit_state();
+    }
+
+    /// Implement Traverse
+    pub fn set_laser(&mut self, value: bool) {
+        self.traverse_state.laserpointer = value;
+        self.emit_state();
+    }
+
+    pub fn traverse_set_limit_inner(&mut self, limit: f64) {
+        self.traverse_state.limit_inner = limit;
+        self.emit_state();
+    }
+
+    pub fn traverse_set_limit_outer(&mut self, limit: f64) {
+        self.traverse_state.limit_outer = limit;
+        self.emit_state();
+    }
+
+    pub fn traverse_set_step_size(&mut self, step_size: f64) {
+        self.traverse_state.step_size = step_size;
+        self.emit_state();
+    }
+
+    pub fn traverse_set_padding(&mut self, padding: f64) {
+        self.traverse_state.padding = padding;
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_limit_inner(&mut self) {
+        self.traverse_state.position_in = self.traverse_state.limit_inner;
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_limit_outer(&mut self) {
+        self.traverse_state.position_in = self.traverse_state.limit_outer;
+        self.emit_state();
+    }
+
+    pub fn traverse_goto_home(&mut self) {
+        self.traverse_state.position_in = 0.0;
+        self.emit_state();
+    }
+
+    pub fn emit_live_values(&mut self) {
+        let event = LiveValuesEvent {
+            traverse_position: Some(0.0),
+            puller_speed: 0.0,
+            spool_rpm: 0.0,
+            tension_arm_angle: 0.0,
+            spool_progress: 0.0,
+        };
+
+        let event = event.build();
+
+        self.namespace.emit(Winder2Events::LiveValues(event));
+    }
+
+    pub fn build_state_event(&mut self) -> StateEvent {
+        StateEvent {
+            is_default_state: self.is_default_state,
+            traverse_state: self.traverse_state.clone(),
+            puller_state: self.puller_state.clone(),
+            spool_automatic_action_state: self.spool_automatic_action_state.clone(),
+            mode_state: self.mode_state.clone(),
+            tension_arm_state: self.tension_arm_state.clone(),
+            spool_speed_controller_state: self.spool_speed_controller_state.clone(),
+            connected_machine_state: self.connected_machine_state.clone(),
+        }
+    }
+
+    pub fn emit_state(&mut self) {
+        let state = self.build_state_event();
+        let event = state.build();
+        self.namespace.emit(Winder2Events::State(event));
+    }
+
+    /// Apply the mode changes to the spool
+    ///
+    /// It contains a transition matrix for atomic changes.
+    /// It will set [`Self::spool_mode`]
+    fn set_traverse_mode(&mut self, mode: &Winder2Mode) {
+        self.mode_state = ModeState {
+            mode: crate::machines::winder2::api::Mode::Standby,
+            can_wind: true,
+        };
+        self.emit_state();
+    }
+
+    /// Implement Tension Arm
+    pub fn tension_arm_zero(&mut self) {
+        self.tension_arm_state.zeroed = true;
+        self.emit_state();
+    }
+
+    pub fn set_spool_automatic_required_meters(&mut self, meters: f64) {
+        self.spool_automatic_action_state.spool_required_meters = meters;
+        self.emit_state();
+    }
+
+    pub fn set_spool_automatic_mode(&mut self, mode: SpoolAutomaticActionMode) {
+        self.spool_automatic_action_state
+            .spool_automatic_action_mode = mode;
+        self.emit_state();
+    }
+
+    pub fn puller_set_regulation(&mut self, puller_regulation_mode: PullerRegulationMode) {
+        self.puller_state.regulation = puller_regulation_mode;
+        self.emit_state();
+    }
+
+    /// Set target speed in m/min
+    pub fn puller_set_target_speed(&mut self, target_speed: f64) {
+        self.puller_state.target_speed = target_speed;
+        self.emit_state();
+    }
+
+    /// Set target diameter in mm
+    pub fn puller_set_target_diameter(&mut self, target_diameter: f64) {
+        self.puller_state.target_diameter = target_diameter;
+        self.emit_state();
+    }
+
+    /// Set forward direction
+    pub fn puller_set_forward(&mut self, forward: bool) {
+        self.puller_state.forward = forward;
+        self.emit_state();
+    }
+
+    /// Set gear ratio for winding speed
+    pub fn puller_set_gear_ratio(&mut self, gear_ratio: GearRatio) {
+        self.puller_state.gear_ratio = gear_ratio;
+        self.emit_state();
+    }
+
+    // Spool Speed Controller API methods
+    pub fn spool_set_regulation_mode(&mut self, regulation_mode: SpoolSpeedControllerType) {
+        self.spool_speed_controller_state.regulation_mode = regulation_mode;
+        self.emit_state();
+    }
+
+    /// Set minimum speed for minmax mode in RPM
+    pub fn spool_set_minmax_min_speed(&mut self, min_speed_rpm: f64) {
+        self.spool_speed_controller_state.minmax_min_speed = min_speed_rpm;
+        self.emit_state();
+    }
+
+    /// Set maximum speed for minmax mode in RPM
+    pub fn spool_set_minmax_max_speed(&mut self, max_speed_rpm: f64) {
+        self.spool_speed_controller_state.minmax_max_speed = max_speed_rpm;
+        self.emit_state();
+    }
+
+    /// Set tension target for adaptive mode (0.0-1.0)
+    pub fn spool_set_adaptive_tension_target(&mut self, tension_target: f64) {
+        self.spool_speed_controller_state.adaptive_tension_target = tension_target;
+        self.emit_state();
+    }
+
+    /// Set radius learning rate for adaptive mode
+    pub fn spool_set_adaptive_radius_learning_rate(&mut self, radius_learning_rate: f64) {
+        self.spool_speed_controller_state
+            .adaptive_radius_learning_rate = radius_learning_rate;
+        self.emit_state();
+    }
+
+    /// Set max speed multiplier for adaptive mode
+    pub fn spool_set_adaptive_max_speed_multiplier(&mut self, max_speed_multiplier: f64) {
+        self.spool_speed_controller_state
+            .adaptive_max_speed_multiplier = max_speed_multiplier;
+        self.emit_state();
+    }
+
+    /// Set acceleration factor for adaptive mode
+    pub fn spool_set_adaptive_acceleration_factor(&mut self, acceleration_factor: f64) {
+        self.spool_speed_controller_state
+            .adaptive_acceleration_factor = acceleration_factor;
+        self.emit_state();
+    }
+
+    /// Set deacceleration urgency multiplier for adaptive mode
+    pub fn spool_set_adaptive_deacceleration_urgency_multiplier(
+        &mut self,
+        deacceleration_urgency_multiplier: f64,
+    ) {
+        self.spool_speed_controller_state
+            .adaptive_deacceleration_urgency_multiplier = deacceleration_urgency_multiplier;
+        self.emit_state();
+    }
+
+    /// Set forward rotation direction
+    pub fn spool_set_forward(&mut self, forward: bool) {
+        self.spool_speed_controller_state.forward = forward;
+        self.emit_state();
+    }
+
+    /// implement machine connection
+    /// set connected buffer
+    pub fn set_connected_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        self.emit_state();
+    }
+
+    /// disconnect buffer
+    pub fn disconnect_buffer(
+        &mut self,
+        machine_identification_unique: MachineIdentificationUnique,
+    ) {
+        self.emit_state();
+    }
+}

server/src/machines/winder2/mock/mod.rs

@@ -0,0 +1,44 @@
+use std::time::Instant;
+
+use control_core::machines::{
+    connection::MachineCrossConnectionState, identification::MachineIdentificationUnique,
+};
+use control_core_derive::Machine;
+pub mod act;
+pub mod api;
+pub mod mock_emit;
+pub mod new;
+use crate::machines::winder2::api::Winder2Namespace;
+
+use super::api::{
+    ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState, TensionArmState,
+    TraverseState,
+};
+
+#[derive(Debug, Machine)]
+pub struct Winder2 {
+    machine_identification_unique: MachineIdentificationUnique,
+    namespace: Winder2Namespace,
+    last_measurement_emit: Instant,
+    pub is_default_state: bool,
+    /// traverse state
+    pub traverse_state: TraverseState,
+    /// puller state
+    pub puller_state: PullerState,
+    /// spool automatic action state and progress
+    pub spool_automatic_action_state: SpoolAutomaticActionState,
+    /// mode state
+    pub mode_state: ModeState,
+    /// tension arm state
+    pub tension_arm_state: TensionArmState,
+    /// spool speed controller state
+    pub spool_speed_controller_state: SpoolSpeedControllerState,
+    /// connected machine state
+    pub connected_machine_state: MachineCrossConnectionState,
+}
+
+impl std::fmt::Display for Winder2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Winder2")
+    }
+}

server/src/machines/winder2/mock/new.rs

@@ -0,0 +1,53 @@
+use crate::machines::winder2::{
+    api::{
+        ModeState, PullerState, SpoolAutomaticActionState, SpoolSpeedControllerState,
+        TensionArmState, TraverseState, Winder2Namespace,
+    },
+    mock::Winder2,
+};
+use control_core::machines::connection::MachineCrossConnectionState;
+
+impl control_core::machines::new::MachineNewTrait for Winder2 {
+    fn new(
+        params: &control_core::machines::new::MachineNewParams<'_, '_, '_, '_, '_, '_, '_>,
+    ) -> Result<Self, anyhow::Error>
+    where
+        Self: Sized,
+    {
+        // Mock machine can work with either Serial or Ethercat hardware
+        // For the mock machine, we don't need to actually use the hardware
+        // We just validate that we have the expected hardware type
+        match params.hardware {
+            control_core::machines::new::MachineNewHardware::Serial(_) => {
+                // For serial mode, we could potentially use the serial device if needed
+                // but for a mock machine, we'll just note it and proceed
+            }
+            control_core::machines::new::MachineNewHardware::Ethercat(_) => {
+                // For ethercat mode, we could potentially use the ethercat devices
+                // but for a mock machine, we'll just note it and proceed
+            }
+        }
+
+        let now = std::time::Instant::now();
+
+        let mut extruder_mock_machine = Self {
+            machine_identification_unique: params.get_machine_identification_unique(),
+            namespace: Winder2Namespace {
+                namespace: params.namespace.clone(),
+            },
+            last_measurement_emit: now,
+            is_default_state: true,
+            traverse_state: TraverseState::default(),
+            puller_state: PullerState::default(),
+            spool_automatic_action_state: SpoolAutomaticActionState::default(),
+            mode_state: ModeState::default(),
+            tension_arm_state: TensionArmState::default(),
+            spool_speed_controller_state: SpoolSpeedControllerState::default(),
+            connected_machine_state: MachineCrossConnectionState::default(),
+        };
+
+        extruder_mock_machine.emit_state();
+
+        Ok(extruder_mock_machine)
+    }
+}

server/src/machines/winder2/mod.rs

@@ -11,37 +11,47 @@ pub mod spool_speed_controller;
 pub mod tension_arm;
 pub mod traverse_controller;
 
-use std::{fmt::Debug, sync::Weak, time::Instant};
+#[cfg(feature = "mock-machine")]
+pub mod mock;
 
-use api::{SpoolAutomaticActionMode, Winder2Namespace};
-use control_core::{
-    converters::angular_step_converter::AngularStepConverter,
-    machines::{
-        connection::{CrossConnectableMachine, MachineCrossConnection},
-        identification::{MachineIdentification, MachineIdentificationUnique},
-        manager::MachineManager,
-    },
-};
-use control_core_derive::Machine;
-use ethercat_hal::io::{
-    digital_input::DigitalInput, digital_output::DigitalOutput,
-    stepper_velocity_el70x1::StepperVelocityEL70x1,
-};
-use puller_speed_controller::PullerSpeedController;
-use smol::lock::RwLock;
-use spool_speed_controller::SpoolSpeedController;
-use tension_arm::TensionArm;
-use traverse_controller::TraverseController;
-use uom::{
-    ConstZero,
-    si::{
-        f64::Length,
-        length::{meter, millimeter},
-        velocity::meter_per_second,
-    },
-};
+#[cfg(feature = "mock-machine")]
+mod winder2_imports {
+    pub use super::api::SpoolAutomaticActionMode;
+    pub use std::time::Instant;
+    pub use uom::si::f64::Length;
+}
 
-use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH, buffer1::BufferV1};
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::api::SpoolAutomaticActionMode;
+    pub use super::api::Winder2Namespace;
+    pub use super::puller_speed_controller::PullerSpeedController;
+    pub use super::spool_speed_controller::SpoolSpeedController;
+    pub use super::tension_arm::TensionArm;
+    pub use super::traverse_controller::TraverseController;
+    pub use control_core::{
+        converters::angular_step_converter::AngularStepConverter,
+        machines::{
+            connection::{CrossConnectableMachine, MachineCrossConnection},
+            identification::{MachineIdentification, MachineIdentificationUnique},
+            manager::MachineManager,
+        },
+    };
+    pub use control_core_derive::Machine;
+    pub use ethercat_hal::io::{
+        digital_input::DigitalInput, digital_output::DigitalOutput,
+        stepper_velocity_el70x1::StepperVelocityEL70x1,
+    };
+    pub use smol::lock::RwLock;
+    pub use std::{fmt::Debug, sync::Weak, time::Instant};
+    pub use uom::si::f64::Length;
+
+    pub use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH, buffer1::BufferV1};
+    pub use uom::ConstZero;
+    pub use uom::si::{length::meter, length::millimeter, velocity::meter_per_second};
+}
+
+pub use winder2_imports::*;
 
 #[derive(Debug)]
 pub struct SpoolAutomaticAction {
@@ -51,6 +61,18 @@ pub struct SpoolAutomaticAction {
     pub mode: SpoolAutomaticActionMode,
 }
 
+impl Default for SpoolAutomaticAction {
+    fn default() -> Self {
+        SpoolAutomaticAction {
+            progress: Length::new::<uom::si::length::meter>(0.0),
+            progress_last_check: Instant::now(),
+            target_length: Length::new::<uom::si::length::meter>(0.0),
+            mode: SpoolAutomaticActionMode::default(),
+        }
+    }
+}
+
+#[cfg(not(feature = "mock-machine"))]
 #[derive(Debug, Machine)]
 pub struct Winder2 {
     // drivers
@@ -96,12 +118,14 @@ pub struct Winder2 {
     emitted_default_state: bool,
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl CrossConnectableMachine<Winder2, BufferV1> for Winder2 {
     fn get_cross_connection(&mut self) -> &mut MachineCrossConnection<Winder2, BufferV1> {
         &mut self.connected_buffer
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl Winder2 {
     pub const MACHINE_IDENTIFICATION: MachineIdentification = MachineIdentification {
         vendor: VENDOR_QITECH,
@@ -277,6 +301,7 @@ impl Winder2 {
 
     pub fn calculate_spool_auto_progress_(&mut self, now: Instant) {
         // Calculate time elapsed since last progress check (in minutes)
+
         let dt = now
             .duration_since(self.spool_automatic_action.progress_last_check)
             .as_secs_f64();
@@ -368,12 +393,14 @@ impl From<Winder2Mode> for PullerMode {
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 impl std::fmt::Display for Winder2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Winder2")
     }
 }
 
+#[cfg(not(feature = "mock-machine"))]
 #[cfg(test)]
 mod tests {
     use super::*;

server/src/machines/winder2/new.rs

@@ -1,50 +1,63 @@
-use std::time::Instant;
+#[cfg(not(feature = "mock-machine"))]
+mod winder2_imports {
+    pub use super::super::api::Winder2Namespace;
+    pub use super::super::tension_arm::TensionArm;
+    pub use super::super::{Winder2, Winder2Mode};
+    pub use crate::machines::winder2::puller_speed_controller::PullerSpeedController;
+    pub use crate::machines::winder2::spool_speed_controller::SpoolSpeedController;
+    pub use crate::machines::winder2::traverse_controller::TraverseController;
+    pub use anyhow::Error;
+    pub use control_core::converters::angular_step_converter::AngularStepConverter;
+    pub use control_core::converters::linear_step_converter::LinearStepConverter;
+    pub use control_core::machines::connection::MachineCrossConnection;
+    pub use control_core::machines::new::{
+        MachineNewHardware, MachineNewParams, MachineNewTrait, validate_no_role_dublicates,
+        validate_same_machine_identification_unique,
+    };
 
-use super::api::Winder2Namespace;
-use super::tension_arm::TensionArm;
-use super::{Winder2, Winder2Mode};
+    pub use control_core::uom_extensions::velocity::meter_per_minute;
+    pub use ethercat_hal::coe::ConfigurableDevice;
+    pub use ethercat_hal::devices::ek1100::EK1100;
+    pub use ethercat_hal::devices::el2002::{EL2002, EL2002_IDENTITY_B, EL2002Port};
+    pub use ethercat_hal::devices::el7031::coe::EL7031Configuration;
+    pub use ethercat_hal::devices::el7031::pdo::EL7031PredefinedPdoAssignment;
+    pub use ethercat_hal::devices::el7031::{
+        EL7031, EL7031_IDENTITY_A, EL7031_IDENTITY_B, EL7031DigitalInputPort, EL7031StepperPort,
+    };
+    pub use ethercat_hal::devices::el7031_0030::coe::EL7031_0030Configuration;
+    pub use ethercat_hal::devices::el7031_0030::pdo::EL7031_0030PredefinedPdoAssignment;
+    pub use ethercat_hal::devices::el7031_0030::{
+        self, EL7031_0030, EL7031_0030_IDENTITY_A, EL7031_0030AnalogInputPort,
+        EL7031_0030StepperPort,
+    };
+    pub use ethercat_hal::devices::el7041_0052::coe::EL7041_0052Configuration;
+    pub use ethercat_hal::devices::el7041_0052::{
+        EL7041_0052, EL7041_0052_IDENTITY_A, EL7041_0052Port,
+    };
+    pub use ethercat_hal::devices::{ek1100::EK1100_IDENTITY_A, el2002::EL2002_IDENTITY_A};
+    pub use ethercat_hal::io::analog_input::AnalogInput;
+    pub use ethercat_hal::io::digital_input::DigitalInput;
+    pub use ethercat_hal::io::digital_output::DigitalOutput;
+    pub use ethercat_hal::io::stepper_velocity_el70x1::StepperVelocityEL70x1;
+    pub use ethercat_hal::shared_config;
+    pub use ethercat_hal::shared_config::el70x1::{EL70x1OperationMode, StmMotorConfiguration};
+    pub use std::time::Instant;
+    pub use uom::ConstZero;
+    pub use uom::si::f64::{Length, Velocity};
+    pub use uom::si::length::{centimeter, meter, millimeter};
+}
+
+#[cfg(not(feature = "mock-machine"))]
+pub use winder2_imports::*;
+
+#[cfg(not(feature = "mock-machine"))]
 use crate::machines::get_ethercat_device;
-use crate::machines::winder2::puller_speed_controller::PullerSpeedController;
-use crate::machines::winder2::spool_speed_controller::SpoolSpeedController;
-use crate::machines::winder2::traverse_controller::TraverseController;
-use anyhow::Error;
-use control_core::converters::angular_step_converter::AngularStepConverter;
-use control_core::converters::linear_step_converter::LinearStepConverter;
-use control_core::machines::connection::MachineCrossConnection;
-use control_core::machines::new::{
-    MachineNewHardware, MachineNewParams, MachineNewTrait, validate_no_role_dublicates,
-    validate_same_machine_identification_unique,
-};
-use control_core::uom_extensions::velocity::meter_per_minute;
-use ethercat_hal::coe::ConfigurableDevice;
-use ethercat_hal::devices::ek1100::EK1100;
-use ethercat_hal::devices::el2002::{EL2002, EL2002_IDENTITY_B, EL2002Port};
-use ethercat_hal::devices::el7031::coe::EL7031Configuration;
-use ethercat_hal::devices::el7031::pdo::EL7031PredefinedPdoAssignment;
-use ethercat_hal::devices::el7031::{
-    EL7031, EL7031_IDENTITY_A, EL7031_IDENTITY_B, EL7031DigitalInputPort, EL7031StepperPort,
-};
-use ethercat_hal::devices::el7031_0030::coe::EL7031_0030Configuration;
-use ethercat_hal::devices::el7031_0030::pdo::EL7031_0030PredefinedPdoAssignment;
-use ethercat_hal::devices::el7031_0030::{
-    self, EL7031_0030, EL7031_0030_IDENTITY_A, EL7031_0030AnalogInputPort, EL7031_0030StepperPort,
-};
-use ethercat_hal::devices::el7041_0052::coe::EL7041_0052Configuration;
-use ethercat_hal::devices::el7041_0052::{EL7041_0052, EL7041_0052_IDENTITY_A, EL7041_0052Port};
-use ethercat_hal::devices::{ek1100::EK1100_IDENTITY_A, el2002::EL2002_IDENTITY_A};
-use ethercat_hal::io::analog_input::AnalogInput;
-use ethercat_hal::io::digital_input::DigitalInput;
-use ethercat_hal::io::digital_output::DigitalOutput;
-use ethercat_hal::io::stepper_velocity_el70x1::StepperVelocityEL70x1;
-use ethercat_hal::shared_config;
-use ethercat_hal::shared_config::el70x1::{EL70x1OperationMode, StmMotorConfiguration};
-use uom::ConstZero;
-use uom::si::f64::{Length, Velocity};
-use uom::si::length::{centimeter, meter, millimeter};
 
+#[cfg(not(feature = "mock-machine"))]
 impl MachineNewTrait for Winder2 {
     fn new<'maindevice>(params: &MachineNewParams) -> Result<Self, Error> {
         // validate general stuff
+
         let device_identification = params.device_group.to_vec();
 
         validate_same_machine_identification_unique(&device_identification)?;

server/src/machines/winder2/puller_speed_controller.rs

@@ -150,8 +150,9 @@ impl PullerSpeedController {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub enum PullerRegulationMode {
+    #[default]
     Speed,
     Diameter,
 }

server/src/machines/winder2/spool_speed_controller.rs

@@ -10,8 +10,9 @@ use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use uom::si::f64::AngularVelocity;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub enum SpoolSpeedControllerType {
+    #[default]
     Adaptive,
     MinMax,
 }

server/src/main.rs

@@ -1,106 +1,71 @@
-#[cfg(feature = "dhat-heap")]
-#[global_allocator]
-static ALLOC: dhat::Alloc = dhat::Alloc;
-
-use app_state::AppState;
-use r#loop::init_loop;
+use futures::{FutureExt, select};
 #[cfg(feature = "mock-machine")]
 use mock::init::init_mock;
-use rest::init::init_api;
-#[cfg(not(feature = "mock-machine"))]
-use serial::init::init_serial;
-use std::sync::Arc;
+
+#[cfg(feature = "mock-machine")]
+pub mod mock;
 
 use crate::panic::init_panic_handling;
-use crate::socketio::queue::init_socketio_queue;
-
+use app_state::AppState;
+use ethercat::{
+    ethercat_discovery_info::{send_ethercat_discovering, send_ethercat_found},
+    init::start_interface_discovery,
+};
+use r#loop::start_loop_thread;
+use rest::init::start_api_thread;
+use serial::init::{handle_serial_device_hotplug, start_serial_discovery};
+use socketio::queue::start_socketio_queue;
+use std::sync::Arc;
 pub mod app_state;
 pub mod ethercat;
 pub mod logging;
 pub mod r#loop;
 pub mod machines;
-#[cfg(feature = "mock-machine")]
-pub mod mock;
 pub mod panic;
 pub mod performance_metrics;
 pub mod rest;
 pub mod serial;
 pub mod socketio;
 
-use crate::ethercat::init::init_ethercat;
-
 fn main() {
     logging::init_tracing();
     tracing::info!("Tracing initialized successfully");
-
     init_panic_handling();
 
-    #[cfg(feature = "memory-locking")]
-    if let Err(e) = control_core::realtime::lock_memory() {
-        tracing::error!("[{}::main] Failed to lock memory: {:?}", module_path!(), e);
-    } else {
-        tracing::info!("[{}::main] Memory locked successfully", module_path!());
-    }
     let app_state = Arc::new(AppState::new());
 
-    // Spawn init thread
-    let init_thread = std::thread::Builder::new()
-        .name("init".to_string())
-        .spawn({
-            move || {
-                #[cfg(feature = "dhat-heap")]
-                init_dhat_heap_profiling();
+    let _ = start_api_thread(app_state.clone());
+    let mut socketio_fut = start_socketio_queue(app_state.clone()).fuse();
+    let mut ethercat_fut = start_interface_discovery().fuse();
+    let mut serial_fut = start_serial_discovery().fuse();
 
-                init_socketio_queue(app_state.clone());
-                init_api(app_state.clone()).expect("Failed to initialize API");
-                init_loop(app_state.clone()).expect("Failed to initialize loop");
-
-                #[cfg(feature = "mock-machine")]
-                init_mock(app_state.clone()).expect("Failed to initialize mock machines");
-
-                #[cfg(not(feature = "mock-machine"))]
-                init_serial(app_state.clone()).expect("Failed to initialize Serial");
-
-                #[cfg(not(feature = "mock-machine"))]
-                init_ethercat(app_state).expect("Failed to initialize EtherCAT");
-            }
-        })
-        .expect("Failed to spawn init thread");
-
-    // Wait for init thread to complete
-    init_thread.join().expect("Init thread panicked");
-
-    // Keep the main thread alive indefinitely
-    // The program should only exit via panic handling or external signals
-    loop {
-        // better way to "sleep", uses basically
-        std::thread::park();
-    }
-}
-
-#[cfg(feature = "dhat-heap")]
-fn init_dhat_heap_profiling() {
-    use std::{process::exit, time::Duration};
-
-    let profiler = dhat::Profiler::new_heap();
+    smol::block_on(async { send_ethercat_discovering(app_state.clone()).await });
 
     smol::block_on(async {
-        let dhat_analysis_time = std::time::Duration::from_secs(60);
-        let dhat_analysis_start = std::time::Instant::now();
-        tracing::info!(
-            "Starting dhat heap profiler for {} seconds",
-            dhat_analysis_time.as_secs()
-        );
-
         loop {
-            use std::time::Duration;
-            smol::Timer::after(Duration::from_secs(1)).await;
+            // lets the async runtime decide which future to run next
+            select! {
+                res = ethercat_fut => {
+                    tracing::info!("EtherCAT task finished: {:?}", res);
+                    match res {
+                        Ok(interface) =>
+                        {
+                            send_ethercat_found(app_state.clone(), &interface).await;
+                            let _ = start_loop_thread(&interface, app_state.clone());
+                        },
+                        Err(_) => (),
+                    };
 
-            // if `dhat-heap` is enabled, we will analyze the heap for 60 seconds and then exit
-            if dhat_analysis_start.elapsed() > dhat_analysis_time {
-                drop(profiler);
-                exit(0)
+                },
+                res = serial_fut => {
+                    let _ = handle_serial_device_hotplug(app_state.clone(),res).await;
+                    serial_fut = start_serial_discovery().fuse();
+                },
+                res = socketio_fut => {
+                    // In theory it should never finish
+                    tracing::warn!("SocketIO task finished: {:?}", res);
+                },
             }
         }
-    })
+    });
 }

server/src/mock/init.rs

@@ -1,5 +1,6 @@
 #[cfg(feature = "mock-machine")]
 use crate::serial::devices::extruder_mock::ExtruderMockSerialDevice;
+use crate::serial::devices::winder_mock::WinderMockSerialDevice;
 #[cfg(feature = "mock-machine")]
 use {
     crate::app_state::AppState,
@@ -12,16 +13,15 @@ use {
     },
     std::sync::Arc,
 };
+
 #[cfg(feature = "mock-machine")]
 pub fn init_mock(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
     // For mock devices, we need to manually create and add them to the machine manager
     // since they won't be detected by the serial detection loop
     return smol::block_on(async {
         // Create a mock serial device manually
-        let (device_thread_panic_tx, _device_thread_panic_rx) = smol::channel::unbounded();
         let serial_params = SerialDeviceNewParams {
             path: "/dev/mock-serial".to_string(),
-            device_thread_panic_tx,
         };
 
         // Create the mock serial device
@@ -57,7 +57,39 @@ pub fn init_mock(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
             }
         };
 
-        match ExtruderMockSerialDevice::new_serial(&serial_params) {
+        let _ = match ExtruderMockSerialDevice::new_serial(&serial_params) {
+            Ok((device_identification, mock_serial_device)) => {
+                // Add the mock device to the machine manager
+                {
+                    let mut machine_guard = app_state.machines.write().await;
+                    machine_guard.add_serial_device(
+                        &device_identification,
+                        mock_serial_device,
+                        &MACHINE_REGISTRY,
+                        app_state.socketio_setup.socket_queue_tx.clone(),
+                        Arc::downgrade(&app_state.machines),
+                    );
+                }
+
+                // Notify clients via socketio about the new machine
+                let app_state_event = app_state.clone();
+                let main_namespace = &mut app_state_event
+                    .socketio_setup
+                    .namespaces
+                    .write()
+                    .await
+                    .main_namespace;
+                let event = MachinesEventBuilder().build(app_state_event.clone());
+                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+                Ok::<(), anyhow::Error>(())
+            }
+            Err(e) => {
+                tracing::error!("Failed to create extruder mock serial device: {}", e);
+                return Err(e);
+            }
+        };
+
+        match WinderMockSerialDevice::new_serial(&serial_params) {
             Ok((device_identification, mock_serial_device)) => {
                 // Add the mock device to the machine manager
                 {

server/src/performance_metrics.rs

@@ -10,8 +10,8 @@ const METRICS_LOG_INTERVAL_SECS: u64 = 30; // Log every 30 seconds
 pub struct EthercatPerformanceMetrics {
     txrx_times: VecDeque<Duration>,
     loop_times: VecDeque<Duration>,
-    last_loop_start: Option<Instant>,
-    last_log_time: Instant,
+    pub last_loop_start: Option<Instant>,
+    pub last_log_time: Instant,
 }
 
 impl Default for EthercatPerformanceMetrics {

server/src/rest/init.rs

@@ -1,65 +1,57 @@
-use super::handlers::machine_mutation::post_machine_mutate;
-use super::handlers::write_machine_device_identification::post_write_machine_device_identification;
-use crate::app_state::AppState;
-use crate::socketio::init::init_socketio;
-use anyhow::anyhow;
+use anyhow::Result;
 use axum::routing::post;
 use std::sync::Arc;
-use std::thread::JoinHandle;
+use std::thread;
 use tower_http::cors::CorsLayer;
 use tower_http::trace::{DefaultMakeSpan, DefaultOnRequest, DefaultOnResponse, TraceLayer};
 use tracing::Level;
 
-pub fn init_api(app_state: Arc<AppState>) -> Result<JoinHandle<()>, anyhow::Error> {
-    std::thread::Builder::new()
-        .name("api".to_string())
-        .spawn(|| {
-            let rt = tokio::runtime::Builder::new_current_thread()
-                .enable_io()
-                .enable_time()
-                .build()
-                .expect("Failed to create runtime");
+use super::handlers::machine_mutation::post_machine_mutate;
+use super::handlers::write_machine_device_identification::post_write_machine_device_identification;
+use crate::app_state::AppState;
+use crate::socketio::init::init_socketio;
 
-            rt.block_on(async {
-                // allow all CORS requests
-                let cors = CorsLayer::permissive();
+async fn init_api(app_state: Arc<AppState>) -> Result<()> {
+    let cors = CorsLayer::permissive();
+    let socketio_layer = init_socketio(&app_state).await;
 
-                // creat socketio layer
-                let socketio_layer = init_socketio(&app_state).await;
+    let trace_layer = TraceLayer::new_for_http()
+        .make_span_with(DefaultMakeSpan::new().level(Level::DEBUG))
+        .on_request(DefaultOnRequest::new().level(Level::TRACE))
+        .on_response(DefaultOnResponse::new().level(Level::TRACE));
 
-                // Create a more detailed trace layer for HTTP requests
-                let trace_layer = TraceLayer::new_for_http()
-                    .make_span_with(
-                        DefaultMakeSpan::new()
-                            .level(Level::DEBUG)
-                            .include_headers(false),
-                    )
-                    .on_request(DefaultOnRequest::new().level(Level::TRACE))
-                    .on_response(
-                        DefaultOnResponse::new()
-                            .level(Level::TRACE)
-                            .include_headers(false),
-                    );
+    let app = axum::Router::new()
+        .route(
+            "/api/v1/write_machine_device_identification",
+            post(post_write_machine_device_identification),
+        )
+        .route("/api/v1/machine/mutate", post(post_machine_mutate))
+        .layer(socketio_layer)
+        .layer(cors)
+        .layer(trace_layer)
+        .with_state(app_state);
 
-                // make axum server to serve the data on /ethercat
-                let app = axum::Router::new()
-                    .route(
-                        "/api/v1/write_machine_device_identification",
-                        post(post_write_machine_device_identification),
-                    )
-                    .route("/api/v1/machine/mutate", post(post_machine_mutate))
-                    .layer(socketio_layer)
-                    .layer(cors)
-                    .layer(trace_layer)
-                    .with_state(app_state);
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3001")
+        .await
+        .expect("Failed to bind to port 3001");
 
-                let listener = tokio::net::TcpListener::bind("0.0.0.0:3001")
-                    .await
-                    .expect("Failed to bind to port 3001");
+    tracing::info!("HTTP server running on 0.0.0.0:3001");
 
-                tracing::info!("Starting HTTP server on 0.0.0.0:3001");
-                axum::serve(listener, app).await.expect("Failed to serve");
-            });
-        })
-        .map_err(|e| anyhow!("Failed to spawn API thread: {}", e))
+    axum::serve(listener, app)
+        .await
+        .map_err(|e| anyhow::anyhow!("Server error: {}", e))
+}
+
+/// Starts the API server in its own thread with a single-threaded Tokio runtime
+pub fn start_api_thread(app_state: Arc<AppState>) -> std::thread::JoinHandle<()> {
+    thread::spawn(move || {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to create Tokio runtime");
+
+        if let Err(err) = rt.block_on(init_api(app_state)) {
+            eprintln!("API server exited with error: {err:?}");
+        }
+    })
 }

server/src/serial/devices/laser/mod.rs

@@ -17,10 +17,7 @@ use control_core::{
         DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
     },
     modbus::{self, ModbusRequest, ModbusResponse},
-    serial::{
-        SerialDevice, SerialDeviceNew, SerialDeviceNewParams, panic::send_serial_device_panic,
-        serial_detection::SerialDeviceRemoval,
-    },
+    serial::{SerialDevice, SerialDeviceNew, SerialDeviceNewParams},
 };
 use serialport::SerialPort;
 use serialport::{ClearBuffer, DataBits, FlowControl, Parity, StopBits};
@@ -125,27 +122,13 @@ impl SerialDeviceNew for Laser {
             path: params.path.clone(),
         }));
 
-        // Spawn the device thread
-        let device_thread_panic_tx = params.device_thread_panic_tx.clone();
+        //// Spawn the device thread
         let _self_clone = _self.clone();
-        let path = params.path.clone();
         thread::Builder::new()
             .name("laser".to_owned())
             .spawn(move || {
-                send_serial_device_panic(path.clone(), device_thread_panic_tx.clone());
                 smol::block_on(async {
-                    let process_result = Self::process(_self_clone).await;
-
-                    let removal = match process_result {
-                        Ok(_) => SerialDeviceRemoval::Disconnect(path),
-                        Err(e) => SerialDeviceRemoval::Error(path, e),
-                    };
-
-                    // if the task exists we want to remove the device
-                    device_thread_panic_tx
-                        .send(removal)
-                        .await
-                        .expect("Failed to send device removal signal");
+                    let _ = Self::process(_self_clone).await;
                 });
             })?;
 

server/src/serial/devices/mod.rs

@@ -3,3 +3,5 @@ pub mod extruder_mock;
 pub mod laser;
 #[cfg(feature = "mock-machine")]
 pub mod mock;
+#[cfg(feature = "mock-machine")]
+pub mod winder_mock;

server/src/serial/devices/winder_mock/mod.rs

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+
+use control_core::{
+    helpers::hashing::{byte_folding_u16, hash_djb2},
+    machines::identification::{
+        DeviceHardwareIdentification, DeviceHardwareIdentificationSerial, DeviceIdentification,
+        DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
+    },
+    serial::{SerialDevice, SerialDeviceNew, SerialDeviceNewParams},
+};
+use smol::lock::RwLock;
+
+use crate::machines::{MACHINE_WINDER_V1, VENDOR_QITECH};
+
+/// Mock serial device for testing MockMachine
+/// This provides a minimal SerialDevice implementation that doesn't require actual hardware
+#[derive(Debug)]
+pub struct WinderMockSerialDevice {
+    pub path: String,
+}
+
+impl SerialDevice for WinderMockSerialDevice {}
+
+impl SerialDeviceNew for WinderMockSerialDevice {
+    fn new_serial(
+        params: &SerialDeviceNewParams,
+    ) -> Result<(DeviceIdentification, Arc<RwLock<Self>>), anyhow::Error>
+    where
+        Self: Sized,
+    {
+        // Generate a unique serial number based on the path
+        let hash = hash_djb2(params.path.as_bytes());
+        let serial = byte_folding_u16(&hash.to_le_bytes());
+
+        let device_identification = DeviceIdentification {
+            device_machine_identification: Some(DeviceMachineIdentification {
+                machine_identification_unique: MachineIdentificationUnique {
+                    machine_identification: MachineIdentification {
+                        vendor: VENDOR_QITECH,
+                        machine: MACHINE_WINDER_V1,
+                    },
+                    serial,
+                },
+                role: 0,
+            }),
+            device_hardware_identification: DeviceHardwareIdentification::Serial(
+                DeviceHardwareIdentificationSerial {
+                    path: params.path.clone(),
+                },
+            ),
+        };
+
+        let mock_serial_device = Arc::new(RwLock::new(WinderMockSerialDevice {
+            path: params.path.clone(),
+        }));
+
+        Ok((device_identification, mock_serial_device))
+    }
+}

server/src/serial/init.rs

@@ -1,74 +1,139 @@
-use crate::socketio::main_namespace::MainNamespaceEvents;
-use crate::socketio::main_namespace::machines_event::MachinesEventBuilder;
-use crate::{app_state::AppState, machines::registry::MACHINE_REGISTRY};
-use control_core::socketio::namespace::NamespaceCacheingLogic;
-use std::{sync::Arc, thread, time::Duration};
+use control_core::{
+    machines::identification::MachineIdentificationUnique,
+    serial::{
+        SerialDeviceIdentification, SerialDeviceNew, SerialDeviceNewParams,
+        serial_detection::SerialDetection,
+    },
+    socketio::namespace::NamespaceCacheingLogic,
+};
+use serialport::UsbPortInfo;
+use smol::Task;
+use std::{collections::HashMap, sync::Arc, time::Duration};
 
-pub fn init_serial(app_state: Arc<AppState>) -> Result<(), anyhow::Error> {
-    let app_state_clone = app_state.clone();
+use crate::{
+    app_state::AppState,
+    machines::{laser::LaserMachine, registry::MACHINE_REGISTRY},
+    socketio::main_namespace::{MainNamespaceEvents, machines_event::MachinesEventBuilder},
+};
 
-    thread::Builder::new()
-        .name("SerialDetectionThread".to_owned())
-        .spawn(move || {
-            let app_state_clone = app_state_clone;
-            smol::block_on(async move {
-                let rt = smol::LocalExecutor::new();
-                rt.run(async {
-                    loop {
-                        let result = {
-                            let mut serial_setup_guard = app_state_clone.serial_setup.write().await;
+use super::devices::laser::Laser;
 
-                            let mut port_result =
-                                serial_setup_guard.serial_detection.check_ports().await;
-
-                            let mut removed_signals = serial_setup_guard
-                                .serial_detection
-                                .check_remove_signals()
-                                .await;
-
-                            port_result.removed.append(&mut removed_signals);
-
-                            port_result
-                        };
-
-                        if !result.added.is_empty() || !result.removed.is_empty() {
-                            // sync serial device discovery to machine manager
-                            {
-                                let mut machine_guard = app_state_clone.machines.write().await;
-                                // turn added devices into machines
-                                for (device_identifiaction, device) in result.added {
-                                    machine_guard.add_serial_device(
-                                        &device_identifiaction,
-                                        device.clone(),
-                                        &MACHINE_REGISTRY,
-                                        app_state_clone.socketio_setup.socket_queue_tx.clone(),
-                                        Arc::downgrade(&app_state.machines),
-                                    )
-                                }
-                                for device_identification in result.removed {
-                                    machine_guard.remove_serial_device(&device_identification)
-                                }
-                            }
-
-                            // Notify client via socketio
-                            let app_state_event = app_state.clone();
-                            smol::block_on(async {
-                                let main_namespace = &mut app_state_event
-                                    .socketio_setup
-                                    .namespaces
-                                    .write()
-                                    .await
-                                    .main_namespace;
-                                let event = MachinesEventBuilder().build(app_state_event.clone());
-                                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
-                            });
-                        }
-                        smol::Timer::after(Duration::from_millis(300)).await;
-                    }
-                })
-                .await;
-            });
-        })
-        .expect("Failed to spawn SerialTxRxThread");
-    Ok(())
+// Async function that runs until at least one serial device is found.
+pub async fn find_serial() -> Option<HashMap<String, UsbPortInfo>> {
+    smol::Timer::after(Duration::from_secs(1)).await;
+    let devices = SerialDetection::detect_devices();
+    if !devices.is_empty() {
+        return Some(devices);
+    } else {
+        return None;
+    }
+}
+
+// Returns a smol::Task that resolves when atleast one device is found.
+pub fn start_serial_discovery() -> Task<Option<HashMap<String, UsbPortInfo>>> {
+    smol::spawn(find_serial())
+}
+
+// This function handles a disconnection and or reconnection of Laser
+// You can easily rewrite it when we have more serialdevices
+// TODO: Add A static list of known SeriadeviceIdents
+pub async fn handle_serial_device_hotplug(
+    app_state: Arc<AppState>,
+    map: Option<HashMap<String, UsbPortInfo>>,
+) {
+    let laser_ident = SerialDeviceIdentification {
+        vendor_id: 0x0403,
+        product_id: 0x6001,
+    };
+
+    let laser = match map {
+        Some(map) => SerialDetection::get_path_by_id(laser_ident, map),
+        None => None,
+    };
+
+    let mut unique_ident: Option<MachineIdentificationUnique> = None;
+
+    {
+        let machines = app_state.machines.read_arc_blocking();
+        for (id, _) in machines.iter() {
+            if id.machine_identification == LaserMachine::MACHINE_IDENTIFICATION {
+                unique_ident = Some(id.clone());
+                break;
+            }
+        }
+    }
+
+    // Machine isnt connected, so add it back
+    if laser.is_some() && unique_ident.is_none() {
+        let serial_params = SerialDeviceNewParams {
+            path: laser.unwrap(),
+        };
+        let _ = match Laser::new_serial(&serial_params) {
+            Ok((device_identification, serial_device)) => {
+                {
+                    let mut machines = app_state.machines.write().await;
+                    machines.add_serial_device(
+                        &device_identification,
+                        serial_device,
+                        &MACHINE_REGISTRY,
+                        app_state.socketio_setup.socket_queue_tx.clone(),
+                        Arc::downgrade(&app_state.machines),
+                    );
+                }
+
+                let app_state_event = app_state.clone();
+                let main_namespace = &mut app_state_event
+                    .socketio_setup
+                    .namespaces
+                    .write()
+                    .await
+                    .main_namespace;
+                let event = MachinesEventBuilder().build(app_state_event.clone());
+                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+            }
+            _ => (),
+        };
+    } else if laser.is_none() && unique_ident.is_some() {
+        let serial_params = SerialDeviceNewParams {
+            path: "".to_string(),
+        };
+
+        let _ = match Laser::new_serial(&serial_params) {
+            Ok((device_identification, _)) => {
+                app_state
+                    .machines
+                    .write()
+                    .await
+                    .remove_serial_device(&device_identification);
+                drop(app_state.machines.clone());
+
+                app_state
+                    .machines
+                    .write_arc()
+                    .await
+                    .serial_machines
+                    .remove(&unique_ident.clone().unwrap());
+
+                app_state
+                    .machines
+                    .write_arc()
+                    .await
+                    .ethercat_machines
+                    .remove(&unique_ident.clone().unwrap());
+
+                drop(app_state.machines.clone());
+
+                let main_namespace = &mut app_state
+                    .socketio_setup
+                    .namespaces
+                    .write()
+                    .await
+                    .main_namespace;
+
+                let event = MachinesEventBuilder().build(app_state.clone());
+                main_namespace.emit(MainNamespaceEvents::MachinesEvent(event));
+            }
+            _ => (),
+        };
+    }
 }

server/src/socketio/init.rs

@@ -7,7 +7,6 @@ use socketioxide::ParserConfig;
 use socketioxide::extract::SocketRef;
 use socketioxide::layer::SocketIoLayer;
 use tracing::info_span;
-use tracing_futures::Instrument;
 
 pub async fn init_socketio(app_state: &Arc<AppState>) -> SocketIoLayer {
     // create
@@ -20,8 +19,8 @@ pub async fn init_socketio(app_state: &Arc<AppState>) -> SocketIoLayer {
     let app_state_main = app_state.clone();
 
     // set the on connect handler for main namespace
-    io.ns("/main", move |socket: SocketRef| {
-        handle_socket_connection(socket, app_state_main.clone());
+    io.ns("/main", async move |socket: SocketRef| {
+        handle_socket_connection(socket, app_state_main.clone()).await;
     });
 
     // Clone app_state for the second handler
@@ -29,8 +28,8 @@ pub async fn init_socketio(app_state: &Arc<AppState>) -> SocketIoLayer {
 
     if let Err(err) = io.dyn_ns(
         "/machine/{vendor}/{machine}/{serial}",
-        move |socket: SocketRef| {
-            handle_socket_connection(socket, app_state_machine.clone());
+        async move |socket: SocketRef| {
+            handle_socket_connection(socket, app_state_machine.clone()).await;
         },
     ) {
         tracing::error!("Failed to detect machine namespace: {}", err);
@@ -43,7 +42,7 @@ pub async fn init_socketio(app_state: &Arc<AppState>) -> SocketIoLayer {
     socketio_layer
 }
 
-fn handle_socket_connection(socket: SocketRef, app_state: Arc<AppState>) {
+async fn handle_socket_connection(socket: SocketRef, app_state: Arc<AppState>) {
     let namespace_id = match NamespaceId::from_str(socket.ns()) {
         Ok(namespace_id) => namespace_id,
         Err(err) => {
@@ -51,53 +50,49 @@ fn handle_socket_connection(socket: SocketRef, app_state: Arc<AppState>) {
             return;
         }
     };
-
-    // Setup disconnection handler
-    setup_disconnection(socket.clone(), namespace_id.clone(), app_state.clone());
-
-    // Setup connection
-    setup_connection(socket, namespace_id, app_state);
+    setup_disconnection(socket.clone(), namespace_id.clone(), app_state.clone()).await;
+    setup_connection(socket, namespace_id, app_state).await;
 }
 
-fn setup_disconnection(socket: SocketRef, namespace_id: NamespaceId, app_state: Arc<AppState>) {
-    socket.on_disconnect(move |socket: SocketRef| {
+async fn setup_disconnection(
+    socket: SocketRef,
+    namespace_id: NamespaceId,
+    app_state: Arc<AppState>,
+) {
+    socket.on_disconnect(async move |socket: SocketRef| {
         let namespace_id = namespace_id.clone();
         let app_state = app_state.clone();
 
-        // Spawn async task to avoid blocking and potential deadlocks
-        smol::spawn(async move {
-            tracing::debug!(
-                "Socket disconnected from namespace socket={:?} namespace={}",
-                socket.id,
-                namespace_id,
-            );
-            let mut socketio_namespaces_guard = app_state.socketio_setup.namespaces.write().await;
+        tracing::info!(
+            "Socket disconnected from namespace socket={:?} namespace={}",
+            socket.id,
+            namespace_id,
+        );
+        let mut socketio_namespaces_guard = app_state.socketio_setup.namespaces.write().await;
 
-            // remove from machine namespace
-            socketio_namespaces_guard
-                .apply_mut(namespace_id.clone(), &app_state, |namespace_interface| {
-                    if let Ok(namespace_interface) = namespace_interface {
-                        namespace_interface.unsubscribe(socket.clone());
-                        tracing::debug!(
-                            "Socket unsubscribed from namespace socket={:?} namespace={}",
-                            socket.id,
-                            namespace_id
-                        );
-                    } else {
-                        tracing::debug!(
-                            "Failed to unsubscribe socket from namespace socket={:?} namespace={}",
-                            socket.id,
-                            namespace_id
-                        );
-                    }
-                })
-                .await;
-        })
-        .detach();
+        // remove from machine namespace
+        socketio_namespaces_guard
+            .apply_mut(namespace_id.clone(), &app_state, |namespace_interface| {
+                if let Ok(namespace_interface) = namespace_interface {
+                    namespace_interface.unsubscribe(socket.clone());
+                    tracing::debug!(
+                        "Socket unsubscribed from namespace socket={:?} namespace={}",
+                        socket.id,
+                        namespace_id
+                    );
+                } else {
+                    tracing::debug!(
+                        "Failed to unsubscribe socket from namespace socket={:?} namespace={}",
+                        socket.id,
+                        namespace_id
+                    );
+                }
+            })
+            .await;
     });
 }
 
-fn setup_connection(socket: SocketRef, namespace_id: NamespaceId, app_state: Arc<AppState>) {
+async fn setup_connection(socket: SocketRef, namespace_id: NamespaceId, app_state: Arc<AppState>) {
     // Spawn async task to avoid blocking and potential deadlocks
     let socket_clone = socket.clone();
     let namespace_id_clone = namespace_id.clone();
@@ -109,12 +104,9 @@ fn setup_connection(socket: SocketRef, namespace_id: NamespaceId, app_state: Arc
         namespace = %namespace_id_clone,
         "Connecting socket to namespace"
     );
-
-    smol::block_on(
-        async move {
-            let mut socketio_namespaces_guard =
-                app_state_clone.socketio_setup.namespaces.write().await;
-            socketio_namespaces_guard
+    let _ = span.enter();
+    let mut socketio_namespaces_guard = app_state_clone.socketio_setup.namespaces.write().await;
+    socketio_namespaces_guard
                 .apply_mut(
                     namespace_id_clone.clone(),
                     &app_state_clone,
@@ -140,9 +132,6 @@ fn setup_connection(socket: SocketRef, namespace_id: NamespaceId, app_state: Arc
                     },
                 )
                 .await;
-        }
-        .instrument(span),
-    );
 
     tracing::info!(
         "Socket connected to namespace socket={:?} namespace={}",

server/src/socketio/queue.rs

@@ -1,15 +1,22 @@
 use crate::app_state::AppState;
+use smol::Task;
 use std::{sync::Arc, time::Instant};
-use tracing::{debug, error, info, instrument, trace};
+use tracing::{debug, info, instrument, trace};
 
 /// Send a single event with retry logic
 #[instrument(skip_all)]
-async fn send_event_with_retry(
+fn send_event_with_retry(
     socket: &socketioxide::extract::SocketRef,
     event: &Arc<control_core::socketio::event::GenericEvent>,
 ) {
+    let mut i = 0;
+    const MAX_RETRY: i32 = 10;
     // retry loop for each event
     loop {
+        if i >= MAX_RETRY {
+            return;
+        }
+        i += 1;
         // check if socket is still connected
         if !socket.connected() {
             trace!(
@@ -58,55 +65,34 @@ async fn send_event_with_retry(
     }
 }
 
-pub fn init_socketio_queue(app_state: Arc<AppState>) {
-    std::thread::Builder::new()
-        .name("socketio-queue".to_string())
-        .spawn(move || {
+async fn socketio_queue_worker(app_state: Arc<AppState>) {
+    tracing::info!("SocketIO global queue listener started");
+    let mut event_count = 0;
+    let mut batch_start = Instant::now();
 
-            let rt = tokio::runtime::Builder::new_current_thread()
-                .enable_io()
-                .enable_time()
-                .build()
-                .expect("Failed to create runtime");
+    while let Ok((socket, event)) = app_state.socketio_setup.socket_queue_rx.recv().await {
+        event_count += 1;
+        send_event_with_retry(&socket, &event);
+        if batch_start.elapsed().as_secs() >= 5 {
+            let elapsed = batch_start.elapsed();
+            if event_count > 0 {
+                debug!(
+                    "[{}::socketio_queue_worker] Processed {} events in {:.2?} ({:.1} events/s)",
+                    module_path!(),
+                    event_count,
+                    elapsed,
+                    event_count as f64 / elapsed.as_secs_f64(),
+                );
+            }
+            event_count = 0;
+            batch_start = Instant::now();
+        }
+    }
 
-            rt.block_on(async {
-                info!("SocketIO global queue listener started");
+    info!("SocketIO global queue listener stopped");
+}
 
-                let mut event_count = 0;
-                let mut batch_start = Instant::now();
-
-                loop {
-                    match app_state.socketio_setup.socket_queue_rx.recv().await {
-                        Ok((socket, event)) => {
-                            event_count += 1;
-
-                            // Handle the received message with retry logic
-                            send_event_with_retry(&socket, &event).await;
-
-                            // Log batch statistics every 5 seconds
-                            if batch_start.elapsed().as_secs() >= 5 {
-                                let elapsed = batch_start.elapsed();
-                                if event_count > 0 {
-                                    debug!(
-                                        "[{}::init_socketio_queue] Processed {} events in {:.2?} ({:.1} events/s)",
-                                        module_path!(),
-                                        event_count,
-                                        elapsed,
-                                        event_count as f64 / elapsed.as_secs_f64(),
-                                    );
-                                }
-                                event_count = 0;
-                                batch_start = Instant::now();
-                            }
-                        }
-                        Err(e) => {
-                            error!(error = %e, "Error receiving from global socketio queue");
-                            info!("SocketIO global queue listener stopping");
-                            break;
-                        }
-                    }
-                }
-            });
-        })
-        .expect("Failed to spawn socketio queue thread");
+/// Returns a spawned async task handling the Socket.IO event queue
+pub fn start_socketio_queue(app_state: Arc<AppState>) -> Task<()> {
+    smol::spawn(socketio_queue_worker(app_state))
 }