feature: community.lexicon.calendar.getRSVP

build.rs

···
     println!("cargo:rerun-if-changed=static/.vite/manifest.json");
 
     // Read Vite manifest to get hashed asset filenames
-    let manifest_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("static/.vite/manifest.json");
+    let manifest_path =
+        std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("static/.vite/manifest.json");
 
     let (bundle_js, bundle_css) = if manifest_path.exists() {
-        let manifest_content = std::fs::read_to_string(&manifest_path)
-            .expect("Failed to read Vite manifest");
-        let manifest: serde_json::Value = serde_json::from_str(&manifest_content)
-            .expect("Failed to parse Vite manifest");
+        let manifest_content =
+            std::fs::read_to_string(&manifest_path).expect("Failed to read Vite manifest");
+        let manifest: serde_json::Value =
+            serde_json::from_str(&manifest_content).expect("Failed to parse Vite manifest");
 
         // Extract main entry point
-        let main_entry = manifest.get("src/main.ts")
+        let main_entry = manifest
+            .get("src/main.ts")
             .expect("Missing src/main.ts in manifest");
 
-        let js_file = main_entry.get("file")
+        let js_file = main_entry
+            .get("file")
             .and_then(|v| v.as_str())
             .expect("Missing file in main entry");
 
-        let css_file = main_entry.get("css")
+        let css_file = main_entry
+            .get("css")
             .and_then(|v| v.as_array())
             .and_then(|arr| arr.first())
             .and_then(|v| v.as_str())

src/atproto/lexicon/lfg.rs

···
         let mut lfg = create_test_lfg();
         lfg.tags = vec![];
         assert!(lfg.validate().is_err());
-        assert_eq!(
-            lfg.validate().unwrap_err(),
-            "At least one tag is required"
-        );
+        assert_eq!(lfg.validate().unwrap_err(), "At least one tag is required");
     }
 
     #[test]

src/atproto/utils.rs

···
 #[cfg(test)]
 mod tests {
     use super::*;
-    use atproto_record::lexicon::app::bsky::richtext::facet::{ByteSlice, Facet, Link, Mention, Tag};
+    use atproto_record::lexicon::app::bsky::richtext::facet::{
+        ByteSlice, Facet, Link, Mention, Tag,
+    };
     use std::collections::HashMap;
 
     #[test]

src/bin/smokesignal.rs

···
 };
 use atproto_oauth_axum::state::OAuthClientConfig;
 use smokesignal::processor::ContentFetcher;
+use smokesignal::service::{ServiceDID, ServiceKey, build_service_document};
+use smokesignal::storage::content::{CachedContentStorage, ContentStorage, FilesystemStorage};
 use smokesignal::tap_processor::TapProcessor;
 use smokesignal::task_search_indexer::SearchIndexer;
-use tokio_util::sync::CancellationToken;
-use smokesignal::service::{ServiceDID, ServiceKey, build_service_document};
-use smokesignal::storage::content::{CachedContentStorage, ContentStorage, FilesystemStorage};
 use smokesignal::{
     http::{
         context::{AppEngine, WebContext},
···
         cache::create_cache_pool,
     },
 };
+use tokio_util::sync::CancellationToken;
 
 use chrono::Duration;
 use smokesignal::config::OAuthBackendConfig;
···
 
         // Create search indexer if enabled
         let search_indexer = if config.enable_opensearch && config.enable_task_opensearch {
-            let opensearch_endpoint = config.opensearch_endpoint.as_ref().expect(
-                "OPENSEARCH_ENDPOINT is required when search indexing is enabled",
-            );
+            let opensearch_endpoint = config
+                .opensearch_endpoint
+                .as_ref()
+                .expect("OPENSEARCH_ENDPOINT is required when search indexing is enabled");
 
             match SearchIndexer::new(
                 opensearch_endpoint,

src/facets.rs

···
             Facet {
                 index: ByteSlice {
                     byte_start: 291, // Should be 290
-                    byte_end: 324,   // Should be 323 - but 324 > text.len() so this facet is SKIPPED
+                    byte_end: 324, // Should be 323 - but 324 > text.len() so this facet is SKIPPED
                 },
                 features: vec![FacetFeature::Link(Link {
                     uri: "https://atprotocalls.leaflet.pub/".to_string(),

src/http/acceptance_operations.rs

···
 
     match put_result {
         PutRecordResponse::StrongRef { uri, .. } => Ok((uri, is_update)),
-        PutRecordResponse::Error(err) => {
-            Err(AcceptanceError::PutRecordFailed(err.error_message().to_string()))
-        }
+        PutRecordResponse::Error(err) => Err(AcceptanceError::PutRecordFailed(
+            err.error_message().to_string(),
+        )),
     }
 }
 
···
 
             Ok(())
         }
-        atproto_client::com::atproto::repo::DeleteRecordResponse::Error(err) => {
-            Err(AcceptanceError::DeleteRecordFailed(
-                err.error_message().to_string(),
-            ))
-        }
+        atproto_client::com::atproto::repo::DeleteRecordResponse::Error(err) => Err(
+            AcceptanceError::DeleteRecordFailed(err.error_message().to_string()),
+        ),
     }
 }
 

src/http/auth_utils.rs

···
     let mut conn = match web_context.cache_pool.get().await {
         Ok(conn) => conn,
         Err(e) => {
-            tracing::debug!(?e, "Failed to get Redis connection for AIP session cache write");
+            tracing::debug!(
+                ?e,
+                "Failed to get Redis connection for AIP session cache write"
+            );
             return;
         }
     };

src/http/errors/mod.rs

···
 pub mod import_error;
 pub mod lfg_error;
 pub mod login_error;
-pub mod profile_import_error;
 pub mod middleware_errors;
+pub mod profile_import_error;
 pub mod url_error;
 pub mod view_event_error;
 pub mod web_error;
···
 pub(crate) use import_error::ImportError;
 pub(crate) use lfg_error::LfgError;
 pub(crate) use login_error::LoginError;
-pub(crate) use profile_import_error::ProfileImportError;
 pub(crate) use middleware_errors::WebSessionError;
+pub(crate) use profile_import_error::ProfileImportError;
 pub(crate) use url_error::UrlError;
 pub(crate) use view_event_error::ViewEventError;
 pub(crate) use web_error::WebError;

src/http/errors/web_error.rs

···
     /// The contained string is the destination URL to redirect to after re-authentication.
     ///
     /// **Error Code:** `error-smokesignal-web-3`
-    #[error("error-smokesignal-web-3 Session expired, re-authentication required (destination: {0})")]
+    #[error(
+        "error-smokesignal-web-3 Session expired, re-authentication required (destination: {0})"
+    )]
     SessionStale(String),
 
     /// An internal server error occurred.

src/http/event_validation.rs

···
 use thiserror::Error;
 
 use atproto_identity::resolve::IdentityResolver;
+use atproto_record::lexicon::TypedBlob;
 use atproto_record::lexicon::app::bsky::richtext::facet::Facet;
 use atproto_record::lexicon::community::lexicon::calendar::event::{
     AspectRatio, EventLink, Media, Mode, Status, TypedEventLink,
 };
 use atproto_record::lexicon::community::lexicon::location::{Address, Geo, LocationOrRef};
-use atproto_record::lexicon::TypedBlob;
 use atproto_record::typed::TypedLexicon;
 
 use crate::atproto::utils::{location_from_address, location_from_geo};

src/http/event_view.rs

···
             .collect();
 
         // Collect structured link URIs for deduplication
-        let structured_link_uris: HashSet<&str> =
-            structured_links.iter().map(|(uri, _)| uri.as_str()).collect();
+        let structured_link_uris: HashSet<&str> = structured_links
+            .iter()
+            .map(|(uri, _)| uri.as_str())
+            .collect();
 
         // Extract facets from the event record and render HTML description
         let (description_html, description_links, description_tags) = if let Some(desc_text) =
···
             header: header_image.clone(),
             header_cid: header_image.map(|(cid, _)| cid),
             thumbnail_cid: find_thumbnail(event).map(|(cid, _)| cid),
-            thumbnail_alt: find_thumbnail(event).and_then(|(_, alt)| if alt.is_empty() { None } else { Some(alt) }),
+            thumbnail_alt: find_thumbnail(event)
+                .and_then(|(_, alt)| if alt.is_empty() { None } else { Some(alt) }),
             require_confirmed_email: event.require_confirmed_email,
             disable_direct_rsvp: event.disable_direct_rsvp,
             rsvp_redirect_url: event.rsvp_redirect_url.clone(),

src/http/h3_utils.rs

···
     lon: f64,
     resolution: Resolution,
 ) -> Result<String, String> {
-    let coord =
-        LatLng::new(lat, lon).map_err(|e| format!("Invalid coordinates: {}", e))?;
+    let coord = LatLng::new(lat, lon).map_err(|e| format!("Invalid coordinates: {}", e))?;
     let cell = coord.to_cell(resolution);
     Ok(cell.to_string())
 }
···
 
     if current_resolution > target_resolution {
         // Cell is at finer resolution, get parent at target resolution
-        cell.parent(target_resolution)
-            .ok_or_else(|| format!("Failed to get parent cell at resolution {:?}", target_resolution))
+        cell.parent(target_resolution).ok_or_else(|| {
+            format!(
+                "Failed to get parent cell at resolution {:?}",
+                target_resolution
+            )
+        })
     } else {
         // Cell is already at or coarser than target resolution
         Ok(cell)
···
 
         // The normalized cell should contain the original cell's location
         let (lat, lon) = h3_to_lat_lon(&h3_res7).unwrap();
-        let expected_parent =
-            lat_lon_to_h3_with_resolution(lat, lon, Resolution::Six).unwrap();
+        let expected_parent = lat_lon_to_h3_with_resolution(lat, lon, Resolution::Six).unwrap();
         assert_eq!(normalized.to_string(), expected_parent);
     }
 

src/http/handle_accept_rsvp.rs

···
             format_error_html, format_success_html, send_acceptance_email_notification,
             verify_event_organizer_authorization,
         },
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
-        errors::{acceptance_error::AcceptanceError, WebError},
+        errors::{WebError, acceptance_error::AcceptanceError},
         middleware_auth::Auth,
         middleware_i18n::Language,
     },

src/http/handle_admin_event_index.rs

···
         params.push(("query", q.clone()));
     }
 
-    let params_refs: Vec<(&str, &str)> = params
-        .iter()
-        .map(|(k, v)| (*k, v.as_str()))
-        .collect();
+    let params_refs: Vec<(&str, &str)> = params.iter().map(|(k, v)| (*k, v.as_str())).collect();
 
     let pagination_view = PaginationView::new(page_size, events.len() as i64, page, params_refs);
 
···
         }
     };
 
-    tracing::info!("Event search index rebuilt: {} events indexed", indexed_count);
+    tracing::info!(
+        "Event search index rebuilt: {} events indexed",
+        indexed_count
+    );
 
     Ok(Redirect::to("/admin/search-index/events").into_response())
 }

src/http/handle_admin_import_event.rs

···
 
 use crate::{
     http::{
-        context::AdminRequestContext, errors::WebError,
+        context::AdminRequestContext,
+        errors::WebError,
         import_utils::{import_event_records, import_from_aturi},
     },
     storage::identity_profile::handle_warm_up,

src/http/handle_admin_profile_index.rs

···
         "https://{}/admin/search-index/profiles",
         admin_ctx.web_context.config.external_base
     );
-    let default_context = admin_template_context(&admin_ctx, &canonical_url, "search-index-profiles");
+    let default_context =
+        admin_template_context(&admin_ctx, &canonical_url, "search-index-profiles");
 
     let render_template = select_template!("admin_profile_index", false, false, admin_ctx.language);
     let error_template = select_template!(false, false, admin_ctx.language);
···
         params.push(("query", q.clone()));
     }
 
-    let params_refs: Vec<(&str, &str)> = params
-        .iter()
-        .map(|(k, v)| (*k, v.as_str()))
-        .collect();
+    let params_refs: Vec<(&str, &str)> = params.iter().map(|(k, v)| (*k, v.as_str())).collect();
 
     let pagination_view = PaginationView::new(page_size, profiles.len() as i64, page, params_refs);
 
···
         }
     };
 
-    tracing::info!("Profile search index rebuilt: {} profiles indexed", indexed_count);
+    tracing::info!(
+        "Profile search index rebuilt: {} profiles indexed",
+        indexed_count
+    );
 
     Ok(Redirect::to("/admin/search-index/profiles").into_response())
 }

src/http/handle_blob.rs

···
     config::OAuthBackendConfig,
     contextual_error,
     http::{
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
-        errors::{blob_error::BlobError, CommonError, WebError},
+        errors::{CommonError, WebError, blob_error::BlobError},
         middleware_auth::Auth,
         middleware_i18n::Language,
     },
···
     let put_record_url = format!("{}/xrpc/com.atproto.repo.putRecord", pds_endpoint);
     let record_value = serde_json::to_value(&put_record_request)
         .map_err(|e| BlobError::PutRecordSerializeFailed(e.to_string()))?;
-    let response = match post_dpop_json(&web_context.http_client, &dpop_auth, &put_record_url, record_value).await {
+    let response = match post_dpop_json(
+        &web_context.http_client,
+        &dpop_auth,
+        &put_record_url,
+        record_value,
+    )
+    .await
+    {
         Ok(response) => response,
         Err(e) => {
             let err_string = e.to_string();
             if err_string.contains("InvalidSwap") {
                 let default_context = minijinja::context! { language => language.to_string(), current_handle => current_handle.clone() };
-                return contextual_error!(web_context, language, error_template, default_context, CommonError::InvalidSwap, StatusCode::CONFLICT);
+                return contextual_error!(
+                    web_context,
+                    language,
+                    error_template,
+                    default_context,
+                    CommonError::InvalidSwap,
+                    StatusCode::CONFLICT
+                );
             }
             return Err(BlobError::PutRecordFailed(e.to_string()).into());
         }
···
     let put_record_url = format!("{}/xrpc/com.atproto.repo.putRecord", pds_endpoint);
     let record_value = serde_json::to_value(&put_record_request)
         .map_err(|e| BlobError::PutRecordSerializeFailed(e.to_string()))?;
-    let response = match post_dpop_json(&web_context.http_client, &dpop_auth, &put_record_url, record_value).await {
+    let response = match post_dpop_json(
+        &web_context.http_client,
+        &dpop_auth,
+        &put_record_url,
+        record_value,
+    )
+    .await
+    {
         Ok(response) => response,
         Err(e) => {
             let err_string = e.to_string();
             if err_string.contains("InvalidSwap") {
                 let default_context = minijinja::context! { language => language.to_string(), current_handle => current_handle.clone() };
-                return contextual_error!(web_context, language, error_template, default_context, CommonError::InvalidSwap, StatusCode::CONFLICT);
+                return contextual_error!(
+                    web_context,
+                    language,
+                    error_template,
+                    default_context,
+                    CommonError::InvalidSwap,
+                    StatusCode::CONFLICT
+                );
             }
             return Err(BlobError::PutRecordFailed(e.to_string()).into());
         }
···
     let put_record_url = format!("{}/xrpc/com.atproto.repo.putRecord", pds_endpoint);
     let record_value = serde_json::to_value(&put_record_request)
         .map_err(|e| BlobError::PutRecordSerializeFailed(e.to_string()))?;
-    let response = match post_dpop_json(&web_context.http_client, &dpop_auth, &put_record_url, record_value).await {
+    let response = match post_dpop_json(
+        &web_context.http_client,
+        &dpop_auth,
+        &put_record_url,
+        record_value,
+    )
+    .await
+    {
         Ok(response) => response,
         Err(e) => {
             let err_string = e.to_string();
             if err_string.contains("InvalidSwap") {
                 let default_context = minijinja::context! { language => language.to_string(), current_handle => current_handle.clone() };
-                return contextual_error!(web_context, language, error_template, default_context, CommonError::InvalidSwap, StatusCode::CONFLICT);
+                return contextual_error!(
+                    web_context,
+                    language,
+                    error_template,
+                    default_context,
+                    CommonError::InvalidSwap,
+                    StatusCode::CONFLICT
+                );
             }
             return Err(BlobError::PutRecordFailed(e.to_string()).into());
         }

src/http/handle_bulk_accept_rsvps.rs

···
             format_error_html, format_success_html, send_acceptance_email_notification,
             verify_event_organizer_authorization,
         },
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
         errors::WebError,
         middleware_auth::Auth,
···
         verify_event_organizer_authorization(web_context, &rsvp.event_aturi, current_did).await?;
 
     // Check AIP session validity before attempting AT Protocol operation
-    if let AipSessionStatus::Stale = require_valid_aip_session(web_context, auth).await.map_err(|e| anyhow::anyhow!("{}", e))? {
+    if let AipSessionStatus::Stale = require_valid_aip_session(web_context, auth)
+        .await
+        .map_err(|e| anyhow::anyhow!("{}", e))?
+    {
         return Err(anyhow::anyhow!("Session expired, please log in again"));
     }
 

src/http/handle_create_event.rs

···
     create_dpop_auth_from_aip_session, create_dpop_auth_from_oauth_session,
 };
 use crate::config::OAuthBackendConfig;
-use crate::http::auth_utils::{require_valid_aip_session, AipSessionStatus};
+use crate::http::auth_utils::{AipSessionStatus, require_valid_aip_session};
 use crate::http::context::WebContext;
 use crate::http::errors::CommonError;
 use crate::http::errors::WebError;
···
         query.starts_at.clone()
     } else {
         let now = Utc::now();
-        let parsed_tz = default_tz.parse::<chrono_tz::Tz>().unwrap_or(chrono_tz::UTC);
+        let parsed_tz = default_tz
+            .parse::<chrono_tz::Tz>()
+            .unwrap_or(chrono_tz::UTC);
         let local_date = now.with_timezone(&parsed_tz).date_naive();
 
         local_date
···
             create_dpop_auth_from_oauth_session(session)?
         }
         (Auth::Aip { access_token, .. }, OAuthBackendConfig::AIP { hostname, .. }) => {
-            create_dpop_auth_from_aip_session(
-                &web_context.http_client,
-                hostname,
-                access_token,
-            )
-            .await?
+            create_dpop_auth_from_aip_session(&web_context.http_client, hostname, access_token)
+                .await?
         }
         _ => return Err(CommonError::NotAuthorized.into()),
     };
···
                 StatusCode::INTERNAL_SERVER_ERROR,
                 Json(json!({
                     "error": err.error_message()
-                }))
-            ).into_response());
+                })),
+            )
+                .into_response());
         }
         Err(err) => {
             return Ok((
                 StatusCode::INTERNAL_SERVER_ERROR,
                 Json(json!({
                     "error": err.to_string()
-                }))
-            ).into_response());
+                })),
+            )
+                .into_response());
         }
     };
 
···
             StatusCode::INTERNAL_SERVER_ERROR,
             Json(json!({
                 "error": err.to_string()
-            }))
-        ).into_response());
+            })),
+        )
+            .into_response());
     }
 
     // Download and store header image from PDS if one was uploaded
···
             "uri": create_record_response.uri,
             "cid": create_record_response.cid,
             "url": event_url
-        }))
-    ).into_response())
+        })),
+    )
+        .into_response())
 }

src/http/handle_create_rsvp.rs

···
 use crate::{
     contextual_error,
     http::{
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
         errors::{CommonError, CreateRsvpError, WebError},
         middleware_auth::Auth,
···
                 let now = Utc::now();
 
                 // Check AIP session validity before attempting AT Protocol operation
-                if let AipSessionStatus::Stale = require_valid_aip_session(&web_context, &auth).await? {
+                if let AipSessionStatus::Stale =
+                    require_valid_aip_session(&web_context, &auth).await?
+                {
                     return Err(WebError::SessionStale("/rsvp".to_string()));
                 }
 

src/http/handle_delete_event.rs

···
     config::OAuthBackendConfig,
     contextual_error,
     http::{
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::UserRequestContext,
         errors::{DeleteEventError, WebError},
         middleware_auth::Auth,
···
     // If form is submitted with confirmation or it's a non-HTMX POST, proceed with deletion
     if form.confirm.as_deref() == Some("true") {
         // Check AIP session validity before attempting AT Protocol operation
-        if let AipSessionStatus::Stale = require_valid_aip_session(&ctx.web_context, &ctx.auth).await? {
+        if let AipSessionStatus::Stale =
+            require_valid_aip_session(&ctx.web_context, &ctx.auth).await?
+        {
             return Err(WebError::SessionStale("/".to_string()));
         }
 

src/http/handle_edit_event.rs

···
 use crate::atproto::auth::{
     create_dpop_auth_from_aip_session, create_dpop_auth_from_oauth_session,
 };
-use crate::http::auth_utils::{require_valid_aip_session, AipSessionStatus};
+use crate::http::auth_utils::{AipSessionStatus, require_valid_aip_session};
 use crate::http::context::UserRequestContext;
 use crate::http::errors::{CommonError, WebError};
 use crate::http::event_form::ManageEvent;
···
     if profile.did != current_handle.did {
         return Ok((
             StatusCode::FORBIDDEN,
-            Json(json!({"error": "Not authorized"}))
-        ).into_response());
+            Json(json!({"error": "Not authorized"})),
+        )
+            .into_response());
     }
 
     // Get existing event
···
         Err(_) => {
             return Ok((
                 StatusCode::NOT_FOUND,
-                Json(json!({"error": "Event not found"}))
-            ).into_response());
+                Json(json!({"error": "Event not found"})),
+            )
+                .into_response());
         }
     };
 
     // Parse existing event record to get created_at
-    let existing_event = match serde_json::from_value::<LexiconCommunityEvent>(event.record.0.clone()) {
-        Ok(evt) => evt,
-        Err(_) => {
-            return Ok((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(json!({"error": "Invalid event format"}))
-            ).into_response());
-        }
-    };
+    let existing_event =
+        match serde_json::from_value::<LexiconCommunityEvent>(event.record.0.clone()) {
+            Ok(evt) => evt,
+            Err(_) => {
+                return Ok((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({"error": "Invalid event format"})),
+                )
+                    .into_response());
+            }
+        };
 
     // Validate and parse the complete request using shared validation
     let facet_limits = crate::facets::FacetLimits {
···
         (Auth::Pds { session, .. }, crate::config::OAuthBackendConfig::ATProtocol { .. }) => {
             create_dpop_auth_from_oauth_session(session)?
         }
-        (Auth::Aip { access_token, .. }, crate::config::OAuthBackendConfig::AIP { hostname, .. }) => {
-            create_dpop_auth_from_aip_session(
-                &ctx.web_context.http_client,
-                hostname,
-                access_token,
-            )
-            .await?
+        (
+            Auth::Aip { access_token, .. },
+            crate::config::OAuthBackendConfig::AIP { hostname, .. },
+        ) => {
+            create_dpop_auth_from_aip_session(&ctx.web_context.http_client, hostname, access_token)
+                .await?
         }
         _ => return Err(CommonError::NotAuthorized.into()),
     };
···
     let the_record = LexiconCommunityEvent {
         name: validated.name.clone(),
         description: validated.description.clone(),
-        created_at: existing_event.created_at,  // Preserve original creation time
+        created_at: existing_event.created_at, // Preserve original creation time
         starts_at: validated.starts_at,
         ends_at: validated.ends_at,
         mode: validated.mode,
···
         uris: validated.uris,
         media: validated.media,
         facets: validated.facets,
-        extra: existing_event.extra.clone(),  // Preserve any extra fields
+        extra: existing_event.extra.clone(), // Preserve any extra fields
     };
 
     // Submit to AT Protocol
···
         Ok(PutRecordResponse::Error(err)) => {
             return Ok((
                 StatusCode::INTERNAL_SERVER_ERROR,
-                Json(json!({"error": err.error_message()}))
-            ).into_response());
+                Json(json!({"error": err.error_message()})),
+            )
+                .into_response());
         }
         Err(err) => {
             return Ok((
                 StatusCode::INTERNAL_SERVER_ERROR,
-                Json(json!({"error": err.to_string()}))
-            ).into_response());
+                Json(json!({"error": err.to_string()})),
+            )
+                .into_response());
         }
     };
 
···
     if let Err(err) = event_update_result {
         return Ok((
             StatusCode::INTERNAL_SERVER_ERROR,
-            Json(json!({"error": err.to_string()}))
-        ).into_response());
+            Json(json!({"error": err.to_string()})),
+        )
+            .into_response());
     }
 
     // Re-index the event in OpenSearch to update locations_geo and other fields
···
             "uri": put_record_response.uri,
             "cid": put_record_response.cid,
             "url": event_url
-        }))
-    ).into_response())
+        })),
+    )
+        .into_response())
 }

src/http/handle_edit_settings.rs

···
     http::errors::{CommonError, WebError},
     select_template,
     storage::{
-        event::{event_get, event_update_with_full_metadata, EventUpdateParams},
+        event::{EventUpdateParams, event_get, event_update_with_full_metadata},
         identity_profile::{handle_for_did, handle_for_handle},
     },
 };

src/http/handle_finalize_acceptance.rs

···
     config::OAuthBackendConfig,
     http::{
         acceptance_utils::format_success_html,
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
-        errors::{acceptance_error::AcceptanceError, WebError},
+        errors::{WebError, acceptance_error::AcceptanceError},
         middleware_auth::Auth,
         middleware_i18n::Language,
     },
···
             acceptance_ticket_delete_by_event_and_rsvp_did, acceptance_ticket_get,
             acceptance_ticket_get_by_event_and_rsvp_did, rsvp_update_validated_at,
         },
-        event::{event_get, rsvp_get_by_event_and_did, rsvp_insert_with_metadata, RsvpInsertParams},
+        event::{
+            RsvpInsertParams, event_get, rsvp_get_by_event_and_did, rsvp_insert_with_metadata,
+        },
     },
 };
 use atproto_client::com::atproto::repo::{PutRecordRequest, PutRecordResponse, put_record};
···
             extra: Default::default(),
         };
 
-        let rsvp_aturi = format!(
-            "at://{}/{}/{}",
-            current_handle.did, RSVP_NSID, record_key
-        );
+        let rsvp_aturi = format!("at://{}/{}/{}", current_handle.did, RSVP_NSID, record_key);
 
         // Convert Rsvp to Value for consistent return type
         let rsvp_value = serde_json::to_value(&new_rsvp)
···
     };
 
     // Parse the RSVP AT-URI to extract the record key
-    let parsed_rsvp_aturi =
-        ATURI::from_str(&rsvp_aturi).map_err(|e| AcceptanceError::InvalidRsvpAtUri(e.to_string()))?;
+    let parsed_rsvp_aturi = ATURI::from_str(&rsvp_aturi)
+        .map_err(|e| AcceptanceError::InvalidRsvpAtUri(e.to_string()))?;
 
     // Update/Create the RSVP in the user's PDS
     let put_record_request = PutRecordRequest {

src/http/handle_index.rs

···
 
 #[derive(Serialize)]
 pub struct DateGroup {
-    pub date: String,           // e.g., "November 10, 2025"
-    pub date_short: String,     // e.g., "Nov 10"
+    pub date: String,       // e.g., "November 10, 2025"
+    pub date_short: String, // e.g., "Nov 10"
     pub event_groups: Vec<EventGroup>,
     pub lfg_groups: Vec<LfgGroup>,
 }
···
     }
 
     // Limit activities to page size + 1
-    let activity_list: Vec<_> = activities
-        .iter()
-        .take(page_size as usize + 1)
-        .collect();
+    let activity_list: Vec<_> = activities.iter().take(page_size as usize + 1).collect();
 
     // Step 1: Group by date, then by event (for events/RSVPs) or by h3_cell (for LFG)
     // Use BTreeMap with Reverse ordering to get newest dates first
-    let mut date_event_groups: BTreeMap<std::cmp::Reverse<chrono::NaiveDate>, HashMap<String, Vec<&crate::storage::event::model::ActivityItem>>> = BTreeMap::new();
-    let mut date_lfg_groups: BTreeMap<std::cmp::Reverse<chrono::NaiveDate>, HashMap<String, Vec<&crate::storage::event::model::ActivityItem>>> = BTreeMap::new();
+    let mut date_event_groups: BTreeMap<
+        std::cmp::Reverse<chrono::NaiveDate>,
+        HashMap<String, Vec<&crate::storage::event::model::ActivityItem>>,
+    > = BTreeMap::new();
+    let mut date_lfg_groups: BTreeMap<
+        std::cmp::Reverse<chrono::NaiveDate>,
+        HashMap<String, Vec<&crate::storage::event::model::ActivityItem>>,
+    > = BTreeMap::new();
 
     for activity in &activity_list {
         let date = activity.discovered_at.date_naive();
···
 
     // Step 3: Build date groups with activities
     // Collect all unique dates from both event and LFG groups
-    let mut all_dates: std::collections::BTreeSet<std::cmp::Reverse<chrono::NaiveDate>> = std::collections::BTreeSet::new();
+    let mut all_dates: std::collections::BTreeSet<std::cmp::Reverse<chrono::NaiveDate>> =
+        std::collections::BTreeSet::new();
     for key in date_event_groups.keys() {
         all_dates.insert(*key);
     }
···
 
                 // Don't show status for grouped RSVPs
                 // Use the newest RSVP's timestamp (created_at if available, else discovered_at)
-                let newest_timestamp = first_activity.created_at.unwrap_or(first_activity.discovered_at);
+                let newest_timestamp = first_activity
+                    .created_at
+                    .unwrap_or(first_activity.discovered_at);
                 activity_displays.push(ActivityDisplay::GroupedRsvp {
                     handles: group_handles,
                     dids,
···
                 // Sort activity displays by timestamp, newest first
                 activity_displays.sort_by(|a, b| {
                     let a_time = match a {
-                        ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                        ActivityDisplay::GroupedRsvp { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
-                        ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                        ActivityDisplay::Individual(view) => {
+                            chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                        }
+                        ActivityDisplay::GroupedRsvp { updated_at, .. } => {
+                            chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                        }
+                        ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                            chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                        }
                     };
                     let b_time = match b {
-                        ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                        ActivityDisplay::GroupedRsvp { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
-                        ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                        ActivityDisplay::Individual(view) => {
+                            chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                        }
+                        ActivityDisplay::GroupedRsvp { updated_at, .. } => {
+                            chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                        }
+                        ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                            chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                        }
                     };
                     b_time.cmp(&a_time) // Descending order: newer timestamps first
                 });
···
         if !event_groups.is_empty() {
             event_groups.sort_by(|a, b| {
                 let a_time = a.activities.first().and_then(|act| match act {
-                    ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                    ActivityDisplay::GroupedRsvp { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
-                    ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                    ActivityDisplay::Individual(view) => {
+                        chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedRsvp { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
                 });
                 let b_time = b.activities.first().and_then(|act| match act {
-                    ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                    ActivityDisplay::GroupedRsvp { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
-                    ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                    ActivityDisplay::Individual(view) => {
+                        chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedRsvp { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
                 });
                 b_time.cmp(&a_time) // Descending order: newer timestamps first
             });
···
                     .collect();
 
                 let first_activity = sorted_activities[0];
-                let newest_timestamp = first_activity.created_at.unwrap_or(first_activity.discovered_at);
+                let newest_timestamp = first_activity
+                    .created_at
+                    .unwrap_or(first_activity.discovered_at);
 
                 lfg_activity_displays.push(ActivityDisplay::GroupedLfg {
                     handles: group_handles,
···
         if !lfg_groups.is_empty() {
             lfg_groups.sort_by(|a, b| {
                 let a_time = a.activities.first().and_then(|act| match act {
-                    ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                    ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                    ActivityDisplay::Individual(view) => {
+                        chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
                     _ => None,
                 });
                 let b_time = b.activities.first().and_then(|act| match act {
-                    ActivityDisplay::Individual(view) => chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok(),
-                    ActivityDisplay::GroupedLfg { updated_at, .. } => chrono::DateTime::parse_from_rfc3339(updated_at).ok(),
+                    ActivityDisplay::Individual(view) => {
+                        chrono::DateTime::parse_from_rfc3339(&view.updated_at).ok()
+                    }
+                    ActivityDisplay::GroupedLfg { updated_at, .. } => {
+                        chrono::DateTime::parse_from_rfc3339(updated_at).ok()
+                    }
                     _ => None,
                 });
                 b_time.cmp(&a_time)
···
         })
         .sum();
 
-    let pagination_view =
-        PaginationView::new(page_size, total_activities as i64, page, params);
+    let pagination_view = PaginationView::new(page_size, total_activities as i64, page, params);
 
     // Truncate if we have more than page_size activities
     if total_activities > page_size as usize {
···
 
     let event_count_formatted = crate::stats::NetworkStats::format_number(stats.event_count);
     let rsvp_count_formatted = crate::stats::NetworkStats::format_number(stats.rsvp_count);
-    let lfg_identities_count_formatted = crate::stats::NetworkStats::format_number(stats.lfg_identities_count);
-    let lfg_locations_count_formatted = crate::stats::NetworkStats::format_number(stats.lfg_locations_count);
+    let lfg_identities_count_formatted =
+        crate::stats::NetworkStats::format_number(stats.lfg_identities_count);
+    let lfg_locations_count_formatted =
+        crate::stats::NetworkStats::format_number(stats.lfg_locations_count);
 
     Ok((
         http::StatusCode::OK,

src/http/handle_lfg.rs

···
 use crate::http::context::WebContext;
 use crate::http::errors::{CommonError, LfgError, WebError};
 use crate::http::event_view::EventView;
-use crate::http::lfg_form::{ALLOWED_DURATIONS, DEFAULT_DURATION_HOURS, MAX_TAGS, MAX_TAG_LENGTH};
+use crate::http::lfg_form::{ALLOWED_DURATIONS, DEFAULT_DURATION_HOURS, MAX_TAG_LENGTH, MAX_TAGS};
 use crate::http::middleware_auth::Auth;
 use crate::http::middleware_i18n::Language;
 use crate::search_index::{GeoCenter, IndexedEvent, IndexedLfgProfile, SearchIndexManager};
 use crate::select_template;
+use crate::storage::StoragePool;
 use crate::storage::atproto_record::atproto_record_upsert;
 use crate::storage::event::event_get;
 use crate::storage::identity_profile::{handle_for_did, handles_by_did};
 use crate::storage::lfg::{lfg_get_active_by_did, lfg_get_all_by_did};
 use crate::storage::profile::profile_get_by_did;
-use crate::storage::StoragePool;
 
 // ============================================================================
 // Request/Response Types
···
         .unwrap_or_default()
 }
 
-
 /// Serializable LFG profile for template display
 #[derive(Debug, Serialize)]
 struct TemplateProfile {
···
 }
 
 /// Enrich LFG profiles with display_name and handle from the database.
-async fn enrich_profiles(pool: &StoragePool, profiles: Vec<IndexedLfgProfile>) -> Vec<TemplateProfile> {
+async fn enrich_profiles(
+    pool: &StoragePool,
+    profiles: Vec<IndexedLfgProfile>,
+) -> Vec<TemplateProfile> {
     let mut enriched = Vec::with_capacity(profiles.len());
 
     for p in profiles {
···
                 .iter()
                 .filter_map(|event| {
                     let organizer = organizer_handles.get(&event.did);
-                    EventView::try_from((
-                        auth.profile(),
-                        organizer,
-                        event,
-                        &facet_limits,
-                    ))
-                    .ok()
+                    EventView::try_from((auth.profile(), organizer, event, &facet_limits)).ok()
                 })
                 .collect();
 
             // Hydrate RSVP counts
-            if let Err(err) = crate::http::event_view::hydrate_event_rsvp_counts(
-                &web_context.pool,
-                &mut events,
-            )
-            .await
+            if let Err(err) =
+                crate::http::event_view::hydrate_event_rsvp_counts(&web_context.pool, &mut events)
+                    .await
             {
                 tracing::warn!("Failed to hydrate event RSVP counts: {}", err);
             }
···
     };
 
     // Store in local database
-    let record_json = serde_json::to_value(&lfg_record).map_err(|e| {
-        LfgError::PdsRecordCreationFailed {
+    let record_json =
+        serde_json::to_value(&lfg_record).map_err(|e| LfgError::PdsRecordCreationFailed {
             message: e.to_string(),
-        }
-    })?;
+        })?;
 
     atproto_record_upsert(
         &web_context.pool,

src/http/handle_location.rs

···
     let search_manager = match SearchIndexManager::new(opensearch_endpoint) {
         Ok(m) => m,
         Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                default_context,
-                err
-            );
+            return contextual_error!(web_context, language, error_template, default_context, err);
         }
     };
 

src/http/handle_location_suggestions.rs

···
 use crate::http::context::WebContext;
 use crate::http::errors::WebError;
 use crate::http::middleware_auth::Auth;
-use crate::storage::atproto_record::{
-    LocationSuggestion, atproto_record_get_location_suggestions,
-};
+use crate::storage::atproto_record::{LocationSuggestion, atproto_record_get_location_suggestions};
 
 /// Response format for location suggestions
 #[derive(Debug, Serialize)]

src/http/handle_manage_event_content.rs

···
                         .into_iter()
                         .filter(|(_, status, validated_at)| {
                             // Check if this RSVP meets any of the display criteria
-                            display_criteria.iter().any(|criterion| match criterion.as_str() {
-                                "going_confirmed" => {
-                                    status == "going" && validated_at.is_some()
-                                }
-                                "going" => status == "going",
-                                "interested" => status == "interested",
-                                _ => false,
-                            })
+                            display_criteria
+                                .iter()
+                                .any(|criterion| match criterion.as_str() {
+                                    "going_confirmed" => {
+                                        status == "going" && validated_at.is_some()
+                                    }
+                                    "going" => status == "going",
+                                    "interested" => status == "interested",
+                                    _ => false,
+                                })
                         })
                         .collect();
 
···
     let private_content_form = crate::http::event_form::PrivateContentFormData {
         private_content: form.private_content.clone(),
         private_content_criteria_going_confirmed: Some(
-            form.private_content_criteria_going_confirmed.unwrap_or(false),
+            form.private_content_criteria_going_confirmed
+                .unwrap_or(false),
         ),
         private_content_criteria_going: Some(form.private_content_criteria_going.unwrap_or(false)),
         private_content_criteria_interested: Some(

src/http/handle_oauth_aip_callback.rs

···
 use std::{collections::HashMap, sync::Arc};
 
 use crate::{
-    atproto::auth::create_dpop_auth_from_aip_session,
-    config::OAuthBackendConfig, contextual_error,
-    facets::FacetLimits,
-    http::handle_email_confirm::send_confirmation_email, select_template,
+    atproto::auth::create_dpop_auth_from_aip_session, config::OAuthBackendConfig, contextual_error,
+    facets::FacetLimits, http::handle_email_confirm::send_confirmation_email, select_template,
     storage::identity_profile::handle_warm_up,
 };
 use anyhow::Result;

src/http/handle_oauth_callback.rs

···
 use minijinja::context as template_context;
 use serde::{Deserialize, Serialize};
 
-use crate::{contextual_error, facets::FacetLimits, select_template, storage::identity_profile::handle_warm_up};
+use crate::{
+    contextual_error, facets::FacetLimits, select_template,
+    storage::identity_profile::handle_warm_up,
+};
 
 use super::{
     context::WebContext,

src/http/handle_preview_description.rs

···
+use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
-use axum::Json;
 use axum_extra::extract::Cached;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
-use crate::facets::{parse_facets_from_text, render_text_with_facets_html, FacetLimits};
+use crate::facets::{FacetLimits, parse_facets_from_text, render_text_with_facets_html};
 use crate::http::context::WebContext;
 use crate::http::errors::WebError;
 use crate::http::middleware_auth::Auth;
···
 
     // Parse facets from the description
     let limits = FacetLimits::default();
-    let facets = parse_facets_from_text(
-        description,
-        web_context.identity_resolver.as_ref(),
-        &limits,
-    )
-    .await;
+    let facets =
+        parse_facets_from_text(description, web_context.identity_resolver.as_ref(), &limits).await;
 
     // Render HTML with facets
     let html = render_text_with_facets_html(description, facets.as_ref(), &limits);

src/http/handle_profile.rs

···
                         };
 
                         // Use created_at if available (from AT Protocol record), otherwise discovered_at
-                        let timestamp = first_activity.created_at.unwrap_or(first_activity.discovered_at);
+                        let timestamp = first_activity
+                            .created_at
+                            .unwrap_or(first_activity.discovered_at);
                         activity_displays.push(ActivityDisplay::GroupedRsvp {
                             handles: group_handles,
                             dids,

src/http/handle_quick_event.rs

···
 use axum_template::RenderHtml;
 use minijinja::context as template_context;
 
-use crate::http::auth_utils::{require_valid_aip_session, AipSessionStatus};
+use crate::http::auth_utils::{AipSessionStatus, require_valid_aip_session};
 use crate::http::context::WebContext;
 use crate::http::errors::WebError;
 use crate::http::middleware_auth::Auth;

src/http/handle_search.rs

···
     profile_index::ProfileIndexManager,
     search_index::SearchIndexManager,
     select_template,
-    storage::{
-        event::event_get,
-        identity_profile::handles_by_did,
-    },
+    storage::{event::event_get, identity_profile::handles_by_did},
 };
 
 #[derive(Debug, Deserialize)]
···
                 language,
                 error_template,
                 default_context,
-                anyhow::anyhow!("error-smokesignal-search-1 Search is not available: Search service is not configured")
+                anyhow::anyhow!(
+                    "error-smokesignal-search-1 Search is not available: Search service is not configured"
+                )
             );
         }
     };
···
     let event_manager = match SearchIndexManager::new(opensearch_endpoint) {
         Ok(m) => m,
         Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                default_context,
-                err
-            );
+            return contextual_error!(web_context, language, error_template, default_context, err);
         }
     };
 
     let profile_manager = match ProfileIndexManager::new(opensearch_endpoint) {
         Ok(m) => m,
         Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                default_context,
-                err
-            );
+            return contextual_error!(web_context, language, error_template, default_context, err);
         }
     };
 
···
                 .iter()
                 .filter_map(|event| {
                     let organizer = organizer_handles.get(&event.did);
-                    EventView::try_from((
-                        auth.profile(),
-                        organizer,
-                        event,
-                        &facet_limits,
-                    ))
-                    .ok()
+                    EventView::try_from((auth.profile(), organizer, event, &facet_limits)).ok()
                 })
                 .collect();
 

src/http/handle_settings.rs

···
 use crate::{
     contextual_error,
     http::{
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
-        context::WebContext, errors::WebError, middleware_auth::Auth, middleware_i18n::Language,
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
+        context::WebContext,
+        errors::WebError,
+        middleware_auth::Auth,
+        middleware_i18n::Language,
         timezones::supported_timezones,
     },
     select_template,

src/http/handle_unaccept_rsvp.rs

···
         acceptance_utils::{
             format_error_html, format_success_html, verify_event_organizer_authorization,
         },
-        auth_utils::{require_valid_aip_session, AipSessionStatus},
+        auth_utils::{AipSessionStatus, require_valid_aip_session},
         context::WebContext,
         errors::WebError,
         middleware_auth::Auth,

src/http/handle_xrpc_get_rsvp.rs

···
+use atproto_record::aturi::ATURI;
+use axum::{
+    extract::{Query, State},
+    response::{IntoResponse, Json},
+};
+use http::StatusCode;
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+
+use crate::http::context::WebContext;
+use crate::storage::event::rsvp_get_by_event_and_did;
+
+#[derive(Debug, Deserialize)]
+pub struct GetRsvpParams {
+    /// AT-URI of the event
+    event: String,
+    /// DID of the identity to get the RSVP for
+    identity: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct GetRsvpResponse {
+    /// AT-URI of the RSVP record
+    uri: String,
+    /// CID of the RSVP record
+    cid: String,
+    /// The RSVP record
+    record: serde_json::Value,
+}
+
+#[derive(Debug, Serialize)]
+struct GetRsvpError {
+    error: String,
+    message: String,
+}
+
+impl GetRsvpError {
+    fn invalid_request(message: &str) -> Self {
+        Self {
+            error: "InvalidRequest".to_string(),
+            message: message.to_string(),
+        }
+    }
+
+    fn not_found(message: &str) -> Self {
+        Self {
+            error: "NotFound".to_string(),
+            message: message.to_string(),
+        }
+    }
+
+    fn internal_error(message: &str) -> Self {
+        Self {
+            error: "InternalServerError".to_string(),
+            message: message.to_string(),
+        }
+    }
+}
+
+/// XRPC query endpoint for getting an RSVP record.
+///
+/// This endpoint retrieves an RSVP record for a specific identity and event.
+/// No authentication is required as RSVP data is public.
+pub(crate) async fn handle_xrpc_get_rsvp(
+    State(web_context): State<WebContext>,
+    Query(params): Query<GetRsvpParams>,
+) -> impl IntoResponse {
+    // Validate event AT-URI format
+    if ATURI::from_str(&params.event).is_err() {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(GetRsvpError::invalid_request("Invalid event AT-URI format")),
+        )
+            .into_response();
+    }
+
+    let identity = match web_context
+        .identity_resolver
+        .resolve(&params.identity)
+        .await
+    {
+        Ok(value) => value,
+        Err(_) => {
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(GetRsvpError::invalid_request("Invalid identity DID format")),
+            )
+                .into_response();
+        }
+    };
+
+    // Fetch the RSVP
+    let rsvp = match rsvp_get_by_event_and_did(&web_context.pool, &params.event, &identity.id).await
+    {
+        Ok(Some(rsvp)) => rsvp,
+        Ok(None) => {
+            return (
+                StatusCode::NOT_FOUND,
+                Json(GetRsvpError::not_found("RSVP not found")),
+            )
+                .into_response();
+        }
+        Err(err) => {
+            tracing::error!(
+                ?err,
+                event = %params.event,
+                identity = %params.identity,
+                "Failed to fetch RSVP"
+            );
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(GetRsvpError::internal_error("Failed to fetch RSVP")),
+            )
+                .into_response();
+        }
+    };
+
+    let response = GetRsvpResponse {
+        uri: rsvp.aturi,
+        cid: rsvp.cid,
+        record: rsvp.record.0,
+    };
+
+    (StatusCode::OK, Json(response)).into_response()
+}

src/http/handle_xrpc_link_attestation.rs

···
     // 9. Store the acceptance ticket using the existing acceptance_ticket_upsert
     if let Err(err) = acceptance_ticket_upsert(
         &web_context.pool,
-        &input.aturi,      // attestation AT-URI as primary key
-        &caller_did,       // organizer DID
-        &input.did,        // target user DID
-        &input.event,      // event AT-URI
+        &input.aturi, // attestation AT-URI as primary key
+        &caller_did,  // organizer DID
+        &input.did,   // target user DID
+        &input.event, // event AT-URI
         &attestation_record,
     )
     .await

src/http/handle_xrpc_search_events.rs

···
     } else {
         // Search with optional query, DID filter, and location CIDs
         match manager
-            .search_events(params.query.as_deref(), did.as_deref(), &params.location, limit)
+            .search_events(
+                params.query.as_deref(),
+                did.as_deref(),
+                &params.location,
+                limit,
+            )
             .await
         {
             Ok(ids) => ids,

src/http/handler_mcp.rs

···
 use axum::{
     extract::State,
-    http::{header, HeaderMap, StatusCode},
+    http::{HeaderMap, StatusCode, header},
     response::{IntoResponse, Json, Response},
 };
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 use crate::aip_auth_cache::AipUserInfo;
 use crate::http::context::WebContext;
···
     );
 
     let mut headers = HeaderMap::new();
-    headers.insert(
-        header::WWW_AUTHENTICATE,
-        www_authenticate.parse().unwrap(),
-    );
+    headers.insert(header::WWW_AUTHENTICATE, www_authenticate.parse().unwrap());
 
     (StatusCode::UNAUTHORIZED, headers, "Unauthorized").into_response()
 }
···
     let params = &request.params;
     tracing::debug!(params = ?params, "Tool call params");
 
-    let tool_name = params
-        .get("name")
-        .and_then(|v| v.as_str())
-        .unwrap_or("");
+    let tool_name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
 
     let arguments = params.get("arguments").unwrap_or(&Value::Null);
 
···
                 "Calling get_event tool"
             );
 
-            match tools::get_event(web_context, bearer_token.as_deref(), repository.clone(), record_key.clone()).await {
+            match tools::get_event(
+                web_context,
+                bearer_token.as_deref(),
+                repository.clone(),
+                record_key.clone(),
+            )
+            .await
+            {
                 Ok(text) => {
                     tracing::info!(
                         repository = %repository,
···
                 "Calling search_events tool"
             );
 
-            match tools::search_events(web_context, bearer_token.as_deref(), repository.clone(), query.clone()).await {
+            match tools::search_events(
+                web_context,
+                bearer_token.as_deref(),
+                repository.clone(),
+                query.clone(),
+            )
+            .await
+            {
                 Ok(text) => {
                     tracing::info!(
                         repository = ?repository,
···
                 }
             };
 
-            match tools::create_rsvp(web_context, &bearer_token, repository.clone(), record_key.clone(), status.clone()).await {
+            match tools::create_rsvp(
+                web_context,
+                &bearer_token,
+                repository.clone(),
+                record_key.clone(),
+                status.clone(),
+            )
+            .await
+            {
                 Ok(text) => {
                     tracing::info!(
                         repository = %repository,
···
 }
 
 /// Internal DELETE handler (no authentication check)
-async fn delete_mcp(
-    State(web_context): State<WebContext>,
-    headers: HeaderMap,
-) -> Response {
+async fn delete_mcp(State(web_context): State<WebContext>, headers: HeaderMap) -> Response {
     // Get session ID from header
     let session_id = headers
         .get(MCP_SESSION_ID_HEADER)

src/http/import_utils.rs

···
     aturi: &str,
 ) -> Result<()> {
     // Parse the AT-URI
-    let parsed = ATURI::from_str(aturi)
-        .with_context(|| format!("Invalid AT-URI: {}", aturi))?;
+    let parsed = ATURI::from_str(aturi).with_context(|| format!("Invalid AT-URI: {}", aturi))?;
 
     let did = &parsed.authority;
     let collection = &parsed.collection;
···
     // Process the record based on its collection
     match collection.as_str() {
         COMMUNITY_EVENT_NSID => {
-            handle_event_import(http_client, pool, content_storage, did, rkey, &cid, &record, pds_endpoint).await?;
+            handle_event_import(
+                http_client,
+                pool,
+                content_storage,
+                did,
+                rkey,
+                &cid,
+                &record,
+                pds_endpoint,
+            )
+            .await?;
         }
         COMMUNITY_RSVP_NSID => {
             handle_rsvp_import(pool, record_resolver, did, rkey, &cid, &record).await?;
         }
         PROFILE_NSID => {
-            handle_profile_import(http_client, pool, content_storage, &document, did, rkey, &cid, &record, pds_endpoint).await?;
+            handle_profile_import(
+                http_client,
+                pool,
+                content_storage,
+                &document,
+                did,
+                rkey,
+                &cid,
+                &record,
+                pds_endpoint,
+            )
+            .await?;
         }
         ACCEPTANCE_NSID => {
             handle_acceptance_import(pool, did, rkey, &cid, &record).await?;
···
     let all_media = event_record.media;
 
     for media in &all_media {
-        if let Err(err) = download_media(http_client, content_storage, pds_endpoint, did, media).await {
+        if let Err(err) =
+            download_media(http_client, content_storage, pds_endpoint, did, media).await
+        {
             tracing::error!(error = ?err, "failed processing image");
         }
     }
···
 
     // Download avatar and banner blobs if present
     if let Some(ref avatar) = profile_record.avatar
-        && let Err(e) = download_avatar(http_client, content_storage, pds_endpoint, did, avatar).await
+        && let Err(e) =
+            download_avatar(http_client, content_storage, pds_endpoint, did, avatar).await
     {
         tracing::warn!(
             error = ?e,
···
     }
 
     if let Some(ref banner) = profile_record.banner
-        && let Err(e) = download_banner(http_client, content_storage, pds_endpoint, did, banner).await
+        && let Err(e) =
+            download_banner(http_client, content_storage, pds_endpoint, did, banner).await
     {
         tracing::warn!(
             error = ?e,
···
     let image_path = format!("{}.png", blob_ref);
     tracing::info!(?image_path, "image_path");
 
-    if content_storage
-        .as_ref()
-        .content_exists(&image_path)
-        .await?
-    {
+    if content_storage.as_ref().content_exists(&image_path).await? {
         tracing::info!(?image_path, "content exists");
         return Ok(());
     }

src/http/mod.rs

···
 pub mod event_form;
 pub mod event_validation;
 pub mod event_view;
+pub mod h3_utils;
 pub mod handle_accept_rsvp;
 pub mod handle_admin_content_list;
 pub mod handle_admin_content_view;
 pub mod handle_admin_denylist;
 pub mod handle_admin_event;
+pub mod handle_admin_event_index;
 pub mod handle_admin_events;
 pub mod handle_admin_handles;
 pub mod handle_admin_identity_profile;
 pub mod handle_admin_import_event;
 pub mod handle_admin_import_rsvp;
 pub mod handle_admin_index;
+pub mod handle_admin_profile_index;
 pub mod handle_admin_rsvp;
 pub mod handle_admin_rsvp_accept;
 pub mod handle_admin_rsvp_accepts;
 pub mod handle_admin_rsvps;
 pub mod handle_admin_search_index;
-pub mod handle_admin_event_index;
-pub mod handle_admin_profile_index;
 pub mod handle_blob;
 pub mod handle_bulk_accept_rsvps;
 pub mod handle_content;
···
 pub mod handle_finalize_acceptance;
 pub mod handle_geo_aggregation;
 pub mod handle_health;
-pub mod handle_lfg;
-pub mod h3_utils;
 pub mod handle_host_meta;
 pub mod handle_import;
 pub mod handle_index;
+pub mod handle_lfg;
 pub mod handle_location;
 pub mod handle_location_suggestions;
 pub mod handle_mailgun_webhook;
···
 pub mod handle_preview_description;
 pub mod handle_profile;
 pub mod handle_quick_event;
-pub mod profile_import;
 pub mod handle_search;
 pub mod handle_set_language;
 pub mod handle_settings;
···
 pub mod handle_view_event;
 pub mod handle_wellknown;
 pub mod handle_xrpc_get_event;
+pub mod handle_xrpc_get_rsvp;
 pub mod handle_xrpc_link_attestation;
 pub mod handle_xrpc_search_events;
 pub mod handler_mcp;
···
 pub mod middleware_auth;
 pub mod middleware_i18n;
 pub mod pagination;
+pub mod profile_import;
 pub mod rsvp_form;
 pub mod server;
 pub mod tab_selector;

src/http/profile_import.rs

···
 use crate::{
     atproto::lexicon::{
         bluesky_profile::{BlueskyProfile, NSID as BLUESKY_PROFILE_NSID},
-        profile::{Profile as SmokesignalProfile, NSID as SMOKESIGNAL_PROFILE_NSID},
+        profile::{NSID as SMOKESIGNAL_PROFILE_NSID, Profile as SmokesignalProfile},
     },
     facets::{FacetLimits, parse_facets_from_text},
-    storage::{StoragePool, content::ContentStorage, profile::{profile_get_by_did, profile_insert}},
+    storage::{
+        StoragePool,
+        content::ContentStorage,
+        profile::{profile_get_by_did, profile_insert},
+    },
 };
 
 use super::errors::ProfileImportError;
···
         };
 
         // Parse facets from description
-        if let Some(facets) = parse_facets_from_text(&truncated, identity_resolver.as_ref(), facet_limits).await {
+        if let Some(facets) =
+            parse_facets_from_text(&truncated, identity_resolver.as_ref(), facet_limits).await
+        {
             smokesignal_profile.facets = Some(facets);
         }
 
···
         swap_commit: None,
     };
 
-    let put_response = put_record(http_client, &Auth::DPoP(dpop_auth.clone()), pds_endpoint, put_request)
-        .await
-        .map_err(|e| ProfileImportError::PdsWriteFailed(e.to_string()))?;
+    let put_response = put_record(
+        http_client,
+        &Auth::DPoP(dpop_auth.clone()),
+        pds_endpoint,
+        put_request,
+    )
+    .await
+    .map_err(|e| ProfileImportError::PdsWriteFailed(e.to_string()))?;
 
     match put_response {
         PutRecordResponse::StrongRef { uri, cid, .. } => {
···
                 .unwrap_or(handle);
 
             // Store profile locally
-            if let Err(e) = profile_insert(pool, &uri, &cid, did, display_name_for_db, &smokesignal_profile).await {
+            if let Err(e) = profile_insert(
+                pool,
+                &uri,
+                &cid,
+                did,
+                display_name_for_db,
+                &smokesignal_profile,
+            )
+            .await
+            {
                 tracing::error!(did = %did, error = %e, "Failed to store imported profile locally");
                 return Err(ProfileImportError::StorageFailed(e.to_string()));
             }
···
         .map_err(|e| ProfileImportError::AvatarProcessFailed(e.to_string()))?;
 
     // Upload processed avatar to user's PDS
-    let new_blob = upload_blob_to_pds(http_client, dpop_auth, pds_endpoint, &processed, "image/png")
-        .await
-        .map_err(|e| ProfileImportError::AvatarUploadFailed(e.to_string()))?;
+    let new_blob = upload_blob_to_pds(
+        http_client,
+        dpop_auth,
+        pds_endpoint,
+        &processed,
+        "image/png",
+    )
+    .await
+    .map_err(|e| ProfileImportError::AvatarUploadFailed(e.to_string()))?;
 
     // Store avatar locally in content storage
     let image_path = format!("{}.png", new_blob.inner.ref_.link);

src/http/server.rs

···
         handle_admin_denylist, handle_admin_denylist_add, handle_admin_denylist_remove,
     },
     handle_admin_event::{handle_admin_event, handle_admin_event_nuke},
+    handle_admin_event_index::{
+        handle_admin_event_index, handle_admin_event_index_delete, handle_admin_event_index_rebuild,
+    },
     handle_admin_events::handle_admin_events,
-    handle_admin_handles::{handle_admin_handles, handle_admin_nuke_identity, handle_admin_tap_sync_all},
+    handle_admin_handles::{
+        handle_admin_handles, handle_admin_nuke_identity, handle_admin_tap_sync_all,
+    },
     handle_admin_identity_profile::{
         handle_admin_identity_profile, handle_admin_identity_profile_ban_did,
         handle_admin_identity_profile_ban_pds, handle_admin_identity_profile_nuke,
···
     handle_admin_import_event::handle_admin_import_event,
     handle_admin_import_rsvp::handle_admin_import_rsvp,
     handle_admin_index::handle_admin_index,
+    handle_admin_profile_index::{
+        handle_admin_profile_index, handle_admin_profile_index_delete,
+        handle_admin_profile_index_rebuild,
+    },
     handle_admin_rsvp::{handle_admin_rsvp, handle_admin_rsvp_nuke},
     handle_admin_rsvp_accept::{handle_admin_rsvp_accept, handle_admin_rsvp_accept_nuke},
     handle_admin_rsvp_accepts::handle_admin_rsvp_accepts,
···
         handle_admin_search_index, handle_admin_search_index_delete,
         handle_admin_search_index_rebuild,
     },
-    handle_admin_event_index::{
-        handle_admin_event_index, handle_admin_event_index_delete,
-        handle_admin_event_index_rebuild,
-    },
-    handle_admin_profile_index::{
-        handle_admin_profile_index, handle_admin_profile_index_delete,
-        handle_admin_profile_index_rebuild,
-    },
     handle_blob::{
         delete_profile_avatar, delete_profile_banner, upload_event_header, upload_event_thumbnail,
         upload_profile_avatar, upload_profile_banner,
···
     handle_finalize_acceptance::handle_finalize_acceptance,
     handle_geo_aggregation::{handle_geo_aggregation, handle_globe_aggregation},
     handle_health::{handle_alive, handle_ready, handle_started},
+    handle_host_meta::handle_host_meta,
+    handle_import::{handle_import, handle_import_submit},
+    handle_index::handle_index,
     handle_lfg::{
         handle_lfg_deactivate, handle_lfg_geo_aggregation, handle_lfg_get, handle_lfg_post,
         handle_lfg_tags_autocomplete,
     },
-    handle_host_meta::handle_host_meta,
-    handle_import::{handle_import, handle_import_submit},
-    handle_index::handle_index,
     handle_location::handle_location,
     handle_location_suggestions::handle_location_suggestions,
     handle_mailgun_webhook::handle_mailgun_webhook,
···
     handle_search::handle_search,
     handle_set_language::handle_set_language,
     handle_settings::{
-        handle_email_update, handle_language_update,
-        handle_notification_email_update, handle_notification_preferences_update,
-        handle_profile_update, handle_settings,
+        handle_email_update, handle_language_update, handle_notification_email_update,
+        handle_notification_preferences_update, handle_profile_update, handle_settings,
         handle_timezone_update,
     },
     handle_unaccept_rsvp::handle_unaccept_rsvp,
···
     handle_view_event::handle_view_event,
     handle_wellknown::handle_wellknown_did_web,
     handle_xrpc_get_event::handle_xrpc_get_event,
+    handle_xrpc_get_rsvp::handle_xrpc_get_rsvp,
     handle_xrpc_link_attestation::handle_xrpc_link_attestation,
     handle_xrpc_search_events::handle_xrpc_search_events,
     handler_mcp::{
···
             "/xrpc/community.lexicon.calendar.searchEvents",
             get(handle_xrpc_search_events),
         )
+        // legacy endpoint
         .route(
             "/xrpc/community.lexicon.calendar.SearchEvents",
             get(handle_xrpc_search_events),
···
             "/xrpc/community.lexicon.calendar.getEvent",
             get(handle_xrpc_get_event),
         )
-                .route(
+        // legacy endpoint
+        .route(
             "/xrpc/community.lexicon.calendar.GetEvent",
             get(handle_xrpc_get_event),
         )
         .route(
+            "/xrpc/community.lexicon.calendar.getRSVP",
+            get(handle_xrpc_get_rsvp),
+        )
+        .route(
             "/xrpc/events.smokesignal.rsvp.linkAttestation",
             post(handle_xrpc_link_attestation),
         )
···
             "/admin/search-index/events/rebuild",
             post(handle_admin_event_index_rebuild),
         )
-        .route("/admin/search-index/profiles", get(handle_admin_profile_index))
+        .route(
+            "/admin/search-index/profiles",
+            get(handle_admin_profile_index),
+        )
         .route(
             "/admin/search-index/profiles/delete",
             post(handle_admin_profile_index_delete),
···
         .route("/quick-event", get(handle_quick_event))
         .route("/event", get(handle_create_event))
         .route("/event", post(handle_create_event_json))
-        .route("/event/preview-description", post(handle_preview_description))
-        .route("/event/location-suggestions", get(handle_location_suggestions))
+        .route(
+            "/event/preview-description",
+            post(handle_preview_description),
+        )
+        .route(
+            "/event/location-suggestions",
+            get(handle_location_suggestions),
+        )
         .route("/rsvp", get(handle_create_rsvp))
         .route("/rsvp", post(handle_create_rsvp))
         .route("/accept_rsvp", post(handle_accept_rsvp))
···
         )
         .route("/ics/{*aturi}", get(handle_export_ics))
         .route("/{handle_slug}/ics", get(handle_event_ics))
-        .route("/{handle_slug}/{event_rkey}/edit", post(handle_edit_event_json))
+        .route(
+            "/{handle_slug}/{event_rkey}/edit",
+            post(handle_edit_event_json),
+        )
         .route(
             "/{handle_slug}/{event_rkey}/manage",
             get(handle_manage_event),

src/image.rs

···
     }
 
     // Try to load the image to ensure it's valid
-    image::load_from_memory(data)
-        .map_err(|e| ImageError::InvalidImageData(e.to_string()))?;
+    image::load_from_memory(data).map_err(|e| ImageError::InvalidImageData(e.to_string()))?;
 
     Ok(())
 }
···
 /// Process avatar image: validate 1:1 aspect ratio, resize to 400x400, convert to PNG
 pub(crate) fn process_avatar(data: &[u8]) -> Result<Vec<u8>, ImageError> {
     // Load the image
-    let img = image::load_from_memory(data)
-        .map_err(|e| ImageError::AvatarLoadFailed(e.to_string()))?;
+    let img =
+        image::load_from_memory(data).map_err(|e| ImageError::AvatarLoadFailed(e.to_string()))?;
 
     let (width, height) = img.dimensions();
 
···
 /// Process banner image: validate 16:9 aspect ratio, resize to 1600x900, convert to PNG
 pub(crate) fn process_banner(data: &[u8]) -> Result<Vec<u8>, ImageError> {
     // Load the image
-    let img = image::load_from_memory(data)
-        .map_err(|e| ImageError::BannerLoadFailed(e.to_string()))?;
+    let img =
+        image::load_from_memory(data).map_err(|e| ImageError::BannerLoadFailed(e.to_string()))?;
 
     let (width, height) = img.dimensions();
 

src/image_errors.rs

···
     ///
     /// This error occurs when an event header image doesn't have the required
     /// 3:1 aspect ratio (allowing 10% deviation).
-    #[error("error-smokesignal-image-10 Event header must have 3:1 aspect ratio: got {width}:{height}")]
+    #[error(
+        "error-smokesignal-image-10 Event header must have 3:1 aspect ratio: got {width}:{height}"
+    )]
     InvalidEventHeaderAspectRatio {
         /// The width of the image in pixels.
         width: u32,
···
     ///
     /// This error occurs when a thumbnail image doesn't have the required
     /// square aspect ratio (allowing 5% deviation).
-    #[error("error-smokesignal-image-13 Thumbnail must have 1:1 aspect ratio: got {width}:{height}")]
+    #[error(
+        "error-smokesignal-image-13 Thumbnail must have 1:1 aspect ratio: got {width}:{height}"
+    )]
     InvalidThumbnailAspectRatio {
         /// The width of the image in pixels.
         width: u32,

src/lib.rs

···
 pub mod mcp;
 pub mod processor;
 pub mod processor_errors;
+pub mod profile_index;
+pub mod profile_index_errors;
 pub mod record_resolver;
 pub mod refresh_tokens_errors;
 pub mod search_index;
-pub mod profile_index;
-pub mod profile_index_errors;
 pub mod service;
 pub mod stats;
 pub mod storage;

src/mcp/tools.rs

···
 use anyhow::Result;
-use atproto_client::com::atproto::repo::{put_record, PutRecordRequest, PutRecordResponse};
-use atproto_identity::resolve::{parse_input, InputType};
+use atproto_client::com::atproto::repo::{PutRecordRequest, PutRecordResponse, put_record};
+use atproto_identity::resolve::{InputType, parse_input};
 use atproto_record::lexicon::community::lexicon::calendar::event::NSID as CommunityLexiconCalendarEventNSID;
-use atproto_record::lexicon::community::lexicon::calendar::rsvp::{Rsvp, RsvpStatus, NSID as RsvpNSID};
+use atproto_record::lexicon::community::lexicon::calendar::rsvp::{
+    NSID as RsvpNSID, Rsvp, RsvpStatus,
+};
 use chrono::Utc;
 use metrohash::MetroHash64;
 use std::hash::Hasher;
···
 use crate::config::OAuthBackendConfig;
 use crate::http::{context::WebContext, utils::url_from_aturi};
 use crate::search_index::SearchIndexManager;
-use crate::storage::event::{event_get, get_event_rsvp_counts, rsvp_get_by_event_and_did, rsvp_insert_with_metadata, RsvpInsertParams};
+use crate::storage::event::{
+    RsvpInsertParams, event_get, get_event_rsvp_counts, rsvp_get_by_event_and_did,
+    rsvp_insert_with_metadata,
+};
 
 /// Wrap response text with safety tags to prevent prompt injection
 pub fn wrap_response_text(text: String) -> String {
···
         }
         Ok(InputType::Handle(_)) | Err(_) => {
             tracing::warn!(repository = %repository, "Invalid repository: not a DID");
-            return Err("Invalid repository: must be a DID (did:plc:... or did:web:...)".to_string());
+            return Err(
+                "Invalid repository: must be a DID (did:plc:... or did:web:...)".to_string(),
+            );
         }
     };
 
···
 
     // Fetch event
     tracing::debug!(aturi = %aturi, "Fetching event from database");
-    let event = event_get(&web_context.pool, &aturi)
-        .await
-        .map_err(|e| {
-            tracing::error!(aturi = %aturi, error = ?e, "Failed to fetch event from database");
-            "Event not found".to_string()
-        })?;
+    let event = event_get(&web_context.pool, &aturi).await.map_err(|e| {
+        tracing::error!(aturi = %aturi, error = ?e, "Failed to fetch event from database");
+        "Event not found".to_string()
+    })?;
 
     tracing::debug!(aturi = %aturi, "Event fetched successfully");
 
···
             match cache.validate_token(token).await {
                 Ok(Some(user_info)) => {
                     tracing::debug!(did = %user_info.sub, "Checking caller's RSVP status");
-                    match rsvp_get_by_event_and_did(&web_context.pool, &aturi, &user_info.sub).await {
+                    match rsvp_get_by_event_and_did(&web_context.pool, &aturi, &user_info.sub).await
+                    {
                         Ok(Some(rsvp)) => {
                             // Parse the RSVP record to get the status
-                            let status_str = rsvp.record.0.get("status")
+                            let status_str = rsvp
+                                .record
+                                .0
+                                .get("status")
                                 .and_then(|v| v.as_str())
                                 .unwrap_or("unknown");
                             tracing::debug!(status = %status_str, "Found caller's RSVP");
···
 
     // Generate event URL
     tracing::debug!(aturi = %aturi, "Generating event URL");
-    let url = url_from_aturi(&web_context.config.external_base, &event.aturi)
-        .map_err(|e| {
-            tracing::error!(aturi = %aturi, error = ?e, "Failed to generate URL");
-            format!("Error generating URL: {}", e)
-        })?;
+    let url = url_from_aturi(&web_context.config.external_base, &event.aturi).map_err(|e| {
+        tracing::error!(aturi = %aturi, error = ?e, "Failed to generate URL");
+        format!("Error generating URL: {}", e)
+    })?;
 
     // Extract event details from record
     let record = &event.record.0;
···
             "Fetching event details"
         );
 
-        let event = event_get(&web_context.pool, aturi)
-            .await
-            .map_err(|e| {
-                tracing::error!(aturi = %aturi, error = ?e, "Error fetching event");
-                format!("Error fetching event {}: {}", aturi, e)
-            })?;
+        let event = event_get(&web_context.pool, aturi).await.map_err(|e| {
+            tracing::error!(aturi = %aturi, error = ?e, "Error fetching event");
+            format!("Error fetching event {}: {}", aturi, e)
+        })?;
 
         let rsvp_counts = get_event_rsvp_counts(&web_context.pool, vec![aturi.clone()])
             .await
···
             match rsvp_get_by_event_and_did(&web_context.pool, aturi, did).await {
                 Ok(Some(rsvp)) => {
                     // Parse the RSVP record to get the status
-                    let status_str = rsvp.record.0.get("status")
+                    let status_str = rsvp
+                        .record
+                        .0
+                        .get("status")
                         .and_then(|v| v.as_str())
                         .unwrap_or("unknown");
                     Some(status_str.to_string())
                 }
-                _ => None
+                _ => None,
             }
         } else {
             None
···
 
     // Validate bearer token to get user info
     let user_info = match &web_context.aip_auth_cache {
-        Some(cache) => {
-            cache.validate_token(bearer_token)
-                .await
-                .map_err(|e| {
-                    tracing::error!(error = ?e, "Failed to validate bearer token");
-                    "Authentication failed".to_string()
-                })?
-                .ok_or_else(|| {
-                    tracing::warn!("Invalid bearer token");
-                    "Invalid authentication token".to_string()
-                })?
-        }
+        Some(cache) => cache
+            .validate_token(bearer_token)
+            .await
+            .map_err(|e| {
+                tracing::error!(error = ?e, "Failed to validate bearer token");
+                "Authentication failed".to_string()
+            })?
+            .ok_or_else(|| {
+                tracing::warn!("Invalid bearer token");
+                "Invalid authentication token".to_string()
+            })?,
         None => {
             tracing::error!("AIP auth cache not configured");
             return Err("Authentication not available".to_string());
···
         }
         Ok(InputType::Handle(_)) | Err(_) => {
             tracing::warn!(repository = %repository, "Invalid repository: not a DID");
-            return Err("Invalid repository: must be a DID (did:plc:... or did:web:...)".to_string());
+            return Err(
+                "Invalid repository: must be a DID (did:plc:... or did:web:...)".to_string(),
+            );
         }
     };
 
···
     // Create DPoP auth from AIP session
     let dpop_auth = match &web_context.config.oauth_backend {
         OAuthBackendConfig::AIP { hostname, .. } => {
-            create_dpop_auth_from_aip_session(
-                &web_context.http_client,
-                hostname,
-                bearer_token,
-            )
-            .await
-            .map_err(|e| {
-                tracing::error!(error = ?e, "Failed to create DPoP auth");
-                format!("Authentication error: {}", e)
-            })?
+            create_dpop_auth_from_aip_session(&web_context.http_client, hostname, bearer_token)
+                .await
+                .map_err(|e| {
+                    tracing::error!(error = ?e, "Failed to create DPoP auth");
+                    format!("Authentication error: {}", e)
+                })?
         }
         _ => {
             tracing::error!("OAuth backend is not AIP");
···
     tracing::debug!(record_key = %rsvp_record_key, "Generated RSVP record key");
 
     // Check for existing RSVP
-    let existing_rsvp = rsvp_get_by_event_and_did(
-        &web_context.pool,
-        &event_aturi,
-        user_did,
-    )
-    .await
-    .ok()
-    .flatten();
+    let existing_rsvp = rsvp_get_by_event_and_did(&web_context.pool, &event_aturi, user_did)
+        .await
+        .ok()
+        .flatten();
 
     let now = Utc::now();
 
···
     );
 
     // Generate event URL
-    let event_url = url_from_aturi(&web_context.config.external_base, &event_aturi)
-        .map_err(|e| {
+    let event_url =
+        url_from_aturi(&web_context.config.external_base, &event_aturi).map_err(|e| {
             tracing::error!(error = ?e, "Failed to generate event URL");
             format!("Error generating URL: {}", e)
         })?;
···
     // Format response
     let text = format!(
         "RSVP created successfully\nEvent: {}\nEvent URL: {}\nStatus: {}\nRSVP AT-URI: {}",
-        event.name,
-        event_url,
-        status,
-        create_record_result.uri
+        event.name, event_url, status, create_record_result.uri
     );
 
     Ok(wrap_response_text(text))

src/processor.rs

···
 use crate::storage::acceptance::{
     acceptance_record_delete, acceptance_record_upsert, rsvp_update_validated_at,
 };
+use crate::storage::atproto_record::{atproto_record_delete, atproto_record_upsert};
 use crate::storage::content::ContentStorage;
 use crate::storage::denylist::denylist_exists;
 use crate::storage::event::EventInsertParams;
···
 use crate::storage::event::event_insert_with_metadata;
 use crate::storage::event::rsvp_delete;
 use crate::storage::event::rsvp_insert_with_metadata;
-use crate::storage::atproto_record::{atproto_record_delete, atproto_record_upsert};
 use crate::storage::profile::profile_delete;
 use crate::storage::profile::profile_insert;
 use atproto_record::lexicon::community::lexicon::calendar::event::{
···
     ) -> Result<()> {
         match collection {
             "community.lexicon.calendar.event" => {
-                self.handle_event_commit(did, rkey, cid, record, live)
-                    .await
+                self.handle_event_commit(did, rkey, cid, record, live).await
             }
             "community.lexicon.calendar.rsvp" => {
                 self.handle_rsvp_commit(did, rkey, cid, record, live).await
···
         live: bool,
     ) -> Result<()> {
         match collection {
-            "community.lexicon.calendar.event" => {
-                self.handle_event_delete(did, rkey, live).await
-            }
+            "community.lexicon.calendar.event" => self.handle_event_delete(did, rkey, live).await,
             "community.lexicon.calendar.rsvp" => self.handle_rsvp_delete(did, rkey, live).await,
             "events.smokesignal.profile" => self.handle_profile_delete(did, rkey).await,
             "events.smokesignal.calendar.acceptance" => {

src/profile_index.rs

···
 use crate::atproto::lexicon::profile::Profile as ProfileRecord;
 use crate::atproto::utils::get_profile_hashtags;
 use crate::profile_index_errors::ProfileIndexError;
-use crate::storage::{identity_profile::handle_for_did, profile::profile_list, StoragePool};
+use crate::storage::{StoragePool, identity_profile::handle_for_did, profile::profile_list};
 
 const INDEX_NAME: &str = "smokesignal-profiles";
 
···
             }
 
             for profile in &profiles {
-                match self.index_profile(pool, identity_resolver.clone(), profile).await {
+                match self
+                    .index_profile(pool, identity_resolver.clone(), profile)
+                    .await
+                {
                     Ok(_) => {
                         indexed_count += 1;
                         tracing::debug!("Indexed profile {}", profile.aturi);
···
             }
         }
 
-        tracing::info!("Profile index rebuild complete: {} profiles indexed", indexed_count);
+        tracing::info!(
+            "Profile index rebuild complete: {} profiles indexed",
+            indexed_count
+        );
         Ok(indexed_count)
     }
 }

src/search_index.rs

···
 use std::sync::Arc;
 
 use crate::atproto::utils::get_event_hashtags;
-use crate::storage::{event::event_list, identity_profile::handle_for_did, StoragePool};
+use crate::storage::{StoragePool, event::event_list, identity_profile::handle_for_did};
 use atproto_record::lexicon::community::lexicon::calendar::event::Event;
 use atproto_record::lexicon::community::lexicon::location::LocationOrRef;
 
···
             }
 
             for event in &events {
-                match self.index_event(pool, identity_resolver.clone(), event).await {
+                match self
+                    .index_event(pool, identity_resolver.clone(), event)
+                    .await
+                {
                     Ok(_) => {
                         indexed_count += 1;
                         tracing::debug!("Indexed event {}", event.aturi);
···
 
         if !response.status_code().is_success() {
             let error_body = response.text().await?;
-            return Err(anyhow::anyhow!("Failed to create LFG index: {}", error_body));
+            return Err(anyhow::anyhow!(
+                "Failed to create LFG index: {}",
+                error_body
+            ));
         }
 
         tracing::info!("Created OpenSearch index {}", Self::LFG_INDEX_NAME);
···
 
         let response = self
             .client
-            .update_by_query(opensearch::UpdateByQueryParts::Index(&[Self::LFG_INDEX_NAME]))
+            .update_by_query(opensearch::UpdateByQueryParts::Index(&[
+                Self::LFG_INDEX_NAME,
+            ]))
             .body(update_body)
             .send()
             .await?;
 
         if !response.status_code().is_success() {
             let error_body = response.text().await?;
-            return Err(anyhow::anyhow!("Failed to deactivate expired LFG profiles: {}", error_body));
+            return Err(anyhow::anyhow!(
+                "Failed to deactivate expired LFG profiles: {}",
+                error_body
+            ));
         }
 
         let body = response.json::<Value>().await?;
···
             LocationOrRef::InlineGeo(_) => "InlineGeo",
             _ => "Other",
         };
-        assert_eq!(variant0, "InlineAddress", "First location should be InlineAddress");
+        assert_eq!(
+            variant0, "InlineAddress",
+            "First location should be InlineAddress"
+        );
 
         // Check second location is a geo
         let variant1 = match &locations[1] {
···
         assert_eq!(variant1, "InlineGeo", "Second location should be InlineGeo");
 
         // Test extract_geo_point
-        let geo_points: Vec<GeoPoint> = locations
-            .iter()
-            .filter_map(extract_geo_point)
-            .collect();
+        let geo_points: Vec<GeoPoint> = locations.iter().filter_map(extract_geo_point).collect();
 
         assert_eq!(geo_points.len(), 1, "Should extract 1 geo point");
         assert!((geo_points[0].lat - 39.707931).abs() < 0.0001);
···
 
         // Parse back from Value (simulating database retrieval)
         let event_roundtrip: EventLexicon = serde_json::from_value(serialized).unwrap();
-        assert_eq!(event_roundtrip.locations.len(), 2, "Should still have 2 locations after roundtrip");
+        assert_eq!(
+            event_roundtrip.locations.len(),
+            2,
+            "Should still have 2 locations after roundtrip"
+        );
 
         // Check that geo location is still correctly identified
         let geo_points: Vec<GeoPoint> = event_roundtrip
···
             .filter_map(extract_geo_point)
             .collect();
 
-        assert_eq!(geo_points.len(), 1, "Should extract 1 geo point after roundtrip");
+        assert_eq!(
+            geo_points.len(),
+            1,
+            "Should extract 1 geo point after roundtrip"
+        );
         assert!((geo_points[0].lat - 39.707931).abs() < 0.0001);
         assert!((geo_points[0].lon - (-84.1648089)).abs() < 0.0001);
     }

src/stats.rs

···
 }
 
 /// Set stats in Redis cache with TTL
-async fn set_cached_stats(
-    cache_pool: &CachePool,
-    stats: &NetworkStats,
-) -> Result<(), StatsError> {
-    let json = serde_json::to_string(stats)
-        .map_err(|e| StatsError::SerializationError(e.to_string()))?;
+async fn set_cached_stats(cache_pool: &CachePool, stats: &NetworkStats) -> Result<(), StatsError> {
+    let json =
+        serde_json::to_string(stats).map_err(|e| StatsError::SerializationError(e.to_string()))?;
 
     let mut conn = cache_pool
         .get()

src/storage/atproto_record.rs

···
         .map_err(StorageError::UnableToExecuteQuery)?;
 
     // Query 2: events with locations created by this user
-    let event_rows: Vec<(String, Option<DateTime<Utc>>, sqlx::types::Json<serde_json::Value>)> =
-        sqlx::query_as(
-            r#"
+    let event_rows: Vec<(
+        String,
+        Option<DateTime<Utc>>,
+        sqlx::types::Json<serde_json::Value>,
+    )> = sqlx::query_as(
+        r#"
             SELECT aturi, updated_at, record
             FROM events
             WHERE did = $1
···
             ORDER BY updated_at DESC NULLS LAST
             LIMIT $2
             "#,
-        )
-        .bind(did)
-        .bind(fetch_limit)
-        .fetch_all(pool)
-        .await
-        .map_err(StorageError::UnableToExecuteQuery)?;
+    )
+    .bind(did)
+    .bind(fetch_limit)
+    .fetch_all(pool)
+    .await
+    .map_err(StorageError::UnableToExecuteQuery)?;
 
     // Collect all suggestions with (priority, timestamp) for sorting
     // Priority: 0 = beaconbits/dropanchor (higher priority), 1 = smokesignal events
···
 /// Extract locations from an event record's locations array.
 ///
 /// Handles both address and geo location types based on the `$type` field.
-fn extract_locations_from_event(aturi: &str, record: &serde_json::Value) -> Vec<LocationSuggestion> {
+fn extract_locations_from_event(
+    aturi: &str,
+    record: &serde_json::Value,
+) -> Vec<LocationSuggestion> {
     let Some(locations) = record.get("locations").and_then(|l| l.as_array()) else {
         return vec![];
     };

src/storage/event.rs

···
         pub rsvp_status: Option<String>,
         pub discovered_at: DateTime<Utc>, // When record was first seen by the system
         pub created_at: Option<DateTime<Utc>>, // From the AT Protocol record metadata
-        pub h3_cell: Option<String>, // H3 cell for LFG location grouping
+        pub h3_cell: Option<String>,      // H3 cell for LFG location grouping
     }
 }
 

src/storage/lfg.rs

···
 //! let lfg: Lfg = serde_json::from_value(record.record.0.clone())?;
 //! ```
 
+use super::StoragePool;
 use super::atproto_record::AtprotoRecord;
 use super::errors::StorageError;
-use super::StoragePool;
 use crate::atproto::lexicon::lfg::NSID;
 
 /// Get the active LFG record for a DID from atproto_records.

src/tap_processor.rs

···
 //! eliminating the need for channel-based message passing.
 
 use anyhow::Result;
-use atproto_tap::{connect, RecordAction, TapConfig, TapEvent};
+use atproto_tap::{RecordAction, TapConfig, TapEvent, connect};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio_stream::StreamExt;
···
                 let live = record.live;
 
                 if !live {
-                    tracing::debug!(
-                        "Processing backfill event: {} {} {}",
-                        collection,
-                        did,
-                        rkey
-                    );
+                    tracing::debug!("Processing backfill event: {} {} {}", collection, did, rkey);
                 }
 
                 match record.action {
···
                             None
                         };
 
-                        let content_future = self
-                            .content_fetcher
-                            .handle_commit(did, collection, rkey, cid, record_value, live);
+                        let content_future = self.content_fetcher.handle_commit(
+                            did,
+                            collection,
+                            rkey,
+                            cid,
+                            record_value,
+                            live,
+                        );
 
                         let index_future = async {
                             if let (Some(indexer), Some(record)) =
···
                     }
                     RecordAction::Delete => {
                         // Process content fetcher and search indexer delete in parallel
-                        let content_future =
-                            self.content_fetcher
-                                .handle_delete(did, collection, rkey, live);
+                        let content_future = self
+                            .content_fetcher
+                            .handle_delete(did, collection, rkey, live);
 
                         let index_future = async {
                             if let Some(ref indexer) = self.search_indexer {

src/task_lfg_cleanup.rs

···
 use tokio::time::{Instant, sleep};
 use tokio_util::sync::CancellationToken;
 
+use crate::atproto::lexicon::lfg::NSID;
 use crate::search_index::SearchIndexManager;
 use crate::storage::StoragePool;
-use crate::atproto::lexicon::lfg::NSID;
 
 /// Configuration for the LFG cleanup task.
 pub struct LfgCleanupTaskConfig {
···
     }
 
     /// Deactivate expired LFG records in the database.
-    async fn deactivate_expired_in_database(
-        &self,
-        now: &chrono::DateTime<Utc>,
-    ) -> Result<u64> {
+    async fn deactivate_expired_in_database(&self, now: &chrono::DateTime<Utc>) -> Result<u64> {
         // Query for active LFG records that have expired
         let result = sqlx::query(
             r#"
···
         match search_index.deactivate_expired_lfg_profiles().await {
             Ok(count) => Ok(count),
             Err(err) => {
-                tracing::warn!("Failed to deactivate expired LFG profiles in OpenSearch: {}", err);
+                tracing::warn!(
+                    "Failed to deactivate expired LFG profiles in OpenSearch: {}",
+                    err
+                );
                 Ok(0)
             }
         }

src/task_search_indexer.rs

···
 use std::sync::Arc;
 
 use crate::atproto::lexicon::lfg::{Lfg, NSID as LFG_NSID};
-use crate::atproto::lexicon::profile::{Profile, NSID as PROFILE_NSID};
+use crate::atproto::lexicon::profile::{NSID as PROFILE_NSID, Profile};
 use crate::atproto::utils::get_profile_hashtags;
 use crate::search_index::SearchIndexManager;
-use crate::storage::event::event_get;
 use crate::storage::StoragePool;
+use crate::storage::event::event_get;
 use crate::task_search_indexer_errors::SearchIndexerError;
 
 /// Build an AT URI with pre-allocated capacity to avoid format! overhead.
···
         let aturi = build_aturi(did, LexiconCommunityEventNSID, rkey);
 
         // Delegate to SearchIndexManager for consistent deletion logic
-        self.event_index_manager.delete_indexed_event(&aturi).await?;
+        self.event_index_manager
+            .delete_indexed_event(&aturi)
+            .await?;
 
         tracing::debug!("Deleted event {} for DID {} from search index", rkey, did);
         Ok(())
···
         // Delegate to SearchIndexManager for consistent deletion logic
         self.event_index_manager.delete_lfg_profile(&aturi).await?;
 
-        tracing::debug!("Deleted LFG profile {} for DID {} from search index", rkey, did);
+        tracing::debug!(
+            "Deleted LFG profile {} for DID {} from search index",
+            rkey,
+            did
+        );
         Ok(())
     }