im not sure what im changing

src/arpparse/mod.rs

@@ -41,7 +41,7 @@ pub struct IpNeighLine {
 
 // NUDState custom Deserialize now lives in arpparse/impl.rs; use serde_with OneOrMany for Vec
 
-#[derive(Debug, PartialEq, Eq, EnumString, Display, Clone, Copy, Hash, serde::Serialize)]
+#[derive(Debug, PartialEq, Eq, EnumString, Display, Clone, Copy, Hash, serde::Serialize, Default)]
 #[strum(serialize_all = "UPPERCASE", ascii_case_insensitive)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum NUDState {
@@ -63,10 +63,7 @@ pub enum NUDState {
     /// neighbour state if it was valid and the
     /// address is not changed by this command.
     Stale,
-    /// this is a pseudo state used when initially
-    /// creating a neighbour entry or after trying to
-    /// remove it before it becomes free to do so.
-    None,
+
 
     /// the neighbour entry has not (yet) been
     /// validated/resolved.
@@ -80,6 +77,13 @@ pub enum NUDState {
     /// success, neighbor validation has ultimately
     /// failed.
     Failed,
+
+    /// this is a pseudo state used when initially
+    /// creating a neighbour entry or after trying to
+    /// remove it before it becomes free to do so.
+    #[serde(other)]
+    #[default]
+    None,
 }
 
 impl NUDState {

src/route/api.rs

@@ -49,12 +49,10 @@ pub async fn status_smart_redirect(
     };
     match serde_html_form::to_string(query) {
         Ok(e) => Ok(Redirect::to(&format!("/api/status?{e}"))),
-        Err(e) => Err((
-            StatusCode::BAD_GATEWAY,
-            Json(ApiError {
-                error: e.to_string(),
-            }),
-        )),
+        Err(e) => Err(ApiError {
+            error: e.to_string(),
+            code: StatusCode::BAD_GATEWAY,
+        }),
     }
 }
 
@@ -67,12 +65,7 @@ pub async fn status_redirect(Path(NamePath { name }): Path<NamePath>) -> Redirec
 
 pub async fn ip(Path(name): Path<String>) -> impl IntoResponse {
     get_ips(&name).await.map_or_else(
-        |e| {
-            ApiError {
-                error: e.to_string(),
-            }
-            .into_response()
-        },
+        |e| ApiError::ise(e.to_string()).into_response(),
         |ips| Json(ips.collect::<Vec<_>>()).into_response(),
     )
 }

src/route/dhcp.rs

@@ -26,12 +26,10 @@ pub async fn get_dhcp_leases(Query(raw): Query<DhcpLeasesQueryRaw>) -> impl Into
             let out = enrich_leases_with_nud_state(leases_with_names).await;
             (StatusCode::OK, Json(out)).into_response()
         }
-        Err(e) => (
-            StatusCode::BAD_GATEWAY,
-            Json(ApiError {
-                error: e.to_string(),
-            }),
-        )
-            .into_response(),
+        Err(e) => ApiError {
+            error: e.to_string(),
+            code: StatusCode::BAD_GATEWAY,
+        }
+        .into_response(),
     }
 }

src/route/error.rs

@@ -7,11 +7,23 @@ use serde::Serialize;
 
 #[derive(Debug, Serialize)]
 pub struct ApiError {
+    #[serde(skip_serializing, skip_deserializing)]
+    pub code: StatusCode,
     pub error: String,
 }
 
+impl ApiError {
+    /// [StatusCode::INTERNAL_SERVER_ERROR]
+    pub const fn ise(error: String) -> Self {
+        Self {
+            code: StatusCode::INTERNAL_SERVER_ERROR,
+            error,
+        }
+    }
+}
+
 impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
-        (StatusCode::INTERNAL_SERVER_ERROR, Json(self)).into_response()
+        (self.code, Json(self)).into_response()
     }
 }

src/route/status.rs

@@ -94,13 +94,11 @@ pub async fn get_status_json(
             )
                 .into_response()
         }
-        Err(error) => (
-            StatusCode::BAD_GATEWAY,
-            Json(ApiError {
-                error: error.to_string(),
-            }),
-        )
-            .into_response(),
+        Err(error) => ApiError {
+            code: StatusCode::BAD_GATEWAY,
+            error: error.to_string(),
+        }
+        .into_response(),
     }
 }
 // Status endpoints

src/utils/query/macs.rs

@@ -48,7 +48,7 @@ pub async fn get_macs(
     let ip_m: HashSet<IpAddr> = futures::future::try_join_all(
         machine_names
             .iter()
-            .map(|c| async { get_ips(c.as_ref()).await }),
+            .map(|c| get_ips(c.as_ref())),
     )
     .await?
     .into_iter()

src/utils/wake/impls.rs

@@ -41,13 +41,13 @@ impl From<WakeTargetResult> for RouteWakeResult {
 }
 
 impl RouteWakeTarget {
-    pub fn to_incomplete(self) -> RouteWakeResult {
+    pub const fn to_incomplete(self) -> RouteWakeResult {
         RouteWakeResult {
             target: self,
             status: RouteWakeStatus::Incomplete,
         }
     }
-    pub fn is_incomplete(&self) -> bool {
+    pub const fn is_incomplete(&self) -> bool {
         !matches!(
             self,
             Self {

src/utils/wake/mod.rs

@@ -22,21 +22,21 @@ pub enum WakeStatus {
     WrongSize,
 }
 impl WakeTarget {
-    fn _new(ip: IpAddr, mac: MacAddr) -> Self {
+    const fn _new(ip: IpAddr, mac: MacAddr) -> Self {
         Self { ip, mac }
     }
-    fn good(self) -> WakeTargetResult {
+    const fn good(self) -> WakeTargetResult {
         WakeTargetResult::new(self, WakeStatus::Success)
     }
-    fn bad(self) -> WakeTargetResult {
+    const fn bad(self) -> WakeTargetResult {
         WakeTargetResult::new(self, WakeStatus::WrongSize)
     }
-    fn errored(self) -> WakeTargetResult {
+    const fn errored(self) -> WakeTargetResult {
         WakeTargetResult::new(self, WakeStatus::NonexistentAddress)
     }
 }
 impl WakeTargetResult {
-    fn new(target: WakeTarget, status: WakeStatus) -> Self {
+    const fn new(target: WakeTarget, status: WakeStatus) -> Self {
         Self { target, status }
     }
 }