fix import issues

ts fixes
wip
2025-08-21 14:37:26 +02:00 · 2025-08-21 12:50:06 +02:00 · 2025-08-21 12:34:15 +02:00 · 2025-08-21 11:48:50 +02:00 · 2025-08-21 11:03:32 +02:00 · 2025-08-20 18:17:32 +02:00
473 changed files with 31745 additions and 97834 deletions
@@ -1,3 +0,0 @@
-.png filter=lfs diff=lfs merge=lfs -text
-.jpg filter=lfs diff=lfs merge=lfs -text
-.jpeg filter=lfs diff=lfs merge=lfs -text
@@ -1,29 +0,0 @@
-This is a machine control software project.
-
-## Repository structure
-
-### Frontend
-
-`/electron`: Frontend code for the control software built with React and Electron.
-
-### Backend
-
-`/server`: Implements machine setup & loop. Exposes a REST & Socket.io API for the electron frontend.
-`/ethercat-hal`: Hardware abstraction layer for Beckhoff (and possibly other EtherCat) devices and protocols.
-`/ethercat-hal-derive`: Macros for ethercat-hal
-`/control-core`: Generic logic for the server.
-
-### HMI Panel Operating System
-
-`/nixos`: Custom Linux with realtime kernel & preconfigured for touchscreens.
-
-### Other
-
-/docs: Documentation for the project.
-
-## Key Guidelines
-
-1. Follow Rust & Typescript best practices and idiomatic patterns
-2. Maintain existing code structure and organization
-3. Write unit tests for new functionality where applicable.
-4. Document public APIs and complex logic in code. Suggest changes to the `docs/` folder when appropriate
@@ -3,5 +3,4 @@ dist/
 .DS_Store
 Cargo.lock
 dhat-heap.json
-build.sh
-
+node_modules/
@@ -1,49 +0,0 @@
-# Canonical identities on the left, aliases on the right.
-# Format options:
-#   Canon Name <canon@example.com> <alias@example.com>
-#   Canon Name <canon@example.com> Alias Name <alias@example.com>
-
-# Icedsoda -> Philipp
-Philipp <29167146+1cedsoda@users.noreply.github.com> <29167146+1cedsoda@users.noreply.github.com>
-
-# kraemr / Robin Krämer -> Robin
-Robin <93094049+kraemr@users.noreply.github.com> <93094049+kraemr@users.noreply.github.com>
-Robin <93094049+kraemr@users.noreply.github.com> Robin Krämer <93094049+kraemr@users.noreply.github.com>
-
-# Oshgnacknak -> Josh
-Josh <osh@oshgnacknak.de> <osh@oshgnacknak.de>
-
-# Milan
-Milan <61654753+MilanVDB@users.noreply.github.com>
-
-# dependabot stays as bot
-Dependabot <49699333+dependabot[bot]@users.noreply.github.com> <49699333+dependabot[bot]@users.noreply.github.com>
-
-# Medformatik / Florian -> Florian
-Florian <dev@fwcr.de> <dev@fwcr.de>
-Florian <dev@fwcr.de> Medformatik <dev@fwcr.de>
-
-# Anatomik5 -> Alisher (merge noreply + gmail under Alisher)
-Alisher <115714693+Anatomik5@users.noreply.github.com> <115714693+Anatomik5@users.noreply.github.com>
-Alisher <115714693+Anatomik5@users.noreply.github.com> Anatomik5 <darmenovalisher@gmail.com>
-Alisher <115714693+Anatomik5@users.noreply.github.com> Darmenov Alisher <115714693+Anatomik5@users.noreply.github.com>
-
-# snacj -> Melvin
-Melvin <0xsnacj@proton.me> <0xsnacj@proton.me>
-Melvin <0xsnacj@proton.me> snacj <bbmelvin@gmx.de>
-Melvin <0xsnacj@proton.me> Melvin Spieß <0xsnacj@proton.me>
-
-# Janhegerq -> Jan
-Jan <219994445+Janhegerq@users.noreply.github.com> <219994445+Janhegerq@users.noreply.github.com>
-Jan <219994445+Janhegerq@users.noreply.github.com> <19994445+Janhegerq@users.noreply.github.com>
-
-# Christian / TheBest6337 -> christian
-Christian <christian.zschoegner@outlook.de> <christian.zschoegner@outlook.de>
-Christian <christian.zschoegner@outlook.de> TheBest6337 <christian.zschoegner@outlook.de>
-Christian <christian.zschoegner@outlook.de> Christian <80114847+TheBest6337@users.noreply.github.com>
-
-# nixos-install.sh
-nixos-install.sh <nixos-install.sh@localhost> <nixos-install.sh@localhost>
-
-# copilot-swe-agent bot
-Copilot <198982749+Copilot@users.noreply.github.com> <198982749+Copilot@users.noreply.github.com>
@@ -1,6 +1,5 @@
 {
    "typescript.inlayHints.enumMemberValues.enabled": false,
-    "git.detectSubmodules": true,
-    "git.detectSubmodulesLimit": 10,
-    "rust-analyzer.check.command": "clippy",
+     "git.detectSubmodules": true,
+     "git.detectSubmodulesLimit": 10,
 }
@@ -1,162 +1,36 @@
-# `2.11.0`
-_21.10.2025_
-
-## General 
- [#829](https://github.com/qitechgmbh/control/pull/829), [#834](https://github.com/qitechgmbh/control/pull/834), Improved overall system stability
-
-## Winder V2 
- [#840](https://github.com/qitechgmbh/control/pull/840) Added XL Winder option
- [#827](https://github.com/qitechgmbh/control/pull/827) Spool can now be run in reverse
-
-## Extruder V2
- [#826](https://github.com/qitechgmbh/control/pull/826) Fine grained Temperature-PID configuration now possible
-
-
-# `2.10.0`
-_16.10.2025_
-
-## Winder V2
- [#776](https://github.com/qitechgmbh/control/pull/776) Added explanation for padding in winder manual
- [#804](https://github.com/qitechgmbh/control/pull/804) Added gearbox conversion
-
-## General 
- [#717](https://github.com/qitechgmbh/control/pull/717) Show from option for graphs added
- [#805](https://github.com/qitechgmbh/control/pull/805) Graphs run better now
-
-
-
-# `2.9.1`
-_10.10.2025_
-
-## Winder V2
- [#796](https://github.com/qitechgmbh/control/pull/796) Winding in adaptive mode, while puller is in reverse mode is now possible
-
-## General
- [#780](https://github.com/qitechgmbh/control/pull/780) Updates are faster now
- [#746](https://github.com/qitechgmbh/control/pull/746) Improved scrollbar styling for manuals
-
-# `2.9.0`
-_06.10.2025_
-
-## Winder V2
- [#778](https://github.com/qitechgmbh/control/pull/778) Increased Winder Traverse Step size limit
-
-## General
- [#725](https://github.com/qitechgmbh/control/pull/725) Improved troubleshooting and update page
- [#625](https://github.com/qitechgmbh/control/pull/625) Improved stability of Machine-Connections
-
-
-# `2.8.0`
-_30.09.2025_
-
-
-## Laser V1
- [#741](https://github.com/qitechgmbh/control/pull/741) Added roundness measurement to two-axis Laser
-
-
-## Winder V2
- [#745](https://github.com/qitechgmbh/control/pull/745), [#756](https://github.com/qitechgmbh/control/pull/756) improved Winder Frontend
-
-## General
- [#447](https://github.com/qitechgmbh/control/pull/447) added AquaPath Machine
-
-
-
-
-# `2.7.0`
-
-_17.09.2025_
-
-## Extruder V2
-
- [#695](https://github.com/qitechgmbh/control/pull/695) Pressure and Rpm Regulation properly switch again
-
-## Winder V2
-
- [#727](https://github.com/qitechgmbh/control/pull/727) Removed estimated diameter
-
-## Laser V1
-
- [#731](https://github.com/qitechgmbh/control/pull/731) Added Laser with two-axis measurements
-
-## General
-
- [#679](https://github.com/qitechgmbh/control/pull/679),[#677](https://github.com/qitechgmbh/control/pull/677),[#698](https://github.com/qitechgmbh/control/pull/698), [#684](https://github.com/qitechgmbh/control/pull/684),[#706](https://github.com/qitechgmbh/control/pull/706) Greatly improved overall system latency and stability
-
- [#720](https://github.com/qitechgmbh/control/pull/720), [#686](https://github.com/qitechgmbh/control/pull/686) Improved User Interface
-
-# `2.6.0`
-
-_03.09.2025_
-
-## Extruder V2
-
- [#658](https://github.com/qitechgmbh/control/pull/658) Added manual
- [#639](https://github.com/qitechgmbh/control/pull/639) Swapped order of screw speed regulation buttons
-
-## Laser V1
-
- [#642](https://github.com/qitechgmbh/control/pull/642) Improved stability of laser connection
-
-## General
-
- [#657](https://github.com/qitechgmbh/control/pull/657) Time frame for graphs is now remembered
- [#641](https://github.com/qitechgmbh/control/pull/641) Removed duplicate scrollbar from manuals
-
-# `2.5.0`
-
-_27.08.2025_
-
-## Extruder V2
-
- [#595](https://github.com/qitechgmbh/control/pull/600) Simplified power graphs
- [#593](https://github.com/qitechgmbh/control/pull/599) Added identifiers for temperature sensors in temperature graph
-
-## Winder V2
-
- [#598](https://github.com/qitechgmbh/control/pull/601) Images now load properly in the manual
-
-## General
-
- [#540](https://github.com/qitechgmbh/control/pull/592) Improved readability of the presets
- [#591](https://github.com/qitechgmbh/control/pull/626) Significantly improved user interface performance and stability
-
 # `2.4.0`
-
 _14.08.2025_

-## Winder V2
-
+## Winder V2 
 - [#550](https://github.com/qitechgmbh/control/pull/551) Can now reset wound distance while winding
-
+  
 ## General
+- [#568](https://github.com/qitechgmbh/control/pull/569) switched to a Realtime Linuxkernel on nixos
+- [#574](https://github.com/qitechgmbh/control/pull/587) isolated cores 2 and 3 on nixos to guarentee strict timings for ethercat
+- [#588](https://github.com/qitechgmbh/control/pull/589) limited frontend to 30 fps to reduce cpu usage
+- [#572](https://github.com/qitechgmbh/control/pull/572) switched to io_uring to reduce latency
+

- [#568](https://github.com/qitechgmbh/control/pull/569),[#572](https://github.com/qitechgmbh/control/pull/572), [#574](https://github.com/qitechgmbh/control/pull/587) Improved EtherCAT performance
- [#588](https://github.com/qitechgmbh/control/pull/589) Improved frontend performance

 # `2.3.0`
-
 _06.08.2025_

 ## Extruder V2
-
 - [#520](https://github.com/qitechgmbh/control/pull/523) added warning message incase inverter is overloaded
 - [#501](https://github.com/qitechgmbh/control/pull/508) raised pressure limit of pressured PID mode for extruder
 - [#519](https://github.com/qitechgmbh/control/pull/549) added total power consumption monitor and graphs for voltage,current and wattage of the motor

-## Winder V2
-
+## Winder V2 
 - [#64](https://github.com/qitechgmbh/control/pull/504) added winder handbook

 ## Laser V1
-
 - [#497](https://github.com/qitechgmbh/control/pull/498) improved diameter visualisation

 ## General
-
 - [#62](https://github.com/qitechgmbh/control/pull/514),[#524](https://github.com/qitechgmbh/control/pull/528) added machine presets to load configurations
 - [#526](https://github.com/qitechgmbh/control/pull/541) added import and export of presets

+
 # `2.2.0`

 _15.07.2025_
@@ -169,7 +43,6 @@ _15.07.2025_
 - [#169](https://github.com/qitechgmbh/control/pull/492), Added a Confirmation Dialog when extruder has not reached 90% of target temperature

 ## Winder V2
-
 - [#471](https://github.com/qitechgmbh/control/pull/480), Added a live value to track the pulled distance and the option of switching to a different Mode after a given distance.

 ## General
@@ -4,26 +4,7 @@ members = [
    "ethercat-hal",
    "ethercat-hal-derive",
    "control-core",
-    "machines",
-    #"ethercat-eeprom-dump",
-    "control-core-derive",
-    "units",
+    "ethercat-eeprom-dump",
 ]
 exclude = []
 resolver = "2"
-
-[workspace.lints.clippy]
-# Individual lints (priority 0)
-
-# don't lint poissbilities for let chains because they were introduces after Rust 1.86
-collapsible_if = "allow"
-
-# Lint groups (priority -1)
-correctness = { level = "warn", priority = -1 }
-suspicious = { level = "warn", priority = -1 }
-complexity = { level = "warn", priority = -1 }
-perf = { level = "warn", priority = -1 }
-style = { level = "warn", priority = -1 }
-pendantic = { level = "warn", priority = -1 }
-cargo = { level = "warn", priority = -1 }
-nursery = { level = "warn", priority = -1 }
@@ -7,9 +7,6 @@ QiTech Control is an industrial control panel software for the next generation o
 [![](https://img.youtube.com/vi/KI3YeBwfV-s/maxresdefault.jpg)](https://www.youtube.com/watch?v=KI3YeBwfV-s)
 *Click here to watch a video demo of our software.*

-[![](https://img.youtube.com/vi/55egCAkQgyM/maxresdefault.jpg)](https://youtu.be/55egCAkQgyM) 
-*Click here to watch a full explainer Video of our Software.*
-
 # Repo Structure

 Frontend
@@ -35,7 +32,7 @@ Other

 ## Backend

-To interface with Beckhoff and other EtherCAT devices we need an EtherCAT master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.
+To interface with Beckhoff and other EtherCAT devices we need an EtherCAY master stoftware. Possibilities are [PySOEM](https://github.com/bnjmnp/pysoem) (Python), [SOEM](https://github.com/OpenEtherCATsociety/SOEM) (C) and [Ethercrab](https://github.com/ethercrab-rs/ethercrab) (Rust). For realtime operation only C and Rust are suitable. We chose Rust because of safety and confidence in the written code.

 [SocketIO](https://socket.io/) was chosen for performant event driven communication from the backend to the server. But we still use REST with [axum](https://docs.rs/axum/latest/axum/) for the communication thet benefits from the request/response model.

@@ -67,12 +64,12 @@ We could combine the code of the frontend and backend using [Doxius](https://dio
 | Machine Type | Version | Release Date | Description                 | Change to Previous Version                             | Vendor ID                  | Machine ID | Implemented | Docs                            |
 | ------------ | ------- | ------------ | --------------------------- | ------------------------------------------------------ | -------------------------- | ---------- | ----------- | ------------------------------- |
 | Winder       | V1      | ???          | Winding Filaments & Similar | -                                                      | 1 (Qitech Industries GmbH) | 1          | Reserved    | -                               |
-| Winder       | V2      | 2025         | Winding Filaments & Similar | Reengineered Traverse                                  | 1 (Qitech Industries GmbH) | 2          | Yes         | [](./docs/machines/winder-1.md) |
+| Winder       | V2      | 2025         | Winding Filaments & Similar | Reengineered Traverse                                  | 1 (Qitech Industries GmbH) | 2          | In Progress | [](./docs/machines/winder-1.md) |
 | Extruder     | V1      | ???          | Single Screw Extruder       | -                                                      | 1 (Qitech Industries GmbH) | 3          | Reserved    | -                               |
-| Extruder     | V2      | 2025         | Single Screw Extruder       | PT100 Thermometers, Optional Additional Heating Zone 4 | 1 (Qitech Industries GmbH) | 4          | Yes         |                                 |
-| Waterway     | V1      | 2025         | Filament Water Cooling      | -                                                      | 1 (Qitech Industries GmbH) | 5          | In Progress     |                                 |
-| Laser        | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Yes         |                                 |
-| Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Yes         | -                               |
+| Extruder     | V2      | 2025         | Single Screw Extruder       | PT100 Thermometers, Optional Additional Heating Zone 4 | 1 (Qitech Industries GmbH) | 4          | Not Yet     |                                 |
+| Waterway     | V1      | 2025         | Filament Water Cooling      | -                                                      | 1 (Qitech Industries GmbH) | 5          | Not Yet     |                                 |
+| Laser        | V1      | ???          | Diameter Measuring Laser    | -                                                      | 1 (Qitech Industries GmbH) | 6          | Not Yet     |                                 |
+| Mock         | -       | ???          | Mock Machine for Testing    | -                                                      | 1 (Qitech Industries GmbH) | 7          | Not Yet     | -                               |

 # More Docs

@@ -1,7 +1,5 @@
 #!/bin/bash

-set -e
-
 FEATURE=""

 # Check if "mock-machine" was passed as an argument
@@ -9,25 +7,19 @@ if [[ "$1" == "mock-machine" ]]; then
    echo "Building Debug Code with mock-machine feature"
    FEATURE="--features mock-machine"
 fi
-
 if [[ "$1" == "release" ]]; then
    echo "building Release Code"
    cargo build --release
 else
    echo "Building Debug Code"
-    cargo build $FEATURE --features development-build
+    cargo build $FEATURE
 fi

 # Only setcap if not building with mock-machine
 if [ "$1" != "mock-machine" ]; then
    echo "Setting capabilities for server executable"
-    sudo setcap 'cap_dac_override,cap_net_raw,cap_sys_nice,cap_ipc_lock=eip' ./target/debug/server
-
-    if compgen -G "/dev/ttyUSB*" > /dev/null; then
-      echo "Setting permissions for serial ports"
-      sudo chown "root:$(groups | cut -f1 -d' ')" /dev/ttyUSB*
-    fi
+    sudo setcap 'cap_net_raw,cap_sys_nice=eip' ./target/debug/server
 fi
-
 # run
 ./target/debug/server
+
@@ -1,43 +0,0 @@
-#!/bin/bash
-
-# Nix store uses sqlite ... SO HAHAHAHAHH NO CONCURRENT ACCESS AHAHAHHAHAHAHHAHAHAHAH
-time nix build .#packages.x86_64-linux.server --impure --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/server-result
-serverstore=$(readlink -f /tmp/server-result) 
-
-time nix build .#packages.x86_64-linux.electron --impure --option sandbox false --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/electron-result
-electronstore=$(readlink -f /tmp/electron-result)
-
-
-nix copy --to "file:///opt/dev-cache" \
-  $(readlink -f /tmp/server-result) \
-  $(readlink -f /tmp/electron-result) --extra-experimental-features nix-command
-
-nix store sign \
-  --key-file /opt/dev-cache/cache-private-key.pem \
-  --store "file:///opt/dev-cache" \
-  --extra-experimental-features nix-command \
-  "$serverstore" "$electronstore"
-
-
-nix path-info "$serverstore" --extra-experimental-features nix-command --extra-experimental-features flakes
-
-
-# nix verify --store "file:///opt/dev-cache" \
-#   --trusted-public-keys "$(cat /opt/dev-cache/cache-public-key.pem)" --extra-experimental-features nix-command --extra-experimental-features flakes \
-#   "$FIRST_PATH" || echo "Verification failed!" 
-
-
-#time nix build .#packages.x86_64-linux.electron --extra-experimental-features nix-command --extra-experimental-features flakes --out-link /tmp/electron-result
-#electronstore=$(readlink -f /tmp/electron-result)
-
-#nix-store --generate-binary-cache-key cache.key cache.pem --extra-experimental-features nix-command
-#nix store sign --key-file cache.key "$serverstore" --extra-experimental-features nix-command
-#nix path-info --json "$serverstore" --extra-experimental-features nix-command --extra-experimental-features flakes
-#export
-#nix-store --export /nix/store/<hash>-server > nix-cache/server.nar
-#nix-store --export /nix/store/<hash>-electron > nix-cache/electron.nar
-
-# Any http server
-# cd ~/nix-cache
-# python3 -m http.server 8080
-# 
@@ -1,15 +0,0 @@
-[package]
-name = "control_core_derive"
-version = "0.1.0"
-edition = "2024"
-
-[lints]
-workspace = true
-
-[lib]
-proc-macro = true
-
-[dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "2.0", features = ["full"] }
@@ -1,65 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use syn::{DeriveInput, Error};
-
-#[proc_macro_derive(BuildEvent)]
-pub fn build_event_derive(item: TokenStream) -> TokenStream {
-    build_event_derive2(item.into()).unwrap().into()
-}
-
-fn build_event_derive2(item: TokenStream2) -> Result<TokenStream2, Error> {
-    // Parse the input tokens into a syntax tree
-    let ast: DeriveInput = syn::parse2(item)?;
-
-    let ident = &ast.ident;
-    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-
-    // Generate the BuildEvent impl
-    let expanded = quote! {
-        impl #impl_generics control_core::socketio::event::BuildEvent for #ident #ty_generics #where_clause {
-            #[doc = "Implemented by the BuildEvent derive macro"]
-            fn build(&self) -> control_core::socketio::event::Event<Self> {
-
-                control_core::socketio::event::Event::new(stringify!(#ident), self.clone())
-
-            }
-        }
-    };
-
-    Ok(expanded)
-}
-
-#[proc_macro_derive(Machine)]
-pub fn machine_derive(item: TokenStream) -> TokenStream {
-    machine_derive2(item.into()).unwrap().into()
-}
-
-fn machine_derive2(item: TokenStream2) -> Result<TokenStream2, Error> {
-    // Parse the input tokens into a syntax tree
-    let ast: DeriveInput = syn::parse2(item)?;
-
-    let ident = &ast.ident;
-
-    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-
-    let expanded = quote! {
-        impl #impl_generics control_core::machines::Machine for #ident #ty_generics #where_clause {
-            fn get_machine_identification_unique(&self) -> control_core::machines::identification::MachineIdentificationUnique {
-                self.machine_identification_unique.clone()
-            }
-        }
-
-        impl #impl_generics control_core::machines::AnyGetters for #ident #ty_generics #where_clause {
-            fn as_any(&self) -> &dyn std::any::Any {
-                self
-            }
-
-            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-                self
-            }
-        }
-    };
-
-    Ok(expanded)
-}
@@ -3,43 +3,28 @@ name = "control_core"
 version = "0.1.0"
 edition = "2024"

-[lints]
-workspace = true
-
 [dependencies]
-anyhow = "1.0.100"
-
-axum = "0.8.6"
-
+anyhow = "1.0.98"
+axum = "0.8.4"
 ethercat_hal = { path = "../ethercat-hal" }
-units = { path = "../units" }
 ethercrab = "0.6"
 interfaces = "0.0.9"
 serde = "1.0.219"
-serialport = "4.7.3"
+serde_json = "1.0.140"
+serialport = "4.7.2"
 smol = "2.0.2"
 socketioxide = "0.17.2"
+uom = "0.36.0"
 bitvec = { version = "1.0.1", features = ["alloc"] }
 crc = "3.3.0"
+serial = "0.4.0"
 tracing = "0.1.41"
-erased-serde = "0.4.8"
+erased-serde = "0.4.6"
 core_affinity = "0.8.3"
-control_core_derive = { version = "0.1.0", path = "../control-core-derive" }
-tokio = { version = "1.45.1", features = ["sync"], optional = true }
-

 [target.'cfg(unix)'.dependencies]
-libc = "0.2.176"
+libc = "0.2.175"

 [dev-dependencies]
 approx = "0.5.1"
 textplots = "0.8"
-tokio = { version = "1.45.1", features = ["rt-multi-thread", "macros", "time"] }
-
-
-[features]
-default = []
-video-streaming = ["dep:tokio"]
-
-[package.metadata.cargo-machete]
-ignored =  ["axum","bitvec","control_core_derive"]
@@ -33,7 +33,7 @@ pub struct ClampingTimeagnosticPidController {
 }

 impl ClampingTimeagnosticPidController {
-    pub const fn new(
+    pub fn new(
        kp: f64,
        ki: f64,
        kd: f64,
@@ -65,7 +65,7 @@ impl ClampingTimeagnosticPidController {
        }
    }

-    pub const fn simple_new(kp: f64, ki: f64, kd: f64) -> Self {
+    pub fn simple_new(kp: f64, ki: f64, kd: f64) -> Self {
        Self {
            kp,
            ki,
@@ -85,26 +85,26 @@ impl ClampingTimeagnosticPidController {
        }
    }

-    pub const fn get_kp(&self) -> f64 {
+    pub fn get_kp(&self) -> f64 {
        self.kp
    }

-    pub const fn get_ki(&self) -> f64 {
+    pub fn get_ki(&self) -> f64 {
        self.ki
    }

-    pub const fn get_kd(&self) -> f64 {
+    pub fn get_kd(&self) -> f64 {
        self.kd
    }

-    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
+    pub fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
        self.reset();
        self.kp = kp;
        self.ki = ki;
        self.kd = kd;
    }

-    pub const fn optional_clamp(value: f64, min: Option<f64>, max: Option<f64>) -> f64 {
+    pub fn optional_clamp(value: f64, min: Option<f64>, max: Option<f64>) -> f64 {
        match (min, max) {
            (Some(min), Some(max)) => value.clamp(min, max),
            (Some(min), None) => value.max(min),
@@ -114,7 +114,7 @@ impl ClampingTimeagnosticPidController {
    }

    pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        match self.last {
+        let signal = match self.last {
            // First update
            None => {
                // Calculate error
@@ -122,10 +122,15 @@ impl ClampingTimeagnosticPidController {

                // Calculate signal
                let signal = self.kp * ep;
-                let clamped_signal = Self::optional_clamp(signal, self.min_signal, self.max_signal);
+                let clamped_signal = ClampingTimeagnosticPidController::optional_clamp(
+                    signal,
+                    self.min_signal,
+                    self.max_signal,
+                );

                // Set values
-                self.ep = Self::optional_clamp(ep, self.min_ep, self.max_ep);
+                self.ep =
+                    ClampingTimeagnosticPidController::optional_clamp(ep, self.min_ep, self.max_ep);
                self.ei = 0.0;
                self.ed = 0.0;
                self.last = Some(t);
@@ -138,11 +143,23 @@ impl ClampingTimeagnosticPidController {
                let dt = t.duration_since(last).as_secs_f64();

                // Calculate errors
-                let ep = Self::optional_clamp(error, self.min_ep, self.max_ep);
+                let ep = ClampingTimeagnosticPidController::optional_clamp(
+                    error,
+                    self.min_ep,
+                    self.max_ep,
+                );

-                let ei = Self::optional_clamp(ep.mul_add(dt, self.ei), self.min_ei, self.max_ei);
+                let ei = ClampingTimeagnosticPidController::optional_clamp(
+                    self.ei + ep * dt,
+                    self.min_ei,
+                    self.max_ei,
+                );

-                let ed = Self::optional_clamp((ep - self.ep) / dt, self.min_ed, self.max_ed);
+                let ed = ClampingTimeagnosticPidController::optional_clamp(
+                    (ep - self.ep) / dt,
+                    self.min_ed,
+                    self.max_ed,
+                );

                // Make factors timeagnostic
                let kp = self.kp * dt;
@@ -150,8 +167,12 @@ impl ClampingTimeagnosticPidController {
                let kd = self.kd * dt;

                // Calculate signal
-                let signal = kd.mul_add(ed, kp.mul_add(ep, ki * ei));
-                let clamped_signal = Self::optional_clamp(signal, self.min_signal, self.max_signal);
+                let signal = kp * ep + ki * ei + kd * ed;
+                let clamped_signal = ClampingTimeagnosticPidController::optional_clamp(
+                    signal,
+                    self.min_signal,
+                    self.max_signal,
+                );

                // Set values
                self.ep = ep;
@@ -161,10 +182,12 @@ impl ClampingTimeagnosticPidController {

                clamped_signal
            }
-        }
+        };
+
+        signal
    }

-    pub const fn reset(&mut self) {
+    pub fn reset(&mut self) {
        self.ep = 0.0;
        self.ei = 0.0;
        self.ed = 0.0;
@@ -22,7 +22,7 @@ pub struct AccelerationSpeedController {
 }

 impl AccelerationSpeedController {
-    pub const fn new(
+    pub fn new(
        min_speed: Option<f64>,
        max_speed: Option<f64>,
        min_acceleration: f64,
@@ -98,16 +98,16 @@ impl AccelerationSpeedController {
        new_speed
    }

-    pub const fn reset(&mut self, initial_speed: f64) {
+    pub fn reset(&mut self, initial_speed: f64) {
        self.last_speed = initial_speed;
        self.last_t = None; // Reset the last update time
    }

-    pub const fn set_max_acceleration(&mut self, acceleration: f64) {
+    pub fn set_max_acceleration(&mut self, acceleration: f64) {
        self.max_acceleration = acceleration;
    }

-    const fn apply_speed_limits(&self, speed: f64) -> f64 {
+    fn apply_speed_limits(&self, speed: f64) -> f64 {
        let mut limited_speed = speed;

        if let Some(min) = self.min_speed {
@@ -121,23 +121,23 @@ impl AccelerationSpeedController {
        limited_speed
    }

-    pub const fn get_min_speed(&self) -> Option<f64> {
+    pub fn get_min_speed(&self) -> Option<f64> {
        self.min_speed
    }

-    pub const fn get_max_speed(&self) -> Option<f64> {
+    pub fn get_max_speed(&self) -> Option<f64> {
        self.max_speed
    }

-    pub const fn set_min_speed(&mut self, min_speed: Option<f64>) {
+    pub fn set_min_speed(&mut self, min_speed: Option<f64>) {
        self.min_speed = min_speed;
    }

-    pub const fn set_max_speed(&mut self, max_speed: Option<f64>) {
+    pub fn set_max_speed(&mut self, max_speed: Option<f64>) {
        self.max_speed = max_speed;
    }

-    pub const fn set_min_acceleration(&mut self, deceleration: f64) {
+    pub fn set_min_acceleration(&mut self, deceleration: f64) {
        self.min_acceleration = deceleration;
    }
 }
@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    angular_acceleration::radian_per_second_squared,
    angular_velocity::radian_per_second,
    f64::{AngularAcceleration, AngularVelocity},
@@ -53,7 +53,7 @@ impl AngularAccelerationSpeedController {
    pub fn update(&mut self, target_speed: AngularVelocity, t: Instant) -> AngularVelocity {
        let target_speed = target_speed.get::<radian_per_second>();
        let new_speed = self.controller.update(target_speed, t);
-        AngularVelocity::new::<radian_per_second>(new_speed)
+        return AngularVelocity::new::<radian_per_second>(new_speed);
    }

    pub fn reset(&mut self, initial_speed: AngularVelocity) {
@@ -73,13 +73,13 @@ impl AngularAccelerationSpeedController {
    pub fn get_min_speed(&self) -> Option<AngularVelocity> {
        self.controller
            .get_min_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
+            .map(|s| AngularVelocity::new::<radian_per_second>(s))
    }

    pub fn get_max_speed(&self) -> Option<AngularVelocity> {
        self.controller
            .get_max_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
+            .map(|s| AngularVelocity::new::<radian_per_second>(s))
    }

    pub fn set_min_speed(&mut self, min_speed: Option<AngularVelocity>) {
@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    acceleration::meter_per_second_squared,
    f64::{Acceleration, Velocity},
    velocity::meter_per_second,
@@ -48,7 +48,7 @@ impl LinearAccelerationLimitingController {
    pub fn update(&mut self, target_speed: Velocity, t: Instant) -> Velocity {
        let target_speed = target_speed.get::<meter_per_second>();
        let new_speed = self.controller.update(target_speed, t);
-        Velocity::new::<meter_per_second>(new_speed)
+        return Velocity::new::<meter_per_second>(new_speed);
    }
    pub fn reset(&mut self, initial_speed: Velocity) {
        let initial_speed = initial_speed.get::<meter_per_second>();
@@ -65,12 +65,12 @@ impl LinearAccelerationLimitingController {
    pub fn get_min_speed(&self) -> Option<Velocity> {
        self.controller
            .get_min_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|s| Velocity::new::<meter_per_second>(s))
    }
    pub fn get_max_speed(&self) -> Option<Velocity> {
        self.controller
            .get_max_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|s| Velocity::new::<meter_per_second>(s))
    }
    pub fn set_min_speed(&mut self, min_speed: Option<Velocity>) {
        self.controller
@@ -21,7 +21,7 @@ pub struct PidController {
 }

 impl PidController {
-    pub const fn new(kp: f64, ki: f64, kd: f64) -> Self {
+    pub fn new(kp: f64, ki: f64, kd: f64) -> Self {
        Self {
            kp,
            ki,
@@ -33,27 +33,27 @@ impl PidController {
        }
    }

-    pub const fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
+    pub fn configure(&mut self, ki: f64, kp: f64, kd: f64) {
        self.reset();
        self.kp = kp;
        self.ki = ki;
        self.kd = kd;
    }

-    pub const fn get_kp(&self) -> f64 {
+    pub fn get_kp(&self) -> f64 {
        self.kp
    }

-    pub const fn get_ki(&self) -> f64 {
+    pub fn get_ki(&self) -> f64 {
        self.ki
    }

-    pub const fn get_kd(&self) -> f64 {
+    pub fn get_kd(&self) -> f64 {
        self.kd
    }

    pub fn update(&mut self, error: f64, t: Instant) -> f64 {
-        match self.last {
+        let signal = match self.last {
            // First update
            None => {
                // Calculate error
@@ -78,11 +78,11 @@ impl PidController {

                // Calculate errors
                let ep = error;
-                let ei = ep.mul_add(dt, self.ei);
+                let ei = self.ei + ep * dt;
                let ed = (ep - self.ep) / dt;

                // Calculate signal
-                let signal = self.kd.mul_add(ed, self.kp.mul_add(ep, self.ki * ei));
+                let signal = self.kp * ep + self.ki * ei + self.kd * ed;

                // Set values
                self.ep = ep;
@@ -92,10 +92,12 @@ impl PidController {

                signal
            }
-        }
+        };
+
+        signal
    }

-    pub const fn reset(&mut self) {
+    pub fn reset(&mut self) {
        self.ep = 0.0;
        self.ei = 0.0;
        self.ed = 0.0;
@@ -3,7 +3,7 @@ use std::fmt;
 // Remove the anyhow::Ok import as it conflicts with std::result::Ok

 /// Errors that can occur when creating or using the motion controller
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum MotionControllerError {
    InvalidSpeedLimits,
    InvalidAccelerationLimits,
@@ -14,25 +14,25 @@ pub enum MotionControllerError {
 impl fmt::Display for MotionControllerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            Self::InvalidSpeedLimits => {
+            MotionControllerError::InvalidSpeedLimits => {
                write!(
                    f,
                    "Invalid speed limits: min_speed must be ≤ 0 and max_speed must be ≥ 0"
                )
            }
-            Self::InvalidAccelerationLimits => {
+            MotionControllerError::InvalidAccelerationLimits => {
                write!(
                    f,
                    "Invalid acceleration limits: min_acceleration must be < 0 and max_acceleration must be > 0"
                )
            }
-            Self::InvalidPositionLimits => {
+            MotionControllerError::InvalidPositionLimits => {
                write!(
                    f,
                    "Invalid position limits: min_position must be ≤ max_position"
                )
            }
-            Self::ZeroDeceleration => {
+            MotionControllerError::ZeroDeceleration => {
                write!(
                    f,
                    "Zero deceleration rate: cannot plan motion without deceleration capability"
@@ -148,7 +148,7 @@ struct MotionConstants {
 }

 /// Represents the current phase of motion
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum MotionPhase {
    Idle,
    IncreasingSpeed,
@@ -170,7 +170,7 @@ pub struct ControllerBuilder {

 impl ControllerBuilder {
    /// Create a new builder
-    pub const fn new() -> Self {
+    pub fn new() -> Self {
        Self {
            min_speed: None,
            max_speed: None,
@@ -184,36 +184,28 @@ impl ControllerBuilder {
    }

    /// Set speed limits (min_speed ≤ 0, max_speed ≥ 0)
-    pub const fn speed_limits(mut self, min_speed: f64, max_speed: f64) -> Self {
+    pub fn speed_limits(mut self, min_speed: f64, max_speed: f64) -> Self {
        self.min_speed = Some(min_speed);
        self.max_speed = Some(max_speed);
        self
    }

    /// Set acceleration limits (min_acceleration < 0, max_acceleration > 0)
-    pub const fn acceleration_limits(
-        mut self,
-        min_acceleration: f64,
-        max_acceleration: f64,
-    ) -> Self {
+    pub fn acceleration_limits(mut self, min_acceleration: f64, max_acceleration: f64) -> Self {
        self.min_acceleration = Some(min_acceleration);
        self.max_acceleration = Some(max_acceleration);
        self
    }

    /// Set position limits (optional)
-    pub const fn position_limits(
-        mut self,
-        min_position: Option<f64>,
-        max_position: Option<f64>,
-    ) -> Self {
+    pub fn position_limits(mut self, min_position: Option<f64>, max_position: Option<f64>) -> Self {
        self.min_position = min_position;
        self.max_position = max_position;
        self
    }

    /// Set tolerances for position and speed comparisons
-    pub const fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
+    pub fn tolerances(mut self, position_tolerance: f64, speed_tolerance: f64) -> Self {
        self.position_tolerance = position_tolerance;
        self.speed_tolerance = speed_tolerance;
        self
@@ -330,7 +322,7 @@ impl AccelerationPositionController {

        let motion_constants = Self::calculate_motion_constants(&config);

-        Ok(Self {
+        Ok(AccelerationPositionController {
            config,
            current_position: 0.0,
            current_speed: 0.0,
@@ -374,19 +366,19 @@ impl AccelerationPositionController {
        }

        Self::new(
-            -speed,                     // min_speed
-            speed,                      // max_speed
-            -acceleration,              // min_acceleration
-            acceleration,               // max_acceleration
-            position.map(|p| -p.abs()), // min_position
-            position.map(|p| p.abs()),  // max_position
-            1e-6,                       // position_tolerance (default)
-            1e-6,                       // speed_tolerance (default)
+            -speed,               // min_speed
+            speed,                // max_speed
+            -acceleration,        // min_acceleration
+            acceleration,         // max_acceleration
+            position.map(|p| -p), // min_position
+            position.map(|p| p),  // max_position
+            1e-6,                 // position_tolerance (default)
+            1e-6,                 // speed_tolerance (default)
        )
    }

    /// Create a new builder for the controller
-    pub const fn builder() -> ControllerBuilder {
+    pub fn builder() -> ControllerBuilder {
        ControllerBuilder::new()
    }

@@ -572,10 +564,8 @@ impl AccelerationPositionController {

        // Calculate distance needed to reach cruise speed from current speed
        let speed_change_distance = if current_speed_in_direction < cruise_speed.abs() {
-            current_speed_in_direction.max(0.0).mul_add(
-                -current_speed_in_direction.max(0.0),
-                cruise_speed.abs().powi(2),
-            ) / (2.0 * acceleration_rate)
+            (cruise_speed.abs().powi(2) - current_speed_in_direction.max(0.0).powi(2))
+                / (2.0 * acceleration_rate)
        } else {
            0.0
        };
@@ -589,10 +579,8 @@ impl AccelerationPositionController {
            // Using corrected kinematic equation: v_peak² = v_current² + 2*a*d_total*a_accel*a_decel/(a_accel + a_decel)
            let accel_decel_factor =
                (acceleration_rate * deceleration_rate) / (acceleration_rate + deceleration_rate);
-            let discriminant = current_speed_in_direction.max(0.0).mul_add(
-                current_speed_in_direction.max(0.0),
-                2.0 * abs_position_change * accel_decel_factor,
-            );
+            let discriminant = current_speed_in_direction.max(0.0).powi(2)
+                + 2.0 * abs_position_change * accel_decel_factor;

            if discriminant >= 0.0 {
                self.peak_speed = discriminant.sqrt() * cruise_speed.signum();
@@ -646,7 +634,7 @@ impl AccelerationPositionController {
                self.current_acceleration = self.config.max_acceleration * self.direction as f64;

                // Update speed
-                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
+                let new_speed = self.current_speed + self.current_acceleration * dt;

                // Check if we've reached peak speed
                if (self.direction > 0 && new_speed >= self.peak_speed)
@@ -677,7 +665,7 @@ impl AccelerationPositionController {
                self.current_acceleration = self.config.min_acceleration * self.direction as f64;

                // Update speed
-                let new_speed = self.current_acceleration.mul_add(dt, self.current_speed);
+                let new_speed = self.current_speed + self.current_acceleration * dt;

                // Check if we've reached zero speed or target
                if (self.current_speed > 0.0 && new_speed <= 0.0)
@@ -701,7 +689,7 @@ impl AccelerationPositionController {
        }

        // Update position based on current speed
-        let new_position = self.current_speed.mul_add(dt, self.current_position);
+        let new_position = self.current_position + self.current_speed * dt;

        // Check position limits and handle violations
        let mut position_limited = false;
@@ -754,7 +742,7 @@ impl AccelerationPositionController {
    ///
    /// Returns the current position of the controlled object.
    /// This value is updated with each call to `update()`.
-    pub const fn get_position(&self) -> f64 {
+    pub fn get_position(&self) -> f64 {
        self.current_position
    }

@@ -763,7 +751,7 @@ impl AccelerationPositionController {
    /// Returns the current speed (velocity) of the controlled object.
    /// Positive values indicate motion towards increasing position,
    /// negative values indicate motion towards decreasing position.
-    pub const fn get_speed(&self) -> f64 {
+    pub fn get_speed(&self) -> f64 {
        self.current_speed
    }

@@ -771,32 +759,32 @@ impl AccelerationPositionController {
    ///
    /// Returns the current acceleration of the controlled object.
    /// Positive values indicate increasing speed, negative values indicate decreasing speed.
-    pub const fn get_acceleration(&self) -> f64 {
+    pub fn get_acceleration(&self) -> f64 {
        self.current_acceleration
    }

    /// Get the target position
-    pub const fn get_target_position(&self) -> f64 {
+    pub fn get_target_position(&self) -> f64 {
        self.target_position
    }

    /// Get the current motion phase
-    pub const fn get_motion_phase(&self) -> MotionPhase {
+    pub fn get_motion_phase(&self) -> MotionPhase {
        self.motion_phase
    }

    /// Get the direction of motion
-    pub const fn get_direction(&self) -> i8 {
+    pub fn get_direction(&self) -> i8 {
        self.direction
    }

    /// Get the calculated peak speed for current motion
-    pub const fn get_peak_speed(&self) -> f64 {
+    pub fn get_peak_speed(&self) -> f64 {
        self.peak_speed
    }

    /// Get the position at which deceleration will begin
-    pub const fn get_deceleration_position(&self) -> f64 {
+    pub fn get_deceleration_position(&self) -> f64 {
        self.deceleration_position
    }

@@ -849,7 +837,7 @@ impl AccelerationPositionController {
    }

    /// Force the controller to stop at current position
-    pub const fn emergency_stop(&mut self) {
+    pub fn emergency_stop(&mut self) {
        self.target_position = self.current_position;
        self.current_speed = 0.0;
        self.current_acceleration = 0.0;
@@ -1018,32 +1006,32 @@ impl AccelerationPositionController {
    }

    /// Get the minimum speed limit
-    pub const fn get_min_speed(&self) -> f64 {
+    pub fn get_min_speed(&self) -> f64 {
        self.config.min_speed
    }

    /// Get the maximum speed limit
-    pub const fn get_max_speed(&self) -> f64 {
+    pub fn get_max_speed(&self) -> f64 {
        self.config.max_speed
    }

    /// Get the minimum acceleration limit
-    pub const fn get_min_acceleration(&self) -> f64 {
+    pub fn get_min_acceleration(&self) -> f64 {
        self.config.min_acceleration
    }

    /// Get the maximum acceleration limit
-    pub const fn get_max_acceleration(&self) -> f64 {
+    pub fn get_max_acceleration(&self) -> f64 {
        self.config.max_acceleration
    }

    /// Get the minimum position limit
-    pub const fn get_min_position(&self) -> Option<f64> {
+    pub fn get_min_position(&self) -> Option<f64> {
        self.config.min_position
    }

    /// Get the maximum position limit
-    pub const fn get_max_position(&self) -> Option<f64> {
+    pub fn get_max_position(&self) -> Option<f64> {
        self.config.max_position
    }

@@ -1080,17 +1068,17 @@ impl AccelerationPositionController {
    }

    /// Get the position tolerance
-    pub const fn get_position_tolerance(&self) -> f64 {
+    pub fn get_position_tolerance(&self) -> f64 {
        self.config.position_tolerance
    }

    /// Get the speed tolerance
-    pub const fn get_speed_tolerance(&self) -> f64 {
+    pub fn get_speed_tolerance(&self) -> f64 {
        self.config.speed_tolerance
    }

    /// Set tolerances for position and speed comparisons
-    pub const fn set_tolerances(&mut self, position_tolerance: f64, speed_tolerance: f64) {
+    pub fn set_tolerances(&mut self, position_tolerance: f64, speed_tolerance: f64) {
        self.config.position_tolerance = position_tolerance;
        self.config.speed_tolerance = speed_tolerance;
    }
@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    angle::radian,
    angular_acceleration::radian_per_second_squared,
    angular_velocity::radian_per_second,
@@ -102,12 +102,16 @@ impl AngularAccelerationPositionController {

    /// Get the minimum angle position limit
    pub fn get_min_position(&self) -> Option<Angle> {
-        self.controller.get_min_position().map(Angle::new::<radian>)
+        self.controller
+            .get_min_position()
+            .map(|angle| Angle::new::<radian>(angle))
    }

    /// Get the maximum angle position limit
    pub fn get_max_position(&self) -> Option<Angle> {
-        self.controller.get_max_position().map(Angle::new::<radian>)
+        self.controller
+            .get_max_position()
+            .map(|angle| Angle::new::<radian>(angle))
    }

    /// Set the minimum angle position limit
@@ -199,8 +203,8 @@ impl AngularAccelerationPositionController {
    /// # Example
    /// ```ignore
    /// use control_core::controllers::second_degree_motion::angular_acceleration_position_controller::AngularAccelerationPositionController;
-    /// use units::f64::Angle;
-    /// use units::angle::degree;
+    /// use uom::si::f64::Angle;
+    /// use uom::si::angle::degree;
    ///
    /// let mut controller = AngularAccelerationPositionController::new_simple(
    ///     Some(Angle::new::<degree>(180.0)),
@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    angular_acceleration::radian_per_second_squared,
    angular_jerk::radian_per_second_cubed,
    angular_velocity::radian_per_second,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     angular_velocity::revolution_per_minute,
 ///     angular_acceleration::revolution_per_minute_per_second,
 ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -65,7 +65,7 @@ impl AngularJerkSpeedController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{
+    /// use uom::si::{
    ///     angular_velocity::revolution_per_minute,
    ///     angular_acceleration::revolution_per_minute_per_second,
    ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -127,7 +127,7 @@ impl AngularJerkSpeedController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{
+    /// use uom::si::{
    ///     angular_velocity::revolution_per_minute,
    ///     angular_acceleration::revolution_per_minute_per_second,
    ///     angular_jerk::revolution_per_minute_per_second_squared,
@@ -185,7 +185,7 @@ impl AngularJerkSpeedController {
    /// # Example
    /// ```ignore
    /// use std::time::Instant;
-    /// use units::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
+    /// use uom::si::{angular_velocity::revolution_per_minute, f64::AngularVelocity};
    ///
    /// let mut controller = AngularJerkSpeedController::new_simple(/* ... */);
    /// let target = AngularVelocity::new::<revolution_per_minute>(1500.0);
@@ -236,7 +236,7 @@ impl AngularJerkSpeedController {
    pub fn get_min_speed(&self) -> Option<AngularVelocity> {
        self.controller
            .get_min_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
+            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
    }

    /// Get the maximum angular velocity limit
@@ -248,7 +248,7 @@ impl AngularJerkSpeedController {
    pub fn get_max_speed(&self) -> Option<AngularVelocity> {
        self.controller
            .get_max_speed()
-            .map(AngularVelocity::new::<radian_per_second>)
+            .map(|speed| AngularVelocity::new::<radian_per_second>(speed))
    }

    /// Set the minimum angular velocity limit
@@ -88,7 +88,7 @@ impl JerkSpeedController {
        )
        .expect("Failed to create AccelerationPositionController");

-        Self { base_controller }
+        JerkSpeedController { base_controller }
    }

    /// Create a new speed controller with simple symmetric limits
@@ -183,7 +183,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Current speed as a floating-point value
-    pub const fn get_speed(&self) -> f64 {
+    pub fn get_speed(&self) -> f64 {
        self.base_controller.get_position()
    }

@@ -193,7 +193,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Current acceleration as a floating-point value
-    pub const fn get_acceleration(&self) -> f64 {
+    pub fn get_acceleration(&self) -> f64 {
        self.base_controller.get_speed()
    }

@@ -203,7 +203,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Current jerk as a floating-point value
-    pub const fn get_jerk(&self) -> f64 {
+    pub fn get_jerk(&self) -> f64 {
        self.base_controller.get_acceleration()
    }

@@ -213,7 +213,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Target speed as a floating-point value
-    pub const fn get_target_speed(&self) -> f64 {
+    pub fn get_target_speed(&self) -> f64 {
        self.base_controller.get_target_position()
    }

@@ -223,7 +223,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Minimum speed limit as an Option<f64>, None if no limit is set
-    pub const fn get_min_speed(&self) -> Option<f64> {
+    pub fn get_min_speed(&self) -> Option<f64> {
        self.base_controller.get_min_position()
    }

@@ -233,7 +233,7 @@ impl JerkSpeedController {
    ///
    /// # Returns
    /// Maximum speed limit as an Option<f64>, None if no limit is set
-    pub const fn get_max_speed(&self) -> Option<f64> {
+    pub fn get_max_speed(&self) -> Option<f64> {
        self.base_controller.get_max_position()
    }

@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    acceleration::meter_per_second_squared,
    f64::{Acceleration, Length, Velocity},
    length::meter,
@@ -22,8 +22,8 @@ use super::acceleration_position_controller::{
 ///
 /// # Example
 /// ```ignore
-/// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-/// use units::f64::{Length, Velocity, Acceleration};
+/// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+/// use uom::si::f64::{Length, Velocity, Acceleration};
 ///
 /// let position_limit = Length::new::<meter>(10.0);
 /// let max_speed = Velocity::new::<meter_per_second>(2.0);
@@ -101,8 +101,8 @@ impl LinearAccelerationPositionController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
-    /// use units::f64::{Length, Velocity, Acceleration};
+    /// use uom::si::{length::meter, velocity::meter_per_second, acceleration::meter_per_second_squared};
+    /// use uom::si::f64::{Length, Velocity, Acceleration};
    ///
    /// let position_limit = Length::new::<meter>(5.0);  // Creates [-5.0, +5.0] meter range
    /// let max_speed = Velocity::new::<meter_per_second>(1.0);  // Creates [-1.0, +1.0] m/s range
@@ -150,7 +150,7 @@ impl LinearAccelerationPositionController {
    /// # Example
    /// ```ignore
    /// use std::time::Instant;
-    /// use units::{length::meter, f64::Length};
+    /// use uom::si::{length::meter, f64::Length};
    ///
    /// let mut controller = LinearAccelerationPositionController::new_simple(
    ///     Some(Length::new::<meter>(10.0)),
@@ -205,7 +205,9 @@ impl LinearAccelerationPositionController {
    /// # Returns
    /// Minimum position limit as an Option<Length>, None if no limit is set
    pub fn get_min_position(&self) -> Option<Length> {
-        self.controller.get_min_position().map(Length::new::<meter>)
+        self.controller
+            .get_min_position()
+            .map(|length| Length::new::<meter>(length))
    }

    /// Get the maximum position limit
@@ -215,7 +217,9 @@ impl LinearAccelerationPositionController {
    /// # Returns  
    /// Maximum position limit as an Option<Length>, None if no limit is set
    pub fn get_max_position(&self) -> Option<Length> {
-        self.controller.get_max_position().map(Length::new::<meter>)
+        self.controller
+            .get_max_position()
+            .map(|length| Length::new::<meter>(length))
    }

    /// Set the minimum position limit
@@ -375,7 +379,7 @@ impl LinearAccelerationPositionController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
+    /// use uom::si::{length::meter, velocity::meter_per_second, f64::{Length, Velocity}};
    ///
    /// let new_position = Length::new::<meter>(0.0);
    ///
@@ -1,6 +1,6 @@
 use std::time::Instant;

-use units::{
+use uom::si::{
    acceleration::meter_per_second_squared,
    f64::{Acceleration, Jerk, Velocity},
    jerk::meter_per_second_cubed,
@@ -23,7 +23,7 @@ use super::jerk_speed_controller::JerkSpeedController;
 ///
 /// # Example
 /// ```ignore
-/// use units::{
+/// use uom::si::{
 ///     velocity::meter_per_second,
 ///     acceleration::meter_per_second_squared,
 ///     jerk::meter_per_second_cubed,
@@ -65,7 +65,7 @@ impl LinearJerkSpeedController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{
+    /// use uom::si::{
    ///     velocity::meter_per_second,
    ///     acceleration::meter_per_second_squared,
    ///     jerk::meter_per_second_cubed,
@@ -127,7 +127,7 @@ impl LinearJerkSpeedController {
    ///
    /// # Example
    /// ```ignore
-    /// use units::{
+    /// use uom::si::{
    ///     velocity::meter_per_second,
    ///     acceleration::meter_per_second_squared,
    ///     jerk::meter_per_second_cubed,
@@ -195,14 +195,14 @@ impl LinearJerkSpeedController {
    pub fn get_min_speed(&self) -> Option<Velocity> {
        self.controller
            .get_min_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|speed| Velocity::new::<meter_per_second>(speed))
    }

    /// Get the maximum velocity limit
    pub fn get_max_speed(&self) -> Option<Velocity> {
        self.controller
            .get_max_speed()
-            .map(Velocity::new::<meter_per_second>)
+            .map(|speed| Velocity::new::<meter_per_second>(speed))
    }

    /// Set the minimum velocity limit
@@ -1,6 +1,8 @@
-use units::{angle::radian, f64::Angle};
+use std::f32::consts::PI;

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+use uom::si::angle::radian;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct AngleConverter {
    pub flip_x: bool, // true to flip X-axis (mirror horizontally)
    pub flip_y: bool, // true to flip Y-axis (mirror vertically)
@@ -9,7 +11,7 @@ pub struct AngleConverter {

 impl AngleConverter {
    /// Create a custom coordinate system
-    pub const fn new(flip_x: bool, flip_y: bool, is_cw: bool) -> Self {
+    pub fn new(flip_x: bool, flip_y: bool, is_cw: bool) -> Self {
        Self {
            flip_x,
            flip_y,
@@ -18,52 +20,52 @@ impl AngleConverter {
    }

    /// Standard mathematical coordinate system (CCW positive, 0° at positive X)
-    pub const fn mathematical() -> Self {
+    pub fn mathematical() -> Self {
        Self::new(false, false, false)
    }

    /// Screen/graphics coordinate system (CW positive, 0° at positive X, Y-flipped)
-    pub const fn screen() -> Self {
+    pub fn screen() -> Self {
        Self::new(false, true, false)
    }

    /// System where 0° points up, clockwise positive
-    pub const fn y_up_cw() -> Self {
+    pub fn y_up_cw() -> Self {
        Self::new(false, false, true)
    }

    /// System where 0° points down, counter-clockwise positive
-    pub const fn y_down_ccw() -> Self {
+    pub fn y_down_ccw() -> Self {
        Self::new(false, true, true)
    }

    /// System where 0° points left, clockwise positive
-    pub const fn x_left_cw() -> Self {
+    pub fn x_left_cw() -> Self {
        Self::new(true, false, false)
    }

    /// System where 0° points right, counter-clockwise positive (same as mathematical)
-    pub const fn x_right_ccw() -> Self {
+    pub fn x_right_ccw() -> Self {
        Self::mathematical()
    }

    /// System where 0° points up, counter-clockwise positive
-    pub const fn y_up_ccw() -> Self {
+    pub fn y_up_ccw() -> Self {
        Self::new(false, false, false)
    }

    /// System where 0° points down, clockwise positive
-    pub const fn y_down_cw() -> Self {
+    pub fn y_down_cw() -> Self {
        Self::new(false, true, false)
    }

    /// System where 0° points left, counter-clockwise positive
-    pub const fn x_left_ccw() -> Self {
+    pub fn x_left_ccw() -> Self {
        Self::new(true, false, true)
    }

    /// Convert angle from mathematical system to this system (f32)
-    pub fn degrees_encode(&self, math_angle_degrees: f64) -> f64 {
+    pub fn degrees_encode(&self, math_angle_degrees: f32) -> f32 {
        let normalized_input = self.normalize_angle(math_angle_degrees);

        let mut result = normalized_input;
@@ -73,7 +75,7 @@ impl AngleConverter {
            (false, false) => {}                      // No change
            (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
            (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result += 180.0,          // Both flips: 180° rotation
+            (true, true) => result = 180.0 + result,  // Both flips: 180° rotation
        }

        // Handle rotation direction
@@ -85,7 +87,7 @@ impl AngleConverter {
    }

    /// Convert angle from this system to mathematical system (f32)
-    pub fn degrees_decode(&self, system_angle_degrees: f64) -> f64 {
+    pub fn degrees_decode(&self, system_angle_degrees: f32) -> f32 {
        let normalized_input = self.normalize_angle(system_angle_degrees);

        let mut result = normalized_input;
@@ -100,24 +102,24 @@ impl AngleConverter {
            (false, false) => {}                      // No change
            (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
            (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result -= 180.0,          // Both flips: inverse 180° rotation
+            (true, true) => result = result - 180.0,  // Both flips: inverse 180° rotation
        }

        self.normalize_angle(result)
    }

    /// Convert angle in radians from mathematical system to this system (f32)
-    pub fn radians_encode(&self, math_angle_radians: f64) -> f64 {
-        let degrees = math_angle_radians.to_degrees();
+    pub fn radians_encode(&self, math_angle_radians: f32) -> f32 {
+        let degrees = math_angle_radians * 180.0 / PI;
        let converted_degrees = self.degrees_encode(degrees);
-        converted_degrees.to_radians()
+        converted_degrees * PI / 180.0
    }

    /// Convert angle in radians from this system to mathematical system (f32)
-    pub fn radians_decode(&self, system_angle_radians: f64) -> f64 {
-        let degrees = system_angle_radians.to_degrees();
+    pub fn radians_decode(&self, system_angle_radians: f32) -> f32 {
+        let degrees = system_angle_radians * 180.0 / PI;
        let converted_degrees = self.degrees_decode(degrees);
-        converted_degrees.to_radians()
+        converted_degrees * PI / 180.0
    }

    /// Convert angle from mathematical system to this system (f64)
@@ -131,7 +133,7 @@ impl AngleConverter {
            (false, false) => {}                      // No change
            (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
            (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result += 180.0,          // Both flips: 180° rotation
+            (true, true) => result = 180.0 + result,  // Both flips: 180° rotation
        }

        // Handle rotation direction
@@ -158,7 +160,7 @@ impl AngleConverter {
            (false, false) => {}                      // No change
            (true, false) => result = 180.0 - result, // X-flip: mirror across Y-axis
            (false, true) => result = -result,        // Y-flip: mirror across X-axis
-            (true, true) => result -= 180.0,          // Both flips: inverse 180° rotation
+            (true, true) => result = result - 180.0,  // Both flips: inverse 180° rotation
        }

        self.normalize_angle_f64(result)
@@ -166,20 +168,20 @@ impl AngleConverter {

    /// Convert angle in radians from mathematical system to this system (f64)
    pub fn radians_encode_f64(&self, math_angle_radians: f64) -> f64 {
-        let degrees = math_angle_radians.to_degrees();
+        let degrees = math_angle_radians * 180.0 / std::f64::consts::PI;
        let converted_degrees = self.degrees_encode_f64(degrees);
-        converted_degrees.to_radians()
+        converted_degrees * std::f64::consts::PI / 180.0
    }

    /// Convert angle in radians from this system to mathematical system (f64)
    pub fn radians_decode_f64(&self, system_angle_radians: f64) -> f64 {
-        let degrees = system_angle_radians.to_degrees();
+        let degrees = system_angle_radians * 180.0 / std::f64::consts::PI;
        let converted_degrees = self.degrees_decode_f64(degrees);
-        converted_degrees.to_radians()
+        converted_degrees * std::f64::consts::PI / 180.0
    }

    /// Normalize angle to [0, 360) range (f32)
-    fn normalize_angle(&self, angle: f64) -> f64 {
+    fn normalize_angle(&self, angle: f32) -> f32 {
        let mut normalized = angle % 360.0;
        if normalized < 0.0 {
            normalized += 360.0;
@@ -203,23 +205,39 @@ pub struct AngleConverterUom {
 }

 impl AngleConverterUom {
-    pub const fn new(angle_converter: AngleConverter) -> Self {
+    pub fn new(angle_converter: AngleConverter) -> Self {
        Self { angle_converter }
    }

-    pub fn encode(&self, angle: Angle) -> Angle {
-        Angle::new::<radian>(self.angle_converter.radians_encode(angle.get::<radian>()))
+    pub fn encode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
+        uom::si::f32::Angle::new::<radian>(
+            self.angle_converter.radians_encode(angle.get::<radian>()),
+        )
    }

-    pub fn decode(&self, angle: Angle) -> Angle {
-        Angle::new::<radian>(self.angle_converter.radians_decode(angle.get::<radian>()))
+    pub fn decode(&self, angle: uom::si::f32::Angle) -> uom::si::f32::Angle {
+        uom::si::f32::Angle::new::<radian>(
+            self.angle_converter.radians_decode(angle.get::<radian>()),
+        )
+    }
+
+    pub fn encode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
+        uom::si::f64::Angle::new::<radian>(
+            self.angle_converter
+                .radians_encode_f64(angle.get::<radian>()),
+        )
+    }
+
+    pub fn decode_f64(&self, angle: uom::si::f64::Angle) -> uom::si::f64::Angle {
+        uom::si::f64::Angle::new::<radian>(
+            self.angle_converter
+                .radians_decode_f64(angle.get::<radian>()),
+        )
    }
 }

 #[cfg(test)]
 mod tests {
-    use std::f32::consts::PI;
-
    use super::*;

    #[test]
@@ -279,8 +297,8 @@ mod tests {
        let converter = AngleConverter::screen();

        // Test radians_encode
-        let result = converter.radians_encode(PI as f64 / 2.0) as f64; // 90° in radians
-        let expected: f64 = 270.0f64 * PI as f64 / 180.0f64; // 270° in radians
+        let result = converter.radians_encode(PI / 2.0); // 90° in radians
+        let expected = 270.0 * PI / 180.0; // 270° in radians
        assert!((result - expected).abs() < 1e-6);
    }

@@ -288,10 +306,10 @@ mod tests {
    fn test_roundtrip_conversion() {
        let converter = AngleConverter::new(true, false, true); // X-flip + CW

-        let original = 75.0_f64;
+        let original = 75.0_f32;
        let converted = converter.degrees_encode(original);
        let roundtrip = converter.degrees_decode(converted);

-        assert!((original - roundtrip as f64).abs() < 1e-6);
+        assert!((original - roundtrip).abs() < 1e-6);
    }
 }
@@ -1,4 +1,4 @@
-use units::{
+use uom::si::{
    angle::revolution,
    angular_acceleration::radian_per_second_squared,
    angular_velocity::revolution_per_second,
@@ -18,7 +18,7 @@ pub struct AngularStepConverter {

 impl AngularStepConverter {
    /// Create a new converter with the specified steps per revolution
-    pub const fn new(steps_per_revolution: i16) -> Self {
+    pub fn new(steps_per_revolution: i16) -> Self {
        Self {
            steps_per_revolution,
        }
@@ -90,7 +90,7 @@ mod tests {
    use super::*;
    use approx::assert_relative_eq;
    use std::f64::EPSILON;
-    use units::{
+    use uom::si::{
        angle::degree, angular_acceleration::degree_per_second_squared,
        angular_velocity::degree_per_second,
    };
@@ -1,279 +0,0 @@
-//! # Circular Converter
-//!
-//! This module provides the `CircularConverter` which handles transformations between
-//! linear and angular measurements for circular motion systems.
-//!
-//! ## Usage
-//!
-//! The `CircularConverter` is designed to work alongside other converters:
-//! - Use `AngularStepConverter` for angular-to-step conversions
-//! - Use `LinearStepConverter` for complete linear-to-step conversions (uses `CircularConverter` internally)
-//! - Use `CircularConverter` directly when you need linear-to-angular conversions without steps
-//!
-//! ## Examples
-//!
-//! ```rust
-//! use control_core::converters::circular_converter::CircularConverter;
-//! use units::{f64::{Length, Velocity}, length::meter, velocity::meter_per_second};
-//!
-//! let converter = CircularConverter::from_radius(Length::new::<meter>(0.1));
-//! let velocity = Velocity::new::<meter_per_second>(1.0);
-//! let angular_velocity = converter.linear_to_angular_velocity(velocity);
-//! ```
-
-use units::{
-    acceleration::meter_per_second_squared,
-    angle::radian,
-    angular_acceleration::radian_per_second_squared,
-    angular_velocity::radian_per_second,
-    f64::{Acceleration, Angle, AngularAcceleration, AngularVelocity, Length, Velocity},
-    length::meter,
-    velocity::meter_per_second,
-};
-
-/// A converter that handles transformations between linear and angular measurements
-/// for circular motion. This includes conversions for position, velocity, acceleration,
-/// and higher-order derivatives based on a circle's geometric properties.
-#[derive(Debug, Clone)]
-pub struct CircularConverter {
-    radius: Length,
-    circumference: Length,
-    diameter: Length,
-}
-
-impl CircularConverter {
-    /// Create a new converter from radius
-    pub fn from_radius(radius: Length) -> Self {
-        let diameter = radius * 2.0;
-        let circumference =
-            Length::new::<meter>(2.0 * std::f64::consts::PI * radius.get::<meter>());
-        Self {
-            radius,
-            diameter,
-            circumference,
-        }
-    }
-
-    /// Create a new converter from diameter
-    pub fn from_diameter(diameter: Length) -> Self {
-        let radius = diameter / 2.0;
-        Self::from_radius(radius)
-    }
-
-    /// Create a new converter from circumference
-    pub fn from_circumference(circumference: Length) -> Self {
-        let radius =
-            Length::new::<meter>(circumference.get::<meter>() / (2.0 * std::f64::consts::PI));
-        Self::from_radius(radius)
-    }
-
-    /// Get the radius
-    pub fn radius(&self) -> Length {
-        self.radius
-    }
-
-    /// Get the diameter
-    pub fn diameter(&self) -> Length {
-        self.diameter
-    }
-
-    /// Get the circumference
-    pub fn circumference(&self) -> Length {
-        self.circumference
-    }
-
-    // Linear to Angular Position Conversions
-
-    /// Convert linear distance to angular position
-    /// Formula: angle = distance / radius
-    pub fn linear_to_angular_position(&self, distance: Length) -> Angle {
-        let angle_rad = distance.get::<meter>() / self.radius.get::<meter>();
-        Angle::new::<radian>(angle_rad)
-    }
-
-    /// Convert angular position to linear distance
-    /// Formula: distance = angle * radius
-    pub fn angular_to_linear_position(&self, angle: Angle) -> Length {
-        let distance = angle.get::<radian>() * self.radius.get::<meter>();
-        Length::new::<meter>(distance)
-    }
-
-    // Linear to Angular Velocity Conversions
-
-    /// Convert linear velocity to angular velocity
-    /// Formula: angular_velocity = linear_velocity / radius
-    pub fn linear_to_angular_velocity(&self, velocity: Velocity) -> AngularVelocity {
-        let angular_velocity_rad_per_s =
-            velocity.get::<meter_per_second>() / self.radius.get::<meter>();
-        AngularVelocity::new::<radian_per_second>(angular_velocity_rad_per_s)
-    }
-
-    /// Convert angular velocity to linear velocity
-    /// Formula: linear_velocity = angular_velocity * radius
-    pub fn angular_to_linear_velocity(&self, angular_velocity: AngularVelocity) -> Velocity {
-        let velocity = angular_velocity.get::<radian_per_second>() * self.radius.get::<meter>();
-        Velocity::new::<meter_per_second>(velocity)
-    }
-
-    // Linear to Angular Acceleration Conversions
-
-    /// Convert linear acceleration to angular acceleration
-    /// Formula: angular_acceleration = linear_acceleration / radius
-    pub fn linear_to_angular_acceleration(
-        &self,
-        acceleration: Acceleration,
-    ) -> AngularAcceleration {
-        let angular_acceleration_rad_per_s2 =
-            acceleration.get::<meter_per_second_squared>() / self.radius.get::<meter>();
-        AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2)
-    }
-
-    /// Convert angular acceleration to linear acceleration
-    /// Formula: linear_acceleration = angular_acceleration * radius
-    pub fn angular_to_linear_acceleration(
-        &self,
-        angular_acceleration: AngularAcceleration,
-    ) -> Acceleration {
-        let acceleration =
-            angular_acceleration.get::<radian_per_second_squared>() * self.radius.get::<meter>();
-        Acceleration::new::<meter_per_second_squared>(acceleration)
-    }
-
-    // Jerk Conversions (using f64 for now since UOM may not have jerk units)
-
-    /// Convert linear jerk to angular jerk
-    /// Formula: angular_jerk = linear_jerk / radius
-    /// Units: rad/s³ = (m/s³) / m
-    pub fn linear_to_angular_jerk(&self, linear_jerk: f64) -> f64 {
-        linear_jerk / self.radius.get::<meter>()
-    }
-
-    /// Convert angular jerk to linear jerk
-    /// Formula: linear_jerk = angular_jerk * radius
-    /// Units: m/s³ = (rad/s³) * m
-    pub fn angular_to_linear_jerk(&self, angular_jerk: f64) -> f64 {
-        angular_jerk * self.radius.get::<meter>()
-    }
-
-    // Arc Length Calculations
-
-    /// Calculate arc length from angle
-    /// Formula: arc_length = angle * radius
-    pub fn angle_to_arc_length(&self, angle: Angle) -> Length {
-        self.angular_to_linear_position(angle)
-    }
-
-    /// Calculate angle from arc length
-    /// Formula: angle = arc_length / radius
-    pub fn arc_length_to_angle(&self, arc_length: Length) -> Angle {
-        self.linear_to_angular_position(arc_length)
-    }
-
-    // Circumference-based calculations
-
-    /// Convert linear distance to number of revolutions
-    /// Formula: revolutions = distance / circumference
-    pub fn linear_distance_to_revolutions(&self, distance: Length) -> f64 {
-        distance.get::<meter>() / self.circumference.get::<meter>()
-    }
-
-    /// Convert number of revolutions to linear distance
-    /// Formula: distance = revolutions * circumference
-    pub fn revolutions_to_linear_distance(&self, revolutions: f64) -> Length {
-        Length::new::<meter>(revolutions * self.circumference.get::<meter>())
-    }
-
-    /// Convert linear velocity to revolutions per second
-    /// Formula: rps = velocity / circumference
-    pub fn linear_velocity_to_rps(&self, velocity: Velocity) -> f64 {
-        velocity.get::<meter_per_second>() / self.circumference.get::<meter>()
-    }
-
-    /// Convert revolutions per second to linear velocity
-    /// Formula: velocity = rps * circumference
-    pub fn rps_to_linear_velocity(&self, rps: f64) -> Velocity {
-        Velocity::new::<meter_per_second>(rps * self.circumference.get::<meter>())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use units::length::centimeter;
-
-    #[test]
-    fn test_constructors() {
-        let radius = Length::new::<centimeter>(5.0);
-        let diameter = Length::new::<centimeter>(10.0);
-        let circumference = Length::new::<centimeter>(2.0 * std::f64::consts::PI * 5.0);
-
-        let converter1 = CircularConverter::from_radius(radius);
-        let converter2 = CircularConverter::from_diameter(diameter);
-        let converter3 = CircularConverter::from_circumference(circumference);
-
-        // All should have approximately the same values
-        assert!((converter1.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
-        assert!((converter2.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
-        assert!((converter3.radius().get::<centimeter>() - 5.0).abs() < 1e-10);
-
-        assert!((converter1.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
-        assert!((converter2.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
-        assert!((converter3.diameter().get::<centimeter>() - 10.0).abs() < 1e-10);
-    }
-
-    #[test]
-    fn test_position_conversions() {
-        let converter = CircularConverter::from_radius(Length::new::<meter>(1.0));
-
-        // Test linear to angular
-        let distance = Length::new::<meter>(std::f64::consts::PI);
-        let angle = converter.linear_to_angular_position(distance);
-        assert!((angle.get::<radian>() - std::f64::consts::PI).abs() < 1e-10);
-
-        // Test angular to linear
-        let angle = Angle::new::<radian>(std::f64::consts::PI / 2.0);
-        let distance = converter.angular_to_linear_position(angle);
-        assert!((distance.get::<meter>() - std::f64::consts::PI / 2.0).abs() < 1e-10);
-    }
-
-    #[test]
-    fn test_velocity_conversions() {
-        let converter = CircularConverter::from_radius(Length::new::<meter>(0.5));
-
-        // Test linear to angular
-        let velocity = Velocity::new::<meter_per_second>(1.0);
-        let angular_velocity = converter.linear_to_angular_velocity(velocity);
-        assert!((angular_velocity.get::<radian_per_second>() - 2.0).abs() < 1e-10);
-
-        // Test angular to linear
-        let angular_velocity = AngularVelocity::new::<radian_per_second>(4.0);
-        let velocity = converter.angular_to_linear_velocity(angular_velocity);
-        assert!((velocity.get::<meter_per_second>() - 2.0).abs() < 1e-10);
-    }
-
-    #[test]
-    fn test_revolution_conversions() {
-        let converter = CircularConverter::from_radius(Length::new::<meter>(1.0));
-
-        // One full revolution should equal circumference
-        let revolutions = 1.0;
-        let distance = converter.revolutions_to_linear_distance(revolutions);
-        assert!((distance.get::<meter>() - converter.circumference().get::<meter>()).abs() < 1e-10);
-
-        // Converting back should give 1 revolution
-        let calculated_revolutions = converter.linear_distance_to_revolutions(distance);
-        assert!((calculated_revolutions - 1.0).abs() < 1e-10);
-    }
-
-    #[test]
-    fn test_jerk_conversions() {
-        let converter = CircularConverter::from_radius(Length::new::<meter>(2.0));
-
-        let linear_jerk = 4.0; // m/s³
-        let angular_jerk = converter.linear_to_angular_jerk(linear_jerk);
-        assert!((angular_jerk - 2.0).abs() < 1e-10); // 4.0 / 2.0 = 2.0 rad/s³
-
-        let calculated_linear_jerk = converter.angular_to_linear_jerk(angular_jerk);
-        assert!((calculated_linear_jerk - linear_jerk).abs() < 1e-10);
-    }
-}
@@ -1,11 +1,14 @@
-use units::{
+use uom::si::{
+    acceleration::meter_per_second_squared,
    angle::revolution,
+    angular_acceleration::radian_per_second_squared,
    angular_velocity::revolution_per_second,
    f64::{Acceleration, Angle, AngularAcceleration, AngularVelocity, Length, Velocity},
+    length::meter,
+    velocity::meter_per_second,
 };

 use super::angular_step_converter::AngularStepConverter;
-use super::circular_converter::CircularConverter;

 /// Converts between linear measurements and motor steps
 ///
@@ -15,52 +18,57 @@ use super::circular_converter::CircularConverter;
 #[derive(Debug, Clone)]
 pub struct LinearStepConverter {
    angular_step_converter: AngularStepConverter,
-    circular_converter: CircularConverter,
+    radius: Length,
+    circumference: Length,
 }

 // Constructor and basic getters
 impl LinearStepConverter {
    /// Create a new converter from radius and steps per revolution
    pub fn from_radius(steps_per_revolution: i16, radius: Length) -> Self {
+        let circumference =
+            Length::new::<meter>(2.0 * std::f64::consts::PI * radius.get::<meter>());
        Self {
            angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            circular_converter: CircularConverter::from_radius(radius),
+            radius,
+            circumference,
        }
    }

    /// Create a new converter from diameter and steps per revolution
    pub fn from_diameter(steps_per_revolution: i16, diameter: Length) -> Self {
-        Self {
-            angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            circular_converter: CircularConverter::from_diameter(diameter),
-        }
+        let radius = diameter / 2.0;
+        Self::from_radius(steps_per_revolution, radius)
    }

    /// Create a new converter from circumference and steps per revolution
    pub fn from_circumference(steps_per_revolution: i16, circumference: Length) -> Self {
+        let radius =
+            Length::new::<meter>(circumference.get::<meter>() / (2.0 * std::f64::consts::PI));
        Self {
            angular_step_converter: AngularStepConverter::new(steps_per_revolution),
-            circular_converter: CircularConverter::from_circumference(circumference),
+            radius,
+            circumference,
        }
    }

    /// Get the radius used by the converter
    pub fn radius(&self) -> Length {
-        self.circular_converter.radius()
+        self.radius
    }

    /// Get the diameter of the system
    pub fn diameter(&self) -> Length {
-        self.circular_converter.diameter()
+        self.radius * 2.0
    }

    /// Get the circumference of the system
    pub fn circumference(&self) -> Length {
-        self.circular_converter.circumference()
+        self.circumference
    }

    /// Get the steps per revolution
-    pub const fn steps_per_revolution(&self) -> i16 {
+    pub fn steps_per_revolution(&self) -> i16 {
        self.angular_step_converter.steps_per_revolution
    }
 }
@@ -71,10 +79,8 @@ impl LinearStepConverter {
    ///
    /// Formula: steps = (distance / circumference) * steps_per_revolution
    pub fn distance_to_steps(&self, distance: Length) -> f64 {
-        // Convert distance to revolutions using CircularConverter
-        let revolutions = self
-            .circular_converter
-            .linear_distance_to_revolutions(distance);
+        // Convert distance to angle: angle = distance/circumference (in revolutions)
+        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
        let angle = Angle::new::<revolution>(revolutions);

        // Convert angle to steps
@@ -88,19 +94,21 @@ impl LinearStepConverter {
        // Convert steps to angle
        let angle = self.angular_step_converter.steps_to_angle(steps);

-        // Convert angle to distance using CircularConverter
+        // Convert angle to distance: distance = angle * circumference
        let revolutions = angle.get::<revolution>();
-        self.circular_converter
-            .revolutions_to_linear_distance(revolutions)
+        let distance = revolutions * self.circumference.get::<meter>();
+
+        Length::new::<meter>(distance)
    }

    /// Convert linear velocity to steps/second
    ///
    /// Formula: steps/second = (velocity / circumference) * steps_per_revolution
    pub fn velocity_to_steps(&self, velocity: Velocity) -> f64 {
-        // Convert linear velocity to revolutions per second using CircularConverter
-        let rps = self.circular_converter.linear_velocity_to_rps(velocity);
-        let angular_velocity = AngularVelocity::new::<revolution_per_second>(rps);
+        // Convert linear velocity to angular velocity: ω = v/circumference (in rev/s)
+        let linear_velocity = velocity.get::<meter_per_second>();
+        let angular_velocity_rps = linear_velocity / self.circumference.get::<meter>();
+        let angular_velocity = AngularVelocity::new::<revolution_per_second>(angular_velocity_rps);

        // Convert angular velocity to steps/second
        self.angular_step_converter
@@ -116,19 +124,23 @@ impl LinearStepConverter {
            .angular_step_converter
            .steps_to_angular_velocity(steps_per_second);

-        // Convert angular velocity to linear velocity using CircularConverter
-        let rps = angular_velocity.get::<revolution_per_second>();
-        self.circular_converter.rps_to_linear_velocity(rps)
+        // Convert angular velocity to linear velocity: v = ω * circumference
+        let angular_velocity_rps = angular_velocity.get::<revolution_per_second>();
+        let linear_velocity = angular_velocity_rps * self.circumference.get::<meter>();
+
+        Velocity::new::<meter_per_second>(linear_velocity)
    }

    /// Convert linear acceleration to steps/second²
    ///
    /// Formula: steps/second² = (acceleration / radius) * (steps_per_revolution / (2π))
    pub fn acceleration_to_steps(&self, acceleration: Acceleration) -> f64 {
-        // Convert linear acceleration to angular acceleration using CircularConverter
-        let angular_acceleration = self
-            .circular_converter
-            .linear_to_angular_acceleration(acceleration);
+        // Convert linear acceleration to angular acceleration: α = a/r
+        let linear_acceleration = acceleration.get::<meter_per_second_squared>();
+        // Calculate angular acceleration in radians per second squared
+        let angular_acceleration_rad_per_s2 = linear_acceleration / self.radius.get::<meter>();
+        let angular_acceleration =
+            AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2);

        // Convert angular acceleration to steps/second²
        self.angular_step_converter
@@ -144,9 +156,12 @@ impl LinearStepConverter {
            .angular_step_converter
            .steps_to_angular_acceleration(steps_per_second_squared);

-        // Convert angular acceleration to linear acceleration using CircularConverter
-        self.circular_converter
-            .angular_to_linear_acceleration(angular_acceleration)
+        // Convert angular acceleration to linear acceleration: a = α * r
+        let angular_acceleration_rad_per_s2 =
+            angular_acceleration.get::<radian_per_second_squared>();
+        let linear_acceleration = angular_acceleration_rad_per_s2 * self.radius.get::<meter>();
+
+        Acceleration::new::<meter_per_second_squared>(linear_acceleration)
    }
 }

@@ -156,9 +171,7 @@ impl LinearStepConverter {
    ///
    /// Formula: angle (in revolutions) = distance / circumference
    pub fn distance_to_angle(&self, distance: Length) -> Angle {
-        let revolutions = self
-            .circular_converter
-            .linear_distance_to_revolutions(distance);
+        let revolutions = distance.get::<meter>() / self.circumference.get::<meter>();
        Angle::new::<revolution>(revolutions)
    }

@@ -167,24 +180,26 @@ impl LinearStepConverter {
    /// Formula: distance = angle (in revolutions) * circumference
    pub fn angle_to_distance(&self, angle: Angle) -> Length {
        let revolutions = angle.get::<revolution>();
-        self.circular_converter
-            .revolutions_to_linear_distance(revolutions)
+        let distance = revolutions * self.circumference.get::<meter>();
+        Length::new::<meter>(distance)
    }

    /// Convert linear velocity to angular velocity
    ///
    /// Formula: angular velocity (in rev/s) = velocity / circumference
    pub fn velocity_to_angular_velocity(&self, velocity: Velocity) -> AngularVelocity {
-        let rps = self.circular_converter.linear_velocity_to_rps(velocity);
-        AngularVelocity::new::<revolution_per_second>(rps)
+        let linear_velocity = velocity.get::<meter_per_second>();
+        let angular_velocity_rps = linear_velocity / self.circumference.get::<meter>();
+        AngularVelocity::new::<revolution_per_second>(angular_velocity_rps)
    }

    /// Convert angular velocity to linear velocity
    ///
    /// Formula: velocity = angular velocity (in rev/s) * circumference
    pub fn angular_velocity_to_velocity(&self, angular_velocity: AngularVelocity) -> Velocity {
-        let rps = angular_velocity.get::<revolution_per_second>();
-        self.circular_converter.rps_to_linear_velocity(rps)
+        let angular_velocity_rps = angular_velocity.get::<revolution_per_second>();
+        let linear_velocity = angular_velocity_rps * self.circumference.get::<meter>();
+        Velocity::new::<meter_per_second>(linear_velocity)
    }

    /// Convert linear acceleration to angular acceleration
@@ -194,8 +209,9 @@ impl LinearStepConverter {
        &self,
        acceleration: Acceleration,
    ) -> AngularAcceleration {
-        self.circular_converter
-            .linear_to_angular_acceleration(acceleration)
+        let linear_acceleration = acceleration.get::<meter_per_second_squared>();
+        let angular_acceleration_rad_per_s2 = linear_acceleration / self.radius.get::<meter>();
+        AngularAcceleration::new::<radian_per_second_squared>(angular_acceleration_rad_per_s2)
    }

    /// Convert angular acceleration to linear acceleration
@@ -205,8 +221,10 @@ impl LinearStepConverter {
        &self,
        angular_acceleration: AngularAcceleration,
    ) -> Acceleration {
-        self.circular_converter
-            .angular_to_linear_acceleration(angular_acceleration)
+        let angular_acceleration_rad_per_s2 =
+            angular_acceleration.get::<radian_per_second_squared>();
+        let linear_acceleration = angular_acceleration_rad_per_s2 * self.radius.get::<meter>();
+        Acceleration::new::<meter_per_second_squared>(linear_acceleration)
    }
 }

@@ -251,10 +269,6 @@ mod tests {
    use super::*;
    use approx::assert_relative_eq;
    use std::f64::EPSILON;
-    use units::{
-        acceleration::meter_per_second_squared, angular_acceleration::radian_per_second_squared,
-        length::meter, velocity::meter_per_second,
-    };

    #[test]
    fn test_new() {
@@ -1,5 +1,5 @@
 pub mod angle_converter;
 pub mod angular_step_converter;
-pub mod circular_converter;
 pub mod linear_step_converter;
 pub mod motor_converter;
+pub mod transmission_converter;
@@ -0,0 +1,22 @@
+use uom::si::f64::AngularVelocity;
+
+#[derive(Debug, Clone)]
+pub struct TransmissionConverter {
+    pub transmission_ratio: f64,
+}
+
+impl TransmissionConverter {
+    pub fn new() -> Self {
+        Self {
+            transmission_ratio: 34.0,
+        }
+    }
+
+    pub fn calculate_screw_output_rpm(&self, rpm: AngularVelocity) -> AngularVelocity {
+        rpm / self.transmission_ratio
+    }
+
+    pub fn calculate_screw_input_rpm(&self, screw_rpm: AngularVelocity) -> AngularVelocity {
+        screw_rpm * self.transmission_ratio
+    }
+}
@@ -1,36 +0,0 @@
-use anyhow::anyhow;
-use smol::lock::Mutex;
-use std::any::Any;
-use std::sync::Arc;
-
-pub trait Downcast<T> {
-    fn downcast(&self) -> Result<T, anyhow::Error>;
-}
-
-pub trait DowncastRef<T> {
-    fn downcast_ref(&self) -> Result<&T, anyhow::Error>;
-}
-
-impl<T: 'static, U: Any + 'static> Downcast<Arc<Mutex<T>>> for Arc<Mutex<U>> {
-    fn downcast(&self) -> Result<Arc<Mutex<T>>, anyhow::Error> {
-        // Acquire a read lock on the RwLock
-        let lock = self.lock_blocking();
-
-        // Check if the inner type can be downcasted to T
-        let any: &dyn Any = &*lock;
-
-        if any.is::<T>() {
-            // Clone the Arc and return it as the desired type
-            let cloned: Arc<Mutex<dyn Any>> = self.clone();
-
-            // Transmute the Arc to the desired type
-            unsafe {
-                let arc = Arc::from_raw(Arc::into_raw(cloned) as *const Mutex<T>);
-
-                Ok(arc)
-            }
-        } else {
-            Err(anyhow!("[{}::downcast] Downcast failed", module_path!()))
-        }
-    }
-}
@@ -1,117 +1,3 @@
-use std::fmt::Display;
-
-use serde::Deserialize;
-use serde::Serialize;
-
-/// Identifies a spacifi machine
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub struct MachineIdentificationUnique {
-    pub machine_identification: MachineIdentification,
-    pub serial: u16,
-}
-
-impl MachineIdentificationUnique {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.machine_identification.is_valid() && self.serial != 0
-    }
-}
-
-impl Display for MachineIdentificationUnique {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}/{}/{}",
-            self.machine_identification.vendor, self.machine_identification.machine, self.serial
-        )
-    }
-}
-
-/// Identifies a machine
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub struct MachineIdentification {
-    pub vendor: u16,
-    pub machine: u16,
-}
-
-impl MachineIdentification {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.vendor != 0 && self.machine != 0
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceMachineIdentification {
-    pub machine_identification_unique: MachineIdentificationUnique,
-    pub role: u16,
-}
-
-impl DeviceMachineIdentification {
-    /// Check if values are non-zero
-    pub const fn is_valid(&self) -> bool {
-        self.machine_identification_unique.is_valid()
-            && self
-                .machine_identification_unique
-                .machine_identification
-                .machine
-                != 0
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceIdentification {
-    pub device_machine_identification: Option<DeviceMachineIdentification>,
-    pub device_hardware_identification: DeviceHardwareIdentification,
-}
-
-impl From<DeviceIdentificationIdentified> for DeviceIdentification {
-    fn from(value: DeviceIdentificationIdentified) -> Self {
-        Self {
-            device_machine_identification: Some(value.device_machine_identification),
-            device_hardware_identification: value.device_hardware_identification,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceIdentificationIdentified {
-    pub device_machine_identification: DeviceMachineIdentification,
-    pub device_hardware_identification: DeviceHardwareIdentification,
-}
-
-impl TryFrom<DeviceIdentification> for DeviceIdentificationIdentified {
-    type Error = anyhow::Error;
-
-    fn try_from(value: DeviceIdentification) -> Result<Self, Self::Error> {
-        let device_machine_identification =
-            value.device_machine_identification.ok_or(anyhow::anyhow!(
-                "[{}::DeviceIdentificationIdentified::try_from] No device machine identification",
-                module_path!()
-            ))?;
-
-        Ok(Self {
-            device_machine_identification,
-            device_hardware_identification: value.device_hardware_identification,
-        })
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum DeviceHardwareIdentification {
-    Ethercat(DeviceHardwareIdentificationEthercat),
-    Serial(DeviceHardwareIdentificationSerial),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceHardwareIdentificationEthercat {
-    pub subdevice_index: usize,
-}
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct DeviceHardwareIdentificationSerial {
-    pub path: String,
-}
-
 use anyhow::Error;
 use anyhow::anyhow;
 use ethercat_hal::devices::ek1100::EK1100_IDENTITY_A;
@@ -121,7 +7,6 @@ use ethercat_hal::devices::el2002::EL2002_IDENTITY_A;
 use ethercat_hal::devices::el2002::EL2002_IDENTITY_B;
 use ethercat_hal::devices::el2004::EL2004_IDENTITY_A;
 use ethercat_hal::devices::el2008::EL2008_IDENTITY_A;
-use ethercat_hal::devices::el2008::EL2008_IDENTITY_B;
 use ethercat_hal::devices::el2521::{
    EL2521_IDENTITY_0000_A, EL2521_IDENTITY_0000_B, EL2521_IDENTITY_0024_A,
 };
@@ -132,8 +17,6 @@ use ethercat_hal::devices::el3024::EL3024_IDENTITY_A;
 use ethercat_hal::devices::el3062_0030::EL3062_0030_IDENTITY_A;
 use ethercat_hal::devices::el3204::EL3204_IDENTITY_A;
 use ethercat_hal::devices::el3204::EL3204_IDENTITY_B;
-use ethercat_hal::devices::el4002::EL4002_IDENTITY_A;
-use ethercat_hal::devices::el5152::EL5152_IDENTITY_A;
 use ethercat_hal::devices::el6021::{
    EL6021_IDENTITY_A, EL6021_IDENTITY_B, EL6021_IDENTITY_C, EL6021_IDENTITY_D,
 };
@@ -147,6 +30,10 @@ use ethercat_hal::helpers::ethercrab_types::{
 use ethercrab::MainDevice;
 use ethercrab::SubDeviceIdentity;

+use crate::machines::identification::DeviceMachineIdentification;
+use crate::machines::identification::MachineIdentification;
+use crate::machines::identification::MachineIdentificationUnique;
+
 #[derive(Debug)]
 pub struct MachineIdentificationAddresses {
    pub vendor_word: u16,
@@ -156,12 +43,7 @@ pub struct MachineIdentificationAddresses {
 }

 impl MachineIdentificationAddresses {
-    pub const fn new(
-        vendor_word: u16,
-        serial_word: u16,
-        machine_word: u16,
-        device_word: u16,
-    ) -> Self {
+    pub fn new(vendor_word: u16, serial_word: u16, machine_word: u16, device_word: u16) -> Self {
        Self {
            vendor_word,
            serial_word,
@@ -191,7 +73,7 @@ pub async fn read_device_identifications<'maindevice>(
 ) -> Vec<Result<DeviceMachineIdentification, Error>> {
    let mut result = Vec::new();
    for subdevice in subdevices.iter() {
-        let identification = machine_device_identification(subdevice, maindevice).await;
+        let identification = machine_device_identification(&subdevice, maindevice).await;
        result.push(identification);
    }
    result
@@ -338,11 +220,11 @@ pub async fn write_machine_device_identification<'maindevice, const MAX_PDI: usi

 /// Returns the EEPROM addresses for the machine device identification
 /// based on the subdevice's identity
-pub fn get_identification_addresses(
+pub fn get_identification_addresses<'maindevice>(
    subdevice_identity: &SubDeviceIdentity,
    subdevice_name: &str,
 ) -> Result<MachineIdentificationAddresses, Error> {
-    let identity_tuple = subdevice_identity_to_tuple(subdevice_identity);
+    let identity_tuple = subdevice_identity_to_tuple(&subdevice_identity);

    Ok(match identity_tuple {
        EK1100_IDENTITY_A => MachineIdentificationAddresses::default(),
@@ -350,25 +232,22 @@ pub fn get_identification_addresses(
        EL1008_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL2002_IDENTITY_A | EL2002_IDENTITY_B => MachineIdentificationAddresses::default(),
        EL2004_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL2008_IDENTITY_A | EL2008_IDENTITY_B => MachineIdentificationAddresses::default(),
+        EL3204_IDENTITY_A | EL3204_IDENTITY_B => MachineIdentificationAddresses::default(),
+        EL2008_IDENTITY_A => MachineIdentificationAddresses::default(),
+        EL3001_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL2521_IDENTITY_0000_A | EL2521_IDENTITY_0000_B | EL2521_IDENTITY_0024_A => {
            MachineIdentificationAddresses::default()
        }
        EL2522_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL3001_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL3021_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL3024_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL3062_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL3204_IDENTITY_A | EL3204_IDENTITY_B => MachineIdentificationAddresses::default(),
-        EL4002_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL5152_IDENTITY_A => MachineIdentificationAddresses::default(),
-        EL6021_IDENTITY_A | EL6021_IDENTITY_B | EL6021_IDENTITY_C | EL6021_IDENTITY_D => {
-            MachineIdentificationAddresses::default()
-        }
        EL7031_IDENTITY_A | EL7031_IDENTITY_B => MachineIdentificationAddresses::default(),
        EL7031_0030_IDENTITY_A => MachineIdentificationAddresses::default(),
        EL7041_0052_IDENTITY_A => MachineIdentificationAddresses::default(),
-
+        EL6021_IDENTITY_A | EL6021_IDENTITY_B | EL6021_IDENTITY_C | EL6021_IDENTITY_D => {
+            MachineIdentificationAddresses::default()
+        }
        _ => {
            // block_on(u16dump(&subdevice, maindevice, 0x00, 0xff))?;
            Err(anyhow!(
@@ -394,8 +273,8 @@ async fn u16dump<'maindevice>(
        words.push(subdevice.eeprom_read(maindevice, word).await?);
    }

-    println!(
-        "EEPROM dump for {} from 0x{:04x} to 0x{:04x}",
+    print!(
+        "EEPROM dump for {} from 0x{:04x} to 0x{:04x}\n",
        subdevice.name(),
        start_byte / 2,
        end_byte / 2
@@ -410,7 +289,7 @@ fn u16print(start_byte: u16, end_byte: u16, data: Vec<u16>) {
    let table_start_word = start_byte & 0xfff0;
    let table_end_word = (end_byte & 0xfff0_u16) + 0x10_u16;

-    let rows = (table_end_word - table_start_word) >> 4;
+    let rows = table_end_word - table_start_word >> 4;

    for row in 0..rows {
        print!("0x{:04x} | ", (table_start_word + row * 0x10) / 2);
@@ -427,7 +306,7 @@ fn u16print(start_byte: u16, end_byte: u16, data: Vec<u16>) {
                }
            }
        }
-        println!();
+        print!("\n");
    }
 }

@@ -1,9 +1,10 @@
+use std::{sync::Arc, time::Duration};
+
 use ethercrab::{
    MainDevice, MainDeviceConfig, PduStorage, Timeouts,
    std::{ethercat_now, tx_rx_task},
 };
 use interfaces::Interface;
-use std::{process::Command, sync::Arc, time::Duration};

 // Constants for EtherCAT configuration
 const IFACE_DISCOVERY_MAX_SUBDEVICES: usize = 16; // Must be power of 2 > 1
@@ -11,46 +12,14 @@ const IFACE_DISCOVERY_MAX_PDU_DATA: usize = PduStorage::element_size(1100);
 const IFACE_DISCOVERY_MAX_FRAMES: usize = 16;
 const IFACE_DISCOVERY_MAX_PDI_LEN: usize = 128;

-/// Sets a network interface to unmanaged by NetworkManager.
-/// Returns true if the command succeeded.
-pub fn set_interface_managed(interface: &str, managed: bool) -> bool {
-    let managed_str = match managed {
-        true => "yes",
-        false => "no",
-    };
-    tracing::info!(
-        "set_interface_managed for {} managed was set to: {}",
-        interface,
-        managed_str
-    );
-    let status = Command::new("nmcli")
-        .args(["dev", "set", interface, "managed", managed_str])
-        .status();
-
-    matches!(status, Ok(s) if s.success())
-}
-
-/// Returns true if the given network interface is Ethernet.
-/// Prevents testing wlan,loopback and other non ethernet devices
-fn is_ethernet(interface: &str) -> std::io::Result<bool> {
-    #[cfg(target_os = "linux")]
-    {
-        let base_path = format!("/sys/class/net/{}", interface);
-        let type_path = std::path::Path::new(&base_path).join("type");
-        let iface_type = std::fs::read_to_string(&type_path)?.trim().to_string();
-        // 1 means Ethernet
-        let reports_as_ethernet = iface_type == "1";
-        // Double-check that it's not a wireless interface
-        let uevent_path = std::path::Path::new(&base_path).join("uevent");
-        let uevent = std::fs::read_to_string(&uevent_path).unwrap_or_default();
-        // If "DEVTYPE=wlan" appears, it's lying
-        let actually_wifi = uevent.contains("DEVTYPE=wlan");
-        return Ok(reports_as_ethernet && !actually_wifi);
-    }
-    #[cfg(not(target_os = "linux"))]
-    return Ok(true);
-}
-
+/// Finds an ethernet interface that is suitable for EtherCAT communication.
+///
+/// ```ignore
+/// match discover_ethercat_interface().await {
+///     Ok(interface) => println!("Found working interface: {}", interface),
+///     Err(_) => println!("No working interface found"),
+/// }
+/// ```
 pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
    tracing::info!("Discovering EtherCAT interface...");

@@ -68,17 +37,17 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
        } else {
            tracing::debug!("Suppressed panic in interface test: {}", panic_info);
        }
+        // Don't call the default hook, which would print the backtrace
    }));

    // Get eligible interfaces
    let mut interfaces = Interface::get_all()
-        .map_err(|e| anyhow::anyhow!("Failed to get network interfaces: {}", e))?
+        .or_else(|e| Err(anyhow::anyhow!("Failed to get network interfaces: {}", e)))?
        .into_iter()
        .filter(|iface| {
            iface.is_up()
                && iface.is_running()
                && !iface.is_loopback()
-                && is_ethernet(&iface.name).unwrap_or(false)
                && !iface.name.starts_with("bridge")
                && !iface.name.starts_with("utun")   // Exclude tunnel interfaces
                && !iface.name.starts_with("awdl")   // Exclude Apple Wireless Direct Link
@@ -87,39 +56,60 @@ pub async fn discover_ethercat_interface() -> Result<String, anyhow::Error> {
        })
        .collect::<Vec<_>>();

+    // Sort interfaces by name
    interfaces.sort_by(|a, b| a.name.cmp(&b.name));
-    let mut interface: Option<&str> = None;

-    for i in 0..interfaces.len() {
-        match test_interface(&interfaces[i].name) {
-            Ok(_) => {
-                // if interface found with ethercat Exit early, we expect only one interface with ethercat
-                interface = Some(&interfaces[i].name);
-                break;
-            }
-            Err(_) => (),
-        }
-    }
+    // Try all interfaces concurrently
+    let tasks = interfaces
+        .iter()
+        .map(|iface| {
+            let name = iface.name.clone();
+            std::thread::Builder::new()
+                .name(format!("ethercat-test-{}", name))
+                .spawn(move || {
+                    std::panic::catch_unwind(|| {
+                        smol::block_on(async {
+                            match test_interface(&name) {
+                                Ok(_) => {
+                                    tracing::info!("Found working EtherCAT interface: {}", name);
+                                    Some(name.clone())
+                                }
+                                Err(_) => {
+                                    tracing::debug!("Interface {} failed", name);
+                                    None
+                                }
+                            }
+                        })
+                    })
+                    .unwrap_or(None)
+                })
+                .expect("Failed to spawn thread")
+        })
+        .collect::<Vec<_>>();

-    for i in 0..interfaces.len() {
-        if interface.is_some() && interface.unwrap() == &interfaces[i].name {
-            set_interface_managed(&interfaces[i].name, false);
-        } else {
-            set_interface_managed(&interfaces[i].name, true);
-        }
-    }
+    // Wait for all tasks to complete and collect successful results
+    let successful_interfaces: Vec<String> = tasks
+        .into_iter()
+        .filter_map(|task| match task.join().expect("Should join thread") {
+            Some(name) => Some(name),
+            None => None,
+        })
+        .collect();
+
+    // Return the first successful interface (they're sorted by name)
+    let result = successful_interfaces.into_iter().next();

    // Restore the default panic hook
    std::panic::set_hook(default_hook);

-    match interface {
-        Some(interface) => return Ok(interface.to_string()),
-        None => return Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
+    match result {
+        Some(name) => Ok(name),
+        None => Err(anyhow::anyhow!("No suitable EtherCAT interface found")),
    }
 }

 fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
-    tracing::info!("Testing interface: {}", interface);
+    tracing::trace!("Testing interface: {}", interface);

    let pdu_storage = Box::leak(Box::new(PduStorage::<
        IFACE_DISCOVERY_MAX_FRAMES,
@@ -133,7 +123,7 @@ fn test_interface(interface: &str) -> Result<(), anyhow::Error> {

    let result = rt.run(async {
        let tx_rx_handle = rt.spawn(
-            tx_rx_task(interface, tx, rx)
+            tx_rx_task(&interface, tx, rx)
                .map_err(|e| anyhow::anyhow!("Failed to spawn TX/RX task: {}", e))?,
        );

@@ -157,7 +147,7 @@ fn test_interface(interface: &str) -> Result<(), anyhow::Error> {
                // Default 10000
                dc_static_sync_iterations: 10000,
                // Default None
-                retry_behaviour: ethercrab::RetryBehaviour::Count(3),
+                retry_behaviour: ethercrab::RetryBehaviour::None,
            },
        ));

@@ -1 +1,2 @@
+pub mod eeprom_identification;
 pub mod interface_discovery;
@@ -1,337 +0,0 @@
-use serde::Serialize;
-use serde::ser::{
-    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
-    SerializeTupleStruct, SerializeTupleVariant, Serializer,
-};
-use std::error::Error;
-use std::fmt::Display;
-use std::hash::{DefaultHasher, Hasher};
-
-#[derive(Debug)]
-pub struct HashSerializerError {}
-
-impl std::fmt::Display for HashSerializerError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&format!("{:?}", self))
-        // f.debug_struct("HashSerialiyerError")
-        // .finish()
-    }
-}
-
-impl Error for HashSerializerError {}
-
-impl serde::ser::Error for HashSerializerError {
-    fn custom<T>(_msg: T) -> Self
-    where
-        T: Display,
-    {
-        Self {}
-    }
-}
-
-pub struct HashSerializer<'a, H: Hasher>(&'a mut H);
-impl<H: Hasher> SerializeSeq for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeTuple for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeTupleStruct for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeTupleVariant for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeMap for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        key.serialize(HashSerializer(self.0))
-    }
-
-    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeStruct for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        // Optional: hash the field name to avoid collisions
-        self.0.write(key.as_bytes());
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> SerializeStructVariant for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.0.write(key.as_bytes());
-        value.serialize(HashSerializer(self.0))
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-impl<H: Hasher> Serializer for HashSerializer<'_, H> {
-    type Ok = ();
-    type Error = HashSerializerError;
-    type SerializeSeq = Self;
-    type SerializeTuple = Self;
-    type SerializeTupleStruct = Self;
-    type SerializeTupleVariant = Self;
-    type SerializeMap = Self;
-    type SerializeStruct = Self;
-    type SerializeStructVariant = Self;
-
-    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
-        self.0.write_u8(v as u8);
-        Ok(())
-    }
-
-    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
-        self.0.write_i8(v);
-        Ok(())
-    }
-
-    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
-        self.0.write_i16(v);
-        Ok(())
-    }
-
-    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
-        self.0.write_i32(v);
-        Ok(())
-    }
-
-    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
-        self.0.write_i64(v);
-        Ok(())
-    }
-
-    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
-        self.0.write_u8(v);
-        Ok(())
-    }
-
-    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
-        self.0.write_u16(v);
-        Ok(())
-    }
-
-    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
-        self.0.write_u32(v);
-        Ok(())
-    }
-
-    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
-        self.0.write_u64(v);
-        Ok(())
-    }
-
-    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
-        self.0.write_u32(v.to_bits());
-        Ok(())
-    }
-
-    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
-        self.0.write_u64(v.to_bits());
-        Ok(())
-    }
-
-    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
-        let mut buf = [0; 4];
-        self.0.write(v.encode_utf8(&mut buf).as_bytes());
-        Ok(())
-    }
-
-    fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
-        self.0.write(v.as_bytes());
-        Ok(())
-    }
-
-    fn serialize_bytes(self, v: &[u8]) -> Result<(), Self::Error> {
-        self.0.write(v);
-        Ok(())
-    }
-
-    fn serialize_none(self) -> Result<(), Self::Error> {
-        self.0.write_u8(0); // type tag for None
-        Ok(())
-    }
-
-    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<(), Self::Error> {
-        self.0.write_u8(1); // type tag for Some
-        value.serialize(self)
-    }
-
-    fn serialize_unit(self) -> Result<(), Self::Error> {
-        self.0.write_u8(0);
-        Ok(())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
-        self.serialize_unit()
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<(), Self::Error> {
-        self.0.write_u32(variant_index);
-        Ok(())
-    }
-
-    fn serialize_newtype_struct<T: ?Sized + Serialize>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error> {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized + Serialize>(
-        self,
-        _name: &'static str,
-        variant_index: u32,
-        _variant: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error> {
-        self.0.write_u32(variant_index);
-        value.serialize(self)
-    }
-
-    // For sequences, tuples, maps, structs, just return self for now
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Ok(self)
-    }
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Ok(self)
-    }
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Ok(self)
-    }
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        self.0.write_u32(variant_index);
-        Ok(self)
-    }
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Ok(self)
-    }
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Ok(self)
-    }
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        self.0.write_u32(variant_index);
-        Ok(self)
-    }
-}
-
-// A helper that uses Serialize to feed into a Hasher without allocating a buffer:
-pub fn hash_with_serde_model<T: Serialize>(value: T) -> u64 {
-    let mut h = DefaultHasher::new();
-    let ser = HashSerializer(&mut h);
-    value.serialize(ser).expect("serialize to hasher failed");
-    h.finish()
-}
@@ -63,11 +63,11 @@ pub fn scale<T>(normalized_value: f64, new_min: T, new_max: T) -> T
 where
    T: Into<f64> + From<f64>,
 {
-    let normalized_value: f64 = normalized_value;
+    let normalized_value: f64 = normalized_value.into();
    let new_min: f64 = new_min.into();
    let new_max: f64 = new_max.into();

-    let result = normalized_value.mul_add(new_max - new_min, new_min);
+    let result = normalized_value * (new_max - new_min) + new_min;
    T::from(result)
 }

@@ -128,11 +128,11 @@ where
    // If we are under X we scale linearly from 0 to y
    // If we are over X we scale linearly from y to 1
    if value_f64 < x_f64 {
-        normalize(value_f64, 0.0, x_f64) * y_f64
+        return normalize(value_f64, 0.0, x_f64) * y_f64;
    } else if value_f64 > x_f64 {
-        normalize(value_f64, x_f64, 1.0).mul_add(1.0 - y_f64, y_f64)
+        return normalize(value_f64, x_f64, 1.0) * (1.0 - y_f64) + y_f64;
    } else {
-        y_f64
+        return y_f64;
    }
 }

@@ -273,7 +273,7 @@ pub fn interpolate_exponential(normalized_value: f64, steepness: f64) -> f64 {
        return normalized_value;
    }
    let numerator = steepness.exp().powf(normalized_value) - 1.0;
-    let denominator = steepness.exp_m1();
+    let denominator = steepness.exp() - 1.0;

    clip(numerator / denominator)
 }
@@ -414,7 +414,7 @@ pub fn interpolate_inflected_exponential(x: f64, steepness: f64) -> f64 {

        // Use standard exponential interpolation
        let result = interpolate_exponential(x_norm, steepness);
-        0.5f64.mul_add(result, 0.5)
+        0.5 + 0.5 * result
    }
 }

@@ -0,0 +1,189 @@
+use smol::Timer;
+use std::time::{Duration, Instant};
+use tracing::instrument;
+
+pub struct LoopThrottle {
+    target_cycle_time: Duration,
+    update_interval_cycles: usize,
+    window_start: Instant,
+    total_cycles: usize,
+    delay: Duration,
+    last_avg_cycle_time: Duration,
+    on_update: Option<Box<dyn Fn(LoopThrottleUpdate)>>,
+}
+
+pub struct LoopThrottleUpdate {
+    pub delay: Duration,
+    pub avg_cycle_time: Duration,
+    pub error: i128, // Error in nanoseconds
+}
+impl LoopThrottle {
+    pub fn new(
+        target_cycle_time: Duration,
+        update_interval_cycles: usize,
+        on_update: Option<Box<dyn Fn(LoopThrottleUpdate)>>,
+    ) -> Self {
+        Self {
+            target_cycle_time,
+            update_interval_cycles,
+            window_start: Instant::now(),
+            total_cycles: 0,
+            delay: target_cycle_time,
+            last_avg_cycle_time: target_cycle_time,
+            on_update,
+        }
+    }
+    #[instrument(skip_all)]
+    pub async fn sleep(&mut self) {
+        self.total_cycles += 1;
+
+        // Check if it's time to update (every N cycles)
+        if self.total_cycles % self.update_interval_cycles == 0 {
+            let actual_total_time = self.window_start.elapsed();
+
+            // Use integer arithmetic where possible
+            let avg_actual_cycle_time_nanos =
+                actual_total_time.as_nanos() / self.update_interval_cycles as u128;
+            let target_cycle_time_nanos = self.target_cycle_time.as_nanos();
+
+            // Calculate error in nanoseconds (signed)
+            let error_nanos = target_cycle_time_nanos as i128 - avg_actual_cycle_time_nanos as i128;
+
+            // Update current delay, allowing zero or negative values to become zero
+            let new_delay_nanos = (self.delay.as_nanos() as i128 + error_nanos).max(0) as u64;
+
+            self.delay = Duration::from_nanos(new_delay_nanos);
+            self.last_avg_cycle_time = Duration::from_nanos(avg_actual_cycle_time_nanos as u64);
+
+            // Reset for next measurement window
+            self.window_start = Instant::now();
+            self.total_cycles = 0; // Reset to prevent overflow
+
+            // if we have an update callback, call it
+            if let Some(on_update) = &self.on_update {
+                on_update(LoopThrottleUpdate {
+                    delay: self.delay,
+                    avg_cycle_time: self.last_avg_cycle_time,
+                    error: error_nanos,
+                });
+            }
+        }
+
+        Timer::after(self.delay).await;
+    }
+
+    pub fn get_cycle_time(&self) -> Duration {
+        self.last_avg_cycle_time
+    }
+
+    pub fn get_delay(&self) -> Duration {
+        self.delay
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use smol::block_on;
+
+    #[test]
+    fn test_adaptive_throttle_timing() {
+        block_on(async {
+            let update_interval_cycles = 100;
+            let target_cycle_time = Duration::from_micros(5);
+            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
+
+            let test_start = Instant::now();
+            let mut cycle_times = Vec::new();
+
+            // Run for several cycles to trigger multiple updates
+            for _ in 0..10000 {
+                let cycle_start = Instant::now();
+
+                // Simulate some work
+                Timer::after(Duration::from_micros(5)).await;
+
+                throttle.sleep().await;
+
+                let cycle_time = cycle_start.elapsed();
+                cycle_times.push(cycle_time);
+            }
+
+            let total_test_time = test_start.elapsed();
+            let avg_cycle_time = cycle_times.iter().sum::<Duration>() / cycle_times.len() as u32;
+
+            println!("Test completed in: {:?}", total_test_time);
+            println!("Average cycle time: {:?}", avg_cycle_time);
+            println!("Target cycle time: {:?}", target_cycle_time);
+            println!("Last measured avg: {:?}", throttle.get_cycle_time());
+
+            // Assert that we're reasonably close to target timing
+            let tolerance = Duration::from_millis(10);
+            assert!(
+                avg_cycle_time >= target_cycle_time.saturating_sub(tolerance)
+                    && avg_cycle_time <= target_cycle_time + tolerance,
+                "Average cycle time {:?} not within tolerance of target {:?}",
+                avg_cycle_time,
+                target_cycle_time
+            );
+        });
+    }
+
+    #[test]
+    fn test_throttle_adaptation() {
+        block_on(async {
+            let target_cycle_time = Duration::from_millis(100);
+            let update_interval_cycles = 3;
+            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
+
+            let initial_delay = throttle.get_delay();
+
+            // Run enough cycles to trigger multiple updates
+            for _ in 0..12 {
+                // Add variable work to test adaptation
+                Timer::after(Duration::from_millis(10)).await;
+                throttle.sleep().await;
+            }
+
+            println!("Initial delay: {:?}", initial_delay);
+            println!("Final delay: {:?}", throttle.get_delay());
+            println!("Last avg cycle time: {:?}", throttle.get_cycle_time());
+
+            assert!(throttle.get_cycle_time() > Duration::ZERO);
+        });
+    }
+
+    #[test]
+    fn test_throttle_initialization() {
+        let update_interval_cycles = 10;
+        let target_cycle_time = Duration::from_millis(75);
+        let throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
+
+        assert_eq!(throttle.get_delay(), target_cycle_time);
+        assert_eq!(throttle.get_cycle_time(), target_cycle_time);
+        assert_eq!(throttle.total_cycles, 0);
+    }
+
+    #[test]
+    fn test_overflow_protection() {
+        block_on(async {
+            let target_cycle_time = Duration::from_micros(1);
+            let update_interval_cycles = 5;
+            let mut throttle = LoopThrottle::new(target_cycle_time, update_interval_cycles, None);
+
+            // Run many cycles to ensure total_cycles resets properly
+            for i in 0..50 {
+                throttle.sleep().await;
+
+                // Verify that total_cycles never exceeds update_interval_cycles
+                assert!(
+                    throttle.total_cycles <= update_interval_cycles,
+                    "Cycle {}: total_cycles ({}) exceeded update_interval_cycles ({})",
+                    i,
+                    throttle.total_cycles,
+                    update_interval_cycles
+                );
+            }
+        });
+    }
+}
@@ -1,6 +1,6 @@
 pub mod compare_lists;
-pub mod hasher_serializer;
 pub mod hashing;
 pub mod interpolation;
+pub mod loop_trottle;
 pub mod moving_time_window;
 pub mod retry;
@@ -11,40 +11,56 @@ pub trait DivideByCount {

 impl DivideByCount for f64 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as f64)
    }
 }

 impl DivideByCount for f32 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as f32)
    }
 }

 impl DivideByCount for i32 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as i32)
    }
 }

 impl DivideByCount for i64 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as i64)
    }
 }

 impl DivideByCount for u32 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as u32)
    }
 }

 impl DivideByCount for u64 {
    fn divide_by_count(self, count: usize) -> Self {
-        self / (count as Self)
+        self / (count as u64)
    }
 }

+/// A generic moving time window that works with numeric types.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::time::{Duration, Instant};
+/// use control_core::helpers::moving_time_window::MovingTimeWindow;
+///
+/// let mut window = MovingTimeWindow::new(Duration::from_secs(10), 100);
+/// window.update(1.5, Instant::now());
+/// window.update(2.5, Instant::now());
+///
+/// let average = window.average();
+/// println!("Average: {}", average);
+/// ```
+
 // Type aliases for common use cases
 pub type F64Window = MovingTimeWindow<f64>;
 pub type F32Window = MovingTimeWindow<f32>;
@@ -178,14 +194,15 @@ where
            .samples
            .iter()
            .map(|(v, _)| *v)
-            .fold(None, |acc, val| {
-                acc.map_or(Some(val), |current_max| {
+            .fold(None, |acc, val| match acc {
+                None => Some(val),
+                Some(current_max) => {
                    if val > current_max {
                        Some(val)
                    } else {
                        Some(current_max)
                    }
-                })
+                }
            })
            .unwrap_or_default();

@@ -212,14 +229,15 @@ where
            .samples
            .iter()
            .map(|(v, _)| *v)
-            .fold(None, |acc, val| {
-                acc.map_or(Some(val), |current_min| {
+            .fold(None, |acc, val| match acc {
+                None => Some(val),
+                Some(current_min) => {
                    if val < current_min {
                        Some(val)
                    } else {
                        Some(current_min)
                    }
-                })
+                }
            })
            .unwrap_or_default();

@@ -1,113 +0,0 @@
-#[cfg(target_os = "linux")]
-use libc;
-use std::ffi::CString;
-use std::io;
-use std::str;
-
-#[cfg(target_os = "linux")]
-fn read_proc_interrupts() -> Result<String, io::Error> {
-    let path = CString::new("/proc/interrupts").unwrap();
-    // O_RDONLY
-    let fd = unsafe { libc::open(path.as_ptr(), libc::O_RDONLY) };
-    if fd < 0 {
-        return Err(io::Error::from_raw_os_error(-fd));
-    }
-
-    let mut buf: Vec<u8> = Vec::new();
-    let mut chunk = [0u8; 8192];
-
-    loop {
-        let n = unsafe { libc::read(fd, chunk.as_mut_ptr() as *mut _, chunk.len()) };
-        if n < 0 {
-            let e = io::Error::from_raw_os_error(-n as i32);
-            unsafe { libc::close(fd) };
-            return Err(e);
-        } else if n == 0 {
-            break;
-        } else {
-            buf.extend_from_slice(&chunk[..n as usize]);
-        }
-    }
-    unsafe { libc::close(fd) };
-    Ok(String::from_utf8_lossy(&buf).into_owned())
-}
-
-#[cfg(target_os = "linux")]
-fn get_interface_irq(proc_content: &str, interface_name: &str) -> Option<u32> {
-    for line in proc_content.lines() {
-        if line.contains(interface_name) {
-            if let Some(colon_pos) = line.find(':') {
-                let head = &line[..colon_pos].trim();
-                // try parse head as integer IRQ number
-                if let Ok(irq) = head.parse::<u32>() {
-                    return Some(irq);
-                }
-            }
-        }
-    }
-    None
-}
-
-/// Since kernel 3.0 it’s possible to use the /proc/irq/<IRQ-NUMBER>/smp_affinity_list
-/// With comma seperated values
-/// This function takes the irq identifier and writes the cpu string
-/// into /proc/irq/irq_number/smp_affinity_list
-#[cfg(target_os = "linux")]
-fn set_irq_affinity_raw(irq: u32, cpu: &str) -> Result<(), io::Error> {
-    let path: String = format!("/proc/irq/{}/smp_affinity_list", irq);
-    let cpath = CString::new(path.clone()).unwrap();
-    // We want to completely overwrite the smp affinities, so that we guarentee execution on the specified cores
-    let file_descriptor = unsafe { libc::open(cpath.as_ptr(), libc::O_WRONLY) };
-
-    if file_descriptor < 0 {
-        tracing::info!("Permission denied to write: {}", path);
-        return Err(io::Error::new(
-            io::ErrorKind::PermissionDenied,
-            format!("failed to open {}: errno {}", path, -file_descriptor),
-        ));
-    }
-    // convert to "raw bytes"
-    // cpu needs to be a string because we need the raw ascii code 48 = '0' and so on as bytes
-    let bytes = cpu.as_bytes();
-    let mut bytes_written_total = 0usize;
-
-    while bytes_written_total < bytes.len() {
-        let to_write = &bytes[bytes_written_total..];
-        let bytes_written = unsafe {
-            libc::write(
-                file_descriptor,
-                to_write.as_ptr() as *const _,
-                to_write.len(),
-            )
-        };
-        if bytes_written < 0 {
-            let e = io::Error::from_raw_os_error(-bytes_written as i32);
-            unsafe { libc::close(file_descriptor) };
-            return Err(e);
-        }
-        bytes_written_total += bytes_written as usize;
-    }
-    unsafe { libc::close(file_descriptor) };
-    Ok(())
-}
-
-/// This is used to make sure that a given irq handler runs on the expected cpu
-/// On Realtime systems this is the make or break fix for certain usecases like ethercrab
-/// On our machines the 99.99th percentile of cycle times was very bad ~5-11 ms while ethercat is supposed to be in the microseconds
-/// After pinning the ethernet irq to the core that the ethercat code ran on 99.99th percentile went down to ~200us (microseconds)
-/// Example input: irq_name: "eno1" , cpu: 2
-/// Remember that cpu cores are counted from 0
-#[cfg(target_os = "linux")]
-pub fn set_irq_affinity(irq_name: &str, cpu: u32) -> Result<(), anyhow::Error> {
-    let proc_contents = read_proc_interrupts()?;
-    let irq = get_interface_irq(&proc_contents, irq_name);
-    if irq.is_none() {
-        return Err(anyhow::anyhow!("Couldnt find irq number!"));
-    }
-    let res = set_irq_affinity_raw(irq.unwrap(), &cpu.to_string());
-    if res.is_err() {
-        return Err(anyhow::anyhow!("Couldnt write affinity list!"));
-    } else {
-        return Ok(());
-    }
-}
@@ -1,14 +1,14 @@
 pub mod controllers;
 pub mod converters;
-pub mod downcast;
 pub mod ethercat;
 pub mod helpers;
-pub mod irq_handling;
+pub mod machines;
 pub mod modbus;
 pub mod realtime;
+pub mod rest;
 pub mod serial;
 pub mod socketio;
-pub mod transmission;
+pub mod uom_extensions;

-#[cfg(feature = "video-streaming")]
-pub mod video_streaming;
+#[macro_use]
+extern crate uom;
@@ -0,0 +1,8 @@
+use serde_json::Value;
+
+use crate::socketio::namespace::Namespace;
+
+pub trait MachineApi {
+    fn api_mutate(&mut self, value: Value) -> Result<(), anyhow::Error>;
+    fn api_event_namespace(&mut self) -> &mut Namespace;
+}
@@ -0,0 +1,113 @@
+use std::fmt::Display;
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/// Identifies a spacifi machine
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct MachineIdentificationUnique {
+    pub machine_identification: MachineIdentification,
+    pub serial: u16,
+}
+
+impl MachineIdentificationUnique {
+    /// Check if values are non-zero
+    pub fn is_valid(&self) -> bool {
+        self.machine_identification.is_valid() && self.serial != 0
+    }
+}
+
+impl Display for MachineIdentificationUnique {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}/{}/{}",
+            self.machine_identification.vendor, self.machine_identification.machine, self.serial
+        )
+    }
+}
+
+/// Identifies a machine
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct MachineIdentification {
+    pub vendor: u16,
+    pub machine: u16,
+}
+
+impl MachineIdentification {
+    /// Check if values are non-zero
+    pub fn is_valid(&self) -> bool {
+        self.vendor != 0 && self.machine != 0
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeviceMachineIdentification {
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub role: u16,
+}
+
+impl DeviceMachineIdentification {
+    /// Check if values are non-zero
+    pub fn is_valid(&self) -> bool {
+        self.machine_identification_unique.is_valid()
+            && self
+                .machine_identification_unique
+                .machine_identification
+                .machine
+                != 0
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeviceIdentification {
+    pub device_machine_identification: Option<DeviceMachineIdentification>,
+    pub device_hardware_identification: DeviceHardwareIdentification,
+}
+
+impl From<DeviceIdentificationIdentified> for DeviceIdentification {
+    fn from(value: DeviceIdentificationIdentified) -> Self {
+        DeviceIdentification {
+            device_machine_identification: Some(value.device_machine_identification),
+            device_hardware_identification: value.device_hardware_identification,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeviceIdentificationIdentified {
+    pub device_machine_identification: DeviceMachineIdentification,
+    pub device_hardware_identification: DeviceHardwareIdentification,
+}
+
+impl TryFrom<DeviceIdentification> for DeviceIdentificationIdentified {
+    type Error = anyhow::Error;
+
+    fn try_from(value: DeviceIdentification) -> Result<Self, Self::Error> {
+        let device_machine_identification =
+            value.device_machine_identification.ok_or(anyhow::anyhow!(
+                "[{}::DeviceIdentificationIdentified::try_from] No device machine identification",
+                module_path!()
+            ))?;
+
+        Ok(DeviceIdentificationIdentified {
+            device_machine_identification,
+            device_hardware_identification: value.device_hardware_identification,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum DeviceHardwareIdentification {
+    Ethercat(DeviceHardwareIdentificationEthercat),
+    Serial(DeviceHardwareIdentificationSerial),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeviceHardwareIdentificationEthercat {
+    pub subdevice_index: usize,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeviceHardwareIdentificationSerial {
+    pub path: String,
+}
@@ -0,0 +1,269 @@
+use smol::{
+    channel::Sender,
+    lock::{Mutex, RwLock},
+};
+use socketioxide::extract::SocketRef;
+
+use crate::{
+    machines::{
+        identification::MachineIdentificationUnique,
+        new::{MachineNewHardware, MachineNewHardwareEthercat, MachineNewParams},
+    },
+    serial::SerialDevice,
+    socketio::event::GenericEvent,
+};
+use std::{
+    collections::HashMap,
+    sync::{Arc, Weak},
+};
+
+use super::{
+    Machine,
+    identification::{DeviceIdentification, DeviceIdentificationIdentified},
+    new::MachineNewHardwareSerial,
+    registry::MachineRegistry,
+};
+#[derive(Debug)]
+pub struct MachineManager {
+    pub ethercat_machines:
+        HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
+    pub serial_machines:
+        HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
+}
+
+impl MachineManager {
+    pub fn new() -> Self {
+        Self {
+            ethercat_machines: HashMap::new(),
+            serial_machines: HashMap::new(),
+        }
+    }
+
+    pub fn set_ethercat_devices<const MAX_SUBDEVICES: usize, const MAX_PDI: usize>(
+        &mut self,
+        device_identifications: &Vec<DeviceIdentification>,
+        machine_registry: &MachineRegistry,
+        hardware: &MachineNewHardwareEthercat,
+        socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+        machine_manager: Weak<RwLock<MachineManager>>,
+    ) {
+        // empty ethercat machines
+        self.ethercat_machines.clear();
+
+        // group devices by machine device identification
+        let device_grouping_result = group_devices_by_identification(device_identifications);
+
+        tracing::info!(
+            "Device Groups {}",
+            device_grouping_result.device_groups.len()
+        );
+
+        let machine_new_hardware = MachineNewHardware::Ethercat(hardware);
+
+        // iterate over all identified device groups but ignore unaffected machines
+        for device_group in device_grouping_result.device_groups.iter() {
+            // get the machine identification
+            let machine_identification = match device_group.first() {
+                Some(device_identification) => &device_identification.device_machine_identification,
+                None => continue, // Skip this group if empty
+            };
+
+            // create the machine
+            let new_machine = machine_registry.new_machine(&MachineNewParams {
+                device_group,
+                hardware: &machine_new_hardware,
+                socket_queue_tx: socket_queue_tx.clone(),
+                machine_manager: machine_manager.clone(),
+            });
+
+            // insert the machine into the ethercat machines map
+            self.ethercat_machines.insert(
+                machine_identification.machine_identification_unique.clone(),
+                new_machine,
+            );
+        }
+    }
+
+    pub fn get(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<&Result<Arc<Mutex<dyn Machine>>, anyhow::Error>> {
+        self.ethercat_machines
+            .get(machine_identification)
+            .or_else(|| self.serial_machines.get(machine_identification))
+    }
+
+    pub fn add_serial_device(
+        &mut self,
+        device_identification: &DeviceIdentification,
+        device: Arc<RwLock<dyn SerialDevice>>,
+        machine_registry: &MachineRegistry,
+        socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+        machine_manager: Weak<RwLock<MachineManager>>,
+    ) {
+        let hardware = MachineNewHardwareSerial { device };
+
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        let new_machine = machine_registry.new_machine(&MachineNewParams {
+            device_group: &vec![device_identification_identified.clone()],
+            hardware: &MachineNewHardware::Serial(&hardware),
+            socket_queue_tx,
+            machine_manager: machine_manager.clone(),
+        });
+
+        tracing::info!("Adding serial machine {:?}", new_machine);
+
+        self.serial_machines.insert(
+            device_identification_identified
+                .device_machine_identification
+                .machine_identification_unique,
+            new_machine,
+        );
+    }
+
+    pub fn remove_serial_device(&mut self, device_identification: &DeviceIdentification) {
+        let device_identification_identified: DeviceIdentificationIdentified =
+            device_identification
+                .clone()
+                .try_into()
+                .expect("Serial devices always have machine identification");
+
+        tracing::info!(
+            "Removing serial machine {:?}",
+            device_identification_identified
+        );
+
+        self.serial_machines.remove(
+            &device_identification_identified
+                .device_machine_identification
+                .machine_identification_unique,
+        );
+    }
+
+    pub fn get_machine_weak(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Weak<Mutex<dyn Machine>>> {
+        let machine = self.ethercat_machines.get(machine_identification);
+        let machine = match machine {
+            Some(machine) => machine,
+            None => {
+                return None;
+            }
+        };
+        let machine = match machine {
+            Ok(machine) => machine,
+            Err(_) => {
+                return None;
+            }
+        };
+        let machine_weak = Arc::downgrade(machine);
+        return Some(machine_weak);
+    }
+
+    pub fn get_serial_weak(
+        &self,
+        machine_identification: &MachineIdentificationUnique,
+    ) -> Option<Weak<Mutex<dyn Machine>>> {
+        let machine = self.serial_machines.get(machine_identification);
+        let machine = match machine {
+            Some(machine) => machine,
+            None => {
+                return None;
+            }
+        };
+        let machine = match machine {
+            Ok(machine) => machine,
+            Err(_) => {
+                return None;
+            }
+        };
+        let machine_weak = Arc::downgrade(machine);
+        return Some(machine_weak);
+    }
+}
+
+/// Groups devices by machine identification
+///
+/// Returns a DeviceGroupingResult containing:
+/// - device_groups: a vector of devices grouped by machine identification
+/// - unidentified_devices: a vector of devices that could not be identified
+pub fn group_devices_by_identification(
+    device_identifications: &Vec<DeviceIdentification>,
+) -> DeviceGroupingResult {
+    let mut device_groups: Vec<Vec<DeviceIdentificationIdentified>> = Vec::new();
+    let mut unidentified_devices: Vec<DeviceIdentification> = Vec::new();
+
+    for device_identification in device_identifications {
+        // if vendor or serial or machine is 0, it is not a valid machine device
+        if let Some(device_machine_identification) =
+            device_identification.device_machine_identification.as_ref()
+        {
+            if !device_machine_identification.is_valid() {
+                unidentified_devices.push(device_identification.clone());
+
+                continue;
+            }
+        } else {
+            unidentified_devices.push(device_identification.clone());
+            continue;
+        }
+
+        // scan over all deice groups
+        // get the first DeviceMachineIdentification
+        // compare and append to the group
+        let mut found = false;
+        for check_group in device_groups.iter_mut() {
+            // get first device in group
+            let first_device = check_group.first().expect("group to not be empty");
+            let first_device_machine_identification = &first_device
+                .device_machine_identification
+                .machine_identification_unique;
+
+            // chek if it has machine identification
+            if let Some(device_machine_identification) =
+                device_identification.device_machine_identification.as_ref()
+            {
+                // compare with the current device
+                if first_device_machine_identification
+                    == &device_machine_identification.machine_identification_unique
+                {
+                    let device_identification_identified = device_identification
+                        .clone()
+                        .try_into()
+                        .expect("should have Some(DeviceMachineIdentification)");
+                    check_group.push(device_identification_identified);
+                    found = true;
+                    break;
+                }
+            }
+        }
+
+        if !found {
+            let device_identification_identified = device_identification
+                .clone()
+                .try_into()
+                .expect("should have Some(DeviceMachineIdentification)");
+            device_groups.push(vec![device_identification_identified]);
+        }
+    }
+
+    DeviceGroupingResult {
+        device_groups,
+        unidentified_devices,
+    }
+}
+
+/// Structure to hold the result of grouping devices by identification
+#[derive(Debug)]
+pub struct DeviceGroupingResult {
+    /// Devices grouped by machine identification
+    pub device_groups: Vec<Vec<DeviceIdentificationIdentified>>,
+    /// Devices that could not be identified
+    pub unidentified_devices: Vec<DeviceIdentification>,
+}
@@ -0,0 +1,82 @@
+use std::{collections::HashMap, sync::Arc};
+
+use smol::lock::Mutex;
+
+use super::{Machine, identification::MachineIdentificationUnique, manager::MachineManager};
+
+pub enum MachineManagerIter<'a> {
+    EthercatMachines {
+        iter: std::collections::hash_map::Iter<
+            'a,
+            MachineIdentificationUnique,
+            Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+        >,
+    },
+    SerialMachines {
+        iter: std::collections::hash_map::Iter<
+            'a,
+            MachineIdentificationUnique,
+            Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+        >,
+    },
+    Done,
+}
+
+pub struct MachineManagerIterator<'a> {
+    iter: MachineManagerIter<'a>,
+    serial_machines:
+        &'a HashMap<MachineIdentificationUnique, Result<Arc<Mutex<dyn Machine>>, anyhow::Error>>,
+}
+
+impl<'a> Iterator for MachineManagerIterator<'a> {
+    type Item = (
+        &'a MachineIdentificationUnique,
+        &'a Result<Arc<Mutex<dyn Machine>>, anyhow::Error>,
+    );
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match &mut self.iter {
+                MachineManagerIter::EthercatMachines { iter } => {
+                    // Try to get the next item from ethercat_machines
+                    if let Some(item) = iter.next() {
+                        return Some(item);
+                    } else {
+                        // If ethercat_machines is exhausted, move to serial_machines
+                        self.iter = MachineManagerIter::SerialMachines {
+                            iter: self.serial_machines.iter(),
+                        };
+                        // Continue to the next iteration of the loop
+                        continue;
+                    }
+                }
+                MachineManagerIter::SerialMachines { iter } => {
+                    // Return the next item from serial_machines or None if exhausted
+                    if let Some(item) = iter.next() {
+                        return Some(item);
+                    } else {
+                        // If serial_machines is also exhausted, we're done
+                        self.iter = MachineManagerIter::Done;
+                        return None;
+                    }
+                }
+                MachineManagerIter::Done => {
+                    // We've exhausted both collections
+                    return None;
+                }
+            }
+        }
+    }
+}
+
+impl MachineManager {
+    // Returns an iterator over all machines (both ethercat and serial)
+    pub fn iter(&self) -> MachineManagerIterator {
+        MachineManagerIterator {
+            iter: MachineManagerIter::EthercatMachines {
+                iter: self.ethercat_machines.iter(),
+            },
+            serial_machines: &self.serial_machines,
+        }
+    }
+}
@@ -0,0 +1,80 @@
+use anyhow::anyhow;
+use api::MachineApi;
+use new::MachineNewTrait;
+use serde::Serialize;
+use smol::lock::Mutex;
+use std::any::Any;
+use std::fmt::Debug;
+use std::sync::{Arc, Weak};
+
+use crate::machines::identification::MachineIdentificationUnique;
+use crate::machines::new::MachineAct;
+pub mod api;
+pub mod identification;
+pub mod manager;
+pub mod manager_iter;
+pub mod new;
+pub mod registry;
+
+pub trait Machine: MachineAct + MachineNewTrait + MachineApi + Any + Debug + Send {
+    fn as_any(&self) -> &dyn Any;
+}
+/// Casts a `dyn Machine` to a specific machine type
+pub async fn downcast_machine<T: Machine>(
+    machine: Arc<Mutex<dyn Machine>>,
+) -> Result<Arc<Mutex<T>>, anyhow::Error> {
+    // Acquire a read lock on the RwLock
+    let read_lock = machine.lock().await;
+
+    // Check if the inner type can be downcasted to T
+    if read_lock.as_any().is::<T>() {
+        // Clone the Arc and return it as the desired type
+        let cloned_machine = Arc::clone(&machine);
+        // Transmute the Arc to the desired type
+        unsafe {
+            Ok(Arc::from_raw(
+                Arc::into_raw(cloned_machine) as *const Mutex<T>
+            ))
+        }
+    } else {
+        Err(anyhow!(
+            "[{}::downcast_machine] Downcast failed",
+            module_path!()
+        ))
+    }
+}
+
+/// Trait to get strong count to see if Weak has reference
+pub trait GetStrongCount {
+    fn get_strong_count(&self) -> usize;
+}
+
+impl<T> GetStrongCount for Weak<Mutex<T>> {
+    fn get_strong_count(&self) -> usize {
+        self.strong_count()
+    }
+}
+
+#[derive(Debug)]
+pub struct ConnectedMachine<T: GetStrongCount> {
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub machine: T,
+}
+
+#[derive(Serialize, Debug, Clone, PartialEq)]
+pub struct ConnectedMachineData {
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub is_available: bool,
+}
+
+impl<T> From<&ConnectedMachine<T>> for ConnectedMachineData
+where
+    T: GetStrongCount,
+{
+    fn from(value: &ConnectedMachine<T>) -> Self {
+        Self {
+            machine_identification_unique: value.machine_identification_unique.clone(),
+            is_available: value.machine.get_strong_count() != 0,
+        }
+    }
+}
@@ -0,0 +1,262 @@
+use crate::{machines::manager::MachineManager, serial::SerialDevice};
+
+use super::identification::DeviceIdentificationIdentified;
+use anyhow::Error;
+use ethercat_hal::{
+    devices::EthercatDevice, helpers::ethercrab_types::EthercrabSubDevicePreoperational,
+};
+use ethercrab::{SubDevice, SubDeviceRef};
+use smol::{channel::Sender, lock::RwLock};
+use socketioxide::extract::SocketRef;
+use std::{
+    pin::Pin,
+    sync::{Arc, Weak},
+    time::Instant,
+};
+
+use crate::socketio::event::GenericEvent;
+
+pub trait MachineNewTrait {
+    fn new<'maindevice, 'subdevices>(
+        params: &MachineNewParams<'maindevice, 'subdevices, '_, '_, '_, '_, '_>,
+    ) -> Result<Self, Error>
+    where
+        Self: Sized;
+}
+
+pub trait MachineAct {
+    fn act(&mut self, now: Instant) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>;
+}
+
+pub struct MachineNewParams<
+    'maindevice,
+    'subdevices,
+    'device_identifications_identified,
+    'ethercat_devices,
+    'machine_new_hardware_etehrcat,
+    'machine_new_hardware_serial,
+    'machine_new_hardware,
+> where
+    'maindevice: 'machine_new_hardware,
+    'subdevices: 'machine_new_hardware,
+    'ethercat_devices: 'machine_new_hardware,
+    'machine_new_hardware_etehrcat: 'machine_new_hardware,
+{
+    pub device_group: &'device_identifications_identified Vec<DeviceIdentificationIdentified>,
+    pub hardware: &'machine_new_hardware MachineNewHardware<
+        'maindevice,
+        'subdevices,
+        'ethercat_devices,
+        'machine_new_hardware_etehrcat,
+        'machine_new_hardware_serial,
+    >,
+    pub socket_queue_tx: Sender<(SocketRef, Arc<GenericEvent>)>,
+    pub machine_manager: Weak<RwLock<MachineManager>>,
+}
+
+pub enum MachineNewHardware<
+    'maindevice,
+    'subdevices,
+    'ethercat_devices,
+    'machine_new_hardware_etehrcat,
+    'machine_new_hardware_serial,
+> where
+    'maindevice: 'machine_new_hardware_etehrcat,
+    'subdevices: 'machine_new_hardware_etehrcat,
+    'ethercat_devices: 'machine_new_hardware_etehrcat,
+{
+    Ethercat(
+        &'machine_new_hardware_etehrcat MachineNewHardwareEthercat<
+            'maindevice,
+            'subdevices,
+            'ethercat_devices,
+        >,
+    ),
+    Serial(&'machine_new_hardware_serial MachineNewHardwareSerial),
+}
+
+pub struct MachineNewHardwareEthercat<'maindevice, 'subdevices, 'ethercat_devices> {
+    pub subdevices:
+        &'subdevices Vec<&'subdevices SubDeviceRef<'maindevice, &'subdevices SubDevice>>,
+    pub ethercat_devices: &'ethercat_devices Vec<Arc<RwLock<dyn EthercatDevice>>>,
+}
+
+pub struct MachineNewHardwareSerial {
+    pub device: Arc<RwLock<dyn SerialDevice>>,
+}
+
+// validates that all devices in the group have the same machine identification
+pub fn validate_same_machine_identification_unique(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+) -> Result<(), Error> {
+    let machine_identification_unique = &identified_device_group
+        .first()
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "[{}::validate_same_machine_identification] No devices in group",
+                module_path!()
+            )
+        })?
+        .device_machine_identification
+        .machine_identification_unique;
+    for device in identified_device_group.iter() {
+        if device
+            .device_machine_identification
+            .machine_identification_unique
+            != *machine_identification_unique
+        {
+            return Err(anyhow::anyhow!(
+                "[{}::validate_same_machine_identification] Different machine identifications",
+                module_path!()
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// validates that every role is unique
+pub fn validate_no_role_dublicates(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+) -> Result<(), Error> {
+    let mut roles = vec![];
+    for device in identified_device_group.iter() {
+        if roles.contains(&device.device_machine_identification.role) {
+            return Err(anyhow::anyhow!(
+                "[{}::validate_no_role_dublicates] Role dublicate",
+                module_path!(),
+            ));
+        }
+        roles.push(device.device_machine_identification.role);
+    }
+    Ok(())
+}
+
+// Inside control_core::machines::new module:
+pub fn get_device_identification_by_role(
+    identified_device_group: &Vec<DeviceIdentificationIdentified>,
+    role: u16,
+) -> Result<&DeviceIdentificationIdentified, Error> {
+    for device in identified_device_group.iter() {
+        if device.device_machine_identification.role == role {
+            return Ok(device);
+        }
+    }
+    Err(anyhow::anyhow!(
+        "[{}::get_device_identification_by_role] Role {} not found",
+        module_path!(),
+        role
+    ))
+}
+
+pub fn get_device_by_index<'maindevice>(
+    devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
+    subdevice_index: usize,
+) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
+    Ok(devices
+        .get(subdevice_index)
+        .ok_or(anyhow::anyhow!(
+            "[{}::get_device_by_index] Index {} out of bounds for devices",
+            module_path!(),
+            subdevice_index
+        ))?
+        .clone())
+}
+
+pub fn get_subdevice_by_index<'subdevices, 'maindevice>(
+    subdevices: &'subdevices Vec<&EthercrabSubDevicePreoperational<'maindevice>>,
+    subdevice_index: usize,
+) -> Result<&'subdevices EthercrabSubDevicePreoperational<'maindevice>, Error> {
+    Ok(subdevices.get(subdevice_index).ok_or(anyhow::anyhow!(
+        "Index {} out of bounds for subdevices",
+        subdevice_index
+    ))?)
+}
+
+pub fn get_ethercat_device_by_index<'maindevice>(
+    ethercat_devices: &Vec<Arc<RwLock<dyn EthercatDevice>>>,
+    subdevice_index: usize,
+) -> Result<Arc<RwLock<dyn EthercatDevice>>, Error> {
+    Ok(ethercat_devices
+        .get(subdevice_index)
+        .ok_or(anyhow::anyhow!(
+            "[{}::get_ethercat_device_by_index] Index {} out of bounds for ethercat devices",
+            module_path!(),
+            subdevice_index
+        ))?
+        .clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::machines::identification::{
+        DeviceHardwareIdentification, DeviceHardwareIdentificationEthercat,
+        DeviceMachineIdentification, MachineIdentification, MachineIdentificationUnique,
+    };
+
+    pub use super::*;
+
+    #[test]
+    fn test_get_device_identification_by_role() {
+        let device_identifications = vec![
+            // role 0
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 1,
+                            machine: 1,
+                        },
+                        serial: 1,
+                    },
+                    role: 0,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 0 },
+                ),
+            },
+            // role 1
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 2,
+                            machine: 2,
+                        },
+                        serial: 2,
+                    },
+                    role: 2,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 1 },
+                ),
+            },
+            // role 2
+            DeviceIdentificationIdentified {
+                device_machine_identification: DeviceMachineIdentification {
+                    machine_identification_unique: MachineIdentificationUnique {
+                        machine_identification: MachineIdentification {
+                            vendor: 3,
+                            machine: 3,
+                        },
+                        serial: 3,
+                    },
+                    role: 1,
+                },
+                device_hardware_identification: DeviceHardwareIdentification::Ethercat(
+                    DeviceHardwareIdentificationEthercat { subdevice_index: 2 },
+                ),
+            },
+        ];
+
+        // search for role 0
+        let result = get_device_identification_by_role(&device_identifications, 0);
+        assert_eq!(result.unwrap().device_machine_identification.role, 0,);
+
+        // search for role 1
+        let result = get_device_identification_by_role(&device_identifications, 1);
+        assert_eq!(result.unwrap().device_machine_identification.role, 1,);
+        // search for role 2
+        let result = get_device_identification_by_role(&device_identifications, 2);
+        assert_eq!(result.unwrap().device_machine_identification.role, 2,);
+    }
+}
@@ -1,31 +1,15 @@
-#[cfg(feature = "mock-machine")]
-use crate::machines::{extruder1::mock::ExtruderV2, mock::MockMachine, winder2::mock::Winder2};
-
-use crate::{Machine, MachineNewParams, machine_identification::MachineIdentification};
-#[cfg(not(feature = "mock-machine"))]
-use crate::{
-    aquapath1::AquaPathV1, buffer1::BufferV1, extruder1::ExtruderV2, laser::LaserMachine,
-    winder2::Winder2,
-};
-
-use lazy_static::lazy_static;
-
+use super::{Machine, identification::MachineIdentification, new::MachineNewParams};
 use anyhow::Error;
-use std::{any::TypeId, collections::HashMap};
+use smol::lock::Mutex;
+use std::{any::TypeId, collections::HashMap, sync::Arc};

 pub type MachineNewClosure =
-    Box<dyn Fn(&MachineNewParams) -> Result<Box<dyn Machine>, Error> + Send + Sync>;
+    Box<dyn Fn(&MachineNewParams) -> Result<Arc<Mutex<dyn Machine>>, Error> + Send + Sync>;

 pub struct MachineRegistry {
    type_map: HashMap<TypeId, (MachineIdentification, MachineNewClosure)>,
 }

-impl Default for MachineRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl MachineRegistry {
    pub fn new() -> Self {
        Self {
@@ -40,9 +24,11 @@ impl MachineRegistry {
        self.type_map.insert(
            TypeId::of::<T>(),
            (
-                machine_identficiation.clone(),
+                machine_identficiation,
                // create a machine construction closure
-                Box::new(|machine_new_params| Ok(Box::new(T::new(machine_new_params)?))),
+                Box::new(|machine_new_params| {
+                    Ok(Arc::new(Mutex::new(T::new(machine_new_params)?)))
+                }),
            ),
        );
    }
@@ -50,7 +36,7 @@ impl MachineRegistry {
    pub fn new_machine(
        &self,
        machine_new_params: &MachineNewParams,
-    ) -> Result<Box<dyn Machine>, anyhow::Error> {
+    ) -> Result<Arc<Mutex<dyn Machine>>, anyhow::Error> {
        // get machiine identification
        let device_identification =
            &machine_new_params
@@ -80,24 +66,3 @@ impl MachineRegistry {
        (machine_new_closure)(machine_new_params)
    }
 }
-
-lazy_static! {
-    pub static ref MACHINE_REGISTRY: MachineRegistry = {
-        let mut mc = MachineRegistry::new();
-        mc.register::<Winder2>(Winder2::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
-    };
-}
@@ -2,10 +2,10 @@ pub mod modbus_serial_interface;

 use anyhow::Error;
 use crc::{CRC_16_MODBUS, Crc};
-use serialport::SerialPort;
+use serial;
 use std::time::Duration;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+
 pub enum ParityType {
    Even,
    Odd,
@@ -62,17 +62,17 @@ impl From<ModbusExceptionCode> for u8 {
 impl From<u8> for ModbusExceptionCode {
    fn from(value: u8) -> Self {
        match value {
-            0 => Self::None,
-            1 => Self::IllegalFunction,
-            2 => Self::IllegalDataAddress,
-            3 => Self::IllegalDataValue,
-            4 => Self::SlaveDeviceFailure,
-            5 => Self::Acknowledge,
-            6 => Self::SlaveDeviceBusy,
-            8 => Self::MemoryParityError,
-            10 => Self::GatewayPathUnavailable,
-            11 => Self::GatewayTargetDeviceFailedToRespond,
-            other => Self::Unknown(other),
+            0 => ModbusExceptionCode::None,
+            1 => ModbusExceptionCode::IllegalFunction,
+            2 => ModbusExceptionCode::IllegalDataAddress,
+            3 => ModbusExceptionCode::IllegalDataValue,
+            4 => ModbusExceptionCode::SlaveDeviceFailure,
+            5 => ModbusExceptionCode::Acknowledge,
+            6 => ModbusExceptionCode::SlaveDeviceBusy,
+            8 => ModbusExceptionCode::MemoryParityError,
+            10 => ModbusExceptionCode::GatewayPathUnavailable,
+            11 => ModbusExceptionCode::GatewayTargetDeviceFailedToRespond,
+            other => ModbusExceptionCode::Unknown(other),
        }
    }
 }
@@ -97,10 +97,10 @@ impl TryFrom<u8> for ModbusFunctionCode {

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
-            0x03 => Ok(Self::ReadHoldingRegister),
-            0x04 => Ok(Self::ReadInputRegister),
-            0x06 => Ok(Self::PresetHoldingRegister),
-            0x08 => Ok(Self::DiagnoseFunction),
+            0x03 => Ok(ModbusFunctionCode::ReadHoldingRegister),
+            0x04 => Ok(ModbusFunctionCode::ReadInputRegister),
+            0x06 => Ok(ModbusFunctionCode::PresetHoldingRegister),
+            0x08 => Ok(ModbusFunctionCode::DiagnoseFunction),
            _ => Err(anyhow::anyhow!("Error: Modbus Function Code doesnt exist!")),
        }
    }
@@ -119,7 +119,7 @@ impl From<ModbusFunctionCode> for u8 {

 impl From<ModbusRequest> for Vec<u8> {
    fn from(request: ModbusRequest) -> Self {
-        let mut buffer = Self::new();
+        let mut buffer = Vec::new();

        buffer.push(request.slave_id);
        buffer.push(request.function_code.into()); // convert functioncode into u8 and push it
@@ -132,7 +132,7 @@ impl From<ModbusRequest> for Vec<u8> {
        // convert u16 value to le_bytes and add it to the end of the frame
        buffer.extend_from_slice(&result_crc.to_le_bytes());

-        buffer
+        return buffer;
    }
 }
 /// Reads data from a Modbus device via a serial port.
@@ -143,7 +143,9 @@ impl From<ModbusRequest> for Vec<u8> {
 /// # Returns
 /// A `Result` containing an `Option` with the raw Modbus response as a `Vec<u8>` if successful,
 /// or `None` if the response is invalid or an error occurs.
-pub fn receive_data_modbus(port: &mut dyn SerialPort) -> Result<Option<Vec<u8>>, anyhow::Error> {
+pub fn receive_data_modbus(
+    port: &mut dyn serial::SerialPort,
+) -> Result<Option<Vec<u8>>, anyhow::Error> {
    let mut buf: [u8; 256] = [0; 256];
    let data_length = port.read(&mut buf)?;
    if data_length == 0 {
@@ -153,7 +155,7 @@ pub fn receive_data_modbus(port: &mut dyn SerialPort) -> Result<Option<Vec<u8>>,
 }

 /// Computes Modbus CRC-16 using `crc` crate.
-pub const fn modbus_crc16(data: &[u8]) -> u16 {
+pub fn modbus_crc16(data: &[u8]) -> u16 {
    let modbus: Crc<u16> = Crc::<u16>::new(&CRC_16_MODBUS);
    modbus.checksum(data)
 }
@@ -204,17 +206,23 @@ fn extract_crc(raw_data: &Vec<u8>) -> Result<u16, Error> {
 }
 impl TryFrom<Vec<u8>> for ModbusResponse {
    type Error = anyhow::Error;
-    fn try_from(value: Vec<u8>) -> Result<Self, Error> {
-        let crc = extract_crc(&value)?;
+    fn try_from(value: Vec<u8>) -> Result<ModbusResponse, Error> {
+        let crc = match extract_crc(&value) {
+            Ok(crc_value) => crc_value,
+            Err(err) => return Err(err),
+        };

        let function_code_res = ModbusFunctionCode::try_from(value[1]);
-        let function_code = function_code_res?;
+        let function_code = match function_code_res {
+            Ok(code) => code,
+            Err(err) => return Err(err),
+        };

-        Ok(Self {
+        Ok(ModbusResponse {
            slave_id: value[0],
-            function_code,
+            function_code: function_code,
            data: value[2..value.len() - 2].to_vec(), // get data without the crc
-            crc,
+            crc: crc,
        })
    }
 }
@@ -226,23 +234,23 @@ impl TryFrom<Vec<u8>> for ModbusResponse {
 /// machine_operation_delay_nano: Delay for the given operation in nanoseconds as specified by the slaves datasheet (example: mitsubishi csfr84 has 12ms for read write in RAM)
 /// baudrate: bits per second
 /// message_size: size of original message in bytes
-pub const fn calculate_modbus_rtu_timeout(
+pub fn calculate_modbus_rtu_timeout(
    bits: u8,
    machine_operation_delay_nano: Duration,
    baudrate: u32,
    message_size: usize,
 ) -> Duration {
    let nanoseconds_per_bit: u64 = (1000000 / baudrate) as u64;
-    let nanoseconds_per_byte: u64 = bits as u64 * nanoseconds_per_bit;
+    let nanoseconds_per_byte: u64 = bits as u64 * nanoseconds_per_bit as u64;

    let transmission_timeout: u64 = nanoseconds_per_byte * message_size as u64;
-    let silent_time: u64 = (nanoseconds_per_byte * (35)) / 10_u64; // silent_time is 3.5x of character length,which is 11 bit for 8E1
+    let silent_time: u64 = (nanoseconds_per_byte * (35)) / 10 as u64; // silent_time is 3.5x of character length,which is 11 bit for 8E1

    let mut full_timeout: u64 = transmission_timeout;
    full_timeout += machine_operation_delay_nano.as_nanos() as u64;
    full_timeout += silent_time;

-    Duration::from_nanos(full_timeout)
+    return Duration::from_nanos(full_timeout);
 }

 #[cfg(test)]
@@ -66,7 +66,7 @@ impl ModbusSerialInterface {
        }
    }

-    pub const fn is_initialized(&self) -> bool {
+    pub fn is_initialized(&self) -> bool {
        !matches!(self.state, State::Uninitialized)
    }

@@ -199,7 +199,7 @@ impl ModbusSerialInterface {
        Some(Duration::from_nanos(total_timeout))
    }

-    pub const fn get_response(&self) -> Option<&ModbusResponse> {
+    pub fn get_response(&self) -> Option<&ModbusResponse> {
        self.response.as_ref()
    }

@@ -1,7 +1,7 @@
 use tracing::debug;
 use tracing::error;

-#[cfg(target_os = "linux")]
+#[cfg(unix)]
 /// Makes the current thread a real-time thread using the PREEMPT_RT capabilities of Linux.
 ///
 /// This function configures the current thread with real-time scheduling properties by:
@@ -47,7 +47,7 @@ use tracing::error;
 ///
 /// - `Ok(())` if the real-time priority was successfully set
 /// - `Err` with the error message if setting the priority failed
-#[cfg(target_os = "linux")]
+#[cfg(unix)]
 pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
    use anyhow::anyhow;
    use libc::{SCHED_FIFO, pthread_setschedparam, sched_param};
@@ -84,9 +84,9 @@ pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
    Ok(())
 }

-#[cfg(not(target_os = "linux"))]
+#[cfg(not(unix))]
 pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
-    tracing::error!("This platform does not support realtime threads");
+    log::error!("This platform does not support realtime threads");
    Ok(())
 }

@@ -137,7 +137,7 @@ pub fn set_realtime_priority() -> Result<(), anyhow::Error> {
 /// # How it works
 ///
 /// [Rest of documentation as before...]
-#[cfg(target_os = "linux")]
+#[cfg(unix)]
 pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
    use libc::{MCL_FUTURE, mlockall};

@@ -154,9 +154,9 @@ pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

-#[cfg(not(target_os = "linux"))]
+#[cfg(not(unix))]
 pub fn lock_memory() -> Result<(), Box<dyn std::error::Error>> {
-    tracing::error!("This platform does not support memory locking");
+    log::error!("This platform does not support memory locking");
    Ok(())
 }

@@ -0,0 +1 @@
+pub mod mutation;
@@ -0,0 +1,35 @@
+use std::fmt::Debug;
+
+use serde::Serialize;
+
+use crate::machines::identification::MachineIdentificationUnique;
+
+#[derive(Debug, Serialize, Clone)]
+pub struct MutationResponse {
+    pub success: bool,
+    pub error: Option<String>,
+}
+
+impl MutationResponse {
+    pub fn success() -> Self {
+        Self {
+            success: true,
+            error: None,
+        }
+    }
+    pub fn error(error: String) -> Self {
+        Self {
+            success: false,
+            error: Some(error),
+        }
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct MachineMutationBody<T>
+where
+    T: Debug,
+{
+    pub machine_identification_unique: MachineIdentificationUnique,
+    pub data: T,
+}
@@ -1,10 +1,12 @@
-/*use std::{any::Any, sync::Arc};
+use std::{any::Any, sync::Arc};

 use smol::lock::RwLock;
 use std::fmt::Debug;

 use crate::machines::identification::DeviceIdentification;

+pub mod panic;
+pub mod registry;
 pub mod serial_detection;

 pub trait SerialDevice: Any + Send + Sync + SerialDeviceNew + Debug {}
@@ -23,11 +25,11 @@ pub trait SerialDeviceThread {

 pub struct SerialDeviceNewParams {
    pub path: String,
+    pub device_thread_panic_tx: smol::channel::Sender<(String, anyhow::Error)>,
 }

-#[derive(PartialEq, Eq, Clone, Debug, Hash)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct SerialDeviceIdentification {
    pub vendor_id: u16,
    pub product_id: u16,
 }
-*/
@@ -0,0 +1,52 @@
+use smol::channel::Sender;
+
+/// 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<(T, anyhow::Error)>,
+) 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");
+        }
+    }
+
+    let device_id_clone = device_identifier.clone();
+    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((
+                    device_id_clone.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
+    }));
+}
@@ -1,14 +1,8 @@
-use lazy_static::lazy_static;
-
+use super::SerialDeviceNewParams;
 use crate::{
-    SerialDevice, SerialDeviceIdentification, machine_identification::DeviceIdentification,
-    serial::devices::laser::Laser,
+    machines::identification::DeviceIdentification,
+    serial::{SerialDevice, SerialDeviceIdentification},
 };
-
-#[cfg(feature = "mock-machine")]
-use crate::serial::devices::mock::MockSerialDevice;
-
-use crate::SerialDeviceNewParams;
 use anyhow::{Error, Result};
 use smol::lock::RwLock;
 use std::{any::TypeId, collections::HashMap, sync::Arc};
@@ -26,12 +20,6 @@ pub struct SerialDeviceRegistry {
    pub type_map: HashMap<TypeId, (SerialDeviceIdentification, SerialDeviceNewClosure)>,
 }

-impl Default for SerialDeviceRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl SerialDeviceRegistry {
    pub fn new() -> Self {
        Self {
@@ -100,22 +88,3 @@ impl SerialDeviceRegistry {
        }
    }
 }
-
-lazy_static! {
-    pub static ref SERIAL_DEVICE_REGISTRY: SerialDeviceRegistry = {
-        let mut sdr = SerialDeviceRegistry::new();
-        sdr.register::<Laser>(SerialDeviceIdentification {
-            vendor_id: 0x0403,
-            product_id: 0x6001,
-        });
-
-        // Register MockSerialDevice when mock-machine feature is enabled
-        #[cfg(feature = "mock-machine")]
-        sdr.register::<MockSerialDevice>(SerialDeviceIdentification {
-            vendor_id: 0x0001, // VENDOR_QITECH
-            product_id: 0x0007, // MACHINE_MOCK
-        });
-
-        sdr
-    };
-}
@@ -7,70 +7,175 @@
 */

 use serialport::{SerialPortInfo, SerialPortType, UsbPortInfo};
-use std::collections::HashMap;
+use smol::{
+    channel::{Receiver, Sender, unbounded},
+    lock::RwLock,
+};
+use std::{collections::HashMap, sync::Arc};

-use super::SerialDeviceIdentification;
-/// Handles scanning and caching of connected USB serial devices.
-pub struct SerialDetection {}
+use crate::{
+    helpers::compare_lists::compare_lists, machines::identification::DeviceIdentification,
+};

-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(),
+use super::{
+    SerialDevice, SerialDeviceIdentification, SerialDeviceNewParams, registry::SerialDeviceRegistry,
+};
+
+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<(String, anyhow::Error)>,
+    pub device_removal_signal_tx: Sender<(String, anyhow::Error)>,
+}
+
+impl<'serialdeviceregistry> SerialDetection<'serialdeviceregistry> {
+    pub fn new(serial_device_registry: &'serialdeviceregistry SerialDeviceRegistry) -> Self {
+        let (device_removal_signal_tx, device_removal_signal_rx) =
+            unbounded::<(String, anyhow::Error)>();
+        SerialDetection {
+            serial_device_registry,
+            ports: HashMap::new(),
+            device_removal_signal_rx,
+            device_removal_signal_tx,
        }
    }

-    /// 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();
+    /*
+     *@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();

        for port in port_list {
-            if let SerialPortType::UsbPort(usb_info) = port.port_type {
-                map.insert(port.port_name, usb_info);
-            }
-        }
-        map
-    }
-
-    /// 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();
-        let usb_devices = Self::extract_usb_serial_devices(ports);
-        usb_devices
-    }
-
-    pub fn device_port_exists(device_path: &str) -> bool {
-        let ports = Self::get_ports();
-        return ports.iter().any(|p| p.port_name == device_path);
-    }
-
-    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;
+            match &port.port_type {
+                SerialPortType::UsbPort(usb_info) => {
+                    usb_ports.push((port.port_name.to_string(), usb_info.clone()));
                }
-            }
+                _ => {}
+            };
        }
-        return false;
+
+        return usb_ports;
    }

-    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());
+    pub async fn check_ports(&mut self) -> CheckPortsResult {
+        // get available ports
+        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);
            }
        }
-        return None;
+
+        result
+    }
+
+    pub async fn check_remove_signals(&mut self) -> Vec<DeviceIdentification> {
+        let mut removed_signals: Vec<DeviceIdentification> = Vec::new();
+        match self.device_removal_signal_rx.try_recv() {
+            Ok((path, error)) => {
+                // remove the device when the tuple positon 1 equals signal
+                if let Some(info) = self.ports.get(&path.clone()) {
+                    removed_signals.push(info.1.clone());
+                };
+                self.ports.remove(&path);
+
+                tracing::trace!("Removed device: {:?}: {}", path, error);
+            }
+            Err(_) => {}
+        }
+        removed_signals
    }
 }
+
+#[derive(Debug)]
+pub struct CheckPortsResult {
+    pub added: Vec<(DeviceIdentification, Arc<RwLock<dyn SerialDevice>>)>,
+    pub removed: Vec<DeviceIdentification>,
+}
@@ -21,10 +21,6 @@ impl std::fmt::Debug for GenericEvent {
    }
 }

-pub trait BuildEvent: Serialize + Send + Sync + Clone {
-    fn build(&self) -> Event<Self>;
-}
-
 #[derive(Debug, Clone, Serialize)]
 pub struct Event<T>
 where
@@ -1,2 +1,3 @@
 pub mod event;
 pub mod namespace;
+pub mod namespace_id;
@@ -4,7 +4,7 @@ use socketioxide::extract::SocketRef;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tracing::instrument;

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Namespace {
    pub sockets: Vec<SocketRef>,
    pub events: HashMap<String, Vec<Arc<GenericEvent>>>,
@@ -30,7 +30,7 @@ impl Namespace {
    #[instrument(skip_all)]
    pub fn subscribe(&mut self, socket: SocketRef) {
        // add the socket to the list
-        self.sockets.push(socket);
+        self.sockets.push(socket.clone());
    }

    /// Removes a socket from the namespace.
@@ -81,7 +81,7 @@ impl Namespace {
        for (_event_name, events) in event_groups {
            for event in events {
                // Send to global queue instead of per-socket queue
-                self.send_to_queue(&socket, event, "reemit");
+                self.send_to_queue(&socket, &event, "reemit");
            }
        }
    }
@@ -97,10 +97,13 @@ impl Namespace {
    fn cache(
        &mut self,
        event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
+        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>,
    ) {
-        let cached_events_for_key = self.events.entry(event.name.clone()).or_default();
-        buffer_fn(cached_events_for_key, &event);
+        let mut cached_events_for_key = self
+            .events
+            .entry(event.name.clone())
+            .or_insert_with(Vec::new);
+        buffer_fn(&mut cached_events_for_key, &event);
    }

    /// Emits an event to all sockets in the namespace and caches it.
@@ -114,10 +117,11 @@ impl Namespace {
    pub fn emit(
        &mut self,
        event: Arc<GenericEvent>,
-        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>,
+        buffer_fn: &Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>,
    ) {
        // cache the event
-        self.cache(event.clone(), buffer_fn);
+        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() {
@@ -167,7 +171,7 @@ impl Namespace {

 impl Drop for Namespace {
    fn drop(&mut self) {
-        //self.disconnect_all();
+        self.disconnect_all();
    }
 }

@@ -187,7 +191,7 @@ pub trait CacheableEvents<Events> {
    fn event_cache_fn(&self) -> CacheFn;
 }

-pub type CacheFn = Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>)>;
+pub type CacheFn = Box<dyn Fn(&mut Vec<Arc<GenericEvent>>, &Arc<GenericEvent>) -> ()>;

 /// [`BufferFn`] that stores the last n events
 pub fn cache_n_events(n: usize) -> CacheFn {
@@ -219,6 +223,7 @@ pub fn cache_first_and_last_event() -> CacheFn {
        if events.len() == 2 {
            events.remove(1);
            events.push(event.clone());
+            return;
        }
    })
 }
@@ -3,7 +3,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 use std::str::FromStr;

-use machines::machine_identification::{MachineIdentification, MachineIdentificationUnique};
+use crate::machines::identification::{MachineIdentification, MachineIdentificationUnique};

 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub enum NamespaceId {
@@ -17,8 +17,8 @@ impl Serialize for NamespaceId {
        S: Serializer,
    {
        match self {
-            Self::Main => serializer.serialize_str("/main"),
-            Self::Machine(id) => {
+            NamespaceId::Main => serializer.serialize_str("/main"),
+            NamespaceId::Machine(id) => {
                let path = format!(
                    "/machine/{}/{}/{}",
                    id.machine_identification.vendor, id.machine_identification.machine, id.serial
@@ -36,7 +36,7 @@ impl<'de> Deserialize<'de> for NamespaceId {
    {
        struct NamespaceIdVisitor;

-        impl Visitor<'_> for NamespaceIdVisitor {
+        impl<'de> Visitor<'de> for NamespaceIdVisitor {
            type Value = NamespaceId;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -85,7 +85,7 @@ impl FromStr for NamespaceId {

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if s == "/main" {
-            return Ok(Self::Main);
+            return Ok(NamespaceId::Main);
        }

        if let Some(machine_path) = s.strip_prefix("/machine/") {
@@ -101,7 +101,7 @@ impl FromStr for NamespaceId {
                    .parse::<u16>()
                    .map_err(|_| "Invalid serial id".to_string())?;

-                return Ok(Self::Machine(MachineIdentificationUnique {
+                return Ok(NamespaceId::Machine(MachineIdentificationUnique {
                    machine_identification: MachineIdentification { vendor, machine },
                    serial,
                }));
@@ -116,8 +116,8 @@ impl FromStr for NamespaceId {
 impl fmt::Display for NamespaceId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            Self::Main => write!(f, "/main"),
-            Self::Machine(id) => {
+            NamespaceId::Main => write!(f, "/main"),
+            NamespaceId::Machine(id) => {
                write!(
                    f,
                    "/machine/{}/{}/{}",
@@ -1,27 +0,0 @@
-use crate::transmission::Transmission;
-
-#[derive(Debug, Clone)]
-pub struct FixedTransmission {
-    ratio: f64,
-}
-
-impl Transmission for FixedTransmission {
-    fn get_ratio(&self) -> f64 {
-        self.ratio
-    }
-}
-
-impl FixedTransmission {
-    /// Creates a new FixedTransmission with the specified ratio.
-    ///
-    /// # Arguments
-    ///
-    /// * `ratio` - The transmission ratio (output over input).
-    ///
-    /// # Returns
-    ///
-    /// A new instance of FixedTransmission.
-    pub const fn new(ratio: f64) -> Self {
-        Self { ratio }
-    }
-}
@@ -1,95 +0,0 @@
-use units::{
-    angle::radian,
-    angular_velocity::radian_per_second,
-    f64::{Angle, AngularVelocity, Length, Velocity},
-    length::meter,
-    velocity::meter_per_second,
-};
-
-pub mod fixed;
-
-/// A trait representing a mechanical transmission system that converts input to output
-/// with a specific gear ratio.
-///
-/// This trait provides methods for working with transmission ratios and converting
-/// between input and output values based on the transmission's gear ratio.
-pub trait Transmission {
-    /// Returns the transmission ratio of this transmission system.
-    ///
-    /// The ratio represents the relationship between input and output speeds/torques.
-    /// A ratio greater than 1.0 indicates speed reduction (torque multiplication),
-    /// while a ratio less than 1.0 indicates speed increase (torque reduction).
-    ///
-    /// # Returns
-    ///
-    /// The transmission ratio as a floating-point number.
-    fn get_ratio(&self) -> f64;
-
-    /// Converts an input value to the corresponding output value using the transmission ratio.
-    ///
-    /// This method multiplies the input by the transmission ratio to calculate the output.
-    /// Typically used for converting input speed to output speed in a transmission system.
-    ///
-    /// # Arguments
-    ///
-    /// * `input` - The input value to be converted
-    ///
-    /// # Returns
-    ///
-    /// The output value after applying the transmission ratio.
-    fn calculate_output(&self, input: f64) -> f64 {
-        input * self.get_ratio()
-    }
-
-    /// Converts an output value to the corresponding input value using the transmission ratio.
-    ///
-    /// This method divides the output by the transmission ratio to calculate the required input.
-    /// Typically used for determining what input is needed to achieve a desired output.
-    ///
-    /// # Arguments
-    ///
-    /// * `output` - The output value to be converted back to input
-    ///
-    /// # Returns
-    ///
-    /// The input value required to produce the given output.
-    fn calculate_input(&self, output: f64) -> f64 {
-        output / self.get_ratio()
-    }
-
-    fn calculate_angular_output(&self, input: Angle) -> Angle {
-        Angle::new::<radian>(self.calculate_output(input.get::<radian>()))
-    }
-
-    fn calculate_angular_input(&self, output: Angle) -> Angle {
-        Angle::new::<radian>(self.calculate_input(output.get::<radian>()))
-    }
-
-    fn calculate_angular_velocity_output(&self, input: AngularVelocity) -> AngularVelocity {
-        AngularVelocity::new::<radian_per_second>(
-            self.calculate_output(input.get::<radian_per_second>()),
-        )
-    }
-
-    fn calculate_angular_velocity_input(&self, output: AngularVelocity) -> AngularVelocity {
-        AngularVelocity::new::<radian_per_second>(
-            self.calculate_input(output.get::<radian_per_second>()),
-        )
-    }
-
-    fn calculate_linear_output(&self, input: Length) -> Length {
-        Length::new::<meter>(self.calculate_output(input.get::<meter>()))
-    }
-
-    fn calculate_linear_input(&self, output: Length) -> Length {
-        Length::new::<meter>(self.calculate_input(output.get::<meter>()))
-    }
-
-    fn calculate_linear_velocity_output(&self, input: Velocity) -> Velocity {
-        Velocity::new::<meter_per_second>(self.calculate_output(input.get::<meter_per_second>()))
-    }
-
-    fn calculate_linear_velocity_input(&self, output: Velocity) -> Velocity {
-        Velocity::new::<meter_per_second>(self.calculate_input(output.get::<meter_per_second>()))
-    }
-}
@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::acceleration;
+
+    @meter_per_minute_per_second: 0.016_666_666_666_666_67; "m/min/s", "meters per minute per second",
+        "meters per minute per second";
+}
@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::angular_acceleration;
+
+    @revolution_per_minute_per_second: 0.104_719_755_119_659_77; "rev/min/s", "revolutions per minute per second",
+        "revolutions per minute per second";
+}
@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::angular_jerk;
+
+    @revolution_per_minute_per_second_squared: 0.104_719_755_119_659_77; "rev/min/s²", "revolution per minute per second squared",
+        "revolution per minute per second squared";
+}
@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::jerk;
+
+    @meter_per_minute_per_second_squared: 0.016_666_666_666_666_666_67; "m/min/s²", "meters per minute per second squared",
+        "meters per minute per second squared";
+}
@@ -0,0 +1,5 @@
+pub mod acceleration;
+pub mod angular_acceleration;
+pub mod angular_jerk;
+pub mod jerk;
+pub mod velocity;
@@ -0,0 +1,7 @@
+unit! {
+    system: uom::si;
+    quantity: uom::si::velocity;
+
+    @meter_per_minute: 0.016_666_666_666_666_67; "m/min", "meters per minute",
+        "meters per minute";
+}
@@ -1,208 +0,0 @@
-use anyhow::Error;
-use std::collections::HashMap;
-use tokio::sync::broadcast;
-
-/// Video stream manager that handles multiple video streams per machine with true broadcasting
-/// Uses tokio broadcast channels to ensure all subscribers receive all messages without stealing
-#[derive(Debug)]
-pub struct VideoStreamManager {
-    /// Each stream has its own broadcast transmitter and template receiver
-    streams: HashMap<String, (broadcast::Sender<Vec<u8>>, broadcast::Receiver<Vec<u8>>)>,
-}
-
-impl VideoStreamManager {
-    pub fn new() -> Self {
-        Self {
-            streams: HashMap::new(),
-        }
-    }
-
-    /// Send a frame to all subscribers of a stream
-    /// Returns Ok if the frame was sent, Err if the stream doesn't exist
-    pub fn send_frame(&self, stream_id: &str, frame: Vec<u8>) -> Result<(), Error> {
-        if let Some((tx, _rx)) = self.streams.get(stream_id) {
-            match tx.send(frame) {
-                Ok(_) => Ok(()),
-                Err(_) => Ok(()), // No receivers, but that's not an error
-            }
-        } else {
-            Err(anyhow::anyhow!("Stream '{}' not found", stream_id))
-        }
-    }
-
-    /// Register a new video stream with the given ID
-    pub fn add_stream(&mut self, stream_id: String) {
-        let (tx, rx) = broadcast::channel::<Vec<u8>>(256); // 256 frame buffer capacity
-        self.streams.insert(stream_id, (tx, rx));
-    }
-
-    /// Get list of available stream IDs
-    pub fn get_streams(&self) -> Vec<String> {
-        self.streams.keys().cloned().collect()
-    }
-
-    /// Check if a stream exists
-    pub fn has_stream(&self, stream_id: &str) -> bool {
-        self.streams.contains_key(stream_id)
-    }
-
-    /// Remove a stream and all its subscribers
-    pub fn remove_stream(&mut self, stream_id: &str) -> bool {
-        self.streams.remove(stream_id).is_some()
-    }
-
-    /// Subscribe to a video stream and get a receiver
-    /// Returns the receiver for the new subscription
-    pub fn subscribe_to_stream(&self, stream_id: &str) -> Option<broadcast::Receiver<Vec<u8>>> {
-        self.streams
-            .get(stream_id)
-            .map(|(_tx, rx)| rx.resubscribe()) // Resubscribe to create a new independent receiver
-    }
-
-    /// Get subscriber count for a stream
-    pub fn get_subscriber_count(&self, stream_id: &str) -> usize {
-        self.streams
-            .get(stream_id)
-            .map_or(0, |(tx, _rx)| tx.receiver_count())
-    }
-
-    /// Get a stream transmitter for sending frames (used by machines to send video)
-    /// Returns None if the stream doesn't exist
-    pub fn get_sender(&self, stream_id: &str) -> Option<broadcast::Sender<Vec<u8>>> {
-        self.streams.get(stream_id).map(|(tx, _rx)| tx.clone())
-    }
-}
-
-impl Default for VideoStreamManager {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_video_stream_manager() {
-        let mut manager = VideoStreamManager::new();
-
-        // Register streams
-        manager.register_stream("camera1".to_string());
-        manager.register_stream("camera2".to_string());
-
-        assert_eq!(manager.get_stream_ids().len(), 2);
-        assert!(manager.has_stream("camera1"));
-        assert!(manager.has_stream("camera2"));
-        assert!(!manager.has_stream("camera3"));
-
-        // Subscribe to streams
-        let mut rx1 = manager.subscribe_to_stream("camera1").unwrap();
-        let mut rx2 = manager.subscribe_to_stream("camera1").unwrap();
-        let mut rx3 = manager.subscribe_to_stream("camera2").unwrap();
-
-        assert_eq!(manager.get_subscriber_count("camera1"), 3); // Original + 2 clones
-        assert_eq!(manager.get_subscriber_count("camera2"), 2); // Original + 1 clone
-        assert_eq!(manager.get_subscriber_count("nonexistent"), 0);
-
-        // Send frames
-        let frame1 = vec![1, 2, 3, 4];
-        let frame2 = vec![5, 6, 7, 8];
-
-        assert!(manager.send_single_frame("camera1", frame1.clone()));
-        assert!(manager.send_single_frame("camera2", frame2.clone()));
-        assert!(!manager.send_single_frame("nonexistent", vec![]));
-
-        // Both camera1 subscribers should receive the frame
-        assert_eq!(rx1.recv().await.unwrap(), frame1);
-        assert_eq!(rx2.recv().await.unwrap(), frame1);
-
-        // Camera2 subscriber should receive its frame
-        assert_eq!(rx3.recv().await.unwrap(), frame2);
-    }
-
-    #[tokio::test]
-    async fn test_video_frame_broadcasting() {
-        let mut manager = VideoStreamManager::new();
-        manager.register_stream("main_camera".to_string());
-
-        // Multiple clients subscribe to the same camera
-        let mut rx1 = manager.subscribe_to_stream("main_camera").unwrap();
-        let mut rx2 = manager.subscribe_to_stream("main_camera").unwrap();
-        let mut rx3 = manager.subscribe_to_stream("main_camera").unwrap();
-
-        // Simulate video frames
-        let frames = vec![
-            vec![0xFF, 0xD8, 0xFF, 0xE0], // JPEG header
-            vec![0x00, 0x01, 0x02, 0x03], // Frame 1
-            vec![0x04, 0x05, 0x06, 0x07], // Frame 2
-        ];
-
-        for frame in &frames {
-            assert!(manager.send_single_frame("main_camera", frame.clone()));
-        }
-
-        // All clients should receive all frames in order
-        for frame in &frames {
-            assert_eq!(rx1.recv().await.unwrap(), *frame);
-            assert_eq!(rx2.recv().await.unwrap(), *frame);
-            assert_eq!(rx3.recv().await.unwrap(), *frame);
-        }
-    }
-
-    #[test]
-    fn test_stream_management() {
-        let mut manager = VideoStreamManager::new();
-
-        // Initially no streams
-        assert_eq!(manager.get_stream_ids().len(), 0);
-
-        // Add streams
-        manager.register_stream("front_camera".to_string());
-        manager.register_stream("rear_camera".to_string());
-        manager.register_stream("side_camera".to_string());
-
-        let mut stream_ids = manager.get_stream_ids();
-        stream_ids.sort(); // Sort for consistent testing
-        assert_eq!(
-            stream_ids,
-            vec!["front_camera", "rear_camera", "side_camera"]
-        );
-
-        // Remove a stream
-        assert!(manager.remove_stream("rear_camera"));
-        assert!(!manager.remove_stream("rear_camera")); // Already removed
-        assert!(!manager.has_stream("rear_camera"));
-
-        assert_eq!(manager.get_stream_ids().len(), 2);
-    }
-
-    #[tokio::test]
-    async fn test_send_frame_results() {
-        let mut manager = VideoStreamManager::new();
-        manager.register_stream("test_camera".to_string());
-
-        // One initial receiver (the original one created in register_stream)
-        let result = manager.send_frame("test_camera", vec![1, 2, 3]).unwrap();
-        assert_eq!(result, 1); // Number of subscribers
-
-        // Add subscribers by cloning the receiver
-        let _rx1 = manager.subscribe_to_stream("test_camera").unwrap();
-        let _rx2 = manager.subscribe_to_stream("test_camera").unwrap();
-
-        // Send frame to multiple subscribers (original + 2 clones = 3 total)
-        let result = manager.send_frame("test_camera", vec![4, 5, 6]).unwrap();
-        assert_eq!(result, 3); // Number of subscribers
-
-        // Try sending to non-existent stream
-        let result = manager.send_frame("nonexistent", vec![7, 8, 9]);
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "Stream 'nonexistent' not found");
-    }
-
-    #[test]
-    fn test_default_video_stream_manager() {
-        let manager = VideoStreamManager::default();
-        assert_eq!(manager.get_stream_ids().len(), 0);
-    }
-}
@@ -0,0 +1,40 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build outputs
+dist/
+build/
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+coverage/
+
+# Logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+
+# TS build
+tsconfig.tsbuildinfo
@@ -0,0 +1,5 @@
+node_modules
+dist
+*.log
+.DS_Store
+coverage
@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false
+}
@@ -0,0 +1,68 @@
+# Control UI
+
+A TypeScript React component library for the QiTech Control system.
+
+## Installation
+
+```bash
+npm install control-ui
+```
+
+## Usage
+
+```typescript
+import { Button } from 'control-ui';
+
+function App() {
+  return (
+    <Button variant="primary" size="medium" onClick={() => console.log('Clicked!')}>
+      Click me
+    </Button>
+  );
+}
+```
+
+## Components
+
+### Button
+
+A customizable button component with multiple variants and sizes.
+
+#### Props
+
+- `variant`: 'primary' | 'secondary' | 'danger' (default: 'primary')
+- `size`: 'small' | 'medium' | 'large' (default: 'medium')
+- `disabled`: boolean (default: false)
+- `onClick`: () => void
+- `className`: string
+- `children`: ReactNode
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+### Linting
+
+```bash
+npm run lint
+```
+
+### Formatting
+
+```bash
+npm run format
+```
+
+## License
+
+MIT
@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.js",
+    "css": "src/styles/global.css",
+    "baseColor": "neutral",
+    "cssVariables": false,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}
@@ -0,0 +1,40 @@
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import pluginReact from 'eslint-plugin-react';
+import eslintPluginPrettierRecommended from 'eslint-config-prettier';
+import path from 'node:path';
+import { includeIgnoreFile } from '@eslint/compat';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const prettierIgnorePath = path.resolve(__dirname, '.prettierignore');
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  includeIgnoreFile(prettierIgnorePath),
+  {
+    ignores: ['dist/**/*', 'node_modules/**/*'],
+  },
+  {
+    files: ['**/*.{js,mjs,cjs,ts,jsx,tsx}'],
+  },
+  { languageOptions: { globals: globals.browser } },
+  pluginJs.configs.recommended,
+  pluginReact.configs.flat.recommended,
+  eslintPluginPrettierRecommended,
+  ...tseslint.configs.recommended,
+  {
+    settings: {
+      react: {
+        version: 'detect',
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-unused-vars': 'warn',
+      'react/no-unknown-property': 'warn',
+    },
+  },
+];
@@ -0,0 +1,110 @@
+{
+  "name": "control-ui",
+  "version": "0.1.0",
+  "description": "UI components and utilities for the control system",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "require": "./dist/*.js"
+    },
+    "./components/*": {
+      "types": "./dist/components/*.d.ts",
+      "import": "./dist/components/*.js",
+      "require": "./dist/components/*.js"
+    },
+    "./components/ui/*": {
+      "types": "./dist/components/ui/*.d.ts",
+      "import": "./dist/components/ui/*.js",
+      "require": "./dist/components/ui/*.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js",
+      "require": "./dist/utils/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf dist",
+    "lint": "eslint .",
+    "lint:write": "eslint . --fix",
+    "format": "prettier --check .",
+    "format:write": "prettier --write .",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "control",
+    "ui",
+    "typescript",
+    "components"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/compat": "^1.2.6",
+    "@eslint/js": "^9.18.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^24.2.1",
+    "@types/react": "^19.0.10",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^4.5.2",
+    "eslint": "^9.20.1",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react": "^7.37.4",
+    "globals": "^16.2.0",
+    "jsdom": "^26.0.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.24.1",
+    "vite": "^6.2.6",
+    "vitest": "^3.0.6"
+  },
+  "dependencies": {
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-navigation-menu": "^1.2.14",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-toggle-group": "^1.1.11",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.540.0",
+    "next-themes": "^0.4.6",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-hook-form": "^7.62.0",
+    "sonner": "^2.0.7",
+    "tailwind-merge": "^3.3.1",
+    "tailwindcss-animate": "^1.0.7",
+    "tw-animate-css": "^1.3.7"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/1cedsoda/control.git",
+    "directory": "control-ui"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  }
+}
@@ -1,6 +1,6 @@
-import { icons as lucideIcons } from "lucide-react";
-import React from "react";
-import { qitechIcons } from "./QitechIcon";
+import { icons as lucideIcons } from 'lucide-react';
+import React from 'react';
+import { qitechIcons } from './QitechIcon';

 type QitechIconName = `qi:${keyof typeof qitechIcons}`;

@@ -18,17 +18,17 @@ export const Icon = ({ name, className }: Props) => {
  if (!name) {
    return null;
  }
-  const library = name.split(":")[0];
-  const rawIcon = name.split(":")[1];
+  const library = name.split(':')[0];
+  const rawIcon = name.split(':')[1];

-  if (library === "lu" && rawIcon in lucideIcons) {
+  if (library === 'lu' && rawIcon in lucideIcons) {
    const LucideIcon = lucideIcons[rawIcon as keyof typeof lucideIcons];
-    return <LucideIcon className={"size-6 " + className} />;
+    return <LucideIcon className={'size-6 ' + className} />;
  }

-  if (library === "qi" && rawIcon in qitechIcons) {
+  if (library === 'qi' && rawIcon in qitechIcons) {
    const QitechIcon = qitechIcons[rawIcon as keyof typeof qitechIcons];
-    return <QitechIcon className={"size-6 " + className} />;
+    return <QitechIcon className={'size-6 ' + className} />;
  }

  console.error(`Icon ${name} not found`, library, rawIcon, lucideIcons);
@@ -0,0 +1,5 @@
+// Component exports
+export * from './ui';
+export * from './Icon';
+export * from './QitechIcon';
+// Add more component exports here as you create them
@@ -0,0 +1,60 @@
+import * as React from 'react';
+import { cva, type VariantProps } from 'class-variance-authority';
+
+import { cn } from '@/utils/tailwind';
+
+const alertVariants = cva(
+  'relative w-full rounded-lg border px-4 py-3 text-sm grid has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] grid-cols-[0_1fr] has-[>svg]:gap-x-3 gap-y-0.5 items-start [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current',
+  {
+    variants: {
+      variant: {
+        default: 'bg-background text-foreground',
+        destructive:
+          'text-destructive-foreground [&>svg]:text-current *:data-[slot=alert-description]:text-destructive-foreground/80',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  }
+);
+
+function Alert({
+  className,
+  variant,
+  ...props
+}: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>) {
+  return (
+    <div
+      data-slot="alert"
+      role="alert"
+      className={cn(alertVariants({ variant }), className)}
+      {...props}
+    />
+  );
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="alert-title"
+      className={cn('col-start-2 line-clamp-1 min-h-4 font-medium tracking-tight', className)}
+      {...props}
+    />
+  );
+}
+
+function AlertDescription({ className, ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="alert-description"
+      className={cn(
+        'text-muted-foreground col-start-2 grid justify-items-start gap-1 text-sm [&_p]:leading-relaxed',
+        className
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Alert, AlertTitle, AlertDescription };
@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { Slot } from '@radix-ui/react-slot';
+import { cva, type VariantProps } from 'class-variance-authority';
+
+import { cn } from '@/utils/tailwind';
+
+const badgeVariants = cva(
+  'inline-flex items-center justify-center rounded-md border border-neutral-200 px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-neutral-950 focus-visible:ring-neutral-950/50 focus-visible:ring-[3px] aria-invalid:ring-red-500/20 dark:aria-invalid:ring-red-500/40 aria-invalid:border-red-500 transition-[color,box-shadow] overflow-hidden dark:border-neutral-800 dark:focus-visible:border-neutral-300 dark:focus-visible:ring-neutral-300/50 dark:aria-invalid:ring-red-900/20 dark:dark:aria-invalid:ring-red-900/40 dark:aria-invalid:border-red-900',
+  {
+    variants: {
+      variant: {
+        default:
+          'border-transparent bg-neutral-900 text-neutral-50 dark:bg-neutral-50 dark:text-neutral-900',
+        secondary:
+          'border-transparent bg-neutral-100 text-neutral-900 dark:bg-neutral-800 dark:text-neutral-50',
+        destructive:
+          'border-transparent bg-red-500 text-white focus-visible:ring-red-500/20 dark:focus-visible:ring-red-500/40 dark:bg-red-500/70 dark:bg-red-900 dark:focus-visible:ring-red-900/20 dark:dark:focus-visible:ring-red-900/40 dark:dark:bg-red-900/70',
+        outline: 'text-neutral-950 dark:text-neutral-50',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  }
+);
+
+function Badge({
+  className,
+  variant,
+  asChild = false,
+  ...props
+}: React.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
+  const Comp = asChild ? Slot : 'span';
+
+  return (
+    <Comp data-slot="badge" className={cn(badgeVariants({ variant }), className)} {...props} />
+  );
+}
+
+export { Badge, badgeVariants };
@@ -1,34 +1,34 @@
-import * as React from "react";
-import { Slot } from "@radix-ui/react-slot";
-import { cva, type VariantProps } from "class-variance-authority";
+import * as React from 'react';
+import { Slot } from '@radix-ui/react-slot';
+import { cva, type VariantProps } from 'class-variance-authority';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

 const buttonVariants = cva(
  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-[color,box-shadow] disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
  {
    variants: {
      variant: {
-        default: "bg-primary text-primary-foreground shadow-xs",
+        default: 'bg-primary text-primary-foreground shadow-xs',
        destructive:
-          "bg-destructive text-white shadow-xs focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40",
-        outline: "border border-input bg-background shadow-xs",
-        secondary: "bg-secondary text-secondary-foreground shadow-xs",
-        ghost: "",
-        link: "text-primary underline-offset-4",
+          'bg-destructive text-white shadow-xs focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40',
+        outline: 'border border-input bg-background shadow-xs',
+        secondary: 'bg-secondary text-secondary-foreground shadow-xs',
+        ghost: '',
+        link: 'text-primary underline-offset-4',
      },
      size: {
-        default: "h-9 px-4 py-2 has-[>svg]:px-3",
-        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
-        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
-        icon: "size-9",
+        default: 'h-9 px-4 py-2 has-[>svg]:px-3',
+        sm: 'h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5',
+        lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
+        icon: 'size-9',
      },
    },
    defaultVariants: {
-      variant: "default",
-      size: "default",
+      variant: 'default',
+      size: 'default',
    },
-  },
+  }
 );

 function Button({
@@ -37,11 +37,11 @@ function Button({
  size,
  asChild = false,
  ...props
-}: React.ComponentProps<"button"> &
+}: React.ComponentProps<'button'> &
  VariantProps<typeof buttonVariants> & {
    asChild?: boolean;
  }) {
-  const Comp = asChild ? Slot : "button";
+  const Comp = asChild ? Slot : 'button';

  return (
    <Comp
@@ -1,30 +1,22 @@
-import * as React from "react";
-import * as DialogPrimitive from "@radix-ui/react-dialog";
-import { XIcon } from "lucide-react";
+import * as React from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { XIcon } from 'lucide-react';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

-function Dialog({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Root>) {
+function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>) {
  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
 }

-function DialogTrigger({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
 }

-function DialogPortal({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+function DialogPortal({ ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>) {
  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
 }

-function DialogClose({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Close>) {
+function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>) {
  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
 }

@@ -36,8 +28,8 @@ function DialogOverlay({
    <DialogPrimitive.Overlay
      data-slot="dialog-overlay"
      className={cn(
-        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/80",
-        className,
+        'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/80',
+        className
      )}
      {...props}
    />
@@ -55,8 +47,8 @@ function DialogContent({
      <DialogPrimitive.Content
        data-slot="dialog-content"
        className={cn(
-          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
-          className,
+          'bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg',
+          className
        )}
        {...props}
      >
@@ -70,37 +62,31 @@ function DialogContent({
  );
 }

-function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+function DialogHeader({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="dialog-header"
-      className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
+      className={cn('flex flex-col gap-2 text-center sm:text-left', className)}
      {...props}
    />
  );
 }

-function DialogFooter({ className, ...props }: React.ComponentProps<"div">) {
+function DialogFooter({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="dialog-footer"
-      className={cn(
-        "flex flex-col-reverse gap-2 sm:flex-row sm:justify-end",
-        className,
-      )}
+      className={cn('flex flex-col-reverse gap-2 sm:flex-row sm:justify-end', className)}
      {...props}
    />
  );
 }

-function DialogTitle({
-  className,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Title>) {
+function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>) {
  return (
    <DialogPrimitive.Title
      data-slot="dialog-title"
-      className={cn("text-lg leading-none font-semibold", className)}
+      className={cn('text-lg leading-none font-semibold', className)}
      {...props}
    />
  );
@@ -113,7 +99,7 @@ function DialogDescription({
  return (
    <DialogPrimitive.Description
      data-slot="dialog-description"
-      className={cn("text-muted-foreground text-sm", className)}
+      className={cn('text-muted-foreground text-sm', className)}
      {...props}
    />
  );
@@ -1,32 +1,23 @@
-import * as React from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
-import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import * as React from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { CheckIcon, ChevronRightIcon, CircleIcon } from 'lucide-react';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

-function DropdownMenu({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
+function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
  return <DropdownMenuPrimitive.Root data-slot="dropdown-menu" {...props} />;
 }

 function DropdownMenuPortal({
  ...props
 }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>) {
-  return (
-    <DropdownMenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />
-  );
+  return <DropdownMenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />;
 }

 function DropdownMenuTrigger({
  ...props
 }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>) {
-  return (
-    <DropdownMenuPrimitive.Trigger
-      data-slot="dropdown-menu-trigger"
-      {...props}
-    />
-  );
+  return <DropdownMenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />;
 }

 function DropdownMenuContent({
@@ -40,8 +31,8 @@ function DropdownMenuContent({
        data-slot="dropdown-menu-content"
        sideOffset={sideOffset}
        className={cn(
-          "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border border-neutral-200 bg-white p-1 text-neutral-950 shadow-md dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50",
-          className,
+          'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border border-neutral-200 bg-white p-1 text-neutral-950 shadow-md dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50',
+          className
        )}
        {...props}
      />
@@ -49,22 +40,18 @@ function DropdownMenuContent({
  );
 }

-function DropdownMenuGroup({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuPrimitive.Group>) {
-  return (
-    <DropdownMenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />
-  );
+function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>) {
+  return <DropdownMenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />;
 }

 function DropdownMenuItem({
  className,
  inset,
-  variant = "default",
+  variant = 'default',
  ...props
 }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
  inset?: boolean;
-  variant?: "default" | "destructive";
+  variant?: 'default' | 'destructive';
 }) {
  return (
    <DropdownMenuPrimitive.Item
@@ -73,7 +60,7 @@ function DropdownMenuItem({
      data-variant={variant}
      className={cn(
        "data-[variant=destructive]:*:[svg]:!text-destructive relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-neutral-100 focus:text-neutral-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 data-[variant=destructive]:text-red-500 data-[variant=destructive]:focus:bg-red-500/10 data-[variant=destructive]:focus:text-red-500 dark:focus:bg-neutral-800 dark:focus:text-neutral-50 dark:data-[variant=destructive]:text-red-900 dark:dark:data-[variant=destructive]:focus:bg-red-900/20 dark:data-[variant=destructive]:focus:bg-red-500/20 dark:data-[variant=destructive]:focus:bg-red-900/10 dark:data-[variant=destructive]:focus:text-red-900 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 [&_svg:not([class*='text-'])]:text-neutral-500 dark:[&_svg:not([class*='text-'])]:text-neutral-400",
-        className,
+        className
      )}
      {...props}
    />
@@ -91,7 +78,7 @@ function DropdownMenuCheckboxItem({
      data-slot="dropdown-menu-checkbox-item"
      className={cn(
        "relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none focus:bg-neutral-100 focus:text-neutral-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-neutral-800 dark:focus:text-neutral-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className,
+        className
      )}
      checked={checked}
      {...props}
@@ -109,12 +96,7 @@ function DropdownMenuCheckboxItem({
 function DropdownMenuRadioGroup({
  ...props
 }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>) {
-  return (
-    <DropdownMenuPrimitive.RadioGroup
-      data-slot="dropdown-menu-radio-group"
-      {...props}
-    />
-  );
+  return <DropdownMenuPrimitive.RadioGroup data-slot="dropdown-menu-radio-group" {...props} />;
 }

 function DropdownMenuRadioItem({
@@ -127,7 +109,7 @@ function DropdownMenuRadioItem({
      data-slot="dropdown-menu-radio-item"
      className={cn(
        "relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none focus:bg-neutral-100 focus:text-neutral-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-neutral-800 dark:focus:text-neutral-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className,
+        className
      )}
      {...props}
    >
@@ -152,10 +134,7 @@ function DropdownMenuLabel({
    <DropdownMenuPrimitive.Label
      data-slot="dropdown-menu-label"
      data-inset={inset}
-      className={cn(
-        "px-2 py-1.5 text-sm font-medium data-[inset]:pl-8",
-        className,
-      )}
+      className={cn('px-2 py-1.5 text-sm font-medium data-[inset]:pl-8', className)}
      {...props}
    />
  );
@@ -168,34 +147,26 @@ function DropdownMenuSeparator({
  return (
    <DropdownMenuPrimitive.Separator
      data-slot="dropdown-menu-separator"
-      className={cn(
-        "-mx-1 my-1 h-px bg-neutral-200 dark:bg-neutral-800",
-        className,
-      )}
+      className={cn('-mx-1 my-1 h-px bg-neutral-200 dark:bg-neutral-800', className)}
      {...props}
    />
  );
 }

-function DropdownMenuShortcut({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
+function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>) {
  return (
    <span
      data-slot="dropdown-menu-shortcut"
      className={cn(
-        "ml-auto text-xs tracking-widest text-neutral-500 dark:text-neutral-400",
-        className,
+        'ml-auto text-xs tracking-widest text-neutral-500 dark:text-neutral-400',
+        className
      )}
      {...props}
    />
  );
 }

-function DropdownMenuSub({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>) {
+function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>) {
  return <DropdownMenuPrimitive.Sub data-slot="dropdown-menu-sub" {...props} />;
 }

@@ -212,8 +183,8 @@ function DropdownMenuSubTrigger({
      data-slot="dropdown-menu-sub-trigger"
      data-inset={inset}
      className={cn(
-        "flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-neutral-100 focus:text-neutral-900 data-[inset]:pl-8 data-[state=open]:bg-neutral-100 data-[state=open]:text-neutral-900 dark:focus:bg-neutral-800 dark:focus:text-neutral-50 dark:data-[state=open]:bg-neutral-800 dark:data-[state=open]:text-neutral-50",
-        className,
+        'flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-neutral-100 focus:text-neutral-900 data-[inset]:pl-8 data-[state=open]:bg-neutral-100 data-[state=open]:text-neutral-900 dark:focus:bg-neutral-800 dark:focus:text-neutral-50 dark:data-[state=open]:bg-neutral-800 dark:data-[state=open]:text-neutral-50',
+        className
      )}
      {...props}
    >
@@ -231,8 +202,8 @@ function DropdownMenuSubContent({
    <DropdownMenuPrimitive.SubContent
      data-slot="dropdown-menu-sub-content"
      className={cn(
-        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border border-neutral-200 bg-white p-1 text-neutral-950 shadow-lg dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50",
-        className,
+        'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border border-neutral-200 bg-white p-1 text-neutral-950 shadow-lg dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50',
+        className
      )}
      {...props}
    />
@@ -1,6 +1,6 @@
-import * as React from "react";
-import * as LabelPrimitive from "@radix-ui/react-label";
-import { Slot } from "@radix-ui/react-slot";
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { Slot } from '@radix-ui/react-slot';
 import {
  Controller,
  ControllerProps,
@@ -9,10 +9,10 @@ import {
  FormProvider,
  useFormContext,
  useFormState,
-} from "react-hook-form";
+} from 'react-hook-form';

-import { cn } from "@/lib/utils";
-import { Label } from "@/components/ui/label";
+import { cn } from '@/utils/tailwind';
+import { Label } from './label';

 const Form = FormProvider;

@@ -23,9 +23,7 @@ type FormFieldContextValue<
  name: TName;
 };

-const FormFieldContext = React.createContext<FormFieldContextValue>(
-  {} as FormFieldContextValue,
-);
+const FormFieldContext = React.createContext<FormFieldContextValue>({} as FormFieldContextValue);

 const FormField = <
  TFieldValues extends FieldValues = FieldValues,
@@ -48,7 +46,7 @@ const useFormField = () => {
  const fieldState = getFieldState(fieldContext.name, formState);

  if (!fieldContext) {
-    throw new Error("useFormField should be used within <FormField>");
+    throw new Error('useFormField should be used within <FormField>');
  }

  const { id } = itemContext;
@@ -67,35 +65,26 @@ type FormItemContextValue = {
  id: string;
 };

-const FormItemContext = React.createContext<FormItemContextValue>(
-  {} as FormItemContextValue,
-);
+const FormItemContext = React.createContext<FormItemContextValue>({} as FormItemContextValue);

-function FormItem({ className, ...props }: React.ComponentProps<"div">) {
+function FormItem({ className, ...props }: React.ComponentProps<'div'>) {
  const id = React.useId();

  return (
    <FormItemContext.Provider value={{ id }}>
-      <div
-        data-slot="form-item"
-        className={cn("grid gap-2", className)}
-        {...props}
-      />
+      <div data-slot="form-item" className={cn('grid gap-2', className)} {...props} />
    </FormItemContext.Provider>
  );
 }

-function FormLabel({
-  className,
-  ...props
-}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+function FormLabel({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>) {
  const { error, formItemId } = useFormField();

  return (
    <Label
      data-slot="form-label"
      data-error={!!error}
-      className={cn("data-[error=true]:text-destructive-foreground", className)}
+      className={cn('data-[error=true]:text-destructive-foreground', className)}
      htmlFor={formItemId}
      {...props}
    />
@@ -103,38 +92,33 @@ function FormLabel({
 }

 function FormControl({ ...props }: React.ComponentProps<typeof Slot>) {
-  const { error, formItemId, formDescriptionId, formMessageId } =
-    useFormField();
+  const { error, formItemId, formDescriptionId, formMessageId } = useFormField();

  return (
    <Slot
      data-slot="form-control"
      id={formItemId}
-      aria-describedby={
-        !error
-          ? `${formDescriptionId}`
-          : `${formDescriptionId} ${formMessageId}`
-      }
+      aria-describedby={!error ? `${formDescriptionId}` : `${formDescriptionId} ${formMessageId}`}
      aria-invalid={!!error}
      {...props}
    />
  );
 }

-function FormDescription({ className, ...props }: React.ComponentProps<"p">) {
+function FormDescription({ className, ...props }: React.ComponentProps<'p'>) {
  const { formDescriptionId } = useFormField();

  return (
    <p
      data-slot="form-description"
      id={formDescriptionId}
-      className={cn("text-muted-foreground text-sm", className)}
+      className={cn('text-muted-foreground text-sm', className)}
      {...props}
    />
  );
 }

-function FormMessage({ className, ...props }: React.ComponentProps<"p">) {
+function FormMessage({ className, ...props }: React.ComponentProps<'p'>) {
  const { error, formMessageId } = useFormField();
  const body = error ? String(error?.message) : props.children;

@@ -146,7 +130,7 @@ function FormMessage({ className, ...props }: React.ComponentProps<"p">) {
    <p
      data-slot="form-message"
      id={formMessageId}
-      className={cn("text-destructive-foreground text-sm", className)}
+      className={cn('text-destructive-foreground text-sm', className)}
      {...props}
    >
      {body}
@@ -0,0 +1,18 @@
+export * from './alert';
+export * from './badge';
+export * from './button';
+export * from './collapsible';
+export * from './dialog';
+export * from './dropdown-menu';
+export * from './form';
+export * from './input';
+export * from './label';
+export * from './navigation-menu';
+export * from './popover';
+export * from './select';
+export * from './separator';
+export * from './skeleton';
+export * from './sonner';
+export * from './table';
+export * from './toggle-group';
+export * from './toggle';
@@ -1,17 +1,17 @@
-import * as React from "react";
+import * as React from 'react';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

-function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+function Input({ className, type, ...props }: React.ComponentProps<'input'>) {
  return (
    <input
      type={type}
      data-slot="input"
      className={cn(
-        "border-input file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground flex h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
-        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
-        "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
-        className,
+        'border-input file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground flex h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
+        'focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]',
+        'aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive',
+        className
      )}
      {...props}
    />
@@ -0,0 +1,21 @@
+'use client';
+
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+
+import { cn } from '@/utils/tailwind';
+
+function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      data-slot="label"
+      className={cn(
+        'flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
+        className
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Label };
@@ -1,9 +1,9 @@
-import * as React from "react";
-import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
-import { cva } from "class-variance-authority";
-import { ChevronDown } from "lucide-react";
+import * as React from 'react';
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
+import { cva } from 'class-variance-authority';
+import { ChevronDown } from 'lucide-react';

-import { cn } from "@/utils/tailwind";
+import { cn } from '@/utils/tailwind';

 const NavigationMenu = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Root>,
@@ -11,10 +11,7 @@ const NavigationMenu = React.forwardRef<
 >(({ className, children, ...props }, ref) => (
  <NavigationMenuPrimitive.Root
    ref={ref}
-    className={cn(
-      "relative z-10 flex max-w-max flex-1 items-center justify-center",
-      className,
-    )}
+    className={cn('relative z-10 flex max-w-max flex-1 items-center justify-center', className)}
    {...props}
  >
    {children}
@@ -29,10 +26,7 @@ const NavigationMenuList = React.forwardRef<
 >(({ className, ...props }, ref) => (
  <NavigationMenuPrimitive.List
    ref={ref}
-    className={cn(
-      "group flex flex-1 list-none items-center justify-center space-x-1",
-      className,
-    )}
+    className={cn('group flex flex-1 list-none items-center justify-center space-x-1', className)}
    {...props}
  />
 ));
@@ -41,7 +35,7 @@ NavigationMenuList.displayName = NavigationMenuPrimitive.List.displayName;
 const NavigationMenuItem = NavigationMenuPrimitive.Item;

 const navigationMenuTriggerStyle = cva(
-  "group inline-flex h-10 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-hidden disabled:pointer-events-none disabled:opacity-50 data-active:bg-accent/50 data-[state=open]:bg-accent/50",
+  'group inline-flex h-10 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-hidden disabled:pointer-events-none disabled:opacity-50 data-active:bg-accent/50 data-[state=open]:bg-accent/50'
 );

 const NavigationMenuTrigger = React.forwardRef<
@@ -50,10 +44,10 @@ const NavigationMenuTrigger = React.forwardRef<
 >(({ className, children, ...props }, ref) => (
  <NavigationMenuPrimitive.Trigger
    ref={ref}
-    className={cn(navigationMenuTriggerStyle(), "group", className)}
+    className={cn(navigationMenuTriggerStyle(), 'group', className)}
    {...props}
  >
-    {children}{" "}
+    {children}{' '}
    <ChevronDown
      className="relative top-[1px] ml-1 h-3 w-3 transition duration-200 group-data-[state=open]:rotate-180"
      aria-hidden="true"
@@ -69,8 +63,8 @@ const NavigationMenuContent = React.forwardRef<
  <NavigationMenuPrimitive.Content
    ref={ref}
    className={cn(
-      "data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 top-0 left-0 w-full md:absolute md:w-auto",
-      className,
+      'data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 top-0 left-0 w-full md:absolute md:w-auto',
+      className
    )}
    {...props}
  />
@@ -83,19 +77,18 @@ const NavigationMenuViewport = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Viewport>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Viewport>
 >(({ className, ...props }, ref) => (
-  <div className={cn("absolute top-full left-0 flex justify-center")}>
+  <div className={cn('absolute top-full left-0 flex justify-center')}>
    <NavigationMenuPrimitive.Viewport
      className={cn(
-        "origin-top-center bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border shadow-lg md:w-[var(--radix-navigation-menu-viewport-width)]",
-        className,
+        'origin-top-center bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border shadow-lg md:w-[var(--radix-navigation-menu-viewport-width)]',
+        className
      )}
      ref={ref}
      {...props}
    />
  </div>
 ));
-NavigationMenuViewport.displayName =
-  NavigationMenuPrimitive.Viewport.displayName;
+NavigationMenuViewport.displayName = NavigationMenuPrimitive.Viewport.displayName;

 const NavigationMenuIndicator = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Indicator>,
@@ -104,16 +97,15 @@ const NavigationMenuIndicator = React.forwardRef<
  <NavigationMenuPrimitive.Indicator
    ref={ref}
    className={cn(
-      "data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in top-full z-1 flex h-1.5 items-end justify-center overflow-hidden",
-      className,
+      'data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in top-full z-1 flex h-1.5 items-end justify-center overflow-hidden',
+      className
    )}
    {...props}
  >
    <div className="bg-border relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm shadow-md" />
  </NavigationMenuPrimitive.Indicator>
 ));
-NavigationMenuIndicator.displayName =
-  NavigationMenuPrimitive.Indicator.displayName;
+NavigationMenuIndicator.displayName = NavigationMenuPrimitive.Indicator.displayName;

 export {
  navigationMenuTriggerStyle,
@@ -1,23 +1,19 @@
-import * as React from "react";
-import * as PopoverPrimitive from "@radix-ui/react-popover";
+import * as React from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

-function Popover({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Root>) {
+function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>) {
  return <PopoverPrimitive.Root data-slot="popover" {...props} />;
 }

-function PopoverTrigger({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
+function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
  return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
 }

 function PopoverContent({
  className,
-  align = "center",
+  align = 'center',
  sideOffset = 4,
  ...props
 }: React.ComponentProps<typeof PopoverPrimitive.Content>) {
@@ -28,8 +24,8 @@ function PopoverContent({
        align={align}
        sideOffset={sideOffset}
        className={cn(
-          "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 rounded-md border border-neutral-200 bg-white p-4 text-neutral-950 shadow-md outline-hidden dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50",
-          className,
+          'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 rounded-md border border-neutral-200 bg-white p-4 text-neutral-950 shadow-md outline-hidden dark:border-neutral-800 dark:bg-neutral-950 dark:text-neutral-50',
+          className
        )}
        {...props}
      />
@@ -37,9 +33,7 @@ function PopoverContent({
  );
 }

-function PopoverAnchor({
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
+function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
  return <PopoverPrimitive.Anchor data-slot="popover-anchor" {...props} />;
 }

@@ -1,24 +1,18 @@
-import * as React from "react";
-import * as SelectPrimitive from "@radix-ui/react-select";
-import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import * as React from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from 'lucide-react';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

-function Select({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>) {
  return <SelectPrimitive.Root data-slot="select" {...props} />;
 }

-function SelectGroup({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Group>) {
+function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>) {
  return <SelectPrimitive.Group data-slot="select-group" {...props} />;
 }

-function SelectValue({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Value>) {
+function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>) {
  return <SelectPrimitive.Value data-slot="select-value" {...props} />;
 }

@@ -32,7 +26,7 @@ function SelectTrigger({
      data-slot="select-trigger"
      className={cn(
        "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive flex h-9 w-full items-center justify-between rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className,
+        className
      )}
      {...props}
    >
@@ -47,7 +41,7 @@ function SelectTrigger({
 function SelectContent({
  className,
  children,
-  position = "popper",
+  position = 'popper',
  ...props
 }: React.ComponentProps<typeof SelectPrimitive.Content>) {
  return (
@@ -55,10 +49,10 @@ function SelectContent({
      <SelectPrimitive.Content
        data-slot="select-content"
        className={cn(
-          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border shadow-md",
-          position === "popper" &&
-            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
-          className,
+          'bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border shadow-md',
+          position === 'popper' &&
+            'data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1',
+          className
        )}
        position={position}
        {...props}
@@ -66,9 +60,9 @@ function SelectContent({
        <SelectScrollUpButton />
        <SelectPrimitive.Viewport
          className={cn(
-            "p-1",
-            position === "popper" &&
-              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1",
+            'p-1',
+            position === 'popper' &&
+              'h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1'
          )}
        >
          {children}
@@ -79,14 +73,11 @@ function SelectContent({
  );
 }

-function SelectLabel({
-  className,
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>) {
  return (
    <SelectPrimitive.Label
      data-slot="select-label"
-      className={cn("px-2 py-1.5 text-sm font-medium", className)}
+      className={cn('px-2 py-1.5 text-sm font-medium', className)}
      {...props}
    />
  );
@@ -102,7 +93,7 @@ function SelectItem({
      data-slot="select-item"
      className={cn(
        "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
-        className,
+        className
      )}
      {...props}
    >
@@ -123,7 +114,7 @@ function SelectSeparator({
  return (
    <SelectPrimitive.Separator
      data-slot="select-separator"
-      className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
+      className={cn('bg-border pointer-events-none -mx-1 my-1 h-px', className)}
      {...props}
    />
  );
@@ -136,10 +127,7 @@ function SelectScrollUpButton({
  return (
    <SelectPrimitive.ScrollUpButton
      data-slot="select-scroll-up-button"
-      className={cn(
-        "flex cursor-default items-center justify-center py-1",
-        className,
-      )}
+      className={cn('flex cursor-default items-center justify-center py-1', className)}
      {...props}
    >
      <ChevronUpIcon className="size-4" />
@@ -154,10 +142,7 @@ function SelectScrollDownButton({
  return (
    <SelectPrimitive.ScrollDownButton
      data-slot="select-scroll-down-button"
-      className={cn(
-        "flex cursor-default items-center justify-center py-1",
-        className,
-      )}
+      className={cn('flex cursor-default items-center justify-center py-1', className)}
      {...props}
    >
      <ChevronDownIcon className="size-4" />
@@ -1,11 +1,11 @@
-import * as React from "react";
-import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as React from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';

-import { cn } from "@/lib/utils";
+import { cn } from '@/utils/tailwind';

 function Separator({
  className,
-  orientation = "horizontal",
+  orientation = 'horizontal',
  decorative = true,
  ...props
 }: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
@@ -15,8 +15,8 @@ function Separator({
      decorative={decorative}
      orientation={orientation}
      className={cn(
-        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
-        className,
+        'bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px',
+        className
      )}
      {...props}
    />
@@ -0,0 +1,14 @@
+import React from 'react';
+import { cn } from '@/utils/tailwind';
+
+function Skeleton({ className, ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="skeleton"
+      className={cn('animate-pulse rounded-md bg-neutral-100 dark:bg-neutral-800', className)}
+      {...props}
+    />
+  );
+}
+
+export { Skeleton };
@@ -0,0 +1,91 @@
+import * as React from 'react';
+
+import { cn } from '@/utils/tailwind';
+
+const Table = React.forwardRef<HTMLTableElement, React.HTMLAttributes<HTMLTableElement>>(
+  ({ className, ...props }, ref) => (
+    <div className="relative w-full overflow-auto">
+      <table ref={ref} className={cn('w-full caption-bottom text-sm', className)} {...props} />
+    </div>
+  )
+);
+Table.displayName = 'Table';
+
+const TableHeader = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <thead ref={ref} className={cn('[&_tr]:border-b', className)} {...props} />
+));
+TableHeader.displayName = 'TableHeader';
+
+const TableBody = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tbody ref={ref} className={cn('[&_tr:last-child]:border-0', className)} {...props} />
+));
+TableBody.displayName = 'TableBody';
+
+const TableFooter = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tfoot
+    ref={ref}
+    className={cn('bg-muted/50 border-t font-medium [&>tr]:last:border-b-0', className)}
+    {...props}
+  />
+));
+TableFooter.displayName = 'TableFooter';
+
+const TableRow = React.forwardRef<HTMLTableRowElement, React.HTMLAttributes<HTMLTableRowElement>>(
+  ({ className, ...props }, ref) => (
+    <tr
+      ref={ref}
+      className={cn('data-[state=selected]:bg-muted border-b transition-colors', className)}
+      {...props}
+    />
+  )
+);
+TableRow.displayName = 'TableRow';
+
+const TableHead = React.forwardRef<
+  HTMLTableCellElement,
+  React.ThHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <th
+    ref={ref}
+    className={cn(
+      'text-muted-foreground h-10 px-2 text-left align-middle font-medium [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]',
+      className
+    )}
+    {...props}
+  />
+));
+TableHead.displayName = 'TableHead';
+
+const TableCell = React.forwardRef<
+  HTMLTableCellElement,
+  React.TdHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <td
+    ref={ref}
+    className={cn(
+      'p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]',
+      className
+    )}
+    {...props}
+  />
+));
+TableCell.displayName = 'TableCell';
+
+const TableCaption = React.forwardRef<
+  HTMLTableCaptionElement,
+  React.HTMLAttributes<HTMLTableCaptionElement>
+>(({ className, ...props }, ref) => (
+  <caption ref={ref} className={cn('text-muted-foreground mt-4 text-sm', className)} {...props} />
+));
+TableCaption.displayName = 'TableCaption';
+
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption };
Author	SHA1	Message	Date
Icedsoda	66b26e951b	fix import issues	2025-08-21 14:37:26 +02:00
Icedsoda	5046acef98	ts fixes	2025-08-21 12:50:06 +02:00
Icedsoda	dd857cdae1	wip	2025-08-21 12:34:15 +02:00
Icedsoda	e366fe5e73	move some components to control-ui	2025-08-21 11:48:50 +02:00
Icedsoda	616cbb2ad5	move icon components to control-ui	2025-08-21 11:03:32 +02:00
Icedsoda	b60620feee	install shadcn components	2025-08-20 18:17:32 +02:00
Icedsoda	b30b72253d	create control-ui package	2025-08-20 18:07:43 +02:00