refactor: linting and formatting

crates/atproto-client/src/client.rs

···
     /// DPoP authentication with proof-of-possession tokens and OAuth access token
     DPoP(DPoPAuth),
     /// App password authentication using JWT bearer tokens
-    AppPassword(AppPasswordAuth)
+    AppPassword(AppPasswordAuth),
 }
 
 /// Performs an unauthenticated HTTP GET request and parses the response as JSON.

crates/atproto-client/src/com_atproto_identity.rs

···
 use serde::{Deserialize, de::DeserializeOwned};
 
 use crate::{
-    client::{get_apppassword_json, get_dpop_json, get_json, Auth},
+    client::{Auth, get_apppassword_json, get_dpop_json, get_json},
     errors::SimpleError,
-    url::URLBuilder
+    url::URLBuilder,
 };
 
 /// Response from the com.atproto.identity.resolveHandle XRPC method.

crates/atproto-client/src/com_atproto_repo.rs

···
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
 use crate::{
-    client::{Auth, get_apppassword_json, get_bytes, get_dpop_json, get_json, post_apppassword_json, post_dpop_json, post_json},
+    client::{
+        Auth, get_apppassword_json, get_bytes, get_dpop_json, get_json, post_apppassword_json,
+        post_dpop_json, post_json,
+    },
     errors::SimpleError,
     url::URLBuilder,
 };

crates/atproto-client/src/lib.rs

···
 pub mod errors;
 pub mod url;
 
+mod com_atproto_identity;
 mod com_atproto_repo;
 mod com_atproto_server;
-mod com_atproto_identity;
 
 /// AT Protocol namespace modules.
 pub mod com {

crates/atproto-jetstream/src/consumer.rs

···
     #[test]
     fn test_parse_account_event() {
         let json_str = r#"{"did":"did:plc:yn72uqr4ihkjfbz7us7buqsq","time_us":1757517640675638,"kind":"account","account":{"active":false,"did":"did:plc:yn72uqr4ihkjfbz7us7buqsq","seq":13206502767,"status":"takendown","time":"2025-09-10T15:20:40.439Z"}}"#;
-        
+
         let event = serde_json::from_str::<JetstreamEvent>(json_str)
             .expect("Failed to parse account event JSON");
-        
+
         match event {
-            JetstreamEvent::Account { did, time_us, kind, account: identity } => {
+            JetstreamEvent::Account {
+                did,
+                time_us,
+                kind,
+                account: identity,
+            } => {
                 assert_eq!(did, "did:plc:yn72uqr4ihkjfbz7us7buqsq");
                 assert_eq!(time_us, 1757517640675638);
                 assert_eq!(kind, "account");
-                
+
                 // Verify the account data structure
                 assert!(identity.is_object());
                 let account_obj = identity.as_object().unwrap();
-                assert_eq!(account_obj.get("active").unwrap(), &serde_json::json!(false));
-                assert_eq!(account_obj.get("did").unwrap(), &serde_json::json!("did:plc:yn72uqr4ihkjfbz7us7buqsq"));
-                assert_eq!(account_obj.get("seq").unwrap(), &serde_json::json!(13206502767i64));
-                assert_eq!(account_obj.get("status").unwrap(), &serde_json::json!("takendown"));
-                assert_eq!(account_obj.get("time").unwrap(), &serde_json::json!("2025-09-10T15:20:40.439Z"));
+                assert_eq!(
+                    account_obj.get("active").unwrap(),
+                    &serde_json::json!(false)
+                );
+                assert_eq!(
+                    account_obj.get("did").unwrap(),
+                    &serde_json::json!("did:plc:yn72uqr4ihkjfbz7us7buqsq")
+                );
+                assert_eq!(
+                    account_obj.get("seq").unwrap(),
+                    &serde_json::json!(13206502767i64)
+                );
+                assert_eq!(
+                    account_obj.get("status").unwrap(),
+                    &serde_json::json!("takendown")
+                );
+                assert_eq!(
+                    account_obj.get("time").unwrap(),
+                    &serde_json::json!("2025-09-10T15:20:40.439Z")
+                );
             }
             _ => panic!("Expected JetstreamEvent::Account variant, got {:?}", event),
         }
···
     #[test]
     fn test_parse_identity_event() {
         let json_str = r#"{"did":"did:plc:mbuadp4xzlbmc2ncqp3pmtox","time_us":1757517628039893,"kind":"identity","identity":{"did":"did:plc:mbuadp4xzlbmc2ncqp3pmtox","handle":"nhieothv.bsky.social","seq":13206497272,"time":"2025-09-10T15:20:27.610Z"}}"#;
-        
+
         let event = serde_json::from_str::<JetstreamEvent>(json_str)
             .expect("Failed to parse identity event JSON");
-        
+
         match event {
-            JetstreamEvent::Identity { did, time_us, kind, identity } => {
+            JetstreamEvent::Identity {
+                did,
+                time_us,
+                kind,
+                identity,
+            } => {
                 assert_eq!(did, "did:plc:mbuadp4xzlbmc2ncqp3pmtox");
                 assert_eq!(time_us, 1757517628039893);
                 assert_eq!(kind, "identity");
-                
+
                 // Verify the identity data structure
                 assert!(identity.is_object());
                 let identity_obj = identity.as_object().unwrap();
-                assert_eq!(identity_obj.get("did").unwrap(), &serde_json::json!("did:plc:mbuadp4xzlbmc2ncqp3pmtox"));
-                assert_eq!(identity_obj.get("handle").unwrap(), &serde_json::json!("nhieothv.bsky.social"));
-                assert_eq!(identity_obj.get("seq").unwrap(), &serde_json::json!(13206497272i64));
-                assert_eq!(identity_obj.get("time").unwrap(), &serde_json::json!("2025-09-10T15:20:27.610Z"));
+                assert_eq!(
+                    identity_obj.get("did").unwrap(),
+                    &serde_json::json!("did:plc:mbuadp4xzlbmc2ncqp3pmtox")
+                );
+                assert_eq!(
+                    identity_obj.get("handle").unwrap(),
+                    &serde_json::json!("nhieothv.bsky.social")
+                );
+                assert_eq!(
+                    identity_obj.get("seq").unwrap(),
+                    &serde_json::json!(13206497272i64)
+                );
+                assert_eq!(
+                    identity_obj.get("time").unwrap(),
+                    &serde_json::json!("2025-09-10T15:20:27.610Z")
+                );
             }
             _ => panic!("Expected JetstreamEvent::Identity variant, got {:?}", event),
         }
···
     #[test]
     fn test_parse_delete_event() {
         let json_str = r#"{"did":"did:plc:5ozthefrqdo5kqnxzfgthhpp","time_us":1757519323847323,"kind":"commit","commit":{"rev":"3lyileto4q52k","operation":"delete","collection":"app.bsky.graph.follow","rkey":"3lxqxntaew32z"}}"#;
-        
+
         let event = serde_json::from_str::<JetstreamEvent>(json_str)
             .expect("Failed to parse delete event JSON");
-        
+
         match event {
-            JetstreamEvent::Delete { did, time_us, kind, commit } => {
+            JetstreamEvent::Delete {
+                did,
+                time_us,
+                kind,
+                commit,
+            } => {
                 assert_eq!(did, "did:plc:5ozthefrqdo5kqnxzfgthhpp");
                 assert_eq!(time_us, 1757519323847323);
                 assert_eq!(kind, "commit");
-                
+
                 // Verify the delete operation details
                 assert_eq!(commit.rev, "3lyileto4q52k");
                 assert_eq!(commit.operation, "delete");
···
     #[test]
     fn test_parse_commit_event() {
         let json_str = r#"{"did":"did:plc:suq5ijgyqmsawwf5tskf654x","time_us":1757519323848962,"kind":"commit","commit":{"rev":"3lyiletdopl2c","operation":"create","collection":"app.bsky.feed.like","rkey":"3lyiletddxt2c","record":{"$type":"app.bsky.feed.like","createdAt":"2025-09-10T15:47:13.086Z","subject":{"cid":"bafyreib2pygab7z5l7nkqf6bchcvgt4jwsqiaenpf3sr65lugum2uvzzf4","uri":"at://did:plc:yw65rktdby2chplqdytqzcao/app.bsky.feed.post/3lyildyjxgs2o"}},"cid":"bafyreigroo6vhxt62ufcndhaxzas6btq4jmniuz4egszbwuqgiyisqwqoy"}}"#;
-        
+
         let event = serde_json::from_str::<JetstreamEvent>(json_str)
             .expect("Failed to parse commit event JSON");
-        
+
         match event {
-            JetstreamEvent::Commit { did, time_us, kind, commit } => {
+            JetstreamEvent::Commit {
+                did,
+                time_us,
+                kind,
+                commit,
+            } => {
                 assert_eq!(did, "did:plc:suq5ijgyqmsawwf5tskf654x");
                 assert_eq!(time_us, 1757519323848962);
                 assert_eq!(kind, "commit");
-                
+
                 // Verify the commit operation details
                 assert_eq!(commit.rev, "3lyiletdopl2c");
                 assert_eq!(commit.operation, "create");
                 assert_eq!(commit.collection, "app.bsky.feed.like");
                 assert_eq!(commit.rkey, "3lyiletddxt2c");
-                assert_eq!(commit.cid, "bafyreigroo6vhxt62ufcndhaxzas6btq4jmniuz4egszbwuqgiyisqwqoy");
-                
+                assert_eq!(
+                    commit.cid,
+                    "bafyreigroo6vhxt62ufcndhaxzas6btq4jmniuz4egszbwuqgiyisqwqoy"
+                );
+
                 // Verify the record data structure
                 assert!(commit.record.is_object());
                 let record_obj = commit.record.as_object().unwrap();
-                assert_eq!(record_obj.get("$type").unwrap(), &serde_json::json!("app.bsky.feed.like"));
-                assert_eq!(record_obj.get("createdAt").unwrap(), &serde_json::json!("2025-09-10T15:47:13.086Z"));
-                
+                assert_eq!(
+                    record_obj.get("$type").unwrap(),
+                    &serde_json::json!("app.bsky.feed.like")
+                );
+                assert_eq!(
+                    record_obj.get("createdAt").unwrap(),
+                    &serde_json::json!("2025-09-10T15:47:13.086Z")
+                );
+
                 // Verify the subject within the record
                 let subject = record_obj.get("subject").unwrap().as_object().unwrap();
-                assert_eq!(subject.get("cid").unwrap(), &serde_json::json!("bafyreib2pygab7z5l7nkqf6bchcvgt4jwsqiaenpf3sr65lugum2uvzzf4"));
-                assert_eq!(subject.get("uri").unwrap(), &serde_json::json!("at://did:plc:yw65rktdby2chplqdytqzcao/app.bsky.feed.post/3lyildyjxgs2o"));
+                assert_eq!(
+                    subject.get("cid").unwrap(),
+                    &serde_json::json!(
+                        "bafyreib2pygab7z5l7nkqf6bchcvgt4jwsqiaenpf3sr65lugum2uvzzf4"
+                    )
+                );
+                assert_eq!(
+                    subject.get("uri").unwrap(),
+                    &serde_json::json!(
+                        "at://did:plc:yw65rktdby2chplqdytqzcao/app.bsky.feed.post/3lyildyjxgs2o"
+                    )
+                );
             }
             _ => panic!("Expected JetstreamEvent::Commit variant, got {:?}", event),
         }
···
     #[test]
     fn test_parse_commit_update_event() {
         let json_str = r#"{"did":"did:plc:mek6cpladv2xrlu2zdykoxgz","time_us":1757519523286358,"kind":"commit","commit":{"rev":"3lyilmalk762z","operation":"update","collection":"app.bsky.actor.profile","rkey":"self","record":{"$type":"app.bsky.actor.profile","avatar":{"$type":"blob","ref":{"$link":"bafkreibmn7xi5iwugioov463wux62dg4m4w6qqrbsnileaobrzgxdwbsqy"},"mimeType":"image/jpeg","size":289838},"banner":{"$type":"blob","ref":{"$link":"bafkreicjgdlfs6fyyddjklfzrf6w2boychodkdebtjaiwavhcffjtuavsi"},"mimeType":"image/jpeg","size":676693},"description":"ela/dela | parte da fauna fantástica do céu azul | praticamente inofensiva","displayName":"la mucura mística","pinnedPost":{"cid":"bafyreihn2t4efvipbcignd6rlybmoecb7hx4jgntsojhpibjzxno3zhbuq","uri":"at://did:plc:mek6cpladv2xrlu2zdykoxgz/app.bsky.feed.post/3lxarfbd4ts2j"}},"cid":"bafyreifpmgw3podvvm4raq6zewn6jhoa73t7mlgf3f7hty2adb6f2ga7j4"}}"#;
-        
+
         let event = serde_json::from_str::<JetstreamEvent>(json_str)
             .expect("Failed to parse commit update event JSON");
-        
+
         match event {
-            JetstreamEvent::Commit { did, time_us, kind, commit } => {
+            JetstreamEvent::Commit {
+                did,
+                time_us,
+                kind,
+                commit,
+            } => {
                 assert_eq!(did, "did:plc:mek6cpladv2xrlu2zdykoxgz");
                 assert_eq!(time_us, 1757519523286358);
                 assert_eq!(kind, "commit");
-                
+
                 // Verify the commit operation details
                 assert_eq!(commit.rev, "3lyilmalk762z");
                 assert_eq!(commit.operation, "update");
                 assert_eq!(commit.collection, "app.bsky.actor.profile");
                 assert_eq!(commit.rkey, "self");
-                assert_eq!(commit.cid, "bafyreifpmgw3podvvm4raq6zewn6jhoa73t7mlgf3f7hty2adb6f2ga7j4");
-                
+                assert_eq!(
+                    commit.cid,
+                    "bafyreifpmgw3podvvm4raq6zewn6jhoa73t7mlgf3f7hty2adb6f2ga7j4"
+                );
+
                 // Verify the record data structure
                 assert!(commit.record.is_object());
                 let record_obj = commit.record.as_object().unwrap();
-                assert_eq!(record_obj.get("$type").unwrap(), &serde_json::json!("app.bsky.actor.profile"));
-                assert_eq!(record_obj.get("description").unwrap(), &serde_json::json!("ela/dela | parte da fauna fantástica do céu azul | praticamente inofensiva"));
-                assert_eq!(record_obj.get("displayName").unwrap(), &serde_json::json!("la mucura mística"));
-                
+                assert_eq!(
+                    record_obj.get("$type").unwrap(),
+                    &serde_json::json!("app.bsky.actor.profile")
+                );
+                assert_eq!(
+                    record_obj.get("description").unwrap(),
+                    &serde_json::json!(
+                        "ela/dela | parte da fauna fantástica do céu azul | praticamente inofensiva"
+                    )
+                );
+                assert_eq!(
+                    record_obj.get("displayName").unwrap(),
+                    &serde_json::json!("la mucura mística")
+                );
+
                 // Verify avatar blob
                 let avatar = record_obj.get("avatar").unwrap().as_object().unwrap();
                 assert_eq!(avatar.get("$type").unwrap(), &serde_json::json!("blob"));
-                assert_eq!(avatar.get("mimeType").unwrap(), &serde_json::json!("image/jpeg"));
+                assert_eq!(
+                    avatar.get("mimeType").unwrap(),
+                    &serde_json::json!("image/jpeg")
+                );
                 assert_eq!(avatar.get("size").unwrap(), &serde_json::json!(289838));
-                
+
                 // Verify banner blob
                 let banner = record_obj.get("banner").unwrap().as_object().unwrap();
                 assert_eq!(banner.get("$type").unwrap(), &serde_json::json!("blob"));
-                assert_eq!(banner.get("mimeType").unwrap(), &serde_json::json!("image/jpeg"));
+                assert_eq!(
+                    banner.get("mimeType").unwrap(),
+                    &serde_json::json!("image/jpeg")
+                );
                 assert_eq!(banner.get("size").unwrap(), &serde_json::json!(676693));
-                
+
                 // Verify pinned post
                 let pinned_post = record_obj.get("pinnedPost").unwrap().as_object().unwrap();
-                assert_eq!(pinned_post.get("cid").unwrap(), &serde_json::json!("bafyreihn2t4efvipbcignd6rlybmoecb7hx4jgntsojhpibjzxno3zhbuq"));
-                assert_eq!(pinned_post.get("uri").unwrap(), &serde_json::json!("at://did:plc:mek6cpladv2xrlu2zdykoxgz/app.bsky.feed.post/3lxarfbd4ts2j"));
+                assert_eq!(
+                    pinned_post.get("cid").unwrap(),
+                    &serde_json::json!(
+                        "bafyreihn2t4efvipbcignd6rlybmoecb7hx4jgntsojhpibjzxno3zhbuq"
+                    )
+                );
+                assert_eq!(
+                    pinned_post.get("uri").unwrap(),
+                    &serde_json::json!(
+                        "at://did:plc:mek6cpladv2xrlu2zdykoxgz/app.bsky.feed.post/3lxarfbd4ts2j"
+                    )
+                );
             }
             _ => panic!("Expected JetstreamEvent::Commit variant, got {:?}", event),
         }

crates/atproto-oauth-aip/src/workflow.rs

···
 //! and protocol violations.
 
 use anyhow::Result;
-use atproto_oauth::workflow::{OAuthRequest, OAuthRequestState, ParResponse, TokenResponse};
+use atproto_oauth::{
+    jwk::WrappedJsonWebKey,
+    workflow::{OAuthRequest, OAuthRequestState, ParResponse, TokenResponse},
+};
 use serde::Deserialize;
 
 use crate::errors::OAuthWorkflowError;
···
     #[cfg_attr(feature = "zeroize", zeroize(skip))]
     pub pds_endpoint: String,
 
+    /// The DPoP (Demonstration of Proof-of-Possession) key in string serialized format.
+    #[cfg_attr(feature = "zeroize", zeroize(skip))]
+    pub dpop_key: Option<String>,
+
     /// The DPoP (Demonstration of Proof-of-Possession) key in JWK format.
     #[cfg_attr(feature = "zeroize", zeroize(skip))]
-    pub dpop_key: String,
+    pub dpop_jwk: Option<WrappedJsonWebKey>,
 
     /// Unix timestamp indicating when this session expires.
     #[cfg_attr(feature = "zeroize", zeroize(skip))]
···
 #[cfg_attr(feature = "zeroize", derive(Zeroize, ZeroizeOnDrop))]
 #[serde(untagged)]
 enum WrappedATProtocolSession {
-    ATProtocolSession(ATProtocolSession),
+    ATProtocolSession(Box<ATProtocolSession>),
 
     #[cfg_attr(feature = "zeroize", zeroize(skip))]
     Error {
···
         .map_err(OAuthWorkflowError::SessionResponseParseFailed)?;
 
     match response {
-        WrappedATProtocolSession::ATProtocolSession(ref value) => Ok(value.clone()),
+        WrappedATProtocolSession::ATProtocolSession(ref value) => Ok(*value.clone()),
         WrappedATProtocolSession::Error {
             ref error,
             ref error_description,

crates/atproto-oauth/src/lib.rs

···
 pub mod pkce;
 /// OAuth resource and authorization server management.
 pub mod resources;
+/// OAuth 2.0 scope definitions and parsing for AT Protocol.
+pub mod scopes;
 /// OAuth request storage abstraction for CRUD operations.
 pub mod storage;
 /// LRU-based implementation of OAuth request storage (requires `lru` feature).
···
 pub mod storage_lru;
 /// OAuth workflow implementation for AT Protocol authorization flows.
 pub mod workflow;
-/// OAuth 2.0 scope definitions and parsing for AT Protocol.
-pub mod scopes;

crates/atproto-oauth/src/scopes.rs

···
         }
 
         let mut scopes = Vec::new();
-        for scope_str in s.trim().split_whitespace() {
+        for scope_str in s.split_whitespace() {
             scopes.push(Self::parse(scope_str)?);
         }
 
···
         let mut suffix = None;
 
         for prefix in &prefixes {
-            if s.starts_with(prefix) {
-                let remainder = &s[prefix.len()..];
-                if remainder.is_empty() || remainder.starts_with(':') || remainder.starts_with('?')
-                {
-                    found_prefix = Some(*prefix);
-                    if remainder.starts_with(':') {
-                        suffix = Some(&remainder[1..]);
-                    } else if remainder.starts_with('?') {
-                        suffix = Some(remainder);
-                    } else {
-                        suffix = None;
-                    }
-                    break;
+            if let Some(remainder) = s.strip_prefix(prefix)
+                && (remainder.is_empty()
+                    || remainder.starts_with(':')
+                    || remainder.starts_with('?'))
+            {
+                found_prefix = Some(*prefix);
+                if let Some(stripped) = remainder.strip_prefix(':') {
+                    suffix = Some(stripped);
+                } else if remainder.starts_with('?') {
+                    suffix = Some(remainder);
+                } else {
+                    suffix = None;
                 }
+                break;
             }
         }
 
···
             (_, Scope::Email) => false,
             (Scope::Account(a), Scope::Account(b)) => {
                 a.resource == b.resource
-                    && match (a.action, b.action) {
-                        (AccountAction::Manage, _) => true,
-                        (AccountAction::Read, AccountAction::Read) => true,
-                        _ => false,
-                    }
+                    && matches!(
+                        (a.action, b.action),
+                        (AccountAction::Manage, _) | (AccountAction::Read, AccountAction::Read)
+                    )
             }
-            (Scope::Identity(a), Scope::Identity(b)) => match (a, b) {
-                (IdentityScope::All, _) => true,
-                (IdentityScope::Handle, IdentityScope::Handle) => true,
-                _ => false,
-            },
+            (Scope::Identity(a), Scope::Identity(b)) => matches!(
+                (a, b),
+                (IdentityScope::All, _) | (IdentityScope::Handle, IdentityScope::Handle)
+            ),
             (Scope::Blob(a), Scope::Blob(b)) => {
                 for b_pattern in &b.accept {
                     let mut granted = false;
···
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s == "*/*" {
             Ok(MimePattern::All)
-        } else if s.ends_with("/*") {
-            Ok(MimePattern::TypeWildcard(s[..s.len() - 2].to_string()))
+        } else if let Some(stripped) = s.strip_suffix("/*") {
+            Ok(MimePattern::TypeWildcard(stripped.to_string()))
         } else if s.contains('/') {
             Ok(MimePattern::Exact(s.to_string()))
         } else {