cargo fmt

src/auth.rs

···
 //! Authentication primitives.
 
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use atrium_crypto::{
     keypair::{Did, Secp256k1Keypair},
     verify::Verifier,
···
 use axum::{extract::FromRequestParts, http::StatusCode};
 use base64::Engine;
 
-use crate::{auth, error::ErrorMessage, AppState, Error};
+use crate::{AppState, Error, auth, error::ErrorMessage};
 
 /// This is an axum request extractor that represents an authenticated user.
 ///
···
                 return Err(Error::with_status(
                     StatusCode::UNAUTHORIZED,
                     anyhow!("no bearer token"),
-                ))
+                ));
             }
         };
 

src/did.rs

···
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use atrium_api::types::string::Did;
 use serde::{Deserialize, Serialize};
 use url::Url;

src/endpoints/identity.rs

···
 use std::collections::HashMap;
 
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use atrium_api::{
     com::atproto::identity,
     types::string::{Datetime, Handle},
···
 use atrium_crypto::keypair::Did;
 use atrium_repo::blockstore::{AsyncBlockStoreWrite, CarStore, DAG_CBOR, SHA2_256};
 use axum::{
+    Json, Router,
     extract::{Query, State},
     http::StatusCode,
     routing::{get, post},
-    Json, Router,
 };
 use constcat::concat;
 
 use crate::{
+    AppState, Client, Db, Error, Result, RotationKey, SigningKey,
     auth::AuthenticatedUser,
     config::AppConfig,
     did,
     firehose::FirehoseProducer,
     plc::{self, PlcOperation, PlcService},
-    AppState, Client, Db, Error, Result, RotationKey, SigningKey,
 };
 
 async fn resolve_handle(
···
     todo!()
 }
 
-#[expect(clippy::too_many_arguments, reason = "Many parameters are required for this endpoint")]
+#[expect(
+    clippy::too_many_arguments,
+    reason = "Many parameters are required for this endpoint"
+)]
 async fn update_handle(
     user: AuthenticatedUser,
     State(skey): State<SigningKey>,

src/endpoints/mod.rs

···
-use axum::{routing::get, Json, Router};
+use axum::{Json, Router, routing::get};
 use serde_json::json;
 
 use crate::{AppState, Result};

src/endpoints/repo.rs

···
 use std::{collections::HashSet, str::FromStr};
 
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use atrium_api::{
     com::atproto::repo::{self, defs::CommitMetaData},
     types::{
-        string::{AtIdentifier, Nsid, Tid},
         LimitedU32, Object, TryFromUnknown, TryIntoUnknown, Unknown,
+        string::{AtIdentifier, Nsid, Tid},
     },
 };
-use atrium_repo::{blockstore::CarStore, Cid};
+use atrium_repo::{Cid, blockstore::CarStore};
 use axum::{
+    Json, Router,
     body::Body,
     extract::{Query, Request, State},
     http::{self, StatusCode},
     routing::{get, post},
-    Json, Router,
 };
 use constcat::concat;
 use futures::TryStreamExt;
···
 use tokio::io::AsyncWriteExt;
 
 use crate::{
+    AppState, Db, Error, Result, SigningKey,
     auth::AuthenticatedUser,
     config::AppConfig,
     firehose::{self, FirehoseProducer, RepoOp},
     metrics::{REPO_COMMITS, REPO_OP_CREATE, REPO_OP_DELETE, REPO_OP_UPDATE},
-    storage, AppState, Db, Error, Result, SigningKey,
+    storage,
 };
 
 /// IPLD CID raw binary

src/endpoints/server.rs

···
 use std::{collections::HashMap, str::FromStr};
 
-use anyhow::{anyhow, Context};
-use argon2::{password_hash::SaltString, Argon2, PasswordHash, PasswordHasher, PasswordVerifier};
+use anyhow::{Context, anyhow};
+use argon2::{Argon2, PasswordHash, PasswordHasher, PasswordVerifier, password_hash::SaltString};
 use atrium_api::{
     com::atproto::server,
     types::string::{Datetime, Did, Handle, Tid},
 };
 use atrium_crypto::keypair::Did as _;
 use atrium_repo::{
-    blockstore::{AsyncBlockStoreWrite, CarStore, DAG_CBOR, SHA2_256},
     Cid, Repository,
+    blockstore::{AsyncBlockStoreWrite, CarStore, DAG_CBOR, SHA2_256},
 };
 use axum::{
+    Json, Router,
     extract::{Query, Request, State},
     http::StatusCode,
     routing::{get, post},
-    Json, Router,
 };
 use constcat::concat;
 use metrics::counter;
···
 use uuid::Uuid;
 
 use crate::{
+    AppState, Client, Db, Error, Result, RotationKey, SigningKey,
     auth::{self, AuthenticatedUser},
     config::AppConfig,
     firehose::{Commit, FirehoseProducer},
     metrics::AUTH_FAILED,
     plc::{self, PlcOperation, PlcService},
-    AppState, Client, Db, Error, Result, RotationKey, SigningKey,
 };
 
 /// This is a dummy password that can be used in absence of a real password.

src/endpoints/sync.rs

···
 use std::str::FromStr;
 
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use atrium_api::{com::atproto::sync, types::string::Did};
 use atrium_repo::{
-    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite, CarStore, DAG_CBOR, SHA2_256},
     Cid,
+    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite, CarStore, DAG_CBOR, SHA2_256},
 };
 use axum::{
+    Json, Router,
     body::Body,
     extract::{Query, State, WebSocketUpgrade},
     http::{self, Response, StatusCode},
     response::IntoResponse,
     routing::get,
-    Json, Router,
 };
 use constcat::concat;
 use futures::stream::TryStreamExt;
 use tokio_util::io::ReaderStream;
 
 use crate::{
+    AppState, Db, Error, Result,
     config::AppConfig,
     firehose::FirehoseProducer,
     storage::{open_repo_db, open_store},
-    AppState, Db, Error, Result,
 };
 
 async fn get_blob(

src/error.rs

···
 }
 impl std::fmt::Display for ErrorMessage {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, r#"{{"error":"{}","message":"{}"}}"#, self.error, self.message)
+        write!(
+            f,
+            r#"{{"error":"{}","message":"{}"}}"#,
+            self.error, self.message
+        )
     }
 }
 impl ErrorMessage {
···
         }
     }
 
-    pub fn with_message(status: StatusCode, err: impl Into<anyhow::Error>, message: impl Into<ErrorMessage>) -> Self {
+    pub fn with_message(
+        status: StatusCode,
+        err: impl Into<anyhow::Error>,
+        message: impl Into<ErrorMessage>,
+    ) -> Self {
         Self {
             status,
             err: err.into(),

src/firehose.rs

···
 use std::{collections::VecDeque, time::Duration};
 
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use atrium_api::{
     com::atproto::sync::{self},
     types::string::{Datetime, Did},
···
 use axum::extract::ws::{Message, WebSocket};
 use metrics::{counter, gauge};
 use rand::Rng;
-use serde::{ser::SerializeMap, Serialize};
+use serde::{Serialize, ser::SerializeMap};
 use tracing::{debug, error, info, warn};
 
 use crate::{
+    Client,
     config::AppConfig,
     metrics::{FIREHOSE_HISTORY, FIREHOSE_LISTENERS, FIREHOSE_MESSAGES, FIREHOSE_SEQUENCE},
-    Client,
 };
 
 enum FirehoseMessage {
···
     }
 
     pub async fn client_connection(&self, ws: WebSocket, cursor: Option<i64>) {
-        let _ = self.tx.send(FirehoseMessage::Connect(Box::new((ws, cursor)))).await;
+        let _ = self
+            .tx
+            .send(FirehoseMessage::Connect(Box::new((ws, cursor))))
+            .await;
     }
 }
 
···
 
             // Drop the connection.
             let _ = ws.send(Message::binary(frame)).await;
-            bail!("connection dropped: cursor {cursor} is greater than the current sequence number {seq}");
+            bail!(
+                "connection dropped: cursor {cursor} is greater than the current sequence number {seq}"
+            );
         }
 
         for (seq, ty, msg) in history.iter() {

src/main.rs

···
 use atrium_crypto::keypair::{Export, Secp256k1Keypair};
 use auth::AuthenticatedUser;
 use axum::{
+    Router,
     body::Body,
     extract::{FromRef, Request, State},
     http::{self, HeaderMap, Response, StatusCode, Uri},
     response::IntoResponse,
     routing::get,
-    Router,
 };
 use azure_core::credentials::TokenCredential;
 use clap::Parser;
-use clap_verbosity_flag::{log::LevelFilter, InfoLevel, Verbosity};
+use clap_verbosity_flag::{InfoLevel, Verbosity, log::LevelFilter};
 use config::AppConfig;
-use figment::{providers::Format, Figment};
+use figment::{Figment, providers::Format};
 use firehose::FirehoseProducer;
 use http_cache_reqwest::{CacheMode, HttpCacheOptions, MokaManager};
 use rand::Rng;
 use serde::{Deserialize, Serialize};
-use sqlx::{sqlite::SqliteConnectOptions, SqlitePool};
+use sqlx::{SqlitePool, sqlite::SqliteConnectOptions};
 use tokio::net::TcpListener;
 use tower_http::{cors::CorsLayer, trace::TraceLayer};
 
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use tracing::{info, warn};
 
 mod auth;
···
 /// This will _very likely_ be changed in the future.
 mod actor_endpoints {
     use atrium_api::app::bsky::actor;
-    use axum::{routing::post, Json};
+    use axum::{Json, routing::post};
     use constcat::concat;
 
     use super::*;
···
             return Err(Error::with_status(
                 StatusCode::BAD_REQUEST,
                 anyhow!("could not find resolve service #{id}"),
-            ))
+            ));
         }
     };
 
···
     if config.test {
         warn!("BluePDS starting up in TEST mode.");
         warn!("This means the application will not federate with the rest of the network.");
-        warn!("If you want to turn this off, either set `test` to false in the config or define `BLUEPDS_TEST = false`");
+        warn!(
+            "If you want to turn this off, either set `test` to false in the config or define `BLUEPDS_TEST = false`"
+        );
     }
 
     // Initialize metrics reporting.

src/plc.rs

···
 use std::collections::HashMap;
 
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use base64::Engine;
 use serde::{Deserialize, Serialize};
 use tracing::debug;

src/storage.rs

···
 
 use anyhow::{Context, Result};
 use atrium_repo::{
-    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite, CarStore},
     Cid, Repository,
+    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite, CarStore},
 };
 
-use crate::{config::RepoConfig, Db};
+use crate::{Db, config::RepoConfig};
 
 pub async fn open_store(
     config: &RepoConfig,
···
         .await
         .context("failed to open repository file")?;
 
-    CarStore::open(f)
-        .await
-        .context("failed to open car store")
+    CarStore::open(f).await.context("failed to open car store")
 }
 
 pub async fn open_repo_db(