Improved error handling (part 3)

42 files changed, 194 insertions, 241 deletions

diff --git a/crates/jmap-proto/src/error/method.rs b/crates/jmap-proto/src/error/method.rs
index 93879b30..b94c4789 100644
--- a/crates/jmap-proto/src/error/method.rs
+++ b/crates/jmap-proto/src/error/method.rs
@@ -136,7 +136,9 @@ impl From<MethodError> for trc::Error {
             ),
         };
 
-        trc::Cause::Jmap
+        let todo = "fix";
+
+        trc::JmapCause::RequestTooLarge
             .ctx(trc::Key::Type, typ)
             .ctx(trc::Key::Details, description)
     }
@@ -184,7 +186,11 @@ impl Serialize for MethodErrorWrapper {
     {
         let mut map = serializer.serialize_map(2.into())?;
 
-        let (error_type, description) = if self.0.matches(trc::Cause::Jmap) {
+        let todo = "fix";
+        let (error_type, description) = if self
+            .0
+            .matches(trc::Cause::Jmap(trc::JmapCause::RequestTooLarge))
+        {
             (
                 self.0
                     .value(trc::Key::Type)
diff --git a/crates/jmap-proto/src/method/changes.rs b/crates/jmap-proto/src/method/changes.rs
index 9993779e..1450b2c1 100644
--- a/crates/jmap-proto/src/method/changes.rs
+++ b/crates/jmap-proto/src/method/changes.rs
@@ -5,8 +5,7 @@
  */
 
 use crate::{
-    error::method::MethodError,
-    parser::{json::Parser, Error, Ignore, JsonObjectParser, Token},
+    parser::{json::Parser, Ignore, JsonObjectParser, Token},
     request::{method::MethodObject, RequestProperty},
     types::{id::Id, property::Property, state::State},
 };
@@ -55,7 +54,7 @@ pub enum RequestArguments {
 }
 
 impl JsonObjectParser for ChangesRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -68,10 +67,9 @@ impl JsonObjectParser for ChangesRequest {
                 MethodObject::EmailSubmission => RequestArguments::EmailSubmission,
                 MethodObject::Quota => RequestArguments::Quota,
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/changes",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/changes", parser.ctx)))
                 }
             },
             account_id: Id::default(),
diff --git a/crates/jmap-proto/src/method/copy.rs b/crates/jmap-proto/src/method/copy.rs
index bd0cea63..7e69bfa2 100644
--- a/crates/jmap-proto/src/method/copy.rs
+++ b/crates/jmap-proto/src/method/copy.rs
@@ -8,9 +8,9 @@ use serde::Serialize;
 use utils::map::vec_map::VecMap;
 
 use crate::{
-    error::{method::MethodError, set::SetError},
+    error::set::SetError,
     object::Object,
-    parser::{json::Parser, Error, JsonObjectParser, Token},
+    parser::{json::Parser, JsonObjectParser, Token},
     request::{method::MethodObject, reference::MaybeReference, RequestProperty},
     types::{
         blob::BlobId,
@@ -88,7 +88,7 @@ pub enum RequestArguments {
 }
 
 impl JsonObjectParser for CopyRequest<RequestArguments> {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -96,10 +96,9 @@ impl JsonObjectParser for CopyRequest<RequestArguments> {
             arguments: match &parser.ctx {
                 MethodObject::Email => RequestArguments::Email,
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/copy",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/copy", parser.ctx)))
                 }
             },
             account_id: Id::default(),
@@ -159,7 +158,7 @@ impl JsonObjectParser for CopyRequest<RequestArguments> {
 }
 
 impl JsonObjectParser for CopyBlobRequest {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/get.rs b/crates/jmap-proto/src/method/get.rs
index 62e49b90..5a9c9905 100644
--- a/crates/jmap-proto/src/method/get.rs
+++ b/crates/jmap-proto/src/method/get.rs
@@ -7,7 +7,7 @@
 use crate::{
     error::method::MethodError,
     object::{blob, email, Object},
-    parser::{json::Parser, Error, JsonObjectParser, Token},
+    parser::{json::Parser, JsonObjectParser, Token},
     request::{
         method::MethodObject,
         reference::{MaybeReference, ResultReference},
@@ -55,7 +55,7 @@ pub struct GetResponse {
 }
 
 impl JsonObjectParser for GetRequest<RequestArguments> {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -73,10 +73,9 @@ impl JsonObjectParser for GetRequest<RequestArguments> {
                 MethodObject::Blob => RequestArguments::Blob(Default::default()),
                 MethodObject::Quota => RequestArguments::Quota,
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/get",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/get", parser.ctx)))
                 }
             },
             account_id: Id::default(),
@@ -130,11 +129,7 @@ impl JsonObjectParser for GetRequest<RequestArguments> {
 }
 
 impl RequestPropertyParser for RequestArguments {
-    fn parse(
-        &mut self,
-        parser: &mut Parser,
-        property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    fn parse(&mut self, parser: &mut Parser, property: RequestProperty) -> trc::Result<bool> {
         match self {
             RequestArguments::Email(arguments) => arguments.parse(parser, property),
             RequestArguments::Blob(arguments) => arguments.parse(parser, property),
diff --git a/crates/jmap-proto/src/method/import.rs b/crates/jmap-proto/src/method/import.rs
index c13daad5..447892f9 100644
--- a/crates/jmap-proto/src/method/import.rs
+++ b/crates/jmap-proto/src/method/import.rs
@@ -66,7 +66,7 @@ pub struct ImportEmailResponse {
 }
 
 impl JsonObjectParser for ImportEmailRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -104,7 +104,7 @@ impl JsonObjectParser for ImportEmailRequest {
 }
 
 impl JsonObjectParser for ImportEmail {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/lookup.rs b/crates/jmap-proto/src/method/lookup.rs
index 7e823ee6..3148d984 100644
--- a/crates/jmap-proto/src/method/lookup.rs
+++ b/crates/jmap-proto/src/method/lookup.rs
@@ -39,7 +39,7 @@ pub struct BlobInfo {
 }
 
 impl JsonObjectParser for BlobLookupRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/parse.rs b/crates/jmap-proto/src/method/parse.rs
index ca1715fc..c33d84fd 100644
--- a/crates/jmap-proto/src/method/parse.rs
+++ b/crates/jmap-proto/src/method/parse.rs
@@ -44,7 +44,7 @@ pub struct ParseEmailResponse {
 }
 
 impl JsonObjectParser for ParseEmailRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/query.rs b/crates/jmap-proto/src/method/query.rs
index 8f531d45..515a3cbf 100644
--- a/crates/jmap-proto/src/method/query.rs
+++ b/crates/jmap-proto/src/method/query.rs
@@ -9,9 +9,8 @@ use std::fmt::Display;
 use store::fts::{FilterItem, FilterType, FtsFilter};
 
 use crate::{
-    error::method::MethodError,
     object::{email, mailbox},
-    parser::{json::Parser, Error, Ignore, JsonObjectParser, Token},
+    parser::{json::Parser, Ignore, JsonObjectParser, Token},
     request::{method::MethodObject, RequestProperty, RequestPropertyParser},
     types::{date::UTCDate, id::Id, keyword::Keyword, state::State},
 };
@@ -151,7 +150,7 @@ pub enum RequestArguments {
 }
 
 impl JsonObjectParser for QueryRequest<RequestArguments> {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -164,10 +163,9 @@ impl JsonObjectParser for QueryRequest<RequestArguments> {
                 MethodObject::Principal => RequestArguments::Principal,
                 MethodObject::Quota => RequestArguments::Quota,
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/query",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/query", parser.ctx)))
                 }
             },
             filter: vec![],
@@ -243,7 +241,7 @@ impl JsonObjectParser for QueryRequest<RequestArguments> {
     }
 }
 
-pub fn parse_filter(parser: &mut Parser) -> crate::parser::Result<Vec<Filter>> {
+pub fn parse_filter(parser: &mut Parser) -> trc::Result<Vec<Filter>> {
     let mut filter = vec![Filter::Close];
     let mut pos_stack = vec![0];
 
@@ -453,9 +451,9 @@ pub fn parse_filter(parser: &mut Parser) -> crate::parser::Result<Vec<Filter>> {
                         break;
                     }
                 } else {
-                    return Err(Error::Method(MethodError::InvalidArguments(
-                        "Malformed filter".to_string(),
-                    )));
+                    return Err(trc::JmapCause::InvalidArguments
+                        .into_err()
+                        .details("Malformed filter"));
                 }
             }
             Token::ArrayEnd => {
@@ -471,7 +469,7 @@ pub fn parse_filter(parser: &mut Parser) -> crate::parser::Result<Vec<Filter>> {
     Ok(filter)
 }
 
-pub fn parse_sort(parser: &mut Parser) -> crate::parser::Result<Vec<Comparator>> {
+pub fn parse_sort(parser: &mut Parser) -> trc::Result<Vec<Comparator>> {
     let mut sort = vec![];
 
     loop {
@@ -527,7 +525,7 @@ pub fn parse_sort(parser: &mut Parser) -> crate::parser::Result<Vec<Comparator>>
 }
 
 impl JsonObjectParser for SortProperty {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -667,11 +665,7 @@ impl Display for SortProperty {
 }
 
 impl RequestPropertyParser for RequestArguments {
-    fn parse(
-        &mut self,
-        parser: &mut Parser,
-        property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    fn parse(&mut self, parser: &mut Parser, property: RequestProperty) -> trc::Result<bool> {
         match self {
             RequestArguments::Email(args) => args.parse(parser, property),
             RequestArguments::Mailbox(args) => args.parse(parser, property),
diff --git a/crates/jmap-proto/src/method/query_changes.rs b/crates/jmap-proto/src/method/query_changes.rs
index 290321bc..f4181840 100644
--- a/crates/jmap-proto/src/method/query_changes.rs
+++ b/crates/jmap-proto/src/method/query_changes.rs
@@ -5,8 +5,7 @@
  */
 
 use crate::{
-    error::method::MethodError,
-    parser::{json::Parser, Error, Ignore, JsonObjectParser, Token},
+    parser::{json::Parser, Ignore, JsonObjectParser, Token},
     request::{method::MethodObject, RequestProperty, RequestPropertyParser},
     types::{id::Id, state::State},
 };
@@ -60,7 +59,7 @@ impl AddedItem {
 }
 
 impl JsonObjectParser for QueryChangesRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -71,10 +70,9 @@ impl JsonObjectParser for QueryChangesRequest {
                 MethodObject::EmailSubmission => RequestArguments::EmailSubmission,
                 MethodObject::Quota => RequestArguments::Quota,
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/queryChanges",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/queryChanges", parser.ctx)))
                 }
             },
             filter: vec![],
diff --git a/crates/jmap-proto/src/method/search_snippet.rs b/crates/jmap-proto/src/method/search_snippet.rs
index e73cd514..203ad226 100644
--- a/crates/jmap-proto/src/method/search_snippet.rs
+++ b/crates/jmap-proto/src/method/search_snippet.rs
@@ -48,7 +48,7 @@ pub struct SearchSnippet {
 }
 
 impl JsonObjectParser for GetSearchSnippetRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/set.rs b/crates/jmap-proto/src/method/set.rs
index 28421cad..4efa7bbd 100644
--- a/crates/jmap-proto/src/method/set.rs
+++ b/crates/jmap-proto/src/method/set.rs
@@ -13,7 +13,7 @@ use crate::{
         set::{InvalidProperty, SetError},
     },
     object::{email_submission, mailbox, sieve, Object},
-    parser::{json::Parser, Error, JsonObjectParser, Token},
+    parser::{json::Parser, JsonObjectParser, Token},
     request::{
         method::MethodObject,
         reference::{MaybeReference, ResultReference},
@@ -99,7 +99,7 @@ pub struct SetResponse {
 }
 
 impl JsonObjectParser for SetRequest<RequestArguments> {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -115,10 +115,9 @@ impl JsonObjectParser for SetRequest<RequestArguments> {
                 MethodObject::VacationResponse => RequestArguments::VacationResponse,
                 MethodObject::SieveScript => RequestArguments::SieveScript(Default::default()),
                 _ => {
-                    return Err(Error::Method(MethodError::UnknownMethod(format!(
-                        "{}/set",
-                        parser.ctx
-                    ))))
+                    return Err(trc::JmapCause::UnknownMethod
+                        .into_err()
+                        .details(format!("{}/set", parser.ctx)))
                 }
             },
             account_id: Id::default(),
@@ -168,7 +167,7 @@ impl JsonObjectParser for SetRequest<RequestArguments> {
 }
 
 impl JsonObjectParser for Object<SetValue> {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -385,11 +384,7 @@ impl<T: Into<AnyId>> From<Vec<MaybeReference<T, String>>> for SetValue {
 }
 
 impl RequestPropertyParser for RequestArguments {
-    fn parse(
-        &mut self,
-        parser: &mut Parser,
-        property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    fn parse(&mut self, parser: &mut Parser, property: RequestProperty) -> trc::Result<bool> {
         match self {
             RequestArguments::Mailbox(args) => args.parse(parser, property),
             RequestArguments::EmailSubmission(args) => args.parse(parser, property),
diff --git a/crates/jmap-proto/src/method/upload.rs b/crates/jmap-proto/src/method/upload.rs
index 25d037f9..e8be489d 100644
--- a/crates/jmap-proto/src/method/upload.rs
+++ b/crates/jmap-proto/src/method/upload.rs
@@ -64,7 +64,7 @@ pub struct BlobUploadResponseObject {
 }
 
 impl JsonObjectParser for BlobUploadRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -96,7 +96,7 @@ impl JsonObjectParser for BlobUploadRequest {
 }
 
 impl JsonObjectParser for UploadObject {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -140,7 +140,7 @@ impl JsonObjectParser for UploadObject {
 }
 
 impl JsonObjectParser for DataSourceObject {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/method/validate.rs b/crates/jmap-proto/src/method/validate.rs
index 3dcbd405..19d05ea8 100644
--- a/crates/jmap-proto/src/method/validate.rs
+++ b/crates/jmap-proto/src/method/validate.rs
@@ -27,7 +27,7 @@ pub struct ValidateSieveScriptResponse {
 }
 
 impl JsonObjectParser for ValidateSieveScriptRequest {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/object/blob.rs b/crates/jmap-proto/src/object/blob.rs
index 0a44e4bf..d38b0664 100644
--- a/crates/jmap-proto/src/object/blob.rs
+++ b/crates/jmap-proto/src/object/blob.rs
@@ -20,7 +20,7 @@ impl RequestPropertyParser for GetArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         match &property.hash[0] {
             0x7465_7366_666f => {
                 self.offset = parser
diff --git a/crates/jmap-proto/src/object/email.rs b/crates/jmap-proto/src/object/email.rs
index 64661b17..28876fcd 100644
--- a/crates/jmap-proto/src/object/email.rs
+++ b/crates/jmap-proto/src/object/email.rs
@@ -29,7 +29,7 @@ impl RequestPropertyParser for GetArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         match (&property.hash[0], &property.hash[1]) {
             (0x7365_6974_7265_706f_7250_7964_6f62, _) => {
                 self.body_properties = <Option<Vec<Property>>>::parse(parser)?;
@@ -66,7 +66,7 @@ impl RequestPropertyParser for QueryArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         if property.hash[0] == 0x0073_6461_6572_6854_6573_7061_6c6c_6f63 {
             self.collapse_threads = parser
                 .next_token::<Ignore>()?
diff --git a/crates/jmap-proto/src/object/email_submission.rs b/crates/jmap-proto/src/object/email_submission.rs
index 7191a5e5..2f429748 100644
--- a/crates/jmap-proto/src/object/email_submission.rs
+++ b/crates/jmap-proto/src/object/email_submission.rs
@@ -25,7 +25,7 @@ impl RequestPropertyParser for SetArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         if property.hash[0] == 0x4565_7461_6470_5573_7365_6363_7553_6e6f
             && property.hash[1] == 0x6c69_616d
         {
diff --git a/crates/jmap-proto/src/object/mailbox.rs b/crates/jmap-proto/src/object/mailbox.rs
index ad3e8a4b..fd34573a 100644
--- a/crates/jmap-proto/src/object/mailbox.rs
+++ b/crates/jmap-proto/src/object/mailbox.rs
@@ -25,7 +25,7 @@ impl RequestPropertyParser for SetArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         if property.hash[0] == 0x4565_766f_6d65_5279_6f72_7473_6544_6e6f
             && property.hash[1] == 0x0073_6c69_616d
         {
@@ -44,7 +44,7 @@ impl RequestPropertyParser for QueryArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         match &property.hash[0] {
             0x6565_7254_7341_7472_6f73 => {
                 self.sort_as_tree = parser
diff --git a/crates/jmap-proto/src/object/mod.rs b/crates/jmap-proto/src/object/mod.rs
index 13c70b67..78157198 100644
--- a/crates/jmap-proto/src/object/mod.rs
+++ b/crates/jmap-proto/src/object/mod.rs
@@ -124,7 +124,7 @@ impl Serialize for Value {
 impl Deserialize for Value {
     fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
         Self::deserialize_from(&mut bytes.iter()).ok_or_else(|| {
-            trc::Cause::DataCorruption
+            trc::StoreCause::DataCorruption
                 .caused_by(trc::location!())
                 .ctx(trc::Key::Value, bytes)
         })
@@ -148,7 +148,7 @@ impl Serialize for &Object<Value> {
 impl Deserialize for Object<Value> {
     fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
         Object::deserialize_from(&mut bytes.iter()).ok_or_else(|| {
-            trc::Cause::DataCorruption
+            trc::StoreCause::DataCorruption
                 .caused_by(trc::location!())
                 .ctx(trc::Key::Value, bytes)
         })
diff --git a/crates/jmap-proto/src/object/sieve.rs b/crates/jmap-proto/src/object/sieve.rs
index 1f05a7f9..bca31205 100644
--- a/crates/jmap-proto/src/object/sieve.rs
+++ b/crates/jmap-proto/src/object/sieve.rs
@@ -21,7 +21,7 @@ impl RequestPropertyParser for SetArguments {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool> {
+    ) -> trc::Result<bool> {
         if property.hash[0] == 0x7461_7669_7463_4173_7365_6363_7553_6e6f
             && property.hash[1] == 0x0074_7069_7263_5365
         {
diff --git a/crates/jmap-proto/src/parser/base32.rs b/crates/jmap-proto/src/parser/base32.rs
index 597d6448..999b6980 100644
--- a/crates/jmap-proto/src/parser/base32.rs
+++ b/crates/jmap-proto/src/parser/base32.rs
@@ -6,7 +6,7 @@
 
 use utils::codec::{base32_custom::BASE32_INVERSE, leb128::Leb128Iterator};
 
-use super::{json::Parser, Error};
+use super::json::Parser;
 
 #[derive(Debug)]
 pub struct JsonBase32Reader<'x, 'y> {
@@ -38,7 +38,7 @@ impl<'x, 'y> JsonBase32Reader<'x, 'y> {
         }
     }
 
-    pub fn error(&mut self) -> Error {
+    pub fn error(&mut self) -> trc::Error {
         self.bytes.error_value()
     }
 }
diff --git a/crates/jmap-proto/src/parser/impls.rs b/crates/jmap-proto/src/parser/impls.rs
index 677aaf34..6f984d09 100644
--- a/crates/jmap-proto/src/parser/impls.rs
+++ b/crates/jmap-proto/src/parser/impls.rs
@@ -14,7 +14,7 @@ use utils::map::{
 use super::{json::Parser, Ignore, JsonObjectParser, Token};
 
 impl JsonObjectParser for u64 {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -36,7 +36,7 @@ impl JsonObjectParser for u64 {
 }
 
 impl JsonObjectParser for u128 {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -58,7 +58,7 @@ impl JsonObjectParser for u128 {
 }
 
 impl JsonObjectParser for String {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -177,7 +177,7 @@ impl JsonObjectParser for String {
 }
 
 impl<T: JsonObjectParser + Eq> JsonObjectParser for Vec<T> {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -197,7 +197,7 @@ impl<T: JsonObjectParser + Eq> JsonObjectParser for Vec<T> {
 }
 
 impl<T: JsonObjectParser + Eq> JsonObjectParser for Option<Vec<T>> {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -221,7 +221,7 @@ impl<T: JsonObjectParser + Eq> JsonObjectParser for Option<Vec<T>> {
 }
 
 impl<T: JsonObjectParser + Eq + BitmapItem> JsonObjectParser for Bitmap<T> {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -245,7 +245,7 @@ impl<T: JsonObjectParser + Eq + BitmapItem> JsonObjectParser for Bitmap<T> {
 }
 
 impl<K: JsonObjectParser + Eq + Display, V: JsonObjectParser> JsonObjectParser for VecMap<K, V> {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -263,7 +263,7 @@ impl<K: JsonObjectParser + Eq + Display, V: JsonObjectParser> JsonObjectParser f
 impl<K: JsonObjectParser + Eq + Display, V: JsonObjectParser> JsonObjectParser
     for Option<VecMap<K, V>>
 {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -284,7 +284,7 @@ impl<K: JsonObjectParser + Eq + Display, V: JsonObjectParser> JsonObjectParser
 }
 
 impl JsonObjectParser for bool {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -297,7 +297,7 @@ impl JsonObjectParser for bool {
 }
 
 impl JsonObjectParser for Ignore {
-    fn parse(parser: &mut Parser<'_>) -> super::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/parser/json.rs b/crates/jmap-proto/src/parser/json.rs
index ce790e6f..5d60aee8 100644
--- a/crates/jmap-proto/src/parser/json.rs
+++ b/crates/jmap-proto/src/parser/json.rs
@@ -6,9 +6,9 @@
 
 use std::{fmt::Display, iter::Peekable, slice::Iter};
 
-use crate::{error::method::MethodError, request::method::MethodObject};
+use crate::request::method::MethodObject;
 
-use super::{Error, Ignore, JsonObjectParser, Token};
+use super::{Ignore, JsonObjectParser, Token};
 
 const MAX_NESTED_LEVELS: u32 = 16;
 
@@ -40,25 +40,33 @@ impl<'x> Parser<'x> {
         }
     }
 
-    pub fn error(&self, message: &str) -> Error {
-        format!("{message} at position {}.", self.pos).into()
+    pub fn error(&self, message: &str) -> trc::Error {
+        trc::JmapCause::NotJSON
+            .into_err()
+            .details(format!("{message} at position {}.", self.pos))
     }
 
-    pub fn error_unterminated(&self) -> Error {
-        format!("Unterminated string at position {pos}.", pos = self.pos).into()
+    pub fn error_unterminated(&self) -> trc::Error {
+        trc::JmapCause::NotJSON.into_err().details(format!(
+            "Unterminated string at position {pos}.",
+            pos = self.pos
+        ))
     }
 
-    pub fn error_utf8(&self) -> Error {
-        format!("Invalid UTF-8 sequence at position {pos}.", pos = self.pos).into()
+    pub fn error_utf8(&self) -> trc::Error {
+        trc::JmapCause::NotJSON.into_err().details(format!(
+            "Invalid UTF-8 sequence at position {pos}.",
+            pos = self.pos
+        ))
     }
 
-    pub fn error_value(&mut self) -> Error {
+    pub fn error_value(&mut self) -> trc::Error {
         if self.is_eof || self.skip_string() {
-            Error::Method(MethodError::InvalidArguments(format!(
+            trc::JmapCause::InvalidArguments.into_err().details(format!(
                 "Invalid value {:?} at position {}.",
                 String::from_utf8_lossy(self.bytes[self.pos_marker..self.pos - 1].as_ref()),
                 self.pos
-            )))
+            ))
         } else {
             self.error_unterminated()
         }
@@ -76,7 +84,7 @@ impl<'x> Parser<'x> {
     }
 
     #[inline(always)]
-    pub fn next_unescaped(&mut self) -> super::Result<Option<u8>> {
+    pub fn next_unescaped(&mut self) -> trc::Result<Option<u8>> {
         match self.next_char() {
             Some(b'"') => {
                 self.is_eof = true;
@@ -112,7 +120,7 @@ impl<'x> Parser<'x> {
         false
     }
 
-    pub fn next_token<T: JsonObjectParser>(&mut self) -> super::Result<Token<T>> {
+    pub fn next_token<T: JsonObjectParser>(&mut self) -> trc::Result<Token<T>> {
         let mut next_ch = self.next_ch.take().or_else(|| self.next_char());
 
         while let Some(mut ch) = next_ch {
@@ -263,9 +271,7 @@ impl<'x> Parser<'x> {
         Err(self.error("Unexpected EOF"))
     }
 
-    pub fn next_dict_key<T: JsonObjectParser + Display + Eq>(
-        &mut self,
-    ) -> super::Result<Option<T>> {
+    pub fn next_dict_key<T: JsonObjectParser + Display + Eq>(&mut self) -> trc::Result<Option<T>> {
         loop {
             match self.next_token::<T>()? {
                 Token::String(k) => {
@@ -281,11 +287,7 @@ impl<'x> Parser<'x> {
         }
     }
 
-    pub fn skip_token(
-        &mut self,
-        start_depth_array: u32,
-        start_depth_dict: u32,
-    ) -> super::Result<()> {
+    pub fn skip_token(&mut self, start_depth_array: u32, start_depth_dict: u32) -> trc::Result<()> {
         while {
             self.next_token::<Ignore>()?;
             start_depth_array != self.depth_array || start_depth_dict != self.depth_dict
diff --git a/crates/jmap-proto/src/parser/mod.rs b/crates/jmap-proto/src/parser/mod.rs
index a21133a2..56fca203 100644
--- a/crates/jmap-proto/src/parser/mod.rs
+++ b/crates/jmap-proto/src/parser/mod.rs
@@ -6,8 +6,6 @@
 
 use std::fmt::Display;
 
-use crate::error::{method::MethodError, request::RequestError};
-
 use self::json::Parser;
 
 pub mod base32;
@@ -32,31 +30,23 @@ pub enum Token<T> {
 impl<T: PartialEq> Eq for Token<T> {}
 
 pub trait JsonObjectParser {
-    fn parse(parser: &mut Parser<'_>) -> Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized;
 }
 
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Debug)]
-pub enum Error {
-    Request(RequestError),
-    Method(MethodError),
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Ignore {}
 
 impl<T: Eq> Token<T> {
-    pub fn unwrap_string(self, property: &str) -> Result<T> {
+    pub fn unwrap_string(self, property: &str) -> trc::Result<T> {
         match self {
             Token::String(s) => Ok(s),
             token => Err(token.error(property, "string")),
         }
     }
 
-    pub fn unwrap_string_or_null(self, property: &str) -> Result<Option<T>> {
+    pub fn unwrap_string_or_null(self, property: &str) -> trc::Result<Option<T>> {
         match self {
             Token::String(s) => Ok(Some(s)),
             Token::Null => Ok(None),
@@ -64,14 +54,14 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn unwrap_bool(self, property: &str) -> Result<bool> {
+    pub fn unwrap_bool(self, property: &str) -> trc::Result<bool> {
         match self {
             Token::Boolean(v) => Ok(v),
             token => Err(token.error(property, "boolean")),
         }
     }
 
-    pub fn unwrap_bool_or_null(self, property: &str) -> Result<Option<bool>> {
+    pub fn unwrap_bool_or_null(self, property: &str) -> trc::Result<Option<bool>> {
         match self {
             Token::Boolean(v) => Ok(Some(v)),
             Token::Null => Ok(None),
@@ -79,7 +69,7 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn unwrap_usize_or_null(self, property: &str) -> Result<Option<usize>> {
+    pub fn unwrap_usize_or_null(self, property: &str) -> trc::Result<Option<usize>> {
         match self {
             Token::Integer(v) if v >= 0 => Ok(Some(v as usize)),
             Token::Float(v) if v >= 0.0 => Ok(Some(v as usize)),
@@ -88,7 +78,7 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn unwrap_uint_or_null(self, property: &str) -> Result<Option<u64>> {
+    pub fn unwrap_uint_or_null(self, property: &str) -> trc::Result<Option<u64>> {
         match self {
             Token::Integer(v) if v >= 0 => Ok(Some(v as u64)),
             Token::Float(v) if v >= 0.0 => Ok(Some(v as u64)),
@@ -97,7 +87,7 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn unwrap_int_or_null(self, property: &str) -> Result<Option<i64>> {
+    pub fn unwrap_int_or_null(self, property: &str) -> trc::Result<Option<i64>> {
         match self {
             Token::Integer(v) => Ok(Some(v)),
             Token::Float(v) => Ok(Some(v as i64)),
@@ -106,7 +96,7 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn unwrap_ints_or_null(self, property: &str) -> Result<Option<i32>> {
+    pub fn unwrap_ints_or_null(self, property: &str) -> trc::Result<Option<i32>> {
         match self {
             Token::Integer(v) => Ok(Some(v as i32)),
             Token::Float(v) => Ok(Some(v as i32)),
@@ -115,7 +105,7 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn assert(self, token: Token<T>) -> Result<()> {
+    pub fn assert(self, token: Token<T>) -> trc::Result<()> {
         if self == token {
             Ok(())
         } else {
@@ -123,22 +113,22 @@ impl<T: Eq> Token<T> {
         }
     }
 
-    pub fn assert_jmap(self, token: Token<T>) -> Result<()> {
+    pub fn assert_jmap(self, token: Token<T>) -> trc::Result<()> {
         if self == token {
             Ok(())
         } else {
-            Err(Error::Request(RequestError::not_request(format!(
+            Err(trc::JmapCause::NotRequest.into_err().details(format!(
                 "Invalid JMAP request: expected '{token}', got '{self}'."
-            ))))
+            )))
         }
     }
 
-    pub fn error(&self, property: &str, expected: &str) -> Error {
-        Error::Method(MethodError::InvalidArguments(if !property.is_empty() {
+    pub fn error(&self, property: &str, expected: &str) -> trc::Error {
+        trc::JmapCause::InvalidArguments.into_err().details(if !property.is_empty() {
             format!("Invalid argument for '{property:?}': expected '{expected}', got '{self}'.",)
         } else {
             format!("Invalid argument: expected '{expected}', got '{self}'.")
-        }))
+        })
     }
 }
 
@@ -148,18 +138,6 @@ impl Display for Ignore {
     }
 }
 
-impl From<String> for Error {
-    fn from(s: String) -> Self {
-        Error::Request(RequestError::not_json(&s))
-    }
-}
-
-impl From<&str> for Error {
-    fn from(s: &str) -> Self {
-        Error::Request(RequestError::not_json(s))
-    }
-}
-
 impl<T> Display for Token<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
diff --git a/crates/jmap-proto/src/request/capability.rs b/crates/jmap-proto/src/request/capability.rs
index 7ec457ef..79d8e58e 100644
--- a/crates/jmap-proto/src/request/capability.rs
+++ b/crates/jmap-proto/src/request/capability.rs
@@ -7,8 +7,7 @@
 use utils::map::vec_map::VecMap;
 
 use crate::{
-    error::request::RequestError,
-    parser::{json::Parser, Error, JsonObjectParser},
+    parser::{json::Parser, JsonObjectParser},
     response::serialize::serialize_hex,
     types::{id::Id, type_state::DataType},
 };
@@ -315,7 +314,7 @@ impl WebSocketCapabilities {
 }
 
 impl JsonObjectParser for Capability {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -343,18 +342,19 @@ impl JsonObjectParser for Capability {
                 0x0061_746f_7571 => Ok(Capability::Quota),
                 _ => Err(parser.error_capability()),
             },
-            Err(Error::Method(_)) => Err(parser.error_capability()),
-            Err(err @ Error::Request(_)) => Err(err),
+            Err(err) if err.is_jmap_method_error() => Err(parser.error_capability()),
+            Err(err) => Err(err),
         }
     }
 }
 
 impl<'x> Parser<'x> {
-    fn error_capability(&mut self) -> Error {
+    fn error_capability(&mut self) -> trc::Error {
         if self.is_eof || self.skip_string() {
-            Error::Request(RequestError::unknown_capability(&String::from_utf8_lossy(
-                self.bytes[self.pos_marker..self.pos - 1].as_ref(),
-            )))
+            trc::JmapCause::UnknownCapability.into_err().details(
+                String::from_utf8_lossy(self.bytes[self.pos_marker..self.pos - 1].as_ref())
+                    .into_owned(),
+            )
         } else {
             self.error_unterminated()
         }
diff --git a/crates/jmap-proto/src/request/echo.rs b/crates/jmap-proto/src/request/echo.rs
index b82a4d86..561bf088 100644
--- a/crates/jmap-proto/src/request/echo.rs
+++ b/crates/jmap-proto/src/request/echo.rs
@@ -15,7 +15,7 @@ pub struct Echo {
 }
 
 impl JsonObjectParser for Echo {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/request/method.rs b/crates/jmap-proto/src/request/method.rs
index b9b51594..be2f4f84 100644
--- a/crates/jmap-proto/src/request/method.rs
+++ b/crates/jmap-proto/src/request/method.rs
@@ -48,7 +48,7 @@ pub enum MethodFunction {
 }
 
 impl JsonObjectParser for MethodName {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/request/mod.rs b/crates/jmap-proto/src/request/mod.rs
index 79468a9d..a223b528 100644
--- a/crates/jmap-proto/src/request/mod.rs
+++ b/crates/jmap-proto/src/request/mod.rs
@@ -77,7 +77,7 @@ pub enum RequestMethod {
 }
 
 impl JsonObjectParser for RequestProperty {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -116,5 +116,5 @@ pub trait RequestPropertyParser {
         &mut self,
         parser: &mut Parser,
         property: RequestProperty,
-    ) -> crate::parser::Result<bool>;
+    ) -> trc::Result<bool>;
 }
diff --git a/crates/jmap-proto/src/request/parser.rs b/crates/jmap-proto/src/request/parser.rs
index 74306337..b25327f5 100644
--- a/crates/jmap-proto/src/request/parser.rs
+++ b/crates/jmap-proto/src/request/parser.rs
@@ -7,10 +7,6 @@
 use std::collections::HashMap;
 
 use crate::{
-    error::{
-        method::MethodError,
-        request::{RequestError, RequestLimitError},
-    },
     method::{
         changes::ChangesRequest,
         copy::{CopyBlobRequest, CopyRequest},
@@ -25,7 +21,7 @@ use crate::{
         upload::BlobUploadRequest,
         validate::ValidateSieveScriptRequest,
     },
-    parser::{json::Parser, Error, Ignore, JsonObjectParser, Token},
+    parser::{json::Parser, Ignore, JsonObjectParser, Token},
     types::any_id::AnyId,
 };
 
@@ -37,7 +33,7 @@ use super::{
 };
 
 impl Request {
-    pub fn parse(json: &[u8], max_calls: usize, max_size: usize) -> Result<Self, RequestError> {
+    pub fn parse(json: &[u8], max_calls: usize, max_size: usize) -> trc::Result<Self> {
         if json.len() <= max_size {
             let mut request = Request {
                 using: 0,
@@ -54,10 +50,12 @@ impl Request {
             if found_valid_keys {
                 Ok(request)
             } else {
-                Err(RequestError::not_request("Invalid JMAP request"))
+                Err(trc::JmapCause::NotRequest
+                    .into_err()
+                    .details("Invalid JMAP request"))
             }
         } else {
-            Err(RequestError::limit(RequestLimitError::SizeRequest))
+            Err(trc::LimitCause::SizeRequest.into_err())
         }
     }
 
@@ -66,7 +64,7 @@ impl Request {
         parser: &mut Parser,
         max_calls: usize,
         key: u128,
-    ) -> Result<bool, RequestError> {
+    ) -> trc::Result<bool> {
         match key {
             0x0067_6e69_7375 => {
                 parser.next_token::<Ignore>()?.assert(Token::ArrayStart)?;
@@ -77,7 +75,7 @@ impl Request {
                         }
                         Token::Comma => (),
                         Token::ArrayEnd => break,
-                        token => return Err(token.error("capability", &token.to_string()).into()),
+                        token => return Err(token.error("capability", &token.to_string())),
                     }
                 }
                 Ok(true)
@@ -92,20 +90,28 @@ impl Request {
                         Token::Comma => continue,
                         Token::ArrayEnd => break,
                         _ => {
-                            return Err(RequestError::not_request("Invalid JMAP request"));
+                            return Err(trc::JmapCause::NotRequest
+                                .into_err()
+                                .details("Invalid JMAP request"));
                         }
                     };
                     if self.method_calls.len() < max_calls {
                         let method_name = match parser.next_token::<MethodName>() {
                             Ok(Token::String(method)) => method,
                             Ok(_) => {
-                                return Err(RequestError::not_request("Invalid JMAP request"));
+                                return Err(trc::JmapCause::NotRequest
+                                    .into_err()
+                                    .details("Invalid JMAP request"));
                             }
-                            Err(Error::Method(MethodError::InvalidArguments(_))) => {
+                            Err(err)
+                                if err.matches(trc::Cause::Jmap(
+                                    trc::JmapCause::InvalidArguments,
+                                )) =>
+                            {
                                 MethodName::error()
                             }
                             Err(err) => {
-                                return Err(err.into());
+                                return Err(err);
                             }
                         };
                         parser.next_token::<Ignore>()?.assert_jmap(Token::Comma)?;
@@ -169,19 +175,19 @@ impl Request {
                             (MethodFunction::Echo, MethodObject::Core) => {
                                 Echo::parse(parser).map(RequestMethod::Echo)
                             }
-                            _ => Err(Error::Method(MethodError::UnknownMethod(
-                                method_name.to_string(),
-                            ))),
+                            _ => Err(trc::JmapCause::UnknownMethod
+                                .into_err()
+                                .details(method_name.to_string())),
                         };
 
                         let method = match method {
                             Ok(method) => method,
-                            Err(Error::Method(err)) => {
+                            Err(err) if !err.is_jmap_method_error() => {
                                 parser.skip_token(start_depth_array, start_depth_dict)?;
-                                RequestMethod::Error(err.into())
+                                RequestMethod::Error(err)
                             }
                             Err(err) => {
-                                return Err(err.into());
+                                return Err(err);
                             }
                         };
 
@@ -196,7 +202,7 @@ impl Request {
                             name: method_name,
                         });
                     } else {
-                        return Err(RequestError::limit(RequestLimitError::CallsIn));
+                        return Err(trc::LimitCause::CallsIn.into_err());
                     }
                 }
                 Ok(true)
@@ -221,15 +227,6 @@ impl Request {
     }
 }
 
-impl From<Error> for RequestError {
-    fn from(value: Error) -> Self {
-        match value {
-            Error::Request(err) => err,
-            Error::Method(err) => RequestError::not_request(err.to_string()),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::request::Request;
diff --git a/crates/jmap-proto/src/request/reference.rs b/crates/jmap-proto/src/request/reference.rs
index 62ca66ba..cd61b941 100644
--- a/crates/jmap-proto/src/request/reference.rs
+++ b/crates/jmap-proto/src/request/reference.rs
@@ -7,8 +7,7 @@
 use std::fmt::Display;
 
 use crate::{
-    error::method::MethodError,
-    parser::{json::Parser, Error, JsonObjectParser, Token},
+    parser::{json::Parser, JsonObjectParser, Token},
     types::{id::Id, pointer::JSONPointer},
 };
 
@@ -45,7 +44,7 @@ impl<V, R> MaybeReference<V, R> {
 }
 
 impl JsonObjectParser for ResultReference {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser) -> trc::Result<Self>
     where
         Self: Sized,
     {
@@ -81,15 +80,15 @@ impl JsonObjectParser for ResultReference {
                 path,
             })
         } else {
-            Err(Error::Method(MethodError::InvalidResultReference(
-                "Missing required fields".into(),
-            )))
+            Err(trc::JmapCause::InvalidResultReference
+                .into_err()
+                .details("Missing required fields"))
         }
     }
 }
 
 impl<T: JsonObjectParser> JsonObjectParser for MaybeReference<T, String> {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/request/websocket.rs b/crates/jmap-proto/src/request/websocket.rs
index c2a42851..b1fcbe4b 100644
--- a/crates/jmap-proto/src/request/websocket.rs
+++ b/crates/jmap-proto/src/request/websocket.rs
@@ -8,7 +8,7 @@ use std::{borrow::Cow, collections::HashMap};
 
 use crate::{
     error::request::{RequestError, RequestErrorType, RequestLimitError},
-    parser::{json::Parser, Error, JsonObjectParser, Token},
+    parser::{json::Parser, JsonObjectParser, Token},
     request::Call,
     response::{serialize::serialize_hex, Response, ResponseMethod},
     types::{any_id::AnyId, id::Id, state::State, type_state::DataType},
@@ -108,11 +108,7 @@ enum MessageType {
 }
 
 impl WebSocketMessage {
-    pub fn parse(
-        json: &[u8],
-        max_calls: usize,
-        max_size: usize,
-    ) -> Result<Self, WebSocketRequestError> {
+    pub fn parse(json: &[u8], max_calls: usize, max_size: usize) -> trc::Result<Self> {
         if json.len() <= max_size {
             let mut message_type = MessageType::None;
             let mut request = WebSocketRequest {
@@ -174,10 +170,12 @@ impl WebSocketMessage {
                 MessageType::PushDisable if !found_request_keys && !found_push_keys => {
                     Ok(WebSocketMessage::PushDisable)
                 }
-                _ => Err(RequestError::not_request("Invalid WebSocket JMAP request").into()),
+                _ => Err(trc::JmapCause::NotRequest
+                    .into_err()
+                    .details("Invalid WebSocket JMAP request")),
             }
         } else {
-            Err(RequestError::limit(RequestLimitError::SizeRequest).into())
+            Err(trc::LimitCause::SizeRequest.into_err())
         }
     }
 }
@@ -205,12 +203,6 @@ impl From<RequestError> for WebSocketRequestError {
     }
 }
 
-impl From<Error> for WebSocketRequestError {
-    fn from(value: Error) -> Self {
-        RequestError::from(value).into()
-    }
-}
-
 impl WebSocketResponse {
     pub fn from_response(response: Response, request_id: Option<String>) -> Self {
         Self {
diff --git a/crates/jmap-proto/src/types/acl.rs b/crates/jmap-proto/src/types/acl.rs
index 8b898a4b..f6a7efcd 100644
--- a/crates/jmap-proto/src/types/acl.rs
+++ b/crates/jmap-proto/src/types/acl.rs
@@ -27,7 +27,7 @@ pub enum Acl {
 }
 
 impl JsonObjectParser for Acl {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/any_id.rs b/crates/jmap-proto/src/types/any_id.rs
index 62ec2397..3adb36f0 100644
--- a/crates/jmap-proto/src/types/any_id.rs
+++ b/crates/jmap-proto/src/types/any_id.rs
@@ -96,7 +96,7 @@ impl From<&AnyId> for Value {
 }
 
 impl JsonObjectParser for AnyId {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/blob.rs b/crates/jmap-proto/src/types/blob.rs
index 7c920823..86b577da 100644
--- a/crates/jmap-proto/src/types/blob.rs
+++ b/crates/jmap-proto/src/types/blob.rs
@@ -38,7 +38,7 @@ pub struct BlobSection {
 }
 
 impl JsonObjectParser for BlobId {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/date.rs b/crates/jmap-proto/src/types/date.rs
index 1c72a8d3..923bc3f7 100644
--- a/crates/jmap-proto/src/types/date.rs
+++ b/crates/jmap-proto/src/types/date.rs
@@ -24,7 +24,7 @@ pub struct UTCDate {
 }
 
 impl JsonObjectParser for UTCDate {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/id.rs b/crates/jmap-proto/src/types/id.rs
index e820ca95..da3498d1 100644
--- a/crates/jmap-proto/src/types/id.rs
+++ b/crates/jmap-proto/src/types/id.rs
@@ -24,7 +24,7 @@ impl Default for Id {
 }
 
 impl JsonObjectParser for Id {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/keyword.rs b/crates/jmap-proto/src/types/keyword.rs
index 737ea3e0..701baf81 100644
--- a/crates/jmap-proto/src/types/keyword.rs
+++ b/crates/jmap-proto/src/types/keyword.rs
@@ -61,7 +61,7 @@ pub enum Keyword {
 }
 
 impl JsonObjectParser for Keyword {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/mod.rs b/crates/jmap-proto/src/types/mod.rs
index 4315d0ad..199bc8ac 100644
--- a/crates/jmap-proto/src/types/mod.rs
+++ b/crates/jmap-proto/src/types/mod.rs
@@ -29,7 +29,7 @@ pub enum MaybeUnparsable<V> {
 }
 
 impl<V: JsonObjectParser> JsonObjectParser for MaybeUnparsable<V> {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self> {
+    fn parse(parser: &mut Parser) -> trc::Result<Self> {
         match V::parse(parser) {
             Ok(value) => Ok(MaybeUnparsable::Value(value)),
             Err(_) if parser.is_eof || parser.skip_string() => Ok(MaybeUnparsable::ParseError(
diff --git a/crates/jmap-proto/src/types/pointer.rs b/crates/jmap-proto/src/types/pointer.rs
index 2d6731b3..2062e6f5 100644
--- a/crates/jmap-proto/src/types/pointer.rs
+++ b/crates/jmap-proto/src/types/pointer.rs
@@ -26,7 +26,7 @@ enum TokenType {
 }
 
 impl JsonObjectParser for JSONPointer {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/property.rs b/crates/jmap-proto/src/types/property.rs
index 40214d59..bc76da48 100644
--- a/crates/jmap-proto/src/types/property.rs
+++ b/crates/jmap-proto/src/types/property.rs
@@ -10,7 +10,7 @@ use mail_parser::HeaderName;
 use serde::Serialize;
 use store::write::{DeserializeFrom, SerializeInto};
 
-use crate::parser::{json::Parser, Error, JsonObjectParser};
+use crate::parser::{json::Parser, JsonObjectParser};
 
 use super::{acl::Acl, id::Id, keyword::Keyword, value::Value};
 
@@ -153,7 +153,7 @@ pub trait IntoProperty: Eq + Display {
 }
 
 impl JsonObjectParser for Property {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self> {
+    fn parse(parser: &mut Parser) -> trc::Result<Self> {
         let mut first_char = 0;
         let mut hash = 0;
         let mut shift = 0;
@@ -190,7 +190,7 @@ impl JsonObjectParser for Property {
 }
 
 impl JsonObjectParser for SetProperty {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self> {
+    fn parse(parser: &mut Parser) -> trc::Result<Self> {
         let mut first_char = 0;
         let mut hash = 0;
         let mut shift = 0;
@@ -251,7 +251,7 @@ impl JsonObjectParser for SetProperty {
                     Ok(id) => {
                         patch.push(Value::Id(id));
                     }
-                    Err(Error::Method(_)) => {
+                    Err(err) if err.is_jmap_method_error() => {
                         property = parser.invalid_property()?;
                     }
                     Err(err) => {
@@ -262,7 +262,7 @@ impl JsonObjectParser for SetProperty {
                     Ok(keyword) => {
                         patch.push(Value::Keyword(keyword));
                     }
-                    Err(Error::Method(_)) => {
+                    Err(err) if err.is_jmap_method_error() => {
                         property = parser.invalid_property()?;
                     }
                     Err(err) => {
@@ -290,7 +290,7 @@ impl JsonObjectParser for SetProperty {
                                     Ok(acl) => {
                                         patch.push(Value::UnsignedInt(acl as u64));
                                     }
-                                    Err(Error::Method(_)) => {
+                                    Err(err) if err.is_jmap_method_error() => {
                                         property = parser.invalid_property()?;
                                     }
                                     Err(err) => {
@@ -469,7 +469,7 @@ fn parse_property(first_char: u8, hash: u128) -> Option<Property> {
     })
 }
 
-fn parse_header_property(parser: &mut Parser) -> crate::parser::Result<Property> {
+fn parse_header_property(parser: &mut Parser) -> trc::Result<Property> {
     let hdr_start_pos = parser.pos;
     let mut has_next = false;
 
@@ -553,7 +553,7 @@ fn parse_sub_property(
     parser: &mut Parser,
     first_char: u8,
     parent_hash: u128,
-) -> crate::parser::Result<Property> {
+) -> trc::Result<Property> {
     let mut hash = 0;
     let mut shift = 0;
 
@@ -585,7 +585,7 @@ fn parse_sub_property(
 }
 
 impl JsonObjectParser for ObjectProperty {
-    fn parse(parser: &mut Parser) -> crate::parser::Result<Self> {
+    fn parse(parser: &mut Parser) -> trc::Result<Self> {
         let mut first_char = 0;
         let mut hash = 0;
         let mut shift = 0;
@@ -707,7 +707,7 @@ impl JsonObjectParser for ObjectProperty {
 }
 
 impl<'x> Parser<'x> {
-    fn invalid_property(&mut self) -> crate::parser::Result<Property> {
+    fn invalid_property(&mut self) -> trc::Result<Property> {
         if self.is_eof || self.skip_string() {
             Ok(Property::_T(
                 String::from_utf8_lossy(self.bytes[self.pos_marker..self.pos - 1].as_ref())
diff --git a/crates/jmap-proto/src/types/state.rs b/crates/jmap-proto/src/types/state.rs
index 20da85dc..422c0e97 100644
--- a/crates/jmap-proto/src/types/state.rs
+++ b/crates/jmap-proto/src/types/state.rs
@@ -72,7 +72,7 @@ impl From<Option<ChangeId>> for State {
 }
 
 impl JsonObjectParser for State {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/type_state.rs b/crates/jmap-proto/src/types/type_state.rs
index 44bd7aaf..563dc14d 100644
--- a/crates/jmap-proto/src/types/type_state.rs
+++ b/crates/jmap-proto/src/types/type_state.rs
@@ -85,7 +85,7 @@ impl From<DataType> for u64 {
 }
 
 impl JsonObjectParser for DataType {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {
diff --git a/crates/jmap-proto/src/types/value.rs b/crates/jmap-proto/src/types/value.rs
index 90a2952d..65c83d88 100644
--- a/crates/jmap-proto/src/types/value.rs
+++ b/crates/jmap-proto/src/types/value.rs
@@ -78,7 +78,7 @@ impl Value {
     pub fn parse<K: JsonObjectParser + IntoProperty, V: JsonObjectParser + IntoValue>(
         token: Token<V>,
         parser: &mut Parser<'_>,
-    ) -> crate::parser::Result<Self> {
+    ) -> trc::Result<Self> {
         Ok(match token {
             Token::String(v) => v.into_value(),
             Token::DictStart => {
@@ -114,7 +114,7 @@ impl Value {
     pub fn from_property(
         parser: &mut Parser<'_>,
         property: &Property,
-    ) -> crate::parser::Result<Self> {
+    ) -> trc::Result<Self> {
         match &property {
             Property::BlobId => Ok(parser
                 .next_token::<BlobId>()?
@@ -327,7 +327,7 @@ impl Value {
 }
 
 impl<T: JsonObjectParser + Display + Eq> JsonObjectParser for SetValueMap<T> {
-    fn parse(parser: &mut Parser<'_>) -> crate::parser::Result<Self>
+    fn parse(parser: &mut Parser<'_>) -> trc::Result<Self>
     where
         Self: Sized,
     {