From 074bfae740d021b9a81174903ca3811327e80a63 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 19 Feb 2026 08:48:23 +0000
Subject: [PATCH 01/36] WIP on custom errors

---
 Cargo.toml                               | 23 +++++++------
 crates/parser/Cargo.toml                 | 13 +++----
 crates/parser/src/errors.rs              | 43 ++++++++++++++++++++++++
 src/components/user_input/file_upload.rs |  3 +-
 src/errors.rs                            |  6 ++++
 5 files changed, 69 insertions(+), 19 deletions(-)
 create mode 100644 src/errors.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0c0feb5..6d62891 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,6 +45,7 @@
             "webgl",
         ], git="https://github.com/WebVOWL/WasmGrapher", branch="master"}
         horned-owl={git="https://github.com/phillord/horned-owl", rev="c4f7835ecae70b5e7281dc23b9b7fc6daa497f1d"}
+        leptos={version="0.8.8", features=["nightly", "multipart", "rkyv"]}
         log="0.4"
         rdf-fusion="0.1.0"
         rkyv="0.8.12"
@@ -69,7 +70,7 @@
     gloo-timers="0.2"
     grapher={workspace=true}
     http={version="1.3.1", optional=true}
-    leptos={version="0.8.8", features=["nightly", "multipart", "rkyv"]}
+    leptos={workspace=true}
     leptos_actix={version="0.8.5", optional=true}
     leptos_meta={version="0.8.5"}
     leptos_router={version="0.8.6", features=["nightly"]}
@@ -326,13 +327,13 @@
         server-fn-prefix="/api"
 
 [lints.clippy]
-pedantic = { level = "deny", priority = -1 }
-nursery = { level = "deny", priority = -1 }
-unwrap_used = { level = "deny" }
-expect_used = { level = "deny" }
-too_many_lines = { level = "allow" }
-missing_panics_doc = { level = "allow" }
-# Triggers false positives on components,
-# See https://github.com/leptos-rs/leptos/issues/3172
-# This should have been fixed around 0.8.3 but it seems not to be?
-must_use_candidate = { level = "allow" }
+    expect_used={level="deny"}
+    missing_panics_doc={level="allow"}
+    nursery={level="deny", priority=-1}
+    pedantic={level="deny", priority=-1}
+    too_many_lines={level="allow"}
+    unwrap_used={level="deny"}
+    # Triggers false positives on components,
+    # See https://github.com/leptos-rs/leptos/issues/3172
+    # This should have been fixed around 0.8.3 but it seems not to be?
+    must_use_candidate={level="allow"}
diff --git a/crates/parser/Cargo.toml b/crates/parser/Cargo.toml
index 18ee286..c804482 100644
--- a/crates/parser/Cargo.toml
+++ b/crates/parser/Cargo.toml
@@ -14,14 +14,15 @@
 
 
 [dependencies]
-    futures={workspace=true}
-    horned-owl={workspace=true}
-    log={workspace=true}
-    rdf-fusion={workspace=true}
+    futures.workspace=true
+    horned-owl.workspace=true
+    leptos.workspace=true
+    log.workspace=true
+    rdf-fusion.workspace=true
     serde="1.0"
-    tokio={workspace=true}
+    tokio.workspace=true
     tokio-stream="0.1.17"
     vowlr-util={path="../util"}
 
 [dev-dependencies]
-env_logger.workspace = true
+    env_logger.workspace=true
diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index 96ffc70..4d1aefd 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -1,6 +1,13 @@
 use std::{io::Error, panic::Location};
 
 use horned_owl::error::HornedError;
+use leptos::{
+    prelude::{FromServerFnError, ServerFnErrorErr},
+    server_fn::{
+        codec::{JsonEncoding, Rkyv},
+        error::IntoAppError,
+    },
+};
 use rdf_fusion::{
     error::LoaderError,
     execution::sparql::error::QueryEvaluationError,
@@ -26,6 +33,42 @@ pub struct VOWLRStoreError {
     location: &'static Location<'static>,
 }
 
+impl FromServerFnError for VOWLRStoreError {
+    type Encoder = JsonEncoding;
+
+    fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
+        match value {
+            ServerFnErrorErr::Registration(_) => todo!(),
+            ServerFnErrorErr::UnsupportedRequestMethod(_) => todo!(),
+            ServerFnErrorErr::Request(_) => todo!(),
+            ServerFnErrorErr::ServerError(e) => todo!(),
+            ServerFnErrorErr::MiddlewareError(_) => todo!(),
+            ServerFnErrorErr::Deserialization(_) => todo!(),
+            ServerFnErrorErr::Serialization(_) => todo!(),
+            ServerFnErrorErr::Args(_) => todo!(),
+            ServerFnErrorErr::MissingArg(_) => todo!(),
+            ServerFnErrorErr::Response(_) => todo!(),
+        }
+    }
+
+    fn ser(&self) -> leptos::server_fn::Bytes {
+        Self::Encoder::encode(self).unwrap_or_else(|e| {
+            Self::Encoder::encode(&Self::from_server_fn_error(
+                ServerFnErrorErr::Serialization(e.to_string()),
+            ))
+            .expect(
+                "error serializing should success at least with the \
+                 Serialization error",
+            )
+        })
+    }
+
+    fn de(data: leptos::server_fn::Bytes) -> Self {
+        Self::Encoder::decode(data)
+            .unwrap_or_else(|e| ServerFnErrorErr::Deserialization(e.to_string()).into_app_error())
+    }
+}
+
 impl From<VOWLRStoreError> for Error {
     fn from(val: VOWLRStoreError) -> Self {
         Error::other(val.to_string())
diff --git a/src/components/user_input/file_upload.rs b/src/components/user_input/file_upload.rs
index e58ace8..475842f 100644
--- a/src/components/user_input/file_upload.rs
+++ b/src/components/user_input/file_upload.rs
@@ -248,8 +248,7 @@ pub async fn handle_internal_sparql(
     if let QueryResults::Solutions(solutions) = query_stream {
         solution_serializer
             .serialize_nodes_stream(&mut data_buffer, solutions)
-            .await
-            .map_err(|e| ServerFnError::ServerError(e.to_string()))?;
+            .await?;
     } else {
         return Err(ServerFnError::ServerError(
             "Query stream is not a solutions stream".to_string(),
diff --git a/src/errors.rs b/src/errors.rs
new file mode 100644
index 0000000..3ff0c58
--- /dev/null
+++ b/src/errors.rs
@@ -0,0 +1,6 @@
+use leptos::prelude::RwSignal;
+
+#[derive(Clone)]
+pub struct ErrorLogContext {
+    pub errors: RwSignal<Vec<String>>,
+}

From d61b7066f555d52eea9f7823e211108b8570fdf6 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 19 Feb 2026 13:26:43 +0000
Subject: [PATCH 02/36] WIP 2 on errors

---
 Cargo.toml                       |  1 +
 crates/parser/Cargo.toml         |  1 +
 crates/parser/src/errors.rs      |  2 +-
 crates/util/Cargo.toml           |  4 +++-
 crates/util/src/error_handler.rs | 39 ++++++++++++++++++++++++++++++++
 crates/util/src/lib.rs           |  1 +
 6 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 crates/util/src/error_handler.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6d62891..3460579 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,6 +50,7 @@
         rdf-fusion="0.1.0"
         rkyv="0.8.12"
         smallvec={version="1.15.1", features=["union"]}
+        strum={version="0.27", features=["derive"]}
         tokio="1.48.0"
 
 [dependencies]
diff --git a/crates/parser/Cargo.toml b/crates/parser/Cargo.toml
index c804482..058be2d 100644
--- a/crates/parser/Cargo.toml
+++ b/crates/parser/Cargo.toml
@@ -20,6 +20,7 @@
     log.workspace=true
     rdf-fusion.workspace=true
     serde="1.0"
+    strum.workspace=true
     tokio.workspace=true
     tokio-stream="0.1.17"
     vowlr-util={path="../util"}
diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index 4d1aefd..518cf8c 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -37,7 +37,7 @@ impl FromServerFnError for VOWLRStoreError {
     type Encoder = JsonEncoding;
 
     fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
-        match value {
+        match value.inner {
             ServerFnErrorErr::Registration(_) => todo!(),
             ServerFnErrorErr::UnsupportedRequestMethod(_) => todo!(),
             ServerFnErrorErr::Request(_) => todo!(),
diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index cb14979..e328b37 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -13,5 +13,7 @@
 
 
 [dependencies]
-    rkyv={workspace=true}
+    leptos.workspace=true
+    log.workspace=true
+    rkyv.workspace=true
     serde={version="1.0", features=["derive"]}
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
new file mode 100644
index 0000000..d7b3905
--- /dev/null
+++ b/crates/util/src/error_handler.rs
@@ -0,0 +1,39 @@
+/// Logs a server message at the error level.
+///
+/// Please use the `target` argument to define the error type. See Examples.
+///
+/// Returns a [`leptos::prelude::ServerFnError::ServerError<String>`]
+///
+/// # Examples
+///
+/// ```
+/// use vowlr_util::error_s;
+/// use leptos::prelude::ServerFnError;
+///
+/// let (err_info, port) = ("No connection", 22);
+///
+/// let s = error_s!("Error: {err_info} on port {port}");
+/// let s1 = error_s!(target: "serializer", "App Error: {err_info}, Port: {port}");
+///
+/// assert_eq!()
+/// ```
+#[macro_export]
+macro_rules! error_s {
+    // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // error!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => ({
+        $log::error!($($arg)+)
+        $leptos::prelude::ServerFnError::ServerError(
+                    $std::format_args!($target, $($arg)+)
+                )
+    });
+
+    // error!(key1 = 42, key2 = true; "a {} event", "log")
+    // error!("a {} event", "log")
+    ($($arg:tt)+) => ({
+        $log::error!($($arg)+)
+        $leptos::prelude::ServerFnError::ServerError(
+                    $std::format_args!($($arg)+)
+                )
+    });
+}
diff --git a/crates/util/src/lib.rs b/crates/util/src/lib.rs
index 0d8681d..d720b9a 100644
--- a/crates/util/src/lib.rs
+++ b/crates/util/src/lib.rs
@@ -1 +1,2 @@
 pub mod datatypes;
+pub mod error_handler;

From 87f5b2e68f1fbfab0ea944a25a26fda568c935ac Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 26 Feb 2026 14:18:40 +0000
Subject: [PATCH 03/36] Add custom error types handling

---
 crates/database/src/errors.rs               | 126 ++++++++++++++++
 crates/database/src/lib.rs                  |  99 +-----------
 crates/database/src/serializers.rs          |   7 +-
 crates/database/src/serializers/frontend.rs |   2 +-
 crates/database/src/serializers/util.rs     |  13 ++
 crates/parser/src/errors.rs                 |  97 ++++++------
 crates/parser/src/parser_util.rs            |  12 +-
 crates/util/src/error_handler.rs            | 157 ++++++++++++++++++++
 crates/util/src/lib.rs                      |   2 +
 9 files changed, 362 insertions(+), 153 deletions(-)
 create mode 100644 crates/database/src/errors.rs

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
new file mode 100644
index 0000000..0019d37
--- /dev/null
+++ b/crates/database/src/errors.rs
@@ -0,0 +1,126 @@
+use crate::serializers::Triple;
+use oxrdf::{BlankNodeIdParseError, IriParseError};
+use vowlr_parser::errors::VOWLRStoreError;
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
+
+// pub trait SerializationErrorExt {
+//     fn triple(&self) -> Option<&Triple>;
+// }
+
+// macro_rules! ser_err {
+//     ($variant:ident($triple:expr, $msg:expr)) => {
+//         $crate::SerializationErrorKind::$variant(($triple).map(Box::new), $msg)
+//     };
+// }
+// pub(crate) use ser_err;
+
+// #[derive(Debug)]
+// pub enum SerializationErrorKind {
+//     MissingObject(Option<Box<Triple>>, String),
+//     MissingSubject(Option<Box<Triple>>, String),
+//     SerializationFailed(Option<Box<Triple>>, String),
+//     IriParseError(Option<Box<Triple>>, Box<IriParseError>),
+//     BlankNodeParseError(Option<Box<Triple>>, Box<BlankNodeIdParseError>),
+// }
+// impl SerializationErrorExt for SerializationErrorKind {
+//     fn triple(&self) -> Option<&Triple> {
+//         match &self {
+//             SerializationErrorKind::MissingObject(triple, _)
+//             | SerializationErrorKind::MissingSubject(triple, _)
+//             | SerializationErrorKind::SerializationFailed(triple, _)
+//             | SerializationErrorKind::IriParseError(triple, _)
+//             | SerializationErrorKind::BlankNodeParseError(triple, _) => {
+//                 triple.as_ref().map(|t| &**t)
+//             }
+//         }
+//     }
+// }
+
+#[derive(Debug)]
+pub enum SerializationErrorKind {
+    /// An error raised when the object of a triple is required but missing.
+    MissingObject(Triple, String),
+    /// An error raised when the subject of a triple is required but missing.
+    MissingSubject(Triple, String),
+    /// An error raised when the serializer encountered an unrecoverable problem.
+    SerializationFailed(Triple, String),
+    /// An error raised during Iri or IriRef validation.
+    IriParseError(Triple, IriParseError),
+    /// An error raised during BlankNode IDs validation
+    BlankNodeParseError(Triple, BlankNodeIdParseError),
+}
+
+#[derive(Debug)]
+pub struct SerializationError {
+    inner: SerializationErrorKind,
+}
+impl std::fmt::Display for SerializationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.inner)
+    }
+}
+
+// impl SerializationErrorExt for SerializationError {
+//     fn triple(&self) -> Option<&Triple> {
+//         self.inner.triple()
+//     }
+// }
+
+impl From<SerializationErrorKind> for SerializationError {
+    fn from(error: SerializationErrorKind) -> Self {
+        SerializationError { inner: error }
+    }
+}
+
+// impl From<IriParseError> for SerializationError {
+//     fn from(error: IriParseError) -> Self {
+//         SerializationError {
+//             inner: SerializationErrorKind::IriParseError(None, Box::new(error)),
+//         }
+//     }
+// }
+
+// impl From<SerializationError> for VOWLRStoreError {
+//     fn from(error: SerializationError) -> Self {
+//         VOWLRStoreError::from(error.to_string())
+//     }
+// }
+
+// impl From<BlankNodeIdParseError> for SerializationError {
+//     fn from(error: BlankNodeIdParseError) -> Self {
+//         SerializationError {
+//             inner: SerializationErrorKind::BlankNodeParseError(None, Box::new(error)),
+//         }
+//     }
+// }
+
+impl From<SerializationError> for ErrorRecord {
+    fn from(value: SerializationError) -> Self {
+        let (message, severity) = match value.inner {
+            SerializationErrorKind::MissingObject(triple, e) => {
+                (format!("{e}\n{triple}"), ErrorSeverity::Warning)
+            }
+            SerializationErrorKind::MissingSubject(triple, e) => {
+                (format!("{e}\n{triple}"), ErrorSeverity::Warning)
+            }
+            SerializationErrorKind::SerializationFailed(triple, e) => {
+                (format!("{e}\n{triple}"), ErrorSeverity::Critical)
+            }
+            SerializationErrorKind::IriParseError(triple, iri_parse_error) => (
+                format!("{iri_parse_error}\n{triple}"),
+                ErrorSeverity::Severe,
+            ),
+            SerializationErrorKind::BlankNodeParseError(triple, blank_node_id_parse_error) => (
+                format!("{blank_node_id_parse_error}\n{triple}"),
+                ErrorSeverity::Severe,
+            ),
+        };
+        ErrorRecord::new(
+            severity,
+            ErrorType::Serializer,
+            message,
+            #[cfg(debug_assertions)]
+            "N/A".to_string(),
+        )
+    }
+}
diff --git a/crates/database/src/lib.rs b/crates/database/src/lib.rs
index b2b1b9c..3e7f2a9 100644
--- a/crates/database/src/lib.rs
+++ b/crates/database/src/lib.rs
@@ -1,11 +1,4 @@
-use std::fmt::{Display, Formatter};
-
-use grapher::prelude::{ElementType, OwlEdge, OwlType, RdfEdge, RdfType};
-use oxrdf::{BlankNodeIdParseError, IriParseError};
-use vowlr_parser::errors::VOWLRStoreError;
-
-use crate::serializers::Triple;
-
+mod errors;
 pub mod serializers;
 pub mod store;
 pub mod vocab;
@@ -16,93 +9,3 @@ pub mod prelude {
 
     pub use crate::store::VOWLRStore;
 }
-
-pub const SYMMETRIC_EDGE_TYPES: [ElementType; 1] =
-    [ElementType::Owl(OwlType::Edge(OwlEdge::DisjointWith))];
-
-pub const PROPERTY_EDGE_TYPES: [ElementType; 7] = [
-    ElementType::Owl(OwlType::Edge(OwlEdge::ObjectProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::DatatypeProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::DeprecatedProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::ExternalProperty)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::ValuesFrom)),
-    ElementType::Owl(OwlType::Edge(OwlEdge::InverseOf)),
-    ElementType::Rdf(RdfType::Edge(RdfEdge::RdfProperty)),
-];
-
-pub trait SerializationErrorExt {
-    fn triple(&self) -> Option<&Triple>;
-}
-
-macro_rules! ser_err {
-    ($variant:ident($triple:expr, $msg:expr)) => {
-        $crate::SerializationErrorKind::$variant(($triple).map(Box::new), $msg)
-    };
-}
-pub(crate) use ser_err;
-
-#[derive(Debug)]
-pub enum SerializationErrorKind {
-    MissingObject(Option<Box<Triple>>, String),
-    MissingSubject(Option<Box<Triple>>, String),
-    SerializationFailed(Option<Box<Triple>>, String),
-    IriParseError(Option<Box<Triple>>, Box<IriParseError>),
-    BlankNodeParseError(Option<Box<Triple>>, Box<BlankNodeIdParseError>),
-}
-impl SerializationErrorExt for SerializationErrorKind {
-    fn triple(&self) -> Option<&Triple> {
-        match &self {
-            SerializationErrorKind::MissingObject(triple, _)
-            | SerializationErrorKind::MissingSubject(triple, _)
-            | SerializationErrorKind::SerializationFailed(triple, _)
-            | SerializationErrorKind::IriParseError(triple, _)
-            | SerializationErrorKind::BlankNodeParseError(triple, _) => {
-                triple.as_ref().map(|t| &**t)
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SerializationError {
-    inner: SerializationErrorKind,
-}
-impl Display for SerializationError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "SerializationError: {:?}", self.inner)
-    }
-}
-
-impl SerializationErrorExt for SerializationError {
-    fn triple(&self) -> Option<&Triple> {
-        self.inner.triple()
-    }
-}
-
-impl From<SerializationErrorKind> for SerializationError {
-    fn from(error: SerializationErrorKind) -> Self {
-        SerializationError { inner: error }
-    }
-}
-
-impl From<IriParseError> for SerializationError {
-    fn from(error: IriParseError) -> Self {
-        SerializationError {
-            inner: SerializationErrorKind::IriParseError(None, Box::new(error)),
-        }
-    }
-}
-
-impl From<SerializationError> for VOWLRStoreError {
-    fn from(error: SerializationError) -> Self {
-        VOWLRStoreError::from(error.to_string())
-    }
-}
-
-impl From<BlankNodeIdParseError> for SerializationError {
-    fn from(error: BlankNodeIdParseError) -> Self {
-        SerializationError {
-            inner: SerializationErrorKind::BlankNodeParseError(None, Box::new(error)),
-        }
-    }
-}
diff --git a/crates/database/src/serializers.rs b/crates/database/src/serializers.rs
index 1fa49c4..308c240 100644
--- a/crates/database/src/serializers.rs
+++ b/crates/database/src/serializers.rs
@@ -8,7 +8,10 @@ use grapher::prelude::{ElementType, GraphDisplayData, OwlEdge, OwlType};
 use log::error;
 use oxrdf::Term;
 
-use crate::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES};
+use crate::{
+    errors::SerializationError,
+    serializers::util::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES},
+};
 
 pub mod frontend;
 pub mod util;
@@ -229,7 +232,7 @@ pub struct SerializationDataBuffer {
     /// Each element is a tuple of:
     /// - 0 = The triple (if any).
     /// - 1 = The reason it failed to serialize (or the message if no triple is available).
-    failed_buffer: Vec<(Option<Triple>, String)>,
+    failed_buffer: Vec<SerializationError>,
     /// The base IRI of the document.
     ///
     /// For instance: `http://purl.obolibrary.org/obo/envo.owl`
diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index ddd4a4b..32bd795 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -6,7 +6,7 @@ use std::{
 
 use super::{Edge, SerializationDataBuffer, Triple};
 use crate::{
-    SerializationError, SerializationErrorExt, ser_err,
+    SerializationError, SerializationErrorKind, /*SerializationErrorExt, ser_err*/
     serializers::util::{get_reserved_iris, trim_tag_circumfix},
     vocab::owl,
 };
diff --git a/crates/database/src/serializers/util.rs b/crates/database/src/serializers/util.rs
index d8f5ccc..08e3c0b 100644
--- a/crates/database/src/serializers/util.rs
+++ b/crates/database/src/serializers/util.rs
@@ -3,6 +3,19 @@ use std::collections::HashSet;
 use crate::vocab::owl;
 use rdf_fusion::model::vocab::{rdf, rdfs};
 
+pub const SYMMETRIC_EDGE_TYPES: [ElementType; 1] =
+    [ElementType::Owl(OwlType::Edge(OwlEdge::DisjointWith))];
+
+pub const PROPERTY_EDGE_TYPES: [ElementType; 7] = [
+    ElementType::Owl(OwlType::Edge(OwlEdge::ObjectProperty)),
+    ElementType::Owl(OwlType::Edge(OwlEdge::DatatypeProperty)),
+    ElementType::Owl(OwlType::Edge(OwlEdge::DeprecatedProperty)),
+    ElementType::Owl(OwlType::Edge(OwlEdge::ExternalProperty)),
+    ElementType::Owl(OwlType::Edge(OwlEdge::ValuesFrom)),
+    ElementType::Owl(OwlType::Edge(OwlEdge::InverseOf)),
+    ElementType::Rdf(RdfType::Edge(RdfEdge::RdfProperty)),
+];
+
 /// Reserved IRIs should not be overridden by e.g. "external class" ElementType.
 pub fn get_reserved_iris() -> HashSet<String> {
     let rdf = vec![rdf::XML_LITERAL];
diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index 518cf8c..4ead104 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -1,74 +1,45 @@
 use std::{io::Error, panic::Location};
 
 use horned_owl::error::HornedError;
-use leptos::{
-    prelude::{FromServerFnError, ServerFnErrorErr},
-    server_fn::{
-        codec::{JsonEncoding, Rkyv},
-        error::IntoAppError,
-    },
-};
+
 use rdf_fusion::{
     error::LoaderError,
     execution::sparql::error::QueryEvaluationError,
     model::{IriParseError, StorageError},
 };
 use tokio::task::JoinError;
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
 
 #[derive(Debug)]
 pub enum VOWLRStoreErrorKind {
-    InvalidInput(String),
+    /// The file type is not supported by the server.
+    ///
+    /// Example: server only supports `.owl` and is given `.png`
+    InvalidFileType(String),
+    /// An error raised by Horned-OWL during parsing (of OWL files).
     HornedError(HornedError),
+    /// Generic IO error.
     IOError(std::io::Error),
+    /// An error raised while trying to parse an invalid IRI.
     IriParseError(IriParseError),
+    /// An error raised while loading a file into a Store (database).
     LoaderError(LoaderError),
+    /// A SPARQL evaluation error.
     QueryEvaluationError(QueryEvaluationError),
+    /// A Tokio task failed to execute to completion.
     JoinError(JoinError),
+    /// An error related to (database) storage operations (reads, writes...).
     StorageError(StorageError),
 }
 
 #[derive(Debug)]
 pub struct VOWLRStoreError {
+    /// The contained error type.
     inner: VOWLRStoreErrorKind,
+    /// The error's location in the source code.
     location: &'static Location<'static>,
 }
 
-impl FromServerFnError for VOWLRStoreError {
-    type Encoder = JsonEncoding;
-
-    fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
-        match value.inner {
-            ServerFnErrorErr::Registration(_) => todo!(),
-            ServerFnErrorErr::UnsupportedRequestMethod(_) => todo!(),
-            ServerFnErrorErr::Request(_) => todo!(),
-            ServerFnErrorErr::ServerError(e) => todo!(),
-            ServerFnErrorErr::MiddlewareError(_) => todo!(),
-            ServerFnErrorErr::Deserialization(_) => todo!(),
-            ServerFnErrorErr::Serialization(_) => todo!(),
-            ServerFnErrorErr::Args(_) => todo!(),
-            ServerFnErrorErr::MissingArg(_) => todo!(),
-            ServerFnErrorErr::Response(_) => todo!(),
-        }
-    }
-
-    fn ser(&self) -> leptos::server_fn::Bytes {
-        Self::Encoder::encode(self).unwrap_or_else(|e| {
-            Self::Encoder::encode(&Self::from_server_fn_error(
-                ServerFnErrorErr::Serialization(e.to_string()),
-            ))
-            .expect(
-                "error serializing should success at least with the \
-                 Serialization error",
-            )
-        })
-    }
-
-    fn de(data: leptos::server_fn::Bytes) -> Self {
-        Self::Encoder::decode(data)
-            .unwrap_or_else(|e| ServerFnErrorErr::Deserialization(e.to_string()).into_app_error())
-    }
-}
-
 impl From<VOWLRStoreError> for Error {
     fn from(val: VOWLRStoreError) -> Self {
         Error::other(val.to_string())
@@ -78,7 +49,7 @@ impl From<String> for VOWLRStoreError {
     #[track_caller]
     fn from(error: String) -> Self {
         VOWLRStoreError {
-            inner: VOWLRStoreErrorKind::InvalidInput(error),
+            inner: VOWLRStoreErrorKind::InvalidFileType(error),
             location: Location::caller(),
         }
     }
@@ -170,7 +141,7 @@ impl std::fmt::Display for VOWLRStoreError {
 impl std::error::Error for VOWLRStoreError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match &self.inner {
-            VOWLRStoreErrorKind::InvalidInput(_) => None,
+            VOWLRStoreErrorKind::InvalidFileType(_) => None,
             VOWLRStoreErrorKind::HornedError(e) => Some(e),
             VOWLRStoreErrorKind::IOError(e) => Some(e),
             VOWLRStoreErrorKind::IriParseError(e) => Some(e),
@@ -181,3 +152,37 @@ impl std::error::Error for VOWLRStoreError {
         }
     }
 }
+
+impl From<VOWLRStoreError> for ErrorRecord {
+    fn from(value: VOWLRStoreError) -> Self {
+        let (message, error_type) = match value.inner {
+            VOWLRStoreErrorKind::InvalidFileType(e) => (e, ErrorType::Parser),
+            VOWLRStoreErrorKind::HornedError(horned_error) => {
+                (horned_error.to_string(), ErrorType::Parser)
+            }
+            VOWLRStoreErrorKind::IOError(error) => (error.to_string(), ErrorType::Generic),
+            VOWLRStoreErrorKind::IriParseError(iri_parse_error) => {
+                (iri_parse_error.to_string(), ErrorType::Parser)
+            }
+            VOWLRStoreErrorKind::LoaderError(loader_error) => {
+                (loader_error.to_string(), ErrorType::Database)
+            }
+            VOWLRStoreErrorKind::QueryEvaluationError(query_evaluation_error) => {
+                (query_evaluation_error.to_string(), ErrorType::Database)
+            }
+            VOWLRStoreErrorKind::JoinError(join_error) => {
+                (join_error.to_string(), ErrorType::Generic)
+            }
+            VOWLRStoreErrorKind::StorageError(storage_error) => {
+                (storage_error.to_string(), ErrorType::Database)
+            }
+        };
+        ErrorRecord::new(
+            ErrorSeverity::Critical,
+            error_type,
+            message,
+            #[cfg(debug_assertions)]
+            value.location.to_string(),
+        )
+    }
+}
diff --git a/crates/parser/src/parser_util.rs b/crates/parser/src/parser_util.rs
index 18b9877..68fee29 100644
--- a/crates/parser/src/parser_util.rs
+++ b/crates/parser/src/parser_util.rs
@@ -87,7 +87,7 @@ pub async fn parse_stream_to(
             let mut buf = Vec::new();
             let mut serializer =
                 RdfSerializer::from_format(format_from_resource_type(&DataType::OWL).ok_or(
-                    VOWLRStoreErrorKind::InvalidInput(format!(
+                    VOWLRStoreErrorKind::InvalidFileType(format!(
                         "Unsupported output type: {:?}",
                         output_type
                     )),
@@ -123,7 +123,7 @@ pub async fn parse_stream_to(
                         writer.flush()?;
                         Ok(writer)
                     }
-                    _ => Err(VOWLRStoreError::from(VOWLRStoreErrorKind::InvalidInput(
+                    _ => Err(VOWLRStoreError::from(VOWLRStoreErrorKind::InvalidFileType(
                         format!("Unsupported output type: {:?}", output_type),
                     ))),
                 })();
@@ -143,7 +143,7 @@ pub async fn parse_stream_to(
                 let result = async {
                     let mut serializer =
                         RdfSerializer::from_format(format_from_resource_type(&output_type).ok_or(
-                            VOWLRStoreErrorKind::InvalidInput(format!(
+                            VOWLRStoreErrorKind::InvalidFileType(format!(
                                 "Unsupported output type: {:?}",
                                 output_type
                             )),
@@ -186,7 +186,7 @@ pub fn parser_from_reader(
     };
 
     let Some(format) = path_type(path) else {
-        return Err(VOWLRStoreErrorKind::InvalidInput(format!(
+        return Err(VOWLRStoreErrorKind::InvalidFileType(format!(
             "Unsupported format {}",
             path.display()
         ))
@@ -313,14 +313,14 @@ pub fn parser_from_reader(
             reader.read_to_end(&mut input)?;
             let input = ParserInput::File(input);
             let format = format_from_resource_type(&f).ok_or_else(|| {
-                VOWLRStoreErrorKind::InvalidInput(format!("could not convert {f:?} to format"))
+                VOWLRStoreErrorKind::InvalidFileType(format!("could not convert {f:?} to format"))
             })?;
             Ok(PreparedParser {
                 parser: make_parser(format),
                 input,
             })
         }
-        _ => Err(VOWLRStoreErrorKind::InvalidInput(format!(
+        _ => Err(VOWLRStoreErrorKind::InvalidFileType(format!(
             "Unsupported parser: {}",
             format.mime_type()
         ))),
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index d7b3905..717e0cd 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -1,3 +1,13 @@
+// Use this to implement (de)encoding error types:
+// Encode: https://github.com/leptos-rs/leptos/blob/6dc8ad4bfa71c33bf67aac514204af5dcaf7a112/server_fn/src/error.rs#L264
+// Decode: https://github.com/leptos-rs/leptos/blob/6dc8ad4bfa71c33bf67aac514204af5dcaf7a112/server_fn/src/error.rs#L306
+
+use leptos::{
+    prelude::{FromServerFnError, ServerFnError, ServerFnErrorErr},
+    server_fn::{Decodes, Encodes, codec::RkyvEncoding, error::IntoAppError},
+};
+use serde::{Deserialize, Serialize};
+
 /// Logs a server message at the error level.
 ///
 /// Please use the `target` argument to define the error type. See Examples.
@@ -37,3 +47,150 @@ macro_rules! error_s {
                 )
     });
 }
+
+#[derive(
+    Debug, Copy, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
+)]
+pub enum ErrorSeverity {
+    Critical,
+    Severe,
+    Medium,
+    Low,
+    Warning,
+    Unset,
+}
+
+impl std::fmt::Display for ErrorSeverity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'e>) -> std::fmt::Result {
+        match self {
+            Self::Critical => write!(
+                f,
+                "an unrecoverable error which makes VOWL-R unusable (do not use the output of VOWL-R!)"
+            ),
+            Self::Severe => write!(
+                f,
+                "an error which highly disrupts the user experience (the output of VOWL-R is likely incorrect)"
+            ),
+            Self::Medium => write!(f, "error desc goes here"),
+            Self::Low => write!(
+                f,
+                "error desc goes here (part of the output of VOWL-R could be incorrect, but should be \"insignificant\")"
+            ),
+            Self::Warning => write!(
+                f,
+                "something happened which may reduce the user experience (but can otherwise be ignored)"
+            ),
+            Self::Unset => write!(f, "unknown severity"),
+        }
+    }
+}
+
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    rkyv::Archive,
+    rkyv::Serialize,
+    rkyv::Deserialize,
+    Serialize,
+    Deserialize,
+    strum::Display,
+)]
+pub enum ErrorType {
+    /// Errors related to database operations.
+    Database,
+    /// Errors related to serializing data from backend to frontend (server -> client).
+    Serializer,
+    /// Errors related to parsing data (e.g. a `.owl` file).
+    Parser,
+    /// Errors related to the graph renderer (i.e. WasmGrapher)
+    Renderer,
+    #[strum(serialize = "GUI")]
+    /// Errors related to the frontend GUI.
+    Gui,
+    /// Errors without a type. Equivalent to a "500 Internal Server Error"
+    Generic,
+}
+
+#[derive(
+    Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
+)]
+pub struct ErrorRecord {
+    /// The severity of an error.
+    ///
+    /// Useful for grouping errors by severity and applying custom color schemes in the GUI.
+    pub severity: ErrorSeverity,
+    /// The type of an error.
+    ///
+    /// Useful for grouping errors by type and debugging for devs.
+    pub error_type: ErrorType,
+    /// The actual error message to show.
+    pub message: String,
+
+    #[cfg(debug_assertions)]
+    /// The location in the source code where the error originated.
+    ///
+    /// Only enabled with [cfg.debug_assertions]
+    pub location: String,
+}
+
+impl ErrorRecord {
+    pub fn new(
+        severity: ErrorSeverity,
+        error_type: ErrorType,
+        message: String,
+        #[cfg(debug_assertions)] location: String,
+    ) -> Self {
+        Self {
+            severity,
+            error_type,
+            message,
+            #[cfg(debug_assertions)]
+            location,
+        }
+    }
+}
+
+#[derive(
+    Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
+)]
+pub struct VOWLRServerError {
+    pub records: Vec<ErrorRecord>,
+}
+
+impl<VOWLRServerError> FromServerFnError for ServerFnError<VOWLRServerError> {
+    type Encoder = RkyvEncoding;
+
+    fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
+        let (severity, error_type, message, location) = match value {
+            ServerFnErrorErr::Registration(e) => todo!(),
+            ServerFnErrorErr::UnsupportedRequestMethod(e) => todo!(),
+            ServerFnErrorErr::Request(e) => todo!(),
+            ServerFnErrorErr::ServerError(e) => todo!(),
+            ServerFnErrorErr::MiddlewareError(e) => todo!(),
+            ServerFnErrorErr::Deserialization(e) => todo!(),
+            ServerFnErrorErr::Serialization(e) => todo!(),
+            ServerFnErrorErr::Args(e) => todo!(),
+            ServerFnErrorErr::MissingArg(e) => todo!(),
+            ServerFnErrorErr::Response(e) => todo!(),
+        }
+
+    }
+
+    fn ser(&self) -> leptos::server_fn::Bytes {
+        Self::Encoder::encode(self).unwrap_or_else(|e| {
+            Self::Encoder::encode(&Self::from_server_fn_error(
+                ServerFnErrorErr::Serialization(e.to_string()),
+            ))
+            .expect(
+                "error serializing should success at least with the \
+                 Serialization error",
+            )
+        })
+    }
+
+    fn de(data: leptos::server_fn::Bytes) -> Self {
+        Self::Encoder::decode(data)
+            .unwrap_or_else(|e| ServerFnErrorErr::Deserialization(e.to_string()).into_app_error())
+    }
+}
diff --git a/crates/util/src/lib.rs b/crates/util/src/lib.rs
index b698f65..f0920e0 100644
--- a/crates/util/src/lib.rs
+++ b/crates/util/src/lib.rs
@@ -1,5 +1,7 @@
 mod datatypes;
+mod error_handler;
 
 pub mod prelude {
     pub use crate::datatypes::DataType;
+    pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType};
 }

From 8fd4d9ff0cc7423ca1e43b8edbb21513d3cc3e88 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 26 Feb 2026 14:18:46 +0000
Subject: [PATCH 04/36] Add strum

---
 crates/util/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index 5a3df5d..0f39188 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -17,3 +17,4 @@
     log.workspace=true
     rkyv.workspace=true
     serde={version="1.0", features=["derive"]}
+    strum.workspace=true

From 92852582f4fcb5cbdfb448708f0262026a99b236 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 26 Feb 2026 14:18:53 +0000
Subject: [PATCH 05/36] Upate Cargo.lock

---
 Cargo.lock | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index e6d6ed7..0579415 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7521,9 +7521,11 @@ dependencies = [
  "env_logger",
  "futures",
  "horned-owl",
+ "leptos",
  "log",
  "rdf-fusion",
  "serde",
+ "strum 0.27.2",
  "tokio",
  "tokio-stream",
  "vowlr-util",
@@ -7542,8 +7544,11 @@ dependencies = [
 name = "vowlr-util"
 version = "0.1.0"
 dependencies = [
+ "leptos",
+ "log",
  "rkyv",
  "serde",
+ "strum 0.27.2",
 ]
 
 [[package]]

From 4f39734f1cbe4afc2ddf0c76c7557a2f429c287c Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 01:49:45 +0100
Subject: [PATCH 06/36] Update Cargo.lock

---
 Cargo.lock | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 0579415..dab2846 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -913,6 +913,12 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "bytecount"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
+
 [[package]]
 name = "bytemuck"
 version = "1.25.0"
@@ -4906,6 +4912,17 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "papergrid"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6978128c8b51d8f4080631ceb2302ab51e32cc6e8615f735ee2f83fd269ae3f1"
+dependencies = [
+ "bytecount",
+ "fnv",
+ "unicode-width",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -6796,6 +6813,30 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "tabled"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e39a2ee1fbcd360805a771e1b300f78cc88fec7b8d3e2f71cd37bbf23e725c7d"
+dependencies = [
+ "papergrid",
+ "tabled_derive",
+ "testing_table",
+]
+
+[[package]]
+name = "tabled_derive"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ea5d1b13ca6cff1f9231ffd62f15eefd72543dab5e468735f1a456728a02846"
+dependencies = [
+ "heck",
+ "proc-macro-error2",
+ "proc-macro2 1.0.106",
+ "quote 1.0.44",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "tachys"
 version = "0.2.13"
@@ -6862,6 +6903,15 @@ dependencies = [
  "syn 0.15.44",
 ]
 
+[[package]]
+name = "testing_table"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f8daae29995a24f65619e19d8d31dea5b389f3d853d8bf297bbf607cd0014cc"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -7549,6 +7599,7 @@ dependencies = [
  "rkyv",
  "serde",
  "strum 0.27.2",
+ "tabled",
 ]
 
 [[package]]

From bc4bd1e42044e1eaaf3b50d0feb13e190c05d3c3 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 01:55:29 +0100
Subject: [PATCH 07/36] Implement conversion functionality between other error
 types, ErrorRecords, and ServerFnError

---
 crates/util/src/error_handler.rs | 284 ++++++++++++++++++++++---------
 1 file changed, 207 insertions(+), 77 deletions(-)

diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 717e0cd..3e3a5a7 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -1,56 +1,32 @@
-// Use this to implement (de)encoding error types:
-// Encode: https://github.com/leptos-rs/leptos/blob/6dc8ad4bfa71c33bf67aac514204af5dcaf7a112/server_fn/src/error.rs#L264
-// Decode: https://github.com/leptos-rs/leptos/blob/6dc8ad4bfa71c33bf67aac514204af5dcaf7a112/server_fn/src/error.rs#L306
+#[cfg(not(feature = "server"))]
+use std::fmt::Write;
 
 use leptos::{
-    prelude::{FromServerFnError, ServerFnError, ServerFnErrorErr},
+    prelude::{FromServerFnError, IntoView, ServerFnError, ServerFnErrorErr},
     server_fn::{Decodes, Encodes, codec::RkyvEncoding, error::IntoAppError},
 };
+
+// use leptos_struct_table::*;
 use serde::{Deserialize, Serialize};
 
-/// Logs a server message at the error level.
-///
-/// Please use the `target` argument to define the error type. See Examples.
-///
-/// Returns a [`leptos::prelude::ServerFnError::ServerError<String>`]
-///
-/// # Examples
-///
-/// ```
-/// use vowlr_util::error_s;
-/// use leptos::prelude::ServerFnError;
-///
-/// let (err_info, port) = ("No connection", 22);
-///
-/// let s = error_s!("Error: {err_info} on port {port}");
-/// let s1 = error_s!(target: "serializer", "App Error: {err_info}, Port: {port}");
-///
-/// assert_eq!()
-/// ```
-#[macro_export]
-macro_rules! error_s {
-    // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // error!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => ({
-        $log::error!($($arg)+)
-        $leptos::prelude::ServerFnError::ServerError(
-                    $std::format_args!($target, $($arg)+)
-                )
-    });
-
-    // error!(key1 = 42, key2 = true; "a {} event", "log")
-    // error!("a {} event", "log")
-    ($($arg:tt)+) => ({
-        $log::error!($($arg)+)
-        $leptos::prelude::ServerFnError::ServerError(
-                    $std::format_args!($($arg)+)
-                )
-    });
-}
+#[cfg(feature = "server")]
+use tabled::{
+    Table, Tabled,
+    settings::{Settings, Style},
+};
 
 #[derive(
-    Debug, Copy, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
+    Debug,
+    Copy,
+    Clone,
+    rkyv::Archive,
+    rkyv::Serialize,
+    rkyv::Deserialize,
+    Serialize,
+    Deserialize,
+    strum::Display,
 )]
+#[strum(serialize_all = "title_case")]
 pub enum ErrorSeverity {
     Critical,
     Severe,
@@ -60,31 +36,39 @@ pub enum ErrorSeverity {
     Unset,
 }
 
-impl std::fmt::Display for ErrorSeverity {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'e>) -> std::fmt::Result {
+impl ErrorSeverity {
+    // TODO: Work in progress. Pls don't remove format!
+    pub fn description(&self) -> String {
         match self {
-            Self::Critical => write!(
-                f,
+            Self::Critical => format!(
                 "an unrecoverable error which makes VOWL-R unusable (do not use the output of VOWL-R!)"
             ),
-            Self::Severe => write!(
-                f,
+            Self::Severe => format!(
                 "an error which highly disrupts the user experience (the output of VOWL-R is likely incorrect)"
             ),
-            Self::Medium => write!(f, "error desc goes here"),
-            Self::Low => write!(
-                f,
+            // TODO
+            Self::Medium => format!("error desc goes here"),
+            // TODO
+            Self::Low => format!(
                 "error desc goes here (part of the output of VOWL-R could be incorrect, but should be \"insignificant\")"
             ),
-            Self::Warning => write!(
-                f,
+            Self::Warning => format!(
                 "something happened which may reduce the user experience (but can otherwise be ignored)"
             ),
-            Self::Unset => write!(f, "unknown severity"),
+            Self::Unset => format!("unknown severity"),
         }
     }
 }
 
+// impl CellValue for ErrorSeverity {
+//     type RenderOptions = ();
+
+//     // #[allow(unused)]
+//     fn render_value(self, _options: Self::RenderOptions) -> impl IntoView {
+//         self.to_string()
+//     }
+// }
+
 #[derive(
     Debug,
     Copy,
@@ -108,13 +92,39 @@ pub enum ErrorType {
     #[strum(serialize = "GUI")]
     /// Errors related to the frontend GUI.
     Gui,
-    /// Errors without a type. Equivalent to a "500 Internal Server Error"
-    Generic,
+    /// Server errors without a type.
+    InternalServerError,
+    /// Client errors without a type.
+    ClientError,
 }
 
+// impl CellValue for ErrorType {
+//     type RenderOptions = ();
+
+//     fn render_value(self, _options: Self::RenderOptions) -> impl IntoView {
+//         self.to_string()
+//     }
+// }
+
 #[derive(
-    Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
+    Debug,
+    Clone,
+    rkyv::Archive,
+    rkyv::Serialize,
+    rkyv::Deserialize,
+    Serialize,
+    Deserialize,
+    // TableRow,
 )]
+#[cfg_attr(feature = "server", derive(Tabled))]
+// #[table(sortable, classes_provider = "TailwindClassesPreset")]
+// TODO: implement a leptos struct table looking like: https://datatables.net/
+/// The fundamental building block of the error handling system.
+///
+/// It stores the data of a single error event.
+///
+/// # Note
+/// Every error type in use should implement [`From<T> for ErrorRecord`].
 pub struct ErrorRecord {
     /// The severity of an error.
     ///
@@ -149,32 +159,99 @@ impl ErrorRecord {
             location,
         }
     }
+
+    #[cfg(feature = "server")]
+    /// Only available on the server.
+    pub fn format_records(records: &[ErrorRecord]) -> String {
+        let table_config = Settings::default().with(Style::modern_rounded());
+        Table::new(records).with(table_config).to_string()
+    }
+}
+
+impl From<ServerFnError> for ErrorRecord {
+    fn from(value: ServerFnError) -> Self {
+        let (error_type, message) = match value {
+            ServerFnError::WrappedServerError(_) => (
+                // TODO: Remove in Leptos v0.9
+                ErrorType::InternalServerError,
+                "deprecated WrappedServerError".to_string(),
+            ),
+            ServerFnError::Registration(e) => (ErrorType::InternalServerError, e),
+            ServerFnError::Request(e) => (ErrorType::ClientError, e),
+            ServerFnError::Response(e) => (ErrorType::InternalServerError, e),
+            ServerFnError::ServerError(e) => (ErrorType::InternalServerError, e),
+            ServerFnError::MiddlewareError(e) => (ErrorType::InternalServerError, e),
+            ServerFnError::Deserialization(e) => (ErrorType::ClientError, e),
+            ServerFnError::Serialization(e) => (ErrorType::ClientError, e),
+            ServerFnError::Args(e) => (ErrorType::InternalServerError, e),
+            ServerFnError::MissingArg(e) => (ErrorType::InternalServerError, e),
+        };
+
+        ErrorRecord::new(
+            ErrorSeverity::Unset,
+            error_type,
+            message,
+            #[cfg(debug_assertions)]
+            "N/A".to_string(),
+        )
+    }
+}
+
+impl From<ServerFnErrorErr> for ErrorRecord {
+    fn from(value: ServerFnErrorErr) -> Self {
+        let a: ServerFnError = value.into();
+        a.into()
+    }
+}
+
+#[cfg(feature = "server")]
+impl std::fmt::Display for ErrorRecord {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let table_config = Settings::default().with(Style::modern_rounded());
+        let table = Table::new([self]).with(table_config).to_string();
+        write!(f, "{}", table)
+    }
+}
+
+#[cfg(not(feature = "server"))]
+impl std::fmt::Display for ErrorRecord {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        #[cfg(debug_assertions)]
+        {
+            write!(
+                f,
+                "{} | {} | {} | {}",
+                self.severity, self.error_type, self.message, self.location
+            )
+        }
+
+        #[cfg(not(debug_assertions))]
+        {
+            write!(
+                f,
+                "{} | {} | {}",
+                self.severity, self.error_type, self.message
+            )
+        }
+    }
 }
 
 #[derive(
     Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
 )]
+/// The struct sent by the server when things go south.
+///
+/// # Note
+/// Every error type in use should implement [`From<T> for VOWLRServerError`].
 pub struct VOWLRServerError {
     pub records: Vec<ErrorRecord>,
 }
 
-impl<VOWLRServerError> FromServerFnError for ServerFnError<VOWLRServerError> {
+impl FromServerFnError for VOWLRServerError {
     type Encoder = RkyvEncoding;
 
     fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
-        let (severity, error_type, message, location) = match value {
-            ServerFnErrorErr::Registration(e) => todo!(),
-            ServerFnErrorErr::UnsupportedRequestMethod(e) => todo!(),
-            ServerFnErrorErr::Request(e) => todo!(),
-            ServerFnErrorErr::ServerError(e) => todo!(),
-            ServerFnErrorErr::MiddlewareError(e) => todo!(),
-            ServerFnErrorErr::Deserialization(e) => todo!(),
-            ServerFnErrorErr::Serialization(e) => todo!(),
-            ServerFnErrorErr::Args(e) => todo!(),
-            ServerFnErrorErr::MissingArg(e) => todo!(),
-            ServerFnErrorErr::Response(e) => todo!(),
-        }
-
+        value.into()
     }
 
     fn ser(&self) -> leptos::server_fn::Bytes {
@@ -182,10 +259,7 @@ impl<VOWLRServerError> FromServerFnError for ServerFnError<VOWLRServerError> {
             Self::Encoder::encode(&Self::from_server_fn_error(
                 ServerFnErrorErr::Serialization(e.to_string()),
             ))
-            .expect(
-                "error serializing should success at least with the \
-                 Serialization error",
-            )
+            .expect("serializing should at least succeed with the serialization error type")
         })
     }
 
@@ -194,3 +268,59 @@ impl<VOWLRServerError> FromServerFnError for ServerFnError<VOWLRServerError> {
             .unwrap_or_else(|e| ServerFnErrorErr::Deserialization(e.to_string()).into_app_error())
     }
 }
+
+impl From<ServerFnError> for VOWLRServerError {
+    fn from(value: ServerFnError) -> Self {
+        let record: ErrorRecord = value.into();
+        record.into()
+    }
+}
+
+impl From<ServerFnErrorErr> for VOWLRServerError {
+    fn from(value: ServerFnErrorErr) -> Self {
+        let record: ErrorRecord = value.into();
+        record.into()
+    }
+}
+
+impl From<ErrorRecord> for VOWLRServerError {
+    fn from(value: ErrorRecord) -> Self {
+        VOWLRServerError {
+            records: vec![value],
+        }
+    }
+}
+
+impl From<Vec<ErrorRecord>> for VOWLRServerError {
+    fn from(value: Vec<ErrorRecord>) -> Self {
+        VOWLRServerError { records: value }
+    }
+}
+
+#[cfg(feature = "server")]
+impl std::fmt::Display for VOWLRServerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", ErrorRecord::format_records(&self.records))
+    }
+}
+
+#[cfg(not(feature = "server"))]
+impl std::fmt::Display for VOWLRServerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        #[cfg(debug_assertions)]
+        {
+            writeln!(f, "Severity | Error Type | Message | Location")?;
+        }
+
+        #[cfg(not(debug_assertions))]
+        {
+            writeln!(f, "Severity | Error Type | Message")?;
+        }
+
+        let mut buffer = String::new();
+        for record in self.records.iter() {
+            writeln!(buffer, "{}", record)?;
+        }
+        write!(f, "{buffer}")
+    }
+}

From 854922927aad288537879194ba65bcc3950722c1 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 01:57:20 +0100
Subject: [PATCH 08/36] Fix Leptos version and test Leptos table gen

---
 Cargo.toml             | 13 ++++++++-----
 crates/util/Cargo.toml |  1 +
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 061aad9..64ff1c2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,8 @@
             "webgl",
         ], git="https://github.com/WebVOWL/WasmGrapher"}
         horned-owl={git="https://github.com/phillord/horned-owl", rev="c4f7835ecae70b5e7281dc23b9b7fc6daa497f1d"}
-        leptos={version="0.8.8", features=["nightly", "multipart", "rkyv"]}
+        leptos={version="0.8.16", features=["nightly", "multipart", "rkyv"]}
+        # leptos-struct-table={version="0.18.0"}
         log="0.4"
         rdf-fusion="0.1.0"
         rkyv="0.8.12"
@@ -69,16 +70,17 @@
     futures={workspace=true}
     getrandom={version="0.3", features=["wasm_js"]}
     gloo-timers="0.2"
-    grapher={workspace=true}
+    grapher.workspace=true
     http={version="1.3.1", optional=true}
-    leptos={version="0.8.16", features=["nightly", "multipart", "rkyv"]}
+    leptos.workspace=true
+    # leptos-struct-table.workspace=true
     leptos_actix={version="0.8.7", optional=true}
     leptos_meta={version="0.8.6"}
     leptos_router={version="0.8.12", features=["nightly"]}
-    log={workspace=true}
+    log.workspace=true
     rayon="1.10"
     reqwest={version="0.12.24", optional=true, features=["json", "stream"]}
-    rkyv={workspace=true}
+    rkyv.workspace=true
     tokio={workspace=true, optional=true}
     vowlr-database={path="crates/database", optional=true}
     vowlr-parser={path="crates/parser", optional=true}
@@ -129,6 +131,7 @@
         "dep:vowlr-database",
         "dep:vowlr-parser",
         "leptos-use/actix",
+        "vowlr-util/server",
     ]
     ssr=[
         "dep:actix-files",
diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index 0f39188..6119334 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -14,6 +14,7 @@
 
 [dependencies]
     leptos.workspace=true
+    # leptos-struct-table.workspace=true
     log.workspace=true
     rkyv.workspace=true
     serde={version="1.0", features=["derive"]}

From 4162439614641082925e731afb4880b920a825d1 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 01:58:03 +0100
Subject: [PATCH 09/36] Fix missing imports

---
 crates/database/src/serializers/util.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/database/src/serializers/util.rs b/crates/database/src/serializers/util.rs
index 08e3c0b..d940a92 100644
--- a/crates/database/src/serializers/util.rs
+++ b/crates/database/src/serializers/util.rs
@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 
 use crate::vocab::owl;
+use grapher::prelude::{ElementType, OwlEdge, OwlType, RdfEdge, RdfType};
 use rdf_fusion::model::vocab::{rdf, rdfs};
 
 pub const SYMMETRIC_EDGE_TYPES: [ElementType; 1] =

From 654b2db06a85417a7e2bf24360a0734c1ed225bd Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 01:59:44 +0100
Subject: [PATCH 10/36] Remove old error code

---
 crates/database/src/errors.rs               | 61 ---------------------
 crates/database/src/serializers/frontend.rs |  2 +-
 2 files changed, 1 insertion(+), 62 deletions(-)

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
index 0019d37..1d669a6 100644
--- a/crates/database/src/errors.rs
+++ b/crates/database/src/errors.rs
@@ -3,39 +3,6 @@ use oxrdf::{BlankNodeIdParseError, IriParseError};
 use vowlr_parser::errors::VOWLRStoreError;
 use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
 
-// pub trait SerializationErrorExt {
-//     fn triple(&self) -> Option<&Triple>;
-// }
-
-// macro_rules! ser_err {
-//     ($variant:ident($triple:expr, $msg:expr)) => {
-//         $crate::SerializationErrorKind::$variant(($triple).map(Box::new), $msg)
-//     };
-// }
-// pub(crate) use ser_err;
-
-// #[derive(Debug)]
-// pub enum SerializationErrorKind {
-//     MissingObject(Option<Box<Triple>>, String),
-//     MissingSubject(Option<Box<Triple>>, String),
-//     SerializationFailed(Option<Box<Triple>>, String),
-//     IriParseError(Option<Box<Triple>>, Box<IriParseError>),
-//     BlankNodeParseError(Option<Box<Triple>>, Box<BlankNodeIdParseError>),
-// }
-// impl SerializationErrorExt for SerializationErrorKind {
-//     fn triple(&self) -> Option<&Triple> {
-//         match &self {
-//             SerializationErrorKind::MissingObject(triple, _)
-//             | SerializationErrorKind::MissingSubject(triple, _)
-//             | SerializationErrorKind::SerializationFailed(triple, _)
-//             | SerializationErrorKind::IriParseError(triple, _)
-//             | SerializationErrorKind::BlankNodeParseError(triple, _) => {
-//                 triple.as_ref().map(|t| &**t)
-//             }
-//         }
-//     }
-// }
-
 #[derive(Debug)]
 pub enum SerializationErrorKind {
     /// An error raised when the object of a triple is required but missing.
@@ -60,40 +27,12 @@ impl std::fmt::Display for SerializationError {
     }
 }
 
-// impl SerializationErrorExt for SerializationError {
-//     fn triple(&self) -> Option<&Triple> {
-//         self.inner.triple()
-//     }
-// }
-
 impl From<SerializationErrorKind> for SerializationError {
     fn from(error: SerializationErrorKind) -> Self {
         SerializationError { inner: error }
     }
 }
 
-// impl From<IriParseError> for SerializationError {
-//     fn from(error: IriParseError) -> Self {
-//         SerializationError {
-//             inner: SerializationErrorKind::IriParseError(None, Box::new(error)),
-//         }
-//     }
-// }
-
-// impl From<SerializationError> for VOWLRStoreError {
-//     fn from(error: SerializationError) -> Self {
-//         VOWLRStoreError::from(error.to_string())
-//     }
-// }
-
-// impl From<BlankNodeIdParseError> for SerializationError {
-//     fn from(error: BlankNodeIdParseError) -> Self {
-//         SerializationError {
-//             inner: SerializationErrorKind::BlankNodeParseError(None, Box::new(error)),
-//         }
-//     }
-// }
-
 impl From<SerializationError> for ErrorRecord {
     fn from(value: SerializationError) -> Self {
         let (message, severity) = match value.inner {
diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index 32bd795..67d1898 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -6,7 +6,7 @@ use std::{
 
 use super::{Edge, SerializationDataBuffer, Triple};
 use crate::{
-    SerializationError, SerializationErrorKind, /*SerializationErrorExt, ser_err*/
+    errors::{SerializationError, SerializationErrorKind},
     serializers::util::{get_reserved_iris, trim_tag_circumfix},
     vocab::owl,
 };

From 40e921d3598bf036574709567d43a3946d3f51f1 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:00:29 +0100
Subject: [PATCH 11/36] Fix: parse errors do not have access to a triple

---
 crates/database/src/errors.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
index 1d669a6..20ad39a 100644
--- a/crates/database/src/errors.rs
+++ b/crates/database/src/errors.rs
@@ -12,9 +12,9 @@ pub enum SerializationErrorKind {
     /// An error raised when the serializer encountered an unrecoverable problem.
     SerializationFailed(Triple, String),
     /// An error raised during Iri or IriRef validation.
-    IriParseError(Triple, IriParseError),
+    IriParseError(String, IriParseError),
     /// An error raised during BlankNode IDs validation
-    BlankNodeParseError(Triple, BlankNodeIdParseError),
+    BlankNodeParseError(String, BlankNodeIdParseError),
 }
 
 #[derive(Debug)]

From be93538ddbe0496ea15217cdcc8e55ea56b7ffdd Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:01:40 +0100
Subject: [PATCH 12/36] Use new error handling backend

---
 crates/database/src/serializers.rs          |  31 +-
 crates/database/src/serializers/frontend.rs | 374 +++++++++++---------
 2 files changed, 206 insertions(+), 199 deletions(-)

diff --git a/crates/database/src/serializers.rs b/crates/database/src/serializers.rs
index 308c240..a2aee08 100644
--- a/crates/database/src/serializers.rs
+++ b/crates/database/src/serializers.rs
@@ -7,11 +7,9 @@ use std::{
 use grapher::prelude::{ElementType, GraphDisplayData, OwlEdge, OwlType};
 use log::error;
 use oxrdf::Term;
+use vowlr_util::prelude::ErrorRecord;
 
-use crate::{
-    errors::SerializationError,
-    serializers::util::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES},
-};
+use crate::serializers::util::{PROPERTY_EDGE_TYPES, SYMMETRIC_EDGE_TYPES};
 
 pub mod frontend;
 pub mod util;
@@ -224,15 +222,8 @@ pub struct SerializationDataBuffer {
     ///   can be either the subject, object or both (in this case, subject is used)
     /// - Value = The unresolved triples.
     unknown_buffer: HashMap<Term, HashSet<Triple>>,
-    /// Stores triples that are impossible to serialize.
-    ///
-    /// This could be caused by various reasons, such as
-    /// visualization of the triple is not supported.
-    ///
-    /// Each element is a tuple of:
-    /// - 0 = The triple (if any).
-    /// - 1 = The reason it failed to serialize (or the message if no triple is available).
-    failed_buffer: Vec<SerializationError>,
+    /// Stores errors encountered during serialization.
+    failed_buffer: Vec<ErrorRecord>,
     /// The base IRI of the document.
     ///
     /// For instance: `http://purl.obolibrary.org/obo/envo.owl`
@@ -412,17 +403,9 @@ impl Display for SerializationDataBuffer {
                     .join("\n")
             )?;
         }
-        writeln!(f, "\tfailed_buffer:")?;
-        for (triple, reason) in self.failed_buffer.iter() {
-            match triple {
-                Some(triple) => {
-                    writeln!(f, "\t\t{} : {}", triple, reason)?;
-                }
-                None => {
-                    writeln!(f, "\t\tNO TRIPLE : {}", reason)?;
-                }
-            }
-        }
+        // Not needed as it's displayed by the serializer
+        // writeln!(f, "\tfailed_buffer:")?;
+        // writeln!(f, "{}", ErrorRecord::format_records(&self.failed_buffer))?;
         writeln!(f, "}}")
     }
 }
diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index 67d1898..052bf29 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -25,6 +25,7 @@ use rdf_fusion::{
     },
 };
 use vowlr_parser::errors::VOWLRStoreError;
+use vowlr_util::prelude::VOWLRServerError;
 
 pub struct GraphDisplayDataSolutionSerializer {
     pub resolvable_iris: HashSet<String>,
@@ -41,13 +42,20 @@ impl GraphDisplayDataSolutionSerializer {
         &self,
         data: &mut GraphDisplayData,
         mut solution_stream: QuerySolutionStream,
-    ) -> Result<(), VOWLRStoreError> {
+    ) -> Result<(), VOWLRServerError> {
         let mut count: u32 = 0;
         info!("Serializing query solution stream...");
         let start_time = Instant::now();
         let mut data_buffer = SerializationDataBuffer::new();
-        while let Some(solution) = solution_stream.next().await {
-            let solution = solution?;
+        while let Some(maybe_solution) = solution_stream.next().await {
+            let solution = match maybe_solution {
+                Ok(solution) => solution,
+                Err(e) => {
+                    let a: VOWLRStoreError = e.into();
+                    data_buffer.failed_buffer.push(a.into());
+                    continue;
+                }
+            };
             let Some(id_term) = solution.get("id") else {
                 continue;
             };
@@ -62,17 +70,18 @@ impl GraphDisplayDataSolutionSerializer {
                 element_type: node_type_term.to_owned(),
                 target: solution.get("target").map(|term| term.to_owned()),
             };
-            match self.write_node_triple(&mut data_buffer, triple) {
-                Ok(_) => (),
-                Err(e) => {
-                    data_buffer
-                        .failed_buffer
-                        .push((e.inner.triple().cloned(), e.to_string()));
-                }
-            }
+
+            self.write_node_triple(&mut data_buffer, triple)
+                .or_else(|e| {
+                    data_buffer.failed_buffer.push(e.into());
+                    Ok::<(), VOWLRServerError>(())
+                })?;
             count += 1;
         }
-        self.check_all_unknowns(&mut data_buffer);
+        self.check_all_unknowns(&mut data_buffer).or_else(|e| {
+            data_buffer.failed_buffer.push(e.into());
+            Ok::<(), VOWLRServerError>(())
+        })?;
 
         let finish_time = Instant::now()
             .checked_duration_since(start_time)
@@ -91,29 +100,16 @@ impl GraphDisplayDataSolutionSerializer {
             data_buffer.node_element_buffer.len(),
             data_buffer.edge_buffer.len(),
             data_buffer.label_buffer.len(),
+            0,
             data_buffer.edge_characteristics.len() + data_buffer.node_characteristics.len(),
-            0
         );
+        debug!("{}", data_buffer);
         if !data_buffer.failed_buffer.is_empty() {
             let total = data_buffer.failed_buffer.len();
-
-            let mut error_log = String::from("[\n");
-            for (triple, reason) in data_buffer.failed_buffer.iter() {
-                match triple {
-                    Some(t) => error_log.push_str(&format!("\t{} : {}\n", t, reason)),
-                    None => error_log.push_str(&format!("\tNO TRIPLE : {}\n", reason)),
-                }
-            }
-            error_log.push(']');
-            error!("Failed to serialize: {}", error_log);
-
-            return Err(VOWLRStoreError::from(format!(
-                "Serialization failed ({} errors): {}",
-                total, error_log
-            )));
+            let err = data_buffer.failed_buffer.into();
+            error!("Failed to serialize {} triples:\n{}", total, err);
+            return Err(err);
         }
-
-        debug!("{}", data_buffer);
         *data = data_buffer.into();
         debug!("{}", data);
         Ok(())
@@ -487,31 +483,39 @@ impl GraphDisplayDataSolutionSerializer {
         }
     }
 
-    fn create_node(
+    fn create_named_node(&self, iri: String) -> Result<NamedNode, SerializationError> {
+        Ok(NamedNode::new(&iri).map_err(|e| SerializationErrorKind::IriParseError(iri, e))?)
+    }
+
+    fn create_blank_node(&self, id: String) -> Result<BlankNode, SerializationError> {
+        Ok(BlankNode::new(&id).map_err(|e| SerializationErrorKind::BlankNodeParseError(id, e))?)
+    }
+
+    fn create_triple(
         &self,
         id: String,
-        node_type: NamedNode,
+        element_type: NamedNode,
         object_iri: Option<String>,
     ) -> Result<Triple, SerializationError> {
         let subject = match NamedNode::new(id.clone()) {
             Ok(node) => Term::NamedNode(node),
-            Err(_) => Term::BlankNode(BlankNode::new(id)?),
+            Err(_) => Term::BlankNode(self.create_blank_node(id)?),
         };
 
         let object = match object_iri {
-            Some(iri) => {
-                let obj = NamedNode::new(iri)?;
-                Some(Term::NamedNode(obj))
-            }
+            Some(iri) => Some(Term::NamedNode(self.create_named_node(iri)?)),
             None => None,
         };
 
-        let t = Triple::new(subject, Term::NamedNode(node_type), object);
+        let t = Triple::new(subject, Term::NamedNode(element_type), object);
         debug!("Created new triple: {}", t);
         Ok(t)
     }
 
-    fn check_all_unknowns(&self, data_buffer: &mut SerializationDataBuffer) {
+    fn check_all_unknowns(
+        &self,
+        data_buffer: &mut SerializationDataBuffer,
+    ) -> Result<(), SerializationError> {
         info!("Second pass: Resolving all possible unknowns");
 
         let unknown_nodes = take(&mut data_buffer.unknown_buffer);
@@ -524,33 +528,21 @@ impl GraphDisplayDataSolutionSerializer {
                 // dummy triple, only subject matters.
                 let external_triple = Triple::new(
                     term,
-                    Term::BlankNode(BlankNode::new("_:external_class").unwrap()),
+                    Term::BlankNode(self.create_blank_node("_:external_class".to_string())?),
                     None,
                 );
-                match self.insert_node(
+
+                self.insert_node(
                     data_buffer,
                     &external_triple,
                     ElementType::Owl(OwlType::Node(OwlNode::ExternalClass)),
-                ) {
-                    Ok(_) => (),
-                    Err(e) => {
-                        data_buffer
-                            .failed_buffer
-                            .push((e.inner.triple().cloned(), e.to_string()));
-                    }
-                }
+                )?;
             }
             for triple in triples {
-                match self.write_node_triple(data_buffer, triple) {
-                    Ok(_) => (),
-                    Err(e) => {
-                        data_buffer
-                            .failed_buffer
-                            .push((e.inner.triple().cloned(), e.to_string()));
-                    }
-                }
+                self.write_node_triple(data_buffer, triple)?;
             }
         }
+        Ok(())
     }
 
     /// Serialize a triple to `data_buffer`.
@@ -559,21 +551,19 @@ impl GraphDisplayDataSolutionSerializer {
         data_buffer: &mut SerializationDataBuffer,
         triple: Triple,
     ) -> Result<(), SerializationError> {
-        // TODO: Collect errors and show to frontend
         debug!("{}", triple);
         match &triple.element_type {
             Term::BlankNode(bnode) => {
                 // The query must never put blank nodes in the ?nodeType variable
                 let msg = format!("Illegal blank node during serialization: '{bnode}'");
-                return Err(ser_err!(SerializationFailed(Some(triple), msg)).into());
+                return Err(SerializationErrorKind::SerializationFailed(triple, msg).into());
             }
             Term::Literal(literal) => {
-                // NOTE: Any string literal goes here, e.g. 'EquivalentClass'.
-                // That is, every BIND("someString" AS ?nodeType)
+                // NOTE: Any string literal goes here, e.g, every BIND("someString" AS ?nodeType)
                 let value = literal.value();
                 match value {
                     "blanknode" => {
-                        info!("Visualizing blank node: {}", triple.id);
+                        debug!("Visualizing blank node: {}", triple.id);
                         self.insert_node(
                             data_buffer,
                             &triple,
@@ -635,10 +625,11 @@ impl GraphDisplayDataSolutionSerializer {
                         )?;
                     }
                     rdfs::DOMAIN => {
-                        error!(
-                            "sparql query should not have rdfs:domain triples: {}",
-                            triple
-                        );
+                        return Err(SerializationErrorKind::SerializationFailed(
+                            triple,
+                            "SPARQL query should not have rdfs:domain triples".to_string(),
+                        )
+                        .into());
                     }
 
                     // rdfs::IS_DEFINED_BY => {}
@@ -653,10 +644,11 @@ impl GraphDisplayDataSolutionSerializer {
                     }
                     // rdfs::MEMBER => {}
                     rdfs::RANGE => {
-                        error!(
-                            "sparql query should not have rdfs:range triples: {}",
-                            triple
-                        );
+                        return Err(SerializationErrorKind::SerializationFailed(
+                            triple,
+                            "SPARQL query should not have rdfs:range triples".to_string(),
+                        )
+                        .into());
                     }
                     rdfs::RESOURCE => {
                         self.insert_node(
@@ -739,7 +731,6 @@ impl GraphDisplayDataSolutionSerializer {
                             &triple,
                             e,
                         );
-                        return Ok(());
                     }
 
                     //TODO: OWL1 (deprecated in OWL2, replaced by rdfs:datatype)
@@ -789,17 +780,17 @@ impl GraphDisplayDataSolutionSerializer {
                         let (index_s, index_o) = self.resolve_so(data_buffer, &triple);
                         match (index_s, index_o) {
                             (Some(index_s), Some(index_o)) => {
-                                match self.merge_nodes(data_buffer, &index_o, &index_s) {
-                                    Ok(_) => (),
-                                    Err(e) => {
-                                        data_buffer
-                                            .failed_buffer
-                                            .push((e.inner.triple().cloned(), e.to_string()));
-                                    }
-                                }
-
-                                // SAFETY: If index_s is Some it exists in node_element_buffer.
-                                if data_buffer.node_element_buffer[&index_s]
+                                self.merge_nodes(data_buffer, &index_o, &index_s)?;
+
+                                let index_s_element = data_buffer
+                                    .node_element_buffer
+                                    .get(&index_s)
+                                    .ok_or_else(|| {
+                                        let msg = "subject not present in node_element_buffer"
+                                            .to_string();
+                                        SerializationErrorKind::SerializationFailed(triple, msg)
+                                    })?;
+                                if *index_s_element
                                     != ElementType::Owl(OwlType::Node(OwlNode::AnonymousClass))
                                 {
                                     self.upgrade_node_type(
@@ -822,7 +813,10 @@ impl GraphDisplayDataSolutionSerializer {
                                     self.add_to_unknown_buffer(data_buffer, target, triple.clone())
                                 }
                                 None => {
-                                    data_buffer.failed_buffer.push((Some(triple), "Failed to merge object of equivalence relation into subject: object not found".to_string()));
+                                    let msg = "Failed to merge object of equivalence relation into subject: object not found".to_string();
+                                    return Err(
+                                        SerializationErrorKind::MissingObject(triple, msg).into()
+                                    );
                                 }
                             },
                             (None, Some(index_o)) => {
@@ -977,10 +971,13 @@ impl GraphDisplayDataSolutionSerializer {
                     // owl::VERSION_INFO => {}
                     // owl::VERSION_IRI => {}
                     // owl::WITH_RESTRICTIONS => {}
-                    _ => match triple.target.clone() {
-                        Some(target) => {
-                            let (node_triple, edge_triple): (Option<Vec<Triple>>, Option<Triple>) =
-                                match (
+                    _ => {
+                        match triple.target.clone() {
+                            Some(target) => {
+                                let (node_triple, edge_triple): (
+                                    Option<Vec<Triple>>,
+                                    Option<Triple>,
+                                ) = match (
                                     self.resolve(data_buffer, triple.id.clone()),
                                     self.resolve(data_buffer, triple.element_type.clone()),
                                     self.resolve(data_buffer, target.clone()),
@@ -990,7 +987,7 @@ impl GraphDisplayDataSolutionSerializer {
                                             "Resolving object property: range: {}, property: {}, domain: {}",
                                             range, property, domain
                                         );
-                                        (None, Some(triple))
+                                        (None, Some(triple.clone()))
                                     }
                                     (Some(domain), Some(property), None) => {
                                         trace!("Missing range: {}", triple);
@@ -999,7 +996,7 @@ impl GraphDisplayDataSolutionSerializer {
                                                 trim_tag_circumfix(domain.to_string().as_str())
                                                     + "_thing";
                                             info!("Creating thing node: {}", target_iri);
-                                            Some(self.create_node(
+                                            Some(self.create_triple(
                                                 target_iri.clone(),
                                                 owl::THING.into(),
                                                 None,
@@ -1009,7 +1006,7 @@ impl GraphDisplayDataSolutionSerializer {
                                                 trim_tag_circumfix(property.to_string().as_str())
                                                     + "_literal";
                                             info!("Creating literal node: {}", target_iri);
-                                            Some(self.create_node(
+                                            Some(self.create_triple(
                                                 target_iri.clone(),
                                                 rdfs::LITERAL.into(),
                                                 None,
@@ -1021,8 +1018,8 @@ impl GraphDisplayDataSolutionSerializer {
                                             Some(node) => (
                                                 Some(vec![node.clone()]),
                                                 Some(Triple {
-                                                    id: triple.id,
-                                                    element_type: triple.element_type,
+                                                    id: triple.id.clone(),
+                                                    element_type: triple.element_type.clone(),
                                                     target: Some(node.id),
                                                 }),
                                             ),
@@ -1034,7 +1031,7 @@ impl GraphDisplayDataSolutionSerializer {
                                                 self.add_to_unknown_buffer(
                                                     data_buffer,
                                                     target,
-                                                    triple,
+                                                    triple.clone(),
                                                 );
                                                 (None, None)
                                             }
@@ -1047,7 +1044,7 @@ impl GraphDisplayDataSolutionSerializer {
                                                 trim_tag_circumfix(range.to_string().as_str())
                                                     + "_thing";
                                             info!("Creating thing node: {}", target_iri);
-                                            Some(self.create_node(
+                                            Some(self.create_triple(
                                                 target_iri.clone(),
                                                 owl::THING.into(),
                                                 None,
@@ -1056,7 +1053,7 @@ impl GraphDisplayDataSolutionSerializer {
                                             let target_iri =
                                                 trim_tag_circumfix(range.to_string().as_str())
                                                     + "_literal";
-                                            Some(self.create_node(
+                                            Some(self.create_triple(
                                                 target_iri.clone(),
                                                 rdfs::LITERAL.into(),
                                                 None,
@@ -1069,8 +1066,8 @@ impl GraphDisplayDataSolutionSerializer {
                                                 Some(vec![node.clone()]),
                                                 Some(Triple {
                                                     id: node.id,
-                                                    element_type: triple.element_type,
-                                                    target: triple.target,
+                                                    element_type: triple.element_type.clone(),
+                                                    target: triple.target.clone(),
                                                 }),
                                             ),
                                             None => {
@@ -1081,7 +1078,7 @@ impl GraphDisplayDataSolutionSerializer {
                                                 self.add_to_unknown_buffer(
                                                     data_buffer,
                                                     target,
-                                                    triple,
+                                                    triple.clone(),
                                                 );
                                                 (None, None)
                                             }
@@ -1090,19 +1087,19 @@ impl GraphDisplayDataSolutionSerializer {
                                     (None, Some(property), None) => {
                                         trace!("Missing domain and range: {}", triple);
                                         if triple.element_type == owl::DATATYPE_PROPERTY.into() {
-                                            let local_literal = NamedNode::new(
+                                            let local_literal = self.create_named_node(
                                                 property.to_string() + "_locallitral",
                                             )?;
-                                            let literal_triple = self.create_node(
+                                            let literal_triple = self.create_triple(
                                                 local_literal.to_string(),
                                                 rdfs::LITERAL.into(),
                                                 None,
                                             )?;
                                             info!("Creating literal node: {}", local_literal);
-                                            let local_thing = NamedNode::new(
+                                            let local_thing = self.create_named_node(
                                                 property.to_string() + "_localthing",
                                             )?;
-                                            let thing_triple = self.create_node(
+                                            let thing_triple = self.create_triple(
                                                 local_thing.to_string(),
                                                 owl::THING.into(),
                                                 None,
@@ -1115,15 +1112,17 @@ impl GraphDisplayDataSolutionSerializer {
                                                 ]),
                                                 Some(Triple {
                                                     id: thing_triple.id.clone(),
-                                                    element_type: triple.element_type,
+                                                    element_type: triple.element_type.clone(),
                                                     target: Some(literal_triple.id),
                                                 }),
                                             )
                                         } else if triple.element_type == owl::OBJECT_PROPERTY.into()
                                         {
-                                            let global_thing =
-                                                NamedNode::new(owl::THING.to_string() + "_thing")?;
-                                            let node = self.create_node(
+                                            let global_thing = self.create_named_node(
+                                                owl::THING.to_string() + "_thing",
+                                            )?;
+
+                                            let node = self.create_triple(
                                                 global_thing.to_string(),
                                                 global_thing,
                                                 None,
@@ -1132,16 +1131,18 @@ impl GraphDisplayDataSolutionSerializer {
                                                 Some(vec![node.clone()]),
                                                 Some(Triple {
                                                     id: node.id.clone(),
-                                                    element_type: triple.element_type,
+                                                    element_type: triple.element_type.clone(),
                                                     target: Some(node.id),
                                                 }),
                                             )
                                         } else {
-                                            return Err(ser_err!(SerializationFailed(
-                                                Some(triple),
-                                                "Illegal property triple".to_string()
-                                            ))
-                                            .into());
+                                            return Err(
+                                                SerializationErrorKind::SerializationFailed(
+                                                    triple,
+                                                    "Illegal property triple".to_string(),
+                                                )
+                                                .into(),
+                                            );
                                         }
                                     }
 
@@ -1153,7 +1154,7 @@ impl GraphDisplayDataSolutionSerializer {
                                         self.add_to_unknown_buffer(
                                             data_buffer,
                                             triple.element_type.clone(),
-                                            triple,
+                                            triple.clone(),
                                         );
                                         (None, None)
                                     }
@@ -1162,77 +1163,100 @@ impl GraphDisplayDataSolutionSerializer {
                                         self.add_to_unknown_buffer(
                                             data_buffer,
                                             triple.id.clone(),
-                                            triple,
+                                            triple.clone(),
                                         );
                                         (None, None)
                                     }
                                 };
-                            match node_triple {
-                                Some(node_triples) => {
-                                    for node_triple in node_triples {
-                                        if node_triple.element_type == owl::THING.into() {
-                                            self.insert_node(
-                                                data_buffer,
-                                                &node_triple,
-                                                ElementType::Owl(OwlType::Node(OwlNode::Thing)),
-                                            )?;
-                                        } else if node_triple.element_type == rdfs::LITERAL.into() {
-                                            self.insert_node(
-                                                data_buffer,
-                                                &node_triple,
-                                                ElementType::Rdfs(RdfsType::Node(
-                                                    RdfsNode::Literal,
-                                                )),
-                                            )?;
+                                match node_triple {
+                                    Some(node_triples) => {
+                                        for node_triple in node_triples {
+                                            if node_triple.element_type == owl::THING.into() {
+                                                self.insert_node(
+                                                    data_buffer,
+                                                    &node_triple,
+                                                    ElementType::Owl(OwlType::Node(OwlNode::Thing)),
+                                                )?;
+                                            } else if node_triple.element_type
+                                                == rdfs::LITERAL.into()
+                                            {
+                                                self.insert_node(
+                                                    data_buffer,
+                                                    &node_triple,
+                                                    ElementType::Rdfs(RdfsType::Node(
+                                                        RdfsNode::Literal,
+                                                    )),
+                                                )?;
+                                            }
                                         }
                                     }
+                                    None => {
+                                        return Err(SerializationErrorKind::SerializationFailed(
+                                            triple.clone(),
+                                            "Error creating node".to_string(),
+                                        )
+                                        .into());
+                                    }
                                 }
-                                None => error!("Error creating node {:?}", node_triple),
-                            }
 
-                            match edge_triple {
-                                Some(edge_triple) => {
-                                    // unwrap safe, edge_triple will always be Some if property can be resolved.
-                                    let property = data_buffer
+                                match edge_triple {
+                                    Some(edge_triple) => {
+                                        // Dummy variable
+                                        // TODO: Refactor clones away in all of serializer
+                                        let dummy = || edge_triple.clone();
+
+                                        let property= data_buffer
                                         .edge_element_buffer
-                                        .get(&edge_triple.element_type)
-                                        .unwrap();
-                                    let edge = self.insert_edge(
-                                        data_buffer,
-                                        &edge_triple,
-                                        *property,
-                                        data_buffer
-                                            .label_buffer
-                                            .get(&edge_triple.element_type)
-                                            .cloned(),
-                                    );
-                                    if let Some(edge) = edge {
-                                        data_buffer.add_property_edge(
-                                            edge_triple.element_type.clone(),
-                                            edge,
-                                        );
-                                        data_buffer.add_property_domain(
-                                            edge_triple.element_type.clone(),
-                                            edge_triple
-                                                .target
-                                                .clone()
-                                                .expect("target should be a string"),
-                                        );
-                                        data_buffer.add_property_range(
-                                            edge_triple.element_type,
-                                            edge_triple.id,
+                                        .get(&edge_triple.element_type).ok_or_else(|| {
+                                            let msg = "Edge triple not present in edge_element_buffer".to_string();
+                                            SerializationErrorKind::SerializationFailed(dummy(), msg)})?;
+                                        let edge = self.insert_edge(
+                                            data_buffer,
+                                            &edge_triple,
+                                            *property,
+                                            data_buffer
+                                                .label_buffer
+                                                .get(&edge_triple.element_type)
+                                                .cloned(),
                                         );
+                                        if let Some(edge) = edge {
+                                            data_buffer.add_property_edge(
+                                                edge_triple.element_type.clone(),
+                                                edge,
+                                            );
+                                            data_buffer.add_property_domain(
+                                                edge_triple.element_type.clone(),
+                                                edge_triple.target.clone().ok_or_else(|| {
+                                                    SerializationErrorKind::SerializationFailed(
+                                                        dummy(),
+                                                        "target should be a string".to_string(),
+                                                    )
+                                                })?,
+                                            );
+                                            data_buffer.add_property_range(
+                                                edge_triple.element_type,
+                                                edge_triple.id,
+                                            );
+                                        }
+                                    }
+                                    None => {
+                                        return Err(SerializationErrorKind::SerializationFailed(
+                                            triple,
+                                            "Error creating edge".to_string(),
+                                        )
+                                        .into());
                                     }
-                                }
-                                None => {
-                                    error!("Error creating edge: ");
                                 }
                             }
+                            None => {
+                                return Err(SerializationErrorKind::SerializationFailed(
+                                    triple,
+                                    "Object property triples should have a target".to_string(),
+                                )
+                                .into());
+                            }
                         }
-                        None => {
-                            error!("object property triples should have a target: {}", triple);
-                        }
-                    },
+                    }
                 }
             }
         }
@@ -1250,16 +1274,16 @@ impl GraphDisplayDataSolutionSerializer {
             Some(s) => match data_buffer.node_characteristics.get_mut(&s) {
                 Some(char) => {
                     for (k, v) in data_buffer.property_edge_map.iter() {
-                        info!("{} -> {}", k, v);
+                        trace!("{} -> {}", k, v);
                     }
-                    info!("Inserting characteristic: {} -> {}", s, arg);
+                    debug!("Inserting characteristic: {} -> {}", s, arg);
                     char.push(arg);
                 }
                 None => {
                     for (k, v) in data_buffer.property_edge_map.iter() {
-                        info!("{} -> {}", k, v);
+                        trace!("{} -> {}", k, v);
                     }
-                    info!("Inserting characteristic: {} -> {}", s, arg);
+                    debug!("Inserting characteristic: {} -> {}", s, arg);
                     let e = data_buffer.property_edge_map.get(&s);
                     match e {
                         Some(e) => {
@@ -1274,7 +1298,7 @@ impl GraphDisplayDataSolutionSerializer {
                 }
             },
             None => {
-                info!("Adding characteristic to unknown buffer: {}", triple);
+                debug!("Adding characteristic to unknown buffer: {}", triple);
                 self.add_to_unknown_buffer(data_buffer, triple.id.clone(), triple);
             }
         }

From 68a7ccb7c48b9424270eeab64150daa6cea82b85 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:02:42 +0100
Subject: [PATCH 13/36] Minor format! changes

---
 crates/database/src/errors.rs | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
index 20ad39a..0ff1024 100644
--- a/crates/database/src/errors.rs
+++ b/crates/database/src/errors.rs
@@ -1,6 +1,5 @@
 use crate::serializers::Triple;
 use oxrdf::{BlankNodeIdParseError, IriParseError};
-use vowlr_parser::errors::VOWLRStoreError;
 use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
 
 #[derive(Debug)]
@@ -37,20 +36,20 @@ impl From<SerializationError> for ErrorRecord {
     fn from(value: SerializationError) -> Self {
         let (message, severity) = match value.inner {
             SerializationErrorKind::MissingObject(triple, e) => {
-                (format!("{e}\n{triple}"), ErrorSeverity::Warning)
+                (format!("{e}:\n{triple}"), ErrorSeverity::Warning)
             }
             SerializationErrorKind::MissingSubject(triple, e) => {
-                (format!("{e}\n{triple}"), ErrorSeverity::Warning)
+                (format!("{e}:\n{triple}"), ErrorSeverity::Warning)
             }
             SerializationErrorKind::SerializationFailed(triple, e) => {
-                (format!("{e}\n{triple}"), ErrorSeverity::Critical)
+                (format!("{e}:\n{triple}"), ErrorSeverity::Critical)
             }
-            SerializationErrorKind::IriParseError(triple, iri_parse_error) => (
-                format!("{iri_parse_error}\n{triple}"),
+            SerializationErrorKind::IriParseError(iri, iri_parse_error) => (
+                format!("{iri_parse_error} (IRI: {iri})"),
                 ErrorSeverity::Severe,
             ),
-            SerializationErrorKind::BlankNodeParseError(triple, blank_node_id_parse_error) => (
-                format!("{blank_node_id_parse_error}\n{triple}"),
+            SerializationErrorKind::BlankNodeParseError(id, blank_node_id_parse_error) => (
+                format!("{blank_node_id_parse_error} (ID: {id})"),
                 ErrorSeverity::Severe,
             ),
         };

From 4f880684d4139a54e14974db8ae7321839f4a832 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:03:42 +0100
Subject: [PATCH 14/36] Impl for our custom server error

---
 crates/parser/src/errors.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index 4ead104..a7fa453 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -8,7 +8,7 @@ use rdf_fusion::{
     model::{IriParseError, StorageError},
 };
 use tokio::task::JoinError;
-use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRServerError};
 
 #[derive(Debug)]
 pub enum VOWLRStoreErrorKind {
@@ -160,7 +160,9 @@ impl From<VOWLRStoreError> for ErrorRecord {
             VOWLRStoreErrorKind::HornedError(horned_error) => {
                 (horned_error.to_string(), ErrorType::Parser)
             }
-            VOWLRStoreErrorKind::IOError(error) => (error.to_string(), ErrorType::Generic),
+            VOWLRStoreErrorKind::IOError(error) => {
+                (error.to_string(), ErrorType::InternalServerError)
+            }
             VOWLRStoreErrorKind::IriParseError(iri_parse_error) => {
                 (iri_parse_error.to_string(), ErrorType::Parser)
             }
@@ -171,7 +173,7 @@ impl From<VOWLRStoreError> for ErrorRecord {
                 (query_evaluation_error.to_string(), ErrorType::Database)
             }
             VOWLRStoreErrorKind::JoinError(join_error) => {
-                (join_error.to_string(), ErrorType::Generic)
+                (join_error.to_string(), ErrorType::InternalServerError)
             }
             VOWLRStoreErrorKind::StorageError(storage_error) => {
                 (storage_error.to_string(), ErrorType::Database)
@@ -186,3 +188,10 @@ impl From<VOWLRStoreError> for ErrorRecord {
         )
     }
 }
+
+impl From<VOWLRStoreError> for VOWLRServerError {
+    fn from(value: VOWLRStoreError) -> Self {
+        let record: ErrorRecord = value.into();
+        record.into()
+    }
+}

From 9fff2ab6ae935473c5ecb25a68a41789cf23fb7b Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:03:53 +0100
Subject: [PATCH 15/36] Export our custom server error

---
 crates/util/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/util/src/lib.rs b/crates/util/src/lib.rs
index f0920e0..f29811f 100644
--- a/crates/util/src/lib.rs
+++ b/crates/util/src/lib.rs
@@ -3,5 +3,5 @@ mod error_handler;
 
 pub mod prelude {
     pub use crate::datatypes::DataType;
-    pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType};
+    pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRServerError};
 }

From f6ae37e5dd302f606b6f5be8e0a7b81ec6721b4e Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:04:05 +0100
Subject: [PATCH 16/36] Add table gen on server

---
 crates/util/Cargo.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index 6119334..7276ae8 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -19,3 +19,7 @@
     rkyv.workspace=true
     serde={version="1.0", features=["derive"]}
     strum.workspace=true
+    tabled={version="0.20", optional=true}
+
+[features]
+    server=["dep:tabled"]

From 5df30a3f99fe4bd5d90a31c11ebec69d2b4c8663 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:04:56 +0100
Subject: [PATCH 17/36] Expand error handling frontend with the new error
 handling backend

---
 src/blocks/workbench.rs           |   9 +--
 src/blocks/workbench/error_log.rs | 112 ++++++++++++++++++++++++++----
 2 files changed, 102 insertions(+), 19 deletions(-)

diff --git a/src/blocks/workbench.rs b/src/blocks/workbench.rs
index 8e4abbf..0a12651 100644
--- a/src/blocks/workbench.rs
+++ b/src/blocks/workbench.rs
@@ -46,14 +46,11 @@ pub fn NewWorkbench() -> impl IntoView {
         total_graph_data,
     });
 
-    let all_errors = RwSignal::new(Vec::<String>::new());
-
-    let error_context = ErrorLogContext { errors: all_errors };
-
-    provide_context(error_context.clone());
+    let error_context = ErrorLogContext::default();
+    provide_context(error_context);
 
     let error_title = Signal::derive(move || {
-        let count = error_context.errors.get().len();
+        let count = error_context.len();
         if count > 0 {
             format!("Error Log ({count})")
         } else {
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 991ccad..93c2fed 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -1,35 +1,121 @@
+// use std::ops::Range;
+
 use super::WorkbenchMenuItems;
 use leptos::prelude::*;
+// use leptos_struct_table::{ColumnSort, TableContent, TableDataProvider};
+use vowlr_util::prelude::{ErrorRecord, VOWLRServerError};
 
-#[derive(Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct ErrorLogContext {
-    pub errors: RwSignal<Vec<String>>,
+    pub records: RwSignal<Vec<ErrorRecord>>,
 }
 
-pub fn ErrorLog() -> impl IntoView {
-    fn unescape_log(s: &str) -> String {
-        s.replace("\\n", "\n").replace("\\t", "\t")
+impl ErrorLogContext {
+    pub fn new(records: Vec<ErrorRecord>) -> Self {
+        Self {
+            records: RwSignal::new(records),
+        }
+    }
+
+    /// Appends an element to the back of a collection.
+    ///
+    /// # Panics
+    /// Panics if you update the value of the signal of `self` before this function returns.
+    pub fn push(&self, record: ErrorRecord) {
+        self.records.update(|records| records.push(record));
+    }
+
+    /// Extends a collection with the contents of an iterator.
+    ///
+    /// # Panics
+    /// Panics if you update the value of the signal of `self` before this function returns.
+    pub fn extend(&self, records: Vec<ErrorRecord>) {
+        self.records.update(|records_| records_.extend(records));
+    }
+
+    /// Clears the collection, removing all values.
+    ///
+    /// Note that this method has no effect on the allocated capacity of the vector.
+    ///
+    /// # Panics
+    /// Panics if you update the value of the signal of `self` before this function returns.
+    pub fn clear(&self) {
+        // self.records.update(|records| records.clear());
+        self.records.update(std::vec::Vec::clear);
+    }
+
+    /// Returns the number of elements in the collection, also referred to as its 'length'
+    ///
+    /// # Panics
+    /// Panics if you try to access the signal of `self` when it has been disposed.
+    pub fn len(&self) -> usize {
+        self.records.read().len()
+    }
+}
+
+impl Default for ErrorLogContext {
+    fn default() -> Self {
+        Self {
+            records: RwSignal::new(Vec::new()),
+        }
+    }
+}
+
+// impl TableDataProvider<ErrorRecord, usize> for ErrorLogContext {
+//     async fn get_rows(
+//         &self,
+//         range: Range<usize>,
+//     ) -> Result<(Vec<ErrorRecord>, Range<usize>), String> {
+//         let records = self.records.read();
+//         if records.is_empty() {
+//             return Ok((vec![], 0..0));
+//         }
+
+//         let start = range.start.min(records.len() - 1);
+//         let end = range.end.min(records.len());
+
+//         let return_range = start..end;
+
+//         Ok((records[return_range.clone()].to_vec(), return_range))
+//     }
+
+//     async fn row_count(&self) -> Option<usize> {
+//         Some(self.len())
+//     }
+
+//     // fn set_sorting(&mut self, sorting: &std::collections::VecDeque<(usize, ColumnSort)>) {}
+// }
+
+impl From<VOWLRServerError> for ErrorLogContext {
+    fn from(value: VOWLRServerError) -> Self {
+        Self::new(value.records)
     }
+}
 
-    let error_log = expect_context::<ErrorLogContext>();
+pub fn ErrorLog() -> impl IntoView {
+    let error_context = expect_context::<ErrorLogContext>();
 
+    // view! {
+    //     <table>
+    //         <TableContent rows=error_context scroll_container="html" />
+    //     </table>
+    // }
     view! {
         {move || {
-            let errors = error_log.errors.get();
+            let records = error_context.records.read();
             view! {
                 <div class="overflow-y-auto p-2 mt-2 bg-red-50 rounded border border-red-200 max-h-130">
-                    {if errors.is_empty() {
+                    {if records.is_empty() {
                         view! { <p class="text-xs text-gray-600">"No errors"</p> }
                             .into_any()
                     } else {
                         view! {
                             <ul class="space-y-1 text-xs text-red-700">
-                                {errors
-                                    .into_iter()
-                                    .map(|err| {
-                                        let err = unescape_log(&err);
+                                {records
+                                    .iter()
+                                    .map(|record| {
                                         view! {
-                                            <li class="font-mono whitespace-pre-wrap">"• " {err}</li>
+                                            <li class="font-mono whitespace-pre-wrap">"• " {record.to_string()}</li>
                                         }
                                     })
                                     .collect_view()}

From 4c695125d044ff49a7876f9690b08ecc4347a997 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Sat, 28 Feb 2026 02:07:08 +0100
Subject: [PATCH 18/36] Begin using new error handling system

---
 src/blocks/workbench/ontology_menu.rs         | 24 +++++---------
 .../ontology_menu/stored_ontology.rs          | 27 ++++++++-------
 src/components/user_input/file_upload.rs      | 33 +++++++------------
 3 files changed, 33 insertions(+), 51 deletions(-)

diff --git a/src/blocks/workbench/ontology_menu.rs b/src/blocks/workbench/ontology_menu.rs
index 28ccc61..027f494 100644
--- a/src/blocks/workbench/ontology_menu.rs
+++ b/src/blocks/workbench/ontology_menu.rs
@@ -19,7 +19,7 @@ pub fn SelectStaticInput() -> impl IntoView {
         graph_data,
         total_graph_data,
     } = expect_context::<GraphDataContext>();
-    let error_log = expect_context::<ErrorLogContext>();
+    let error_context = expect_context::<ErrorLogContext>();
     let selected_ontology = RwSignal::new(String::new());
     let loading = RwSignal::new(false);
 
@@ -64,8 +64,7 @@ pub fn SelectStaticInput() -> impl IntoView {
                                     .send(RenderEvent::LoadGraph(new_graph_data));
                             }
                             Err(e) => {
-                                let err_msg = format!("Error loading stored ontology: {e}");
-                                error_log.errors.update(|errors| errors.push(err_msg));
+                                error_context.extend(e.records);
                             }
                         }
                         loading.set(false);
@@ -98,7 +97,7 @@ pub fn UploadInput() -> impl IntoView {
         graph_data,
         total_graph_data,
     } = expect_context::<GraphDataContext>();
-    let error_log = expect_context::<ErrorLogContext>();
+    let error_context = expect_context::<ErrorLogContext>();
     let upload = FileUpload::new();
     let local_loading_done = upload.local_action.value();
     let remote_loading_done = upload.remote_action.value();
@@ -123,14 +122,12 @@ pub fn UploadInput() -> impl IntoView {
                                 .send(RenderEvent::LoadGraph(new_graph_data));
                         }
                         Err(e) => {
-                            let err_msg = format!("Error processing file: {e}");
-                            error_log.errors.update(|errors| errors.push(err_msg));
+                            error_context.extend(e.records);
                         }
                     }
                 }),
                 Err(e) => {
-                    let err_msg = format!("Error loading file: {e}");
-                    error_log.errors.update(|errors| errors.push(err_msg));
+                    error_context.push(e.into());
                 }
             }
         }
@@ -150,14 +147,12 @@ pub fn UploadInput() -> impl IntoView {
                                 .send(RenderEvent::LoadGraph(new_graph_data));
                         }
                         Err(e) => {
-                            let err_msg = format!("Error processing URL: {e}");
-                            error_log.errors.update(|errors| errors.push(err_msg));
+                            error_context.extend(e.records);
                         }
                     }
                 }),
                 Err(e) => {
-                    let err_msg = format!("Error loading from URL: {e}");
-                    error_log.errors.update(|errors| errors.push(err_msg));
+                    error_context.push(e.into());
                 }
             }
         }
@@ -275,7 +270,7 @@ pub fn UploadInput() -> impl IntoView {
 
 #[component]
 pub fn FetchData() -> impl IntoView {
-    let error_log = expect_context::<ErrorLogContext>();
+    let error_context = expect_context::<ErrorLogContext>();
 
     let handle_reload = move || {
         spawn_local(async move {
@@ -287,8 +282,7 @@ pub fn FetchData() -> impl IntoView {
                         .send(RenderEvent::LoadGraph(graph_data));
                 }
                 Err(e) => {
-                    let err_msg = format!("Error reloading data: {e}");
-                    error_log.errors.update(|errors| errors.push(err_msg));
+                    error_context.extend(e.records);
                 }
             }
         });
diff --git a/src/blocks/workbench/ontology_menu/stored_ontology.rs b/src/blocks/workbench/ontology_menu/stored_ontology.rs
index e59ecc5..1c74ac9 100644
--- a/src/blocks/workbench/ontology_menu/stored_ontology.rs
+++ b/src/blocks/workbench/ontology_menu/stored_ontology.rs
@@ -5,9 +5,12 @@ use leptos::server_fn::codec::Rkyv;
 use std::path::Path;
 #[cfg(feature = "server")]
 use vowlr_database::prelude::{GraphDisplayDataSolutionSerializer, QueryResults, VOWLRStore};
+#[cfg(feature = "server")]
+use vowlr_parser::errors::VOWLRStoreError;
 use vowlr_sparql_queries::prelude::DEFAULT_QUERY;
+use vowlr_util::prelude::VOWLRServerError;
 
-fn ontology_file_path(name: &str) -> Result<&'static str, ServerFnError<String>> {
+fn ontology_file_path(name: &str) -> Result<&'static str, VOWLRServerError> {
     match name {
         "Clinical Trials Ontology (CTO) (273 classes)" => {
             Ok("src/assets/data/ClinicalTrialOntology-merged.owl")
@@ -15,22 +18,17 @@ fn ontology_file_path(name: &str) -> Result<&'static str, ServerFnError<String>>
         "Friend of a Friend (FOAF) vocabulary (22 classes)" => Ok("src/assets/data/foaf.ttl"),
         "VOWL-R Benchmark Ontology (2.5k nodes)" => Ok("src/assets/data/vowlr-benchmark-2500.ofn"),
         "The Environment Ontology (6.9k classes)" => Ok("src/assets/data/envo.owl"),
-        _ => Err(ServerFnError::ServerError(format!(
-            "Unknown ontology: {name}"
-        ))),
+        _ => Err(ServerFnError::ServerError(format!("Unknown ontology: {name}")).into()),
     }
 }
 
 #[server(input = Rkyv, output = Rkyv)]
-pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, ServerFnError<String>> {
+pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, VOWLRServerError> {
     let file_path = ontology_file_path(&name)?;
     let path = Path::new(file_path);
 
     let store = VOWLRStore::default();
-    store
-        .insert_file(path, false)
-        .await
-        .map_err(|e| ServerFnError::ServerError(format!("Failed to load ontology file: {e}")))?;
+    store.insert_file(path, false).await?;
 
     let mut data_buffer = GraphDisplayData::new();
     let solution_serializer = GraphDisplayDataSolutionSerializer::new();
@@ -38,17 +36,18 @@ pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, Serv
         .session
         .query(DEFAULT_QUERY.as_str())
         .await
-        .map_err(|e| ServerFnError::ServerError(format!("SPARQL query failed: {e}")))?;
+        .map_err(|e| <VOWLRStoreError as Into<VOWLRServerError>>::into(e.into()))?;
 
     if let QueryResults::Solutions(solutions) = query_stream {
         solution_serializer
             .serialize_nodes_stream(&mut data_buffer, solutions)
-            .await
-            .map_err(|e| ServerFnError::ServerError(e.to_string()))?;
+            .await?;
     } else {
         return Err(ServerFnError::ServerError(
-            "Query stream is not a solutions stream".to_string(),
-        ));
+            "Query stream is not a solutions stream (only SELECT queries are supported)"
+                .to_string(),
+        )
+        .into());
     }
     Ok(data_buffer)
 }
diff --git a/src/components/user_input/file_upload.rs b/src/components/user_input/file_upload.rs
index fc51c7d..47a74c6 100644
--- a/src/components/user_input/file_upload.rs
+++ b/src/components/user_input/file_upload.rs
@@ -15,7 +15,9 @@ use std::path::Path;
 use std::rc::Rc;
 #[cfg(feature = "server")]
 use vowlr_database::prelude::{GraphDisplayDataSolutionSerializer, QueryResults, VOWLRStore};
-use vowlr_util::prelude::DataType;
+#[cfg(feature = "server")]
+use vowlr_parser::errors::VOWLRStoreError;
+use vowlr_util::prelude::{DataType, VOWLRServerError};
 use web_sys::{FileList, FormData};
 
 #[cfg(feature = "ssr")]
@@ -121,10 +123,7 @@ pub async fn handle_local(data: MultipartData) -> Result<(DataType, usize), Serv
         }
     }
 
-    session
-        .complete_upload()
-        .await
-        .map_err(|e| ServerFnError::new(e.to_string()))?;
+    session.complete_upload().await?;
     Ok((dtype, count))
 }
 
@@ -159,10 +158,7 @@ pub async fn handle_remote(url: String) -> Result<(DataType, usize), ServerFnErr
             chunk_result.map_err(|e| ServerFnError::new(format!("Error reading chunk: {e}")))?;
 
         total += chunk.len();
-        session
-            .upload_chunk(&chunk)
-            .await
-            .map_err(|e| ServerFnError::new(e.to_string()))?;
+        session.upload_chunk(&chunk).await?;
         progress::add_chunk(&progress_key, chunk.len()).await;
     }
 
@@ -199,10 +195,7 @@ pub async fn handle_sparql(
 
     let progress_key = format!("sparql-{endpoint}");
     progress::reset(&progress_key);
-    session
-        .start_upload(&progress_key)
-        .await
-        .map_err(|e| ServerFnError::new(e.to_string()))?;
+    session.start_upload(&progress_key).await?;
 
     let mut total = 0;
     let mut stream = resp.bytes_stream();
@@ -219,10 +212,7 @@ pub async fn handle_sparql(
     }
 
     progress::remove(&progress_key);
-    session
-        .complete_upload()
-        .await
-        .map_err(|e| ServerFnError::new(e.to_string()))?;
+    session.complete_upload().await?;
 
     let dtype = if accept_type.contains("xml") {
         DataType::SPARQLXML
@@ -233,9 +223,7 @@ pub async fn handle_sparql(
 }
 
 #[server (input = Rkyv, output = Rkyv)]
-pub async fn handle_internal_sparql(
-    query: String,
-) -> Result<GraphDisplayData, ServerFnError<String>> {
+pub async fn handle_internal_sparql(query: String) -> Result<GraphDisplayData, VOWLRServerError> {
     let vowlr = VOWLRStore::default();
 
     let mut data_buffer = GraphDisplayData::new();
@@ -244,7 +232,7 @@ pub async fn handle_internal_sparql(
         .session
         .query(query.as_str())
         .await
-        .map_err(|e| ServerFnError::ServerError(format!("SPARQL query failed: {e}")))?;
+        .map_err(|e| <VOWLRStoreError as Into<VOWLRServerError>>::into(e.into()))?;
     if let QueryResults::Solutions(solutions) = query_stream {
         solution_serializer
             .serialize_nodes_stream(&mut data_buffer, solutions)
@@ -252,7 +240,8 @@ pub async fn handle_internal_sparql(
     } else {
         return Err(ServerFnError::ServerError(
             "Query stream is not a solutions stream".to_string(),
-        ));
+        )
+        .into());
     }
     Ok(data_buffer)
 }

From b97cd6e5dc351ce2a76c7a3285c982034cf7b97f Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Wed, 4 Mar 2026 10:32:46 +0000
Subject: [PATCH 19/36] WIP 1 on tables

---
 crates/util/src/error_handler.rs  | 47 ++++++++++++++++++++++-
 crates/util/src/layout.rs         |  6 +++
 crates/util/src/lib.rs            |  2 +
 src/blocks/workbench.rs           |  2 +-
 src/blocks/workbench/error_log.rs | 63 +++++++++++++++++--------------
 src/components.rs                 |  1 +
 src/components/table.rs           | 36 ++++++++++++++++++
 7 files changed, 126 insertions(+), 31 deletions(-)
 create mode 100644 crates/util/src/layout.rs
 create mode 100644 src/components/table.rs

diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 3e3a5a7..f512ce8 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -2,8 +2,9 @@
 use std::fmt::Write;
 
 use leptos::{
-    prelude::{FromServerFnError, IntoView, ServerFnError, ServerFnErrorErr},
+    prelude::{ElementChild, FromServerFnError, IntoView, ServerFnError, ServerFnErrorErr, Signal},
     server_fn::{Decodes, Encodes, codec::RkyvEncoding, error::IntoAppError},
+    view,
 };
 
 // use leptos_struct_table::*;
@@ -15,6 +16,8 @@ use tabled::{
     settings::{Settings, Style},
 };
 
+use crate::layout::TableHTML;
+
 #[derive(
     Debug,
     Copy,
@@ -168,6 +171,48 @@ impl ErrorRecord {
     }
 }
 
+impl TableHTML for ErrorRecord {
+    fn header(&self) -> impl IntoView {
+        view! {
+            <thead>
+                <tr>
+                    <th>{"Severity"}</th>
+                    <th>{"Error Type"}</th>
+                    <th>{"Message"}</th>
+                    {
+                        #[cfg(debug_assertions)]
+                        view! {<th>{"Code Location"}</th>}
+                    }
+                </tr>
+            </thead>
+        }
+    }
+
+    fn row(&self) -> impl IntoView {
+        view! {
+            <tr>
+                <td>
+                    {self.severity.to_string()}
+                </td>
+                <td>
+                    {self.error_type.to_string()}
+                </td>
+                <td>
+                    {self.message.clone()}
+                </td>
+                {
+                    #[cfg(debug_assertions)]
+                    view! {
+                        <td>
+                            {self.location.to_string()}
+                        </td>
+                    }
+                }
+            </tr>
+        }
+    }
+}
+
 impl From<ServerFnError> for ErrorRecord {
     fn from(value: ServerFnError) -> Self {
         let (error_type, message) = match value {
diff --git a/crates/util/src/layout.rs b/crates/util/src/layout.rs
new file mode 100644
index 0000000..09d38ce
--- /dev/null
+++ b/crates/util/src/layout.rs
@@ -0,0 +1,6 @@
+use leptos::IntoView;
+
+pub trait TableHTML {
+    fn header(&self) -> impl IntoView;
+    fn row(&self) -> impl IntoView;
+}
diff --git a/crates/util/src/lib.rs b/crates/util/src/lib.rs
index f29811f..31f0b51 100644
--- a/crates/util/src/lib.rs
+++ b/crates/util/src/lib.rs
@@ -1,7 +1,9 @@
 mod datatypes;
 mod error_handler;
+mod layout;
 
 pub mod prelude {
     pub use crate::datatypes::DataType;
     pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRServerError};
+    pub use crate::layout::TableHTML;
 }
diff --git a/src/blocks/workbench.rs b/src/blocks/workbench.rs
index 0a12651..a26bf90 100644
--- a/src/blocks/workbench.rs
+++ b/src/blocks/workbench.rs
@@ -27,7 +27,7 @@ pub struct GraphDataContext {
 #[component]
 fn WorkbenchMenuItems(#[prop(into)] title: String, children: Children) -> impl IntoView {
     view! {
-        <div class="flex flex-col justify-center p-2 w-[250px]">
+        <div class="flex flex-col justify-center p-2 min-w-250 md:min-w-[30vw]">
             <div class="workbench-menu-header">
                 <h3>{title}</h3>
             </div>
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 93c2fed..5fc9e52 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -3,6 +3,7 @@
 use super::WorkbenchMenuItems;
 use leptos::prelude::*;
 // use leptos_struct_table::{ColumnSort, TableContent, TableDataProvider};
+use crate::components::table::Table;
 use vowlr_util::prelude::{ErrorRecord, VOWLRServerError};
 
 #[derive(Debug, Copy, Clone)]
@@ -95,40 +96,44 @@ impl From<VOWLRServerError> for ErrorLogContext {
 pub fn ErrorLog() -> impl IntoView {
     let error_context = expect_context::<ErrorLogContext>();
 
+    view! {
+        <Table items=error_context.records />
+    }
     // view! {
     //     <table>
     //         <TableContent rows=error_context scroll_container="html" />
     //     </table>
     // }
-    view! {
-        {move || {
-            let records = error_context.records.read();
-            view! {
-                <div class="overflow-y-auto p-2 mt-2 bg-red-50 rounded border border-red-200 max-h-130">
-                    {if records.is_empty() {
-                        view! { <p class="text-xs text-gray-600">"No errors"</p> }
-                            .into_any()
-                    } else {
-                        view! {
-                            <ul class="space-y-1 text-xs text-red-700">
-                                {records
-                                    .iter()
-                                    .map(|record| {
-                                        view! {
-                                            <li class="font-mono whitespace-pre-wrap">"• " {record.to_string()}</li>
-                                        }
-                                    })
-                                    .collect_view()}
-
-                            </ul>
-                        }
-                            .into_any()
-                    }}
-                </div>
-            }
-                .into_any()
-        }}
-    }
+
+    // view! {
+    //     {move || {
+    //         let records = error_context.records.read();
+    //         view! {
+    //             <div class="overflow-y-auto p-2 mt-2 bg-red-50 rounded border border-red-200 max-h-130">
+    //                 {if records.is_empty() {
+    //                     view! { <p class="text-xs text-gray-600">"No errors"</p> }
+    //                         .into_any()
+    //                 } else {
+    //                     view! {
+    //                         <ul class="space-y-1 text-xs text-red-700">
+    //                             {records
+    //                                 .iter()
+    //                                 .map(|record| {
+    //                                     view! {
+    //                                         <li class="font-mono whitespace-pre-wrap">"• " {record.to_string()}</li>
+    //                                     }
+    //                                 })
+    //                                 .collect_view()}
+
+    //                         </ul>
+    //                     }
+    //                         .into_any()
+    //                 }}
+    //             </div>
+    //         }
+    //             .into_any()
+    //     }}
+    // }
 }
 
 #[component]
diff --git a/src/components.rs b/src/components.rs
index 6116624..7b1726d 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -6,5 +6,6 @@ pub mod lists;
 pub mod menu;
 pub mod progress_bar;
 // pub mod theme;
+pub mod table;
 pub mod tooltip;
 pub mod user_input;
diff --git a/src/components/table.rs b/src/components/table.rs
new file mode 100644
index 0000000..72be2b0
--- /dev/null
+++ b/src/components/table.rs
@@ -0,0 +1,36 @@
+use crate::components::icon::MaybeShowIcon;
+use leptos::{html::Div, prelude::*};
+use leptos_use::on_click_outside;
+use vowlr_util::prelude::{ErrorRecord, TableHTML};
+
+/// A table
+#[component]
+pub fn Table<T>(#[prop(into)] items: Signal<Vec<T>>) -> impl IntoView
+where
+    T: TableHTML + Send + Sync + 'static,
+{
+    // view! {
+    //     <table class="table-auto">
+    //     {move || {
+    //         let a = items.read();
+
+    //         view!{
+    //             a.iter().map(|item| item.row()).collect_view()
+    //         }.into_any()
+    //     }}
+    //     </table>
+    // }
+
+    view! {
+        {move || {
+            let stuff =  items.read();
+            view! {
+                <table class="border-1 border-solid border-collapse table-auto md:table-fixed md:w-[80vw]">
+                   {stuff.iter().map(|item| item.header()).next().collect_view()}
+                   {stuff.iter().map(|item| item.row()).collect_view()}
+                </table>
+            }
+                .into_any()
+        }}
+    }
+}

From bc040d6526ac534a807244574afa8089a1e4688f Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:02:45 +0000
Subject: [PATCH 20/36] Add type annotation

---
 crates/database/src/serializers/frontend.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index 052bf29..e122cc6 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -106,7 +106,7 @@ impl GraphDisplayDataSolutionSerializer {
         debug!("{}", data_buffer);
         if !data_buffer.failed_buffer.is_empty() {
             let total = data_buffer.failed_buffer.len();
-            let err = data_buffer.failed_buffer.into();
+            let err: VOWLRServerError = take(&mut data_buffer.failed_buffer).into();
             error!("Failed to serialize {} triples:\n{}", total, err);
             return Err(err);
         }

From caabb0859019cba123e0259c8616af9a11ca4fc1 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Thu, 5 Mar 2026 14:03:08 +0000
Subject: [PATCH 21/36] WIP on frontend table

---
 crates/database/src/errors.rs     |  4 +--
 crates/util/src/error_handler.rs  | 57 ++++++++++++++-----------------
 src/blocks/workbench.rs           |  5 +--
 src/blocks/workbench/error_log.rs |  7 ++--
 src/components/lists.rs           |  3 +-
 src/components/table.rs           | 28 +++++++--------
 6 files changed, 48 insertions(+), 56 deletions(-)

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
index 0ff1024..6a74979 100644
--- a/crates/database/src/errors.rs
+++ b/crates/database/src/errors.rs
@@ -46,11 +46,11 @@ impl From<SerializationError> for ErrorRecord {
             }
             SerializationErrorKind::IriParseError(iri, iri_parse_error) => (
                 format!("{iri_parse_error} (IRI: {iri})"),
-                ErrorSeverity::Severe,
+                ErrorSeverity::Error,
             ),
             SerializationErrorKind::BlankNodeParseError(id, blank_node_id_parse_error) => (
                 format!("{blank_node_id_parse_error} (ID: {id})"),
-                ErrorSeverity::Severe,
+                ErrorSeverity::Error,
             ),
         };
         ErrorRecord::new(
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index f512ce8..0ef5982 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -2,7 +2,7 @@
 use std::fmt::Write;
 
 use leptos::{
-    prelude::{ElementChild, FromServerFnError, IntoView, ServerFnError, ServerFnErrorErr, Signal},
+    prelude::*,
     server_fn::{Decodes, Encodes, codec::RkyvEncoding, error::IntoAppError},
     view,
 };
@@ -32,9 +32,7 @@ use crate::layout::TableHTML;
 #[strum(serialize_all = "title_case")]
 pub enum ErrorSeverity {
     Critical,
-    Severe,
-    Medium,
-    Low,
+    Error,
     Warning,
     Unset,
 }
@@ -46,15 +44,10 @@ impl ErrorSeverity {
             Self::Critical => format!(
                 "an unrecoverable error which makes VOWL-R unusable (do not use the output of VOWL-R!)"
             ),
-            Self::Severe => format!(
+            Self::Error => format!(
                 "an error which highly disrupts the user experience (the output of VOWL-R is likely incorrect)"
             ),
-            // TODO
-            Self::Medium => format!("error desc goes here"),
-            // TODO
-            Self::Low => format!(
-                "error desc goes here (part of the output of VOWL-R could be incorrect, but should be \"insignificant\")"
-            ),
+
             Self::Warning => format!(
                 "something happened which may reduce the user experience (but can otherwise be ignored)"
             ),
@@ -120,8 +113,11 @@ pub enum ErrorType {
     // TableRow,
 )]
 #[cfg_attr(feature = "server", derive(Tabled))]
-// #[table(sortable, classes_provider = "TailwindClassesPreset")]
-// TODO: implement a leptos struct table looking like: https://datatables.net/
+// #[table(
+//     // sortable,
+//     impl_vec_data_provider,
+//     classes_provider = "TailwindClassesPreset"
+// )]
 /// The fundamental building block of the error handling system.
 ///
 /// It stores the data of a single error event.
@@ -172,41 +168,40 @@ impl ErrorRecord {
 }
 
 impl TableHTML for ErrorRecord {
+    // TODO: implement a leptos struct table looking like: https://datatables.net/
+    // Tailwind Table: https://www.material-tailwind.com/docs/html/table#table-with-hover
     fn header(&self) -> impl IntoView {
         view! {
-            <thead>
+
                 <tr>
                     <th>{"Severity"}</th>
                     <th>{"Error Type"}</th>
                     <th>{"Message"}</th>
                     {
                         #[cfg(debug_assertions)]
-                        view! {<th>{"Code Location"}</th>}
+                        view! { <th>{"Code Location"}</th> }
                     }
                 </tr>
-            </thead>
+
         }
     }
 
     fn row(&self) -> impl IntoView {
+        let tr_color = match self.severity {
+            ErrorSeverity::Critical => "border-b border-red-800 bg-red-800 text-neutral-800",
+            ErrorSeverity::Error => "border-b border-rose-600 bg-rose-600 text-neutral-800",
+            ErrorSeverity::Warning => "border-b border-amber-600 bg-amber-600 text-neutral-800",
+            ErrorSeverity::Unset => "border-b border-slate-500 dark:border-white/10",
+        };
+
         view! {
-            <tr>
-                <td>
-                    {self.severity.to_string()}
-                </td>
-                <td>
-                    {self.error_type.to_string()}
-                </td>
-                <td>
-                    {self.message.clone()}
-                </td>
+            <tr class=format!("hover:bg-slate-50 {tr_color}")>
+                <td>{self.severity.to_string()}</td>
+                <td>{self.error_type.to_string()}</td>
+                <td>{self.message.clone()}</td>
                 {
                     #[cfg(debug_assertions)]
-                    view! {
-                        <td>
-                            {self.location.to_string()}
-                        </td>
-                    }
+                    view! { <td>{self.location.to_string()}</td> }
                 }
             </tr>
         }
diff --git a/src/blocks/workbench.rs b/src/blocks/workbench.rs
index a26bf90..71fbd30 100644
--- a/src/blocks/workbench.rs
+++ b/src/blocks/workbench.rs
@@ -9,7 +9,7 @@ use crate::components::lists::{ListDetails, ListElement};
 use crate::components::menu::vertical_menu::VerticalMenu;
 use about_menu::AboutMenu;
 use error_log::ErrorLogContext;
-use error_log::ErrorMenu;
+use error_log::{ErrorLog, ErrorMenu};
 use export_menu::ExportMenu;
 use filter_menu::FilterMenu;
 use grapher::prelude::GraphDisplayData;
@@ -31,7 +31,7 @@ fn WorkbenchMenuItems(#[prop(into)] title: String, children: Children) -> impl I
             <div class="workbench-menu-header">
                 <h3>{title}</h3>
             </div>
-            <div>{children()}</div>
+            {children()}
         </div>
     }
 }
@@ -89,6 +89,7 @@ pub fn NewWorkbench() -> impl IntoView {
                 <ErrorMenu />
             </ListElement>
 
+
         </VerticalMenu>
     }
 }
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 5fc9e52..a595f7b 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -1,9 +1,9 @@
 // use std::ops::Range;
 
 use super::WorkbenchMenuItems;
+use crate::components::table::Table;
 use leptos::prelude::*;
 // use leptos_struct_table::{ColumnSort, TableContent, TableDataProvider};
-use crate::components::table::Table;
 use vowlr_util::prelude::{ErrorRecord, VOWLRServerError};
 
 #[derive(Debug, Copy, Clone)]
@@ -95,9 +95,10 @@ impl From<VOWLRServerError> for ErrorLogContext {
 
 pub fn ErrorLog() -> impl IntoView {
     let error_context = expect_context::<ErrorLogContext>();
-
     view! {
-        <Table items=error_context.records />
+        <div class="min-w-250 md:min-w-[80vw]">
+            <Table items=error_context.records />
+        </div>
     }
     // view! {
     //     <table>
diff --git a/src/components/lists.rs b/src/components/lists.rs
index b328b21..e5e3d76 100644
--- a/src/components/lists.rs
+++ b/src/components/lists.rs
@@ -16,7 +16,6 @@ pub fn ListElement(
     let target = NodeRef::<Div>::new();
 
     let _ = on_click_outside(target, move |_| show_element.update(|show| *show = false));
-
     view! {
         <li on:click=move |_| show_element.update(|show| *show = true)>
             <a
@@ -28,7 +27,7 @@ pub fn ListElement(
             </a>
                 <div
                     node_ref=target
-                    class="overflow-y-scroll absolute top-0 left-full m-4 bg-white border-gray-100 w-fit max-h-[80vh] min-h-[80vh]"
+                    class="overflow-y-scroll absolute top-0 left-full bg-white border-gray-100 w-fit max-h-[80vh] min-h-[80vh]"
                     style=move || {
                         if show_element.get() { "" } else { "display: none" }
                     }
diff --git a/src/components/table.rs b/src/components/table.rs
index 72be2b0..c3ec3b9 100644
--- a/src/components/table.rs
+++ b/src/components/table.rs
@@ -9,25 +9,21 @@ pub fn Table<T>(#[prop(into)] items: Signal<Vec<T>>) -> impl IntoView
 where
     T: TableHTML + Send + Sync + 'static,
 {
-    // view! {
-    //     <table class="table-auto">
-    //     {move || {
-    //         let a = items.read();
-
-    //         view!{
-    //             a.iter().map(|item| item.row()).collect_view()
-    //         }.into_any()
-    //     }}
-    //     </table>
-    // }
-
     view! {
         {move || {
-            let stuff =  items.read();
+            let stuff = items.read();
             view! {
-                <table class="border-1 border-solid border-collapse table-auto md:table-fixed md:w-[80vw]">
-                   {stuff.iter().map(|item| item.header()).next().collect_view()}
-                   {stuff.iter().map(|item| item.row()).collect_view()}
+                <table class="text-left text-sm font-light text-surface dark:text-white rounded border-solid border-collapse border-1 table-auto ">
+                    <thead class="border-b border-neutral-200 font-medium dark:border-white/10">
+                        {stuff
+                            .iter()
+                            .map(T::header)
+                            .next()
+                            .collect_view()}
+                    </thead>
+                    <tbody>
+                        {stuff.iter().map(T::row).collect_view()}
+                    </tbody>
                 </table>
             }
                 .into_any()

From e8af2e84a4ecef15582ed0cfb77c171e3434896d Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 13:44:18 +0000
Subject: [PATCH 22/36] Remove leptos-struct-table

---
 Cargo.toml                        |  3 +--
 crates/util/Cargo.toml            |  1 -
 crates/util/src/error_handler.rs  | 33 +------------------------------
 src/blocks/workbench/error_log.rs | 31 ++---------------------------
 4 files changed, 4 insertions(+), 64 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 64ff1c2..59d960c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,7 +46,6 @@
         ], git="https://github.com/WebVOWL/WasmGrapher"}
         horned-owl={git="https://github.com/phillord/horned-owl", rev="c4f7835ecae70b5e7281dc23b9b7fc6daa497f1d"}
         leptos={version="0.8.16", features=["nightly", "multipart", "rkyv"]}
-        # leptos-struct-table={version="0.18.0"}
         log="0.4"
         rdf-fusion="0.1.0"
         rkyv="0.8.12"
@@ -73,7 +72,6 @@
     grapher.workspace=true
     http={version="1.3.1", optional=true}
     leptos.workspace=true
-    # leptos-struct-table.workspace=true
     leptos_actix={version="0.8.7", optional=true}
     leptos_meta={version="0.8.6"}
     leptos_router={version="0.8.12", features=["nightly"]}
@@ -117,6 +115,7 @@
             "HtmlInputElement",
             "HtmlCollection",
             "Blob",
+            "BlobPropertyBag",
         ]
 
 
diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index 7276ae8..8a50aa5 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -14,7 +14,6 @@
 
 [dependencies]
     leptos.workspace=true
-    # leptos-struct-table.workspace=true
     log.workspace=true
     rkyv.workspace=true
     serde={version="1.0", features=["derive"]}
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 0ef5982..c333fd8 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -6,8 +6,6 @@ use leptos::{
     server_fn::{Decodes, Encodes, codec::RkyvEncoding, error::IntoAppError},
     view,
 };
-
-// use leptos_struct_table::*;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "server")]
@@ -56,15 +54,6 @@ impl ErrorSeverity {
     }
 }
 
-// impl CellValue for ErrorSeverity {
-//     type RenderOptions = ();
-
-//     // #[allow(unused)]
-//     fn render_value(self, _options: Self::RenderOptions) -> impl IntoView {
-//         self.to_string()
-//     }
-// }
-
 #[derive(
     Debug,
     Copy,
@@ -94,30 +83,10 @@ pub enum ErrorType {
     ClientError,
 }
 
-// impl CellValue for ErrorType {
-//     type RenderOptions = ();
-
-//     fn render_value(self, _options: Self::RenderOptions) -> impl IntoView {
-//         self.to_string()
-//     }
-// }
-
 #[derive(
-    Debug,
-    Clone,
-    rkyv::Archive,
-    rkyv::Serialize,
-    rkyv::Deserialize,
-    Serialize,
-    Deserialize,
-    // TableRow,
+    Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
 )]
 #[cfg_attr(feature = "server", derive(Tabled))]
-// #[table(
-//     // sortable,
-//     impl_vec_data_provider,
-//     classes_provider = "TailwindClassesPreset"
-// )]
 /// The fundamental building block of the error handling system.
 ///
 /// It stores the data of a single error event.
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index a595f7b..715eaaf 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -1,5 +1,3 @@
-// use std::ops::Range;
-
 use super::WorkbenchMenuItems;
 use crate::components::table::Table;
 use leptos::prelude::*;
@@ -62,33 +60,8 @@ impl Default for ErrorLogContext {
     }
 }
 
-// impl TableDataProvider<ErrorRecord, usize> for ErrorLogContext {
-//     async fn get_rows(
-//         &self,
-//         range: Range<usize>,
-//     ) -> Result<(Vec<ErrorRecord>, Range<usize>), String> {
-//         let records = self.records.read();
-//         if records.is_empty() {
-//             return Ok((vec![], 0..0));
-//         }
-
-//         let start = range.start.min(records.len() - 1);
-//         let end = range.end.min(records.len());
-
-//         let return_range = start..end;
-
-//         Ok((records[return_range.clone()].to_vec(), return_range))
-//     }
-
-//     async fn row_count(&self) -> Option<usize> {
-//         Some(self.len())
-//     }
-
-//     // fn set_sorting(&mut self, sorting: &std::collections::VecDeque<(usize, ColumnSort)>) {}
-// }
-
-impl From<VOWLRServerError> for ErrorLogContext {
-    fn from(value: VOWLRServerError) -> Self {
+impl From<VOWLRError> for ErrorLogContext {
+    fn from(value: VOWLRError) -> Self {
         Self::new(value.records)
     }
 }

From c7e1fc941a5d820b7eca48a170747191d42e47e4 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 13:54:29 +0000
Subject: [PATCH 23/36] Fix typo

---
 src/components/icon.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/icon.rs b/src/components/icon.rs
index 9f327ee..3b51a62 100644
--- a/src/components/icon.rs
+++ b/src/components/icon.rs
@@ -32,7 +32,7 @@ pub fn Icon(
             .attr("stroke", icon.stroke)
             .attr("fill", icon.fill.unwrap_or("currentColor"))
             .attr("role", "graphics-symbol")
-            .inner_html(icon.data) // Using nner_html due to https://github.com/carloskiki/leptos-icons/issues/64
+            .inner_html(icon.data) // Using inner_html due to https://github.com/carloskiki/leptos-icons/issues/64
         // .child(svg::InertElement::new(icon.data))
     }
 }

From 2de8cd1568503a767fe37cbf83412a8e2640d942 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:13:17 +0000
Subject: [PATCH 24/36] Add location tracking

---
 crates/database/src/errors.rs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/database/src/errors.rs b/crates/database/src/errors.rs
index 6a74979..61ce678 100644
--- a/crates/database/src/errors.rs
+++ b/crates/database/src/errors.rs
@@ -1,3 +1,5 @@
+use std::panic::Location;
+
 use crate::serializers::Triple;
 use oxrdf::{BlankNodeIdParseError, IriParseError};
 use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType};
@@ -18,7 +20,10 @@ pub enum SerializationErrorKind {
 
 #[derive(Debug)]
 pub struct SerializationError {
+    /// The contained error type.
     inner: SerializationErrorKind,
+    /// The error's location in the source code.
+    location: &'static Location<'static>,
 }
 impl std::fmt::Display for SerializationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -27,8 +32,12 @@ impl std::fmt::Display for SerializationError {
 }
 
 impl From<SerializationErrorKind> for SerializationError {
+    #[track_caller]
     fn from(error: SerializationErrorKind) -> Self {
-        SerializationError { inner: error }
+        SerializationError {
+            inner: error,
+            location: Location::caller(),
+        }
     }
 }
 
@@ -58,7 +67,7 @@ impl From<SerializationError> for ErrorRecord {
             ErrorType::Serializer,
             message,
             #[cfg(debug_assertions)]
-            "N/A".to_string(),
+            Some(value.location.to_string()),
         )
     }
 }

From b3ac836e70cb28109d14b4b1f0e38daf545785e0 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:13:31 +0000
Subject: [PATCH 25/36] Use debug instead of info

---
 crates/database/src/store.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/database/src/store.rs b/crates/database/src/store.rs
index 2923774..5d43993 100644
--- a/crates/database/src/store.rs
+++ b/crates/database/src/store.rs
@@ -1,5 +1,5 @@
 use futures::{StreamExt, stream::BoxStream};
-use log::{info, warn};
+use log::{debug, info, warn};
 use rdf_fusion::store::Store;
 use std::path::Path;
 use std::time::Duration;
@@ -60,7 +60,7 @@ impl VOWLRStore {
         &self,
         resource_type: DataType,
     ) -> Result<BoxStream<'static, Result<Vec<u8>, VOWLRStoreError>>, VOWLRStoreError> {
-        info!(
+        debug!(
             "Store size before export: {}",
             self.session.len().await.unwrap_or(0)
         );

From 990a48006d565ea7fd24fbeaa5e94e4e9efc1395 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:16:59 +0000
Subject: [PATCH 26/36] Rename VOWLRServerError to VOWLRError

---
 crates/database/src/serializers/frontend.rs   | 10 ++++-----
 crates/parser/src/errors.rs                   |  4 ++--
 crates/util/src/error_handler.rs              | 22 +++++++++----------
 crates/util/src/lib.rs                        |  2 +-
 src/blocks/workbench/error_log.rs             |  3 +--
 .../ontology_menu/stored_ontology.rs          |  8 +++----
 src/components/user_input/file_upload.rs      |  6 ++---
 7 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index e122cc6..b1c40a2 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -25,7 +25,7 @@ use rdf_fusion::{
     },
 };
 use vowlr_parser::errors::VOWLRStoreError;
-use vowlr_util::prelude::VOWLRServerError;
+use vowlr_util::prelude::VOWLRError;
 
 pub struct GraphDisplayDataSolutionSerializer {
     pub resolvable_iris: HashSet<String>,
@@ -42,7 +42,7 @@ impl GraphDisplayDataSolutionSerializer {
         &self,
         data: &mut GraphDisplayData,
         mut solution_stream: QuerySolutionStream,
-    ) -> Result<(), VOWLRServerError> {
+    ) -> Result<(), VOWLRError> {
         let mut count: u32 = 0;
         info!("Serializing query solution stream...");
         let start_time = Instant::now();
@@ -74,13 +74,13 @@ impl GraphDisplayDataSolutionSerializer {
             self.write_node_triple(&mut data_buffer, triple)
                 .or_else(|e| {
                     data_buffer.failed_buffer.push(e.into());
-                    Ok::<(), VOWLRServerError>(())
+                    Ok::<(), VOWLRError>(())
                 })?;
             count += 1;
         }
         self.check_all_unknowns(&mut data_buffer).or_else(|e| {
             data_buffer.failed_buffer.push(e.into());
-            Ok::<(), VOWLRServerError>(())
+            Ok::<(), VOWLRError>(())
         })?;
 
         let finish_time = Instant::now()
@@ -106,7 +106,7 @@ impl GraphDisplayDataSolutionSerializer {
         debug!("{}", data_buffer);
         if !data_buffer.failed_buffer.is_empty() {
             let total = data_buffer.failed_buffer.len();
-            let err: VOWLRServerError = take(&mut data_buffer.failed_buffer).into();
+            let err: VOWLRError = take(&mut data_buffer.failed_buffer).into();
             error!("Failed to serialize {} triples:\n{}", total, err);
             return Err(err);
         }
diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index a7fa453..b523f82 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -8,7 +8,7 @@ use rdf_fusion::{
     model::{IriParseError, StorageError},
 };
 use tokio::task::JoinError;
-use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRServerError};
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRError};
 
 #[derive(Debug)]
 pub enum VOWLRStoreErrorKind {
@@ -189,7 +189,7 @@ impl From<VOWLRStoreError> for ErrorRecord {
     }
 }
 
-impl From<VOWLRStoreError> for VOWLRServerError {
+impl From<VOWLRStoreError> for VOWLRError {
     fn from(value: VOWLRStoreError) -> Self {
         let record: ErrorRecord = value.into();
         record.into()
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index c333fd8..d25c97f 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -248,15 +248,15 @@ impl std::fmt::Display for ErrorRecord {
 #[derive(
     Debug, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Serialize, Deserialize,
 )]
-/// The struct sent by the server when things go south.
+/// The struct used by VOWL-R when things go south.
 ///
 /// # Note
 /// Every error type in use should implement [`From<T> for VOWLRServerError`].
-pub struct VOWLRServerError {
+pub struct VOWLRError {
     pub records: Vec<ErrorRecord>,
 }
 
-impl FromServerFnError for VOWLRServerError {
+impl FromServerFnError for VOWLRError {
     type Encoder = RkyvEncoding;
 
     fn from_server_fn_error(value: ServerFnErrorErr) -> Self {
@@ -278,43 +278,43 @@ impl FromServerFnError for VOWLRServerError {
     }
 }
 
-impl From<ServerFnError> for VOWLRServerError {
+impl From<ServerFnError> for VOWLRError {
     fn from(value: ServerFnError) -> Self {
         let record: ErrorRecord = value.into();
         record.into()
     }
 }
 
-impl From<ServerFnErrorErr> for VOWLRServerError {
+impl From<ServerFnErrorErr> for VOWLRError {
     fn from(value: ServerFnErrorErr) -> Self {
         let record: ErrorRecord = value.into();
         record.into()
     }
 }
 
-impl From<ErrorRecord> for VOWLRServerError {
+impl From<ErrorRecord> for VOWLRError {
     fn from(value: ErrorRecord) -> Self {
-        VOWLRServerError {
+        VOWLRError {
             records: vec![value],
         }
     }
 }
 
-impl From<Vec<ErrorRecord>> for VOWLRServerError {
+impl From<Vec<ErrorRecord>> for VOWLRError {
     fn from(value: Vec<ErrorRecord>) -> Self {
-        VOWLRServerError { records: value }
+        VOWLRError { records: value }
     }
 }
 
 #[cfg(feature = "server")]
-impl std::fmt::Display for VOWLRServerError {
+impl std::fmt::Display for VOWLRError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", ErrorRecord::format_records(&self.records))
     }
 }
 
 #[cfg(not(feature = "server"))]
-impl std::fmt::Display for VOWLRServerError {
+impl std::fmt::Display for VOWLRError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         #[cfg(debug_assertions)]
         {
diff --git a/crates/util/src/lib.rs b/crates/util/src/lib.rs
index 31f0b51..4a8033c 100644
--- a/crates/util/src/lib.rs
+++ b/crates/util/src/lib.rs
@@ -4,6 +4,6 @@ mod layout;
 
 pub mod prelude {
     pub use crate::datatypes::DataType;
-    pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRServerError};
+    pub use crate::error_handler::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRError};
     pub use crate::layout::TableHTML;
 }
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 715eaaf..308ee79 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -1,8 +1,7 @@
 use super::WorkbenchMenuItems;
 use crate::components::table::Table;
 use leptos::prelude::*;
-// use leptos_struct_table::{ColumnSort, TableContent, TableDataProvider};
-use vowlr_util::prelude::{ErrorRecord, VOWLRServerError};
+use vowlr_util::prelude::{ErrorRecord, VOWLRError};
 
 #[derive(Debug, Copy, Clone)]
 pub struct ErrorLogContext {
diff --git a/src/blocks/workbench/ontology_menu/stored_ontology.rs b/src/blocks/workbench/ontology_menu/stored_ontology.rs
index 1c74ac9..02d1775 100644
--- a/src/blocks/workbench/ontology_menu/stored_ontology.rs
+++ b/src/blocks/workbench/ontology_menu/stored_ontology.rs
@@ -8,9 +8,9 @@ use vowlr_database::prelude::{GraphDisplayDataSolutionSerializer, QueryResults,
 #[cfg(feature = "server")]
 use vowlr_parser::errors::VOWLRStoreError;
 use vowlr_sparql_queries::prelude::DEFAULT_QUERY;
-use vowlr_util::prelude::VOWLRServerError;
+use vowlr_util::prelude::VOWLRError;
 
-fn ontology_file_path(name: &str) -> Result<&'static str, VOWLRServerError> {
+fn ontology_file_path(name: &str) -> Result<&'static str, VOWLRError> {
     match name {
         "Clinical Trials Ontology (CTO) (273 classes)" => {
             Ok("src/assets/data/ClinicalTrialOntology-merged.owl")
@@ -23,7 +23,7 @@ fn ontology_file_path(name: &str) -> Result<&'static str, VOWLRServerError> {
 }
 
 #[server(input = Rkyv, output = Rkyv)]
-pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, VOWLRServerError> {
+pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, VOWLRError> {
     let file_path = ontology_file_path(&name)?;
     let path = Path::new(file_path);
 
@@ -36,7 +36,7 @@ pub async fn load_stored_ontology(name: String) -> Result<GraphDisplayData, VOWL
         .session
         .query(DEFAULT_QUERY.as_str())
         .await
-        .map_err(|e| <VOWLRStoreError as Into<VOWLRServerError>>::into(e.into()))?;
+        .map_err(|e| <VOWLRStoreError as Into<VOWLRError>>::into(e.into()))?;
 
     if let QueryResults::Solutions(solutions) = query_stream {
         solution_serializer
diff --git a/src/components/user_input/file_upload.rs b/src/components/user_input/file_upload.rs
index 47a74c6..da3724f 100644
--- a/src/components/user_input/file_upload.rs
+++ b/src/components/user_input/file_upload.rs
@@ -17,7 +17,7 @@ use std::rc::Rc;
 use vowlr_database::prelude::{GraphDisplayDataSolutionSerializer, QueryResults, VOWLRStore};
 #[cfg(feature = "server")]
 use vowlr_parser::errors::VOWLRStoreError;
-use vowlr_util::prelude::{DataType, VOWLRServerError};
+use vowlr_util::prelude::{DataType, VOWLRError};
 use web_sys::{FileList, FormData};
 
 #[cfg(feature = "ssr")]
@@ -223,7 +223,7 @@ pub async fn handle_sparql(
 }
 
 #[server (input = Rkyv, output = Rkyv)]
-pub async fn handle_internal_sparql(query: String) -> Result<GraphDisplayData, VOWLRServerError> {
+pub async fn handle_internal_sparql(query: String) -> Result<GraphDisplayData, VOWLRError> {
     let vowlr = VOWLRStore::default();
 
     let mut data_buffer = GraphDisplayData::new();
@@ -232,7 +232,7 @@ pub async fn handle_internal_sparql(query: String) -> Result<GraphDisplayData, V
         .session
         .query(query.as_str())
         .await
-        .map_err(|e| <VOWLRStoreError as Into<VOWLRServerError>>::into(e.into()))?;
+        .map_err(|e| <VOWLRStoreError as Into<VOWLRError>>::into(e.into()))?;
     if let QueryResults::Solutions(solutions) = query_stream {
         solution_serializer
             .serialize_nodes_stream(&mut data_buffer, solutions)

From 71a993c3a90d0a8f2d585a83cda4511552ea07ec Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:17:51 +0000
Subject: [PATCH 27/36] Make error location an option

---
 crates/parser/src/errors.rs      | 2 +-
 crates/util/src/error_handler.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/parser/src/errors.rs b/crates/parser/src/errors.rs
index b523f82..503b930 100644
--- a/crates/parser/src/errors.rs
+++ b/crates/parser/src/errors.rs
@@ -184,7 +184,7 @@ impl From<VOWLRStoreError> for ErrorRecord {
             error_type,
             message,
             #[cfg(debug_assertions)]
-            value.location.to_string(),
+            Some(value.location.to_string()),
         )
     }
 }
diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index d25c97f..4f9b912 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -124,7 +124,7 @@ impl ErrorRecord {
             error_type,
             message,
             #[cfg(debug_assertions)]
-            location,
+            location: location.unwrap_or("Unknown".to_string()),
         }
     }
 
@@ -201,7 +201,7 @@ impl From<ServerFnError> for ErrorRecord {
             error_type,
             message,
             #[cfg(debug_assertions)]
-            "N/A".to_string(),
+            None,
         )
     }
 }

From ca5d7cdbd8e888d0e7e67ef2b0f239e951e082d8 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:18:15 +0000
Subject: [PATCH 28/36] Impl Display and extension

---
 crates/util/src/datatypes.rs | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/crates/util/src/datatypes.rs b/crates/util/src/datatypes.rs
index a75422c..709b2ec 100644
--- a/crates/util/src/datatypes.rs
+++ b/crates/util/src/datatypes.rs
@@ -5,21 +5,32 @@ use serde::{Deserialize, Serialize};
 
 /// Supported content types.
 #[repr(C)]
-#[derive(Archive, RDeserialize, RSerialize, Deserialize, Serialize, Debug, Clone)]
+#[derive(
+    Archive, RDeserialize, RSerialize, Deserialize, Serialize, Debug, Copy, Clone, strum::Display,
+)]
+#[strum(serialize_all = "UPPERCASE")]
 pub enum DataType {
     OWL,
     OFN,
     OWX,
     TTL,
     RDF,
+    #[strum(serialize = "N-Triples")]
     NTriples,
+    #[strum(serialize = "N-Quads")]
     NQuads,
+    #[strum(serialize = "TriG")]
     TriG,
+    #[strum(serialize = "JSON-LD")]
     JsonLd,
     N3,
+    #[strum(serialize = "SPARQL JSON")]
     SPARQLJSON,
+    #[strum(serialize = "SPARQL XML")]
     SPARQLXML,
+    #[strum(serialize = "SPARQL CSV")]
     SPARQLCSV,
+    #[strum(serialize = "SPARQL TSV")]
     SPARQLTSV,
     /// Fallback when type can't be determined.
     UNKNOWN,
@@ -47,6 +58,27 @@ impl DataType {
             Self::UNKNOWN => "application/octet-stream",
         }
     }
+
+    /// Returns the extension of the data.
+    pub fn extension(&self) -> &'static str {
+        match self {
+            DataType::OWL => "owl",
+            DataType::OFN => "ofn",
+            DataType::OWX => "owx",
+            DataType::TTL => "ttl",
+            DataType::RDF => "rdf",
+            DataType::NTriples => "nt",
+            DataType::NQuads => "nq",
+            DataType::TriG => "trig",
+            DataType::JsonLd => "jsonld",
+            DataType::N3 => "n3",
+            DataType::SPARQLJSON => "srj",
+            DataType::SPARQLXML => "srx",
+            DataType::SPARQLCSV => "src",
+            DataType::SPARQLTSV => "tsv",
+            DataType::UNKNOWN => "txt",
+        }
+    }
 }
 
 impl From<&Path> for DataType {

From 53e1be92ca0b7001f3510fbf8b65e87b42926497 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:18:44 +0000
Subject: [PATCH 29/36] Fix CSS

---
 crates/util/src/error_handler.rs | 48 ++++++++++++++++++--------------
 src/components/table.rs          | 20 ++++---------
 2 files changed, 33 insertions(+), 35 deletions(-)

diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 4f9b912..83468a8 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -117,7 +117,7 @@ impl ErrorRecord {
         severity: ErrorSeverity,
         error_type: ErrorType,
         message: String,
-        #[cfg(debug_assertions)] location: String,
+        #[cfg(debug_assertions)] location: Option<String>,
     ) -> Self {
         Self {
             severity,
@@ -140,37 +140,43 @@ impl TableHTML for ErrorRecord {
     // TODO: implement a leptos struct table looking like: https://datatables.net/
     // Tailwind Table: https://www.material-tailwind.com/docs/html/table#table-with-hover
     fn header(&self) -> impl IntoView {
+        let th_css =
+            "p-1 font-sans text-sm antialiased font-normal leading-normal text-blue-gray-900";
         view! {
-
-                <tr>
-                    <th>{"Severity"}</th>
-                    <th>{"Error Type"}</th>
-                    <th>{"Message"}</th>
-                    {
-                        #[cfg(debug_assertions)]
-                        view! { <th>{"Code Location"}</th> }
-                    }
-                </tr>
-
+            <tr class="border-b">
+                <th class=th_css>{"Severity"}</th>
+                <th class=th_css>{"Error Type"}</th>
+                <th class=th_css>{"Message"}</th>
+                {
+                    #[cfg(debug_assertions)]
+                    view! { <th class=th_css>{"Code Location"}</th> }
+                }
+            </tr>
         }
     }
 
     fn row(&self) -> impl IntoView {
         let tr_color = match self.severity {
-            ErrorSeverity::Critical => "border-b border-red-800 bg-red-800 text-neutral-800",
-            ErrorSeverity::Error => "border-b border-rose-600 bg-rose-600 text-neutral-800",
-            ErrorSeverity::Warning => "border-b border-amber-600 bg-amber-600 text-neutral-800",
-            ErrorSeverity::Unset => "border-b border-slate-500 dark:border-white/10",
+            ErrorSeverity::Critical => "border-red-300 bg-red-100 text-red-700",
+            ErrorSeverity::Error => "border-red-200 bg-red-50 text-red-700",
+            ErrorSeverity::Warning => "border-yellow-200 bg-yellow-50 text-yellow-700",
+            ErrorSeverity::Unset => "border-slate-200 bg-slate-50 text-slate-700",
         };
 
+        #[cfg(debug_assertions)]
+        let td_css = "p-2 whitespace-pre-wrap font-sans text-sm antialiased font-normal leading-normal text-blue-gray-900";
+
+        #[cfg(not(debug_assertions))]
+        let td_css = "p-2 mr-2 whitespace-pre-wrap font-sans text-sm antialiased font-normal leading-normal text-blue-gray-900";
+
         view! {
-            <tr class=format!("hover:bg-slate-50 {tr_color}")>
-                <td>{self.severity.to_string()}</td>
-                <td>{self.error_type.to_string()}</td>
-                <td>{self.message.clone()}</td>
+            <tr class=format!("border-b hover:bg-slate-200 {tr_color}")>
+                <td class=td_css>{self.severity.to_string()}</td>
+                <td class=td_css>{self.error_type.to_string()}</td>
+                <td class=td_css>{self.message.clone()}</td>
                 {
                     #[cfg(debug_assertions)]
-                    view! { <td>{self.location.to_string()}</td> }
+                    view! { <td class=td_css>{self.location.to_string()}</td> }
                 }
             </tr>
         }
diff --git a/src/components/table.rs b/src/components/table.rs
index c3ec3b9..cd71451 100644
--- a/src/components/table.rs
+++ b/src/components/table.rs
@@ -1,7 +1,5 @@
-use crate::components::icon::MaybeShowIcon;
-use leptos::{html::Div, prelude::*};
-use leptos_use::on_click_outside;
-use vowlr_util::prelude::{ErrorRecord, TableHTML};
+use leptos::prelude::*;
+use vowlr_util::prelude::TableHTML;
 
 /// A table
 #[component]
@@ -13,17 +11,11 @@ where
         {move || {
             let stuff = items.read();
             view! {
-                <table class="text-left text-sm font-light text-surface dark:text-white rounded border-solid border-collapse border-1 table-auto ">
-                    <thead class="border-b border-neutral-200 font-medium dark:border-white/10">
-                        {stuff
-                            .iter()
-                            .map(T::header)
-                            .next()
-                            .collect_view()}
+                <table class="text-sm font-light text-left rounded-sm border border-separate table-auto dark:text-white text-surface border-spacing-0 border-tools-table-outline">
+                    <thead class="font-medium border-b border-neutral-200 dark:border-white/10">
+                        {stuff.iter().map(T::header).next().collect_view()}
                     </thead>
-                    <tbody>
-                        {stuff.iter().map(T::row).collect_view()}
-                    </tbody>
+                    <tbody>{stuff.iter().map(T::row).collect_view()}</tbody>
                 </table>
             }
                 .into_any()

From e4af6d81e3f1c4110e079d05fd944f7ce0bd45fa Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:19:10 +0000
Subject: [PATCH 30/36] Add client errors

---
 src/error.rs  | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/errors.rs |  6 ----
 src/lib.rs    |  1 +
 3 files changed, 82 insertions(+), 6 deletions(-)
 create mode 100644 src/error.rs
 delete mode 100644 src/errors.rs

diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..61bcde1
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,81 @@
+use std::panic::Location;
+
+use vowlr_util::prelude::{ErrorRecord, ErrorSeverity, ErrorType, VOWLRError};
+
+#[derive(Debug)]
+pub enum ClientErrorKind {
+    /// An error raised when an unexpected value was received from JS-land.
+    JavaScriptError(String),
+    /// Errors related to the graph renderer (i.e. ``WasmGrapher``)
+    RenderError(String),
+}
+
+impl From<ClientErrorKind> for ErrorRecord {
+    #[track_caller]
+    fn from(value: ClientErrorKind) -> Self {
+        let (message, error_type, severity) = match value {
+            ClientErrorKind::JavaScriptError(e) => (e, ErrorType::Gui, ErrorSeverity::Error),
+            ClientErrorKind::RenderError(e) => (e, ErrorType::Renderer, ErrorSeverity::Critical),
+        };
+        Self::new(
+            severity,
+            error_type,
+            message,
+            #[cfg(debug_assertions)]
+            Some(Location::caller().to_string()),
+        )
+    }
+}
+
+impl From<ClientErrorKind> for VOWLRError {
+    fn from(value: ClientErrorKind) -> Self {
+        let a: ErrorRecord = value.into();
+        a.into()
+    }
+}
+
+// #[derive(Debug)]
+// pub struct VOWLRClientError {
+//     /// The contained error type.
+//     inner: ClientErrorKind,
+//     /// The error's location in the source code.
+//     location: &'static Location<'static>,
+// }
+// impl std::fmt::Display for VOWLRClientError {
+//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//         write!(f, "{:?}", self.inner)
+//     }
+// }
+
+// impl From<ClientErrorKind> for VOWLRClientError {
+//     #[track_caller]
+//     fn from(error: ClientErrorKind) -> Self {
+//         VOWLRClientError {
+//             inner: error,
+//             location: Location::caller(),
+//         }
+//     }
+// }
+
+// impl From<VOWLRClientError> for ErrorRecord {
+//     fn from(value: VOWLRClientError) -> Self {
+//         let (message, error_type, severity) = match value.inner {
+//             ClientErrorKind::JavaScriptError(e) => (e, ErrorType::Gui, ErrorSeverity::Error),
+//             ClientErrorKind::RenderError(e) => (e, ErrorType::Renderer, ErrorSeverity::Critical),
+//         };
+//         ErrorRecord::new(
+//             severity,
+//             error_type,
+//             message,
+//             #[cfg(debug_assertions)]
+//             Some(value.location.to_string()),
+//         )
+//     }
+// }
+
+// impl From<VOWLRClientError> for VOWLRError {
+//     fn from(value: VOWLRClientError) -> Self {
+//         let a: ErrorRecord = value.into();
+//         a.into()
+//     }
+// }
diff --git a/src/errors.rs b/src/errors.rs
deleted file mode 100644
index 3ff0c58..0000000
--- a/src/errors.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use leptos::prelude::RwSignal;
-
-#[derive(Clone)]
-pub struct ErrorLogContext {
-    pub errors: RwSignal<Vec<String>>,
-}
diff --git a/src/lib.rs b/src/lib.rs
index bf039cf..ebf5754 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,6 +16,7 @@ pub use wasm_bindgen_rayon::init_thread_pool;
 pub mod app;
 pub mod blocks;
 pub mod components;
+pub mod error;
 pub mod hydration_scripts;
 pub mod pages;
 

From 180d3ad5a189205cbf57fde25a9a8a128ca8d011 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:19:35 +0000
Subject: [PATCH 31/36] Refactor error log

---
 src/blocks/workbench/error_log.rs | 68 ++++++++++++++-----------------
 1 file changed, 30 insertions(+), 38 deletions(-)

diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 308ee79..6cdae97 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -1,5 +1,6 @@
 use super::WorkbenchMenuItems;
 use crate::components::table::Table;
+use leptos::either::Either;
 use leptos::prelude::*;
 use vowlr_util::prelude::{ErrorRecord, VOWLRError};
 
@@ -49,6 +50,14 @@ impl ErrorLogContext {
     pub fn len(&self) -> usize {
         self.records.read().len()
     }
+
+    /// Returns `true` if the vector contains no elements.
+    ///
+    /// # Panics
+    /// Panics if you try to access the signal of `self` when it has been disposed.
+    pub fn is_empty(&self) -> bool {
+        self.records.read().is_empty()
+    }
 }
 
 impl Default for ErrorLogContext {
@@ -67,46 +76,29 @@ impl From<VOWLRError> for ErrorLogContext {
 
 pub fn ErrorLog() -> impl IntoView {
     let error_context = expect_context::<ErrorLogContext>();
-    view! {
-        <div class="min-w-250 md:min-w-[80vw]">
-            <Table items=error_context.records />
-        </div>
-    }
-    // view! {
-    //     <table>
-    //         <TableContent rows=error_context scroll_container="html" />
-    //     </table>
-    // }
 
-    // view! {
-    //     {move || {
-    //         let records = error_context.records.read();
-    //         view! {
-    //             <div class="overflow-y-auto p-2 mt-2 bg-red-50 rounded border border-red-200 max-h-130">
-    //                 {if records.is_empty() {
-    //                     view! { <p class="text-xs text-gray-600">"No errors"</p> }
-    //                         .into_any()
-    //                 } else {
-    //                     view! {
-    //                         <ul class="space-y-1 text-xs text-red-700">
-    //                             {records
-    //                                 .iter()
-    //                                 .map(|record| {
-    //                                     view! {
-    //                                         <li class="font-mono whitespace-pre-wrap">"• " {record.to_string()}</li>
-    //                                     }
-    //                                 })
-    //                                 .collect_view()}
+    view! {
+        {move || {
+            if error_context.is_empty() {
+                Either::Left(
+                    view! {
+                        <p class="font-sans text-xl antialiased font-normal leading-normal text-blue-gray-900">
+                            "No errors"
+                        </p>
+                    },
+                )
+            } else {
+                Either::Right(
 
-    //                         </ul>
-    //                     }
-    //                         .into_any()
-    //                 }}
-    //             </div>
-    //         }
-    //             .into_any()
-    //     }}
-    // }
+                    view! {
+                        <div class="min-w-250 md:min-w-[80vw]">
+                            <Table items=error_context.records />
+                        </div>
+                    },
+                )
+            }
+        }}
+    }
 }
 
 #[component]

From f638130740dba07470ef0f7aadf7e053ff27cf94 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:19:49 +0000
Subject: [PATCH 32/36] Cleanup

---
 src/blocks/workbench.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blocks/workbench.rs b/src/blocks/workbench.rs
index 71fbd30..9c9bc0a 100644
--- a/src/blocks/workbench.rs
+++ b/src/blocks/workbench.rs
@@ -4,12 +4,13 @@ mod export_menu;
 mod filter_menu;
 mod ontology_menu;
 mod options_menu;
+
 // mod search_menu;1
 use crate::components::lists::{ListDetails, ListElement};
 use crate::components::menu::vertical_menu::VerticalMenu;
 use about_menu::AboutMenu;
 use error_log::ErrorLogContext;
-use error_log::{ErrorLog, ErrorMenu};
+use error_log::ErrorMenu;
 use export_menu::ExportMenu;
 use filter_menu::FilterMenu;
 use grapher::prelude::GraphDisplayData;
@@ -89,7 +90,6 @@ pub fn NewWorkbench() -> impl IntoView {
                 <ErrorMenu />
             </ListElement>
 
-
         </VerticalMenu>
     }
 }

From 7fad57d6fbc8e5b34a8831bfcffa0b01b6282dde Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:20:04 +0000
Subject: [PATCH 33/36] Refactor export menu to use new error handling system

---
 src/blocks/workbench/export_menu.rs | 268 ++++++++++++----------------
 1 file changed, 117 insertions(+), 151 deletions(-)

diff --git a/src/blocks/workbench/export_menu.rs b/src/blocks/workbench/export_menu.rs
index 61f70c4..0f95cc6 100644
--- a/src/blocks/workbench/export_menu.rs
+++ b/src/blocks/workbench/export_menu.rs
@@ -1,38 +1,105 @@
 use super::WorkbenchMenuItems;
+use crate::blocks::workbench::error_log::ErrorLogContext;
 use crate::components::icon::Icon;
+use crate::error::ClientErrorKind;
 use futures::StreamExt;
 use leptos::prelude::*;
 use leptos::server_fn::codec::{ByteStream, Streaming};
 #[cfg(feature = "server")]
 use vowlr_database::prelude::VOWLRStore;
+use vowlr_util::prelude::{DataType, VOWLRError};
+use web_sys::{Blob, BlobPropertyBag, HtmlAnchorElement, Url, js_sys, wasm_bindgen::JsCast};
 
 #[server(output = Streaming)]
-pub async fn export_owl(resource_type: String) -> Result<ByteStream<ServerFnError>, ServerFnError> {
+/// Export a graph from the database
+pub async fn export_graph(resource_type: DataType) -> Result<ByteStream<VOWLRError>, VOWLRError> {
     let store = VOWLRStore::default();
-    let stream = store.serialize_stream(resource_type.into()).await?;
+    let stream = store.serialize_stream(resource_type).await?;
     Ok(ByteStream::new(stream.map(|chunk| {
         chunk
-            .map_err(|e| ServerFnError::new(e.to_string()))
             .map(bytes::Bytes::from)
+            .map_err(std::convert::Into::into)
     })))
 }
 
+pub async fn download_ontology(
+    resource_type: DataType,
+    progress_message: RwSignal<String>,
+) -> Result<(), VOWLRError> {
+    let byte_stream = export_graph(resource_type).await?;
+
+    // Download data from server
+    progress_message.set("Downloaded: 0 MB".to_string());
+    let mut stream = byte_stream.into_inner();
+    let mut data = Vec::new();
+    let mut downloaded = 0;
+    while let Some(chunk) = stream.next().await {
+        let bytes = chunk?;
+        downloaded += bytes.len();
+        let mb = downloaded as f64 / 1_024.0 / 1_024.0;
+        progress_message.set(format!("Downloaded: {:.2} MB", mb));
+        data.extend(bytes);
+    }
+    progress_message.set("Processing...".to_string());
+
+    // Package received data into a blob object with apropriate metadata
+    let window = web_sys::window().ok_or_else(|| {
+        ClientErrorKind::JavaScriptError("Failed to get the Window object".to_string())
+    })?;
+    let document = window.document().ok_or_else(|| {
+        ClientErrorKind::JavaScriptError("Failed to get Document object".to_string())
+    })?;
+    let body = document.body().ok_or_else(|| {
+        ClientErrorKind::JavaScriptError("Failed to get the docoment body".to_string())
+    })?;
+
+    let blob_parts = js_sys::Array::new();
+    let uint8_array = js_sys::Uint8Array::from(data.as_slice());
+    blob_parts.push(&uint8_array.into());
+
+    let blob_options = BlobPropertyBag::new();
+    blob_options.set_type(resource_type.mime_type());
+
+    let blob = Blob::new_with_str_sequence_and_options(&blob_parts, &blob_options)
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+
+    // Create the URL and anchor button to show download in the browser.
+    let url = Url::create_object_url_with_blob(&blob)
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+    let a: HtmlAnchorElement = document
+        .create_element("a")
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?
+        // SAFETY: Creating HTML element "a" will always have type 'HtmlAnchorElement'.
+        .unchecked_into::<HtmlAnchorElement>();
+    a.set_href(&url);
+    a.set_download(format!("ontology.{}", resource_type.extension()).as_str());
+    a.set_attribute("style", "display: none")
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+
+    body.append_child(&a)
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+    a.click();
+
+    // Cleanup
+    body.remove_child(&a)
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+    Url::revoke_object_url(&url)
+        .map_err(|e| ClientErrorKind::JavaScriptError(format!("{e:#?}")))?;
+    progress_message.set("Download complete".to_string());
+
+    Ok(())
+}
+
 #[component]
 pub fn ExportButton(
     #[prop(into)] label: String,
     #[prop(into)] icon: icondata::Icon,
-    #[prop(optional)] on_click: Option<Callback<()>>,
+    on_click: impl Fn() + 'static,
 ) -> impl IntoView {
-    let onclick_handler = move |_| {
-        if let Some(cb) = &on_click {
-            cb.run(());
-        }
-    };
-
     view! {
         <button
             class="flex relative gap-1 justify-center items-center m-2 w-40 h-10 font-semibold bg-gray-200 rounded-sm transition-colors cursor-pointer text-[#000000] hover:bg-[#dd9900]"
-            on:click=onclick_handler
+            on:click=move |_| { on_click() }
         >
             <Icon icon=icon />
             {label}
@@ -40,115 +107,22 @@ pub fn ExportButton(
     }
 }
 
-#[cfg(all(target_family = "wasm", target_os = "unknown"))]
-pub fn download_ontology(resource_type: &str, progress_message: RwSignal<String>) {
-    let resource = resource_type.to_string();
-    let (mime_type, download_name) = download_metadata(resource_type);
+#[component]
+pub fn ExportMenu() -> impl IntoView {
+    let progress_message = RwSignal::new(String::new());
 
-    leptos::task::spawn_local(async move {
-        match export_owl(resource.clone()).await {
-            Ok(byte_stream) => {
-                progress_message.set("Downloaded: 0 MB".to_string());
-                let mut stream = byte_stream.into_inner();
-                let mut data = Vec::new();
-                let mut downloaded = 0;
-                while let Some(chunk) = stream.next().await {
-                    match chunk {
-                        Ok(bytes) => {
-                            downloaded += bytes.len();
-                            let mb = downloaded as f64 / 1_024.0 / 1_024.0;
-                            progress_message.set(format!("Downloaded: {:.2} MB", mb));
-                            data.extend(bytes);
-                        }
-                        Err(e) => leptos::logging::error!("Error in stream: {:?}", e),
-                    }
+    let download = Action::new(|input: &(DataType, RwSignal<String>)| {
+        let (resource_type, progress_message) = input.to_owned();
+        async move {
+            match download_ontology(resource_type, progress_message).await {
+                Ok(()) => (),
+                Err(e) => {
+                    let error_context = expect_context::<ErrorLogContext>();
+                    error_context.extend(e.records);
                 }
-                progress_message.set("Processing...".to_string());
-                leptos::logging::log!(
-                    "Export success for {}, data length: {}",
-                    resource,
-                    data.len()
-                );
-                use web_sys::wasm_bindgen::JsCast;
-                use web_sys::{Blob, HtmlAnchorElement, Url};
-
-                let window = web_sys::window().unwrap();
-                let document = window.document().unwrap();
-                let body = document.body().unwrap();
-
-                let blob_parts = web_sys::js_sys::Array::new();
-                let uint8_array = web_sys::js_sys::Uint8Array::from(data.as_slice());
-                blob_parts.push(&uint8_array.into());
-
-                let mut blob_options = web_sys::BlobPropertyBag::new();
-                blob_options.set_type(mime_type);
-
-                let blob =
-                    Blob::new_with_str_sequence_and_options(&blob_parts, &blob_options).unwrap();
-                let url = Url::create_object_url_with_blob(&blob).unwrap();
-                leptos::logging::log!("URL: {}", url);
-                let a = document
-                    .create_element("a")
-                    .unwrap()
-                    .unchecked_into::<HtmlAnchorElement>();
-                a.set_href(&url);
-                a.set_download(&download_name);
-                a.set_attribute("style", "display: none").unwrap();
-
-                body.append_child(&a).unwrap();
-                a.click();
-                body.remove_child(&a).unwrap();
-                Url::revoke_object_url(&url).unwrap();
-                progress_message.set("Download complete".to_string());
-            }
-            Err(e) => {
-                leptos::logging::error!("Export failed: {:?}", e);
-                progress_message.set(format!("Export failed: {:?}", e));
             }
         }
     });
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn download_ontology(resource_type: &str, progress_message: RwSignal<String>) {
-    let _ = resource_type;
-    progress_message.set("Ontology export is only available in the browser build.".to_string());
-    leptos::logging::warn!(
-        "download_ontology invoked on non-wasm target; skipping client download"
-    );
-}
-
-#[cfg(all(target_family = "wasm", target_os = "unknown"))]
-fn download_metadata(resource_type: &str) -> (&'static str, String) {
-    let normalized = resource_type.to_ascii_uppercase();
-    let extension = match normalized.as_str() {
-        "RDF" => "rdf",
-        "OWL" => "owl",
-        "TTL" => "ttl",
-        "NTRIPLES" => "nt",
-        "NQUADS" => "nq",
-        "OFN" => "ofn",
-        "OWX" => "owx",
-        _ => "dat",
-    };
-
-    let mime = match normalized.as_str() {
-        "RDF" => "application/rdf+xml",
-        "OWL" => "application/owl+xml",
-        "TTL" => "text/turtle",
-        "N-TRIPLES" => "application/n-triples",
-        "N-QUADS" => "application/n-quads",
-        "OFN" => "text/plain",
-        "OWX" => "application/owl+xml",
-        _ => "application/octet-stream",
-    };
-
-    (mime, format!("ontology.{}", extension))
-}
-
-#[component]
-pub fn ExportMenu() -> impl IntoView {
-    let progress_message = RwSignal::new(String::new());
 
     view! {
         <WorkbenchMenuItems title="Export Ontology">
@@ -158,62 +132,54 @@ pub fn ExportMenu() -> impl IntoView {
                 // <ExportButton label="TeX" icon=icondata::BiExportRegular />
                 // <ExportButton label="URL" icon=icondata::BiExportRegular />
                 <ExportButton
-                    label="OWL"
+                    label=DataType::OWL.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("OWL", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::OWL, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="RDF"
+                    label=DataType::RDF.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("RDF", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::RDF, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="TTL"
+                    label=DataType::TTL.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("TTL", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::TTL, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="N-Triples"
+                    label=DataType::NTriples.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("NTriples", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::NTriples, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="N-Quads"
+                    label=DataType::NQuads.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("NQuads", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::NQuads, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="OFN"
+                    label=DataType::OFN.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("OFN", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::OFN, progress_message));
+                    }
                 />
                 <ExportButton
-                    label="OWX"
+                    label=DataType::OWX.to_string()
                     icon=icondata::BiExportRegular
-                    on_click=Callback::new({
-                        let progress_message = progress_message;
-                        move |()| download_ontology("OWX", progress_message)
-                    })
+                    on_click=move || {
+                        download.dispatch((DataType::OWX, progress_message));
+                    }
                 />
-
             </div>
             {move || {
                 let msg = progress_message.get();

From 159076522cad551024eb1fa01dddcbde5c2f9de5 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Mon, 9 Mar 2026 12:08:17 +0000
Subject: [PATCH 34/36] Remove severity description

---
 crates/util/src/error_handler.rs | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 83468a8..5cfe34c 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -35,25 +35,6 @@ pub enum ErrorSeverity {
     Unset,
 }
 
-impl ErrorSeverity {
-    // TODO: Work in progress. Pls don't remove format!
-    pub fn description(&self) -> String {
-        match self {
-            Self::Critical => format!(
-                "an unrecoverable error which makes VOWL-R unusable (do not use the output of VOWL-R!)"
-            ),
-            Self::Error => format!(
-                "an error which highly disrupts the user experience (the output of VOWL-R is likely incorrect)"
-            ),
-
-            Self::Warning => format!(
-                "something happened which may reduce the user experience (but can otherwise be ignored)"
-            ),
-            Self::Unset => format!("unknown severity"),
-        }
-    }
-}
-
 #[derive(
     Debug,
     Copy,

From ce0ce364d6da14379b0ac90103ac4a8121679f1a Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Mon, 9 Mar 2026 13:52:17 +0000
Subject: [PATCH 35/36] Allow deprecated warn

---
 crates/util/src/error_handler.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/util/src/error_handler.rs b/crates/util/src/error_handler.rs
index 5cfe34c..bea35bd 100644
--- a/crates/util/src/error_handler.rs
+++ b/crates/util/src/error_handler.rs
@@ -167,8 +167,8 @@ impl TableHTML for ErrorRecord {
 impl From<ServerFnError> for ErrorRecord {
     fn from(value: ServerFnError) -> Self {
         let (error_type, message) = match value {
+            #[allow(deprecated, reason = "TODO: Remove in Leptos v0.9")]
             ServerFnError::WrappedServerError(_) => (
-                // TODO: Remove in Leptos v0.9
                 ErrorType::InternalServerError,
                 "deprecated WrappedServerError".to_string(),
             ),

From 8da2fc6c1189f7083aefd9fec55ba2046fd92302 Mon Sep 17 00:00:00 2001
From: TheRealMorgenfrue <33068980+TheRealMorgenfrue@users.noreply.github.com>
Date: Mon, 9 Mar 2026 14:14:25 +0000
Subject: [PATCH 36/36] Clippy fixes

---
 crates/database/src/serializers/frontend.rs | 37 ++++++++++++++++++++-
 src/blocks/workbench/error_log.rs           |  1 +
 src/blocks/workbench/export_menu.rs         |  4 +--
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/crates/database/src/serializers/frontend.rs b/crates/database/src/serializers/frontend.rs
index b1c40a2..83c628a 100644
--- a/crates/database/src/serializers/frontend.rs
+++ b/crates/database/src/serializers/frontend.rs
@@ -266,6 +266,10 @@ impl GraphDisplayDataSolutionSerializer {
             .insert(edge);
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     pub fn redirect_iri(
         &self,
         data_buffer: &mut SerializationDataBuffer,
@@ -280,6 +284,10 @@ impl GraphDisplayDataSolutionSerializer {
         Ok(())
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     pub fn check_unknown_buffer(
         &self,
         data_buffer: &mut SerializationDataBuffer,
@@ -294,6 +302,10 @@ impl GraphDisplayDataSolutionSerializer {
         Ok(())
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn insert_node(
         &self,
         data_buffer: &mut SerializationDataBuffer,
@@ -398,6 +410,10 @@ impl GraphDisplayDataSolutionSerializer {
         }
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn merge_nodes(
         &self,
         data_buffer: &mut SerializationDataBuffer,
@@ -483,14 +499,26 @@ impl GraphDisplayDataSolutionSerializer {
         }
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn create_named_node(&self, iri: String) -> Result<NamedNode, SerializationError> {
         Ok(NamedNode::new(&iri).map_err(|e| SerializationErrorKind::IriParseError(iri, e))?)
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn create_blank_node(&self, id: String) -> Result<BlankNode, SerializationError> {
         Ok(BlankNode::new(&id).map_err(|e| SerializationErrorKind::BlankNodeParseError(id, e))?)
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn create_triple(
         &self,
         id: String,
@@ -511,7 +539,10 @@ impl GraphDisplayDataSolutionSerializer {
         debug!("Created new triple: {}", t);
         Ok(t)
     }
-
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     fn check_all_unknowns(
         &self,
         data_buffer: &mut SerializationDataBuffer,
@@ -545,6 +576,10 @@ impl GraphDisplayDataSolutionSerializer {
         Ok(())
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "fixed when serializer is refactored to use pointers instead of values"
+    )]
     /// Serialize a triple to `data_buffer`.
     fn write_node_triple(
         &self,
diff --git a/src/blocks/workbench/error_log.rs b/src/blocks/workbench/error_log.rs
index 6cdae97..30e8f07 100644
--- a/src/blocks/workbench/error_log.rs
+++ b/src/blocks/workbench/error_log.rs
@@ -32,6 +32,7 @@ impl ErrorLogContext {
         self.records.update(|records_| records_.extend(records));
     }
 
+    #[expect(unused)]
     /// Clears the collection, removing all values.
     ///
     /// Note that this method has no effect on the allocated capacity of the vector.
diff --git a/src/blocks/workbench/export_menu.rs b/src/blocks/workbench/export_menu.rs
index 0f95cc6..0293262 100644
--- a/src/blocks/workbench/export_menu.rs
+++ b/src/blocks/workbench/export_menu.rs
@@ -36,8 +36,8 @@ pub async fn download_ontology(
     while let Some(chunk) = stream.next().await {
         let bytes = chunk?;
         downloaded += bytes.len();
-        let mb = downloaded as f64 / 1_024.0 / 1_024.0;
-        progress_message.set(format!("Downloaded: {:.2} MB", mb));
+        let mb = downloaded / 1_024 / 1_024;
+        progress_message.set(format!("Downloaded: {mb:.2} MB"));
         data.extend(bytes);
     }
     progress_message.set("Processing...".to_string());