refactor: cleaned up default record resolver

crates/atproto-client/src/record_resolver.rs

···
 //! Helpers for resolving AT Protocol records referenced by URI.
 
 use std::str::FromStr;
+use std::sync::Arc;
 
 use anyhow::{Result, anyhow, bail};
 use async_trait::async_trait;
+use atproto_identity::traits::IdentityResolver;
 use atproto_record::aturi::ATURI;
 
 use crate::{
···
 }
 
 /// Resolver that fetches records using public XRPC endpoints.
+///
+/// Uses an identity resolver to dynamically determine the PDS endpoint for each record.
 #[derive(Clone)]
 pub struct HttpRecordResolver {
     http_client: reqwest::Client,
-    base_url: String,
+    identity_resolver: Arc<dyn IdentityResolver>,
 }
 
 impl HttpRecordResolver {
-    /// Create a new resolver using the provided HTTP client and PDS base URL.
-    pub fn new(http_client: reqwest::Client, base_url: impl Into<String>) -> Self {
+    /// Create a new resolver using the provided HTTP client and identity resolver.
+    ///
+    /// The identity resolver is used to dynamically determine the PDS endpoint for each record
+    /// based on the authority (DID or handle) in the AT URI.
+    pub fn new(
+        http_client: reqwest::Client,
+        identity_resolver: Arc<dyn IdentityResolver>,
+    ) -> Self {
         Self {
             http_client,
-            base_url: base_url.into(),
+            identity_resolver,
         }
     }
 }
···
         T: serde::de::DeserializeOwned + Send,
     {
         let parsed = ATURI::from_str(aturi).map_err(|error| anyhow!(error))?;
+
+        // Resolve the authority (DID or handle) to get the DID document
+        let document = self
+            .identity_resolver
+            .resolve(&parsed.authority)
+            .await
+            .map_err(|error| {
+                anyhow!("Failed to resolve identity for {}: {}", parsed.authority, error)
+            })?;
+
+        // Extract PDS endpoint from the DID document
+        let pds_endpoints = document.pds_endpoints();
+        let base_url = pds_endpoints
+            .first()
+            .ok_or_else(|| anyhow!("No PDS endpoint found for {}", parsed.authority))?;
+
         let auth = Auth::None;
 
         let response = get_record(
             &self.http_client,
             &auth,
-            &self.base_url,
+            base_url,
             &parsed.authority,
             &parsed.collection,
             &parsed.record_key,