diff --git a/lexica/src/app_bsky/actor.rs b/lexica/src/app_bsky/actor.rs
index 0fffa6c5..e00c0cc8 100644
--- a/lexica/src/app_bsky/actor.rs
+++ b/lexica/src/app_bsky/actor.rs
@@ -1,6 +1,7 @@
 use crate::app_bsky::embed::External;
-use crate::app_bsky::graph::ListViewBasic;
+use crate::app_bsky::graph::{ListViewBasic, StarterPackViewBasic};
 use crate::com_atproto::label::Label;
+use crate::StrongRef;
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
@@ -21,10 +22,15 @@ pub struct ProfileViewerState {
     pub following: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub followed_by: Option<String>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub known_followers: Option<()>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub activity_subscriptions: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub known_followers: Option<KnownFollowers>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct KnownFollowers {
+    pub count: i64,
+    pub followers: Vec<ProfileViewBasic>,
 }
 
 #[derive(Clone, Default, Debug, Serialize, Deserialize)]
@@ -216,13 +222,13 @@ pub struct ProfileViewDetailed {
     pub posts_count: i64,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub associated: Option<ProfileAssociated>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub joined_via_starter_pack: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub joined_via_starter_pack: Option<StarterPackViewBasic>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub viewer: Option<ProfileViewerState>,
     pub labels: Vec<Label>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub pinned_post: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pinned_post: Option<StrongRef>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub verification: Option<VerificationState>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -288,3 +294,86 @@ pub struct StatusView {
 pub struct StatusViewEmbed {
     pub external: External,
 }
+
+// ============================================================================
+// Response Types for XRPC Endpoints
+// ============================================================================
+
+/// Response for app.bsky.actor.getProfiles
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetProfilesResponse {
+    pub profiles: Vec<ProfileViewDetailed>,
+}
+
+/// Response for app.bsky.actor.searchActors
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchActorsResponse {
+    pub actors: Vec<ProfileView>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cursor: Option<String>,
+}
+
+/// Response for app.bsky.actor.searchActorsTypeahead
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchActorsTypeaheadResponse {
+    pub actors: Vec<ProfileViewBasic>,
+}
+
+/// Response for app.bsky.actor.getSuggestions
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetSuggestionsResponse {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cursor: Option<String>,
+    pub actors: Vec<ProfileView>,
+}
+
+// ============================================================================
+// Request Parameter Types for XRPC Endpoints
+// ============================================================================
+
+/// Parameters for app.bsky.actor.getProfiles
+#[derive(Clone, Debug, Deserialize)]
+pub struct GetProfilesParams {
+    /// List of actor DIDs or handles (max 25)
+    pub actors: Vec<String>,
+}
+
+/// Parameters for app.bsky.actor.searchActors
+#[derive(Clone, Debug, Deserialize)]
+pub struct SearchActorsParams {
+    /// Search query string
+    pub q: Option<String>,
+    /// Deprecated: use 'q' instead
+    pub term: Option<String>,
+    /// Number of results to return (1-100, default 25)
+    #[serde(default)]
+    pub limit: Option<u8>,
+    /// Pagination cursor
+    pub cursor: Option<String>,
+}
+
+/// Parameters for app.bsky.actor.searchActorsTypeahead
+#[derive(Clone, Debug, Deserialize)]
+pub struct SearchActorsTypeaheadParams {
+    /// Search query string (prefix search)
+    pub q: Option<String>,
+    /// Deprecated: use 'q' instead
+    pub term: Option<String>,
+    /// Number of results to return (1-100, default 10)
+    #[serde(default)]
+    pub limit: Option<u8>,
+}
+
+/// Parameters for app.bsky.actor.getSuggestions
+#[derive(Clone, Debug, Deserialize)]
+pub struct GetSuggestionsParams {
+    /// Number of results to return (1-100, default 50)
+    #[serde(default)]
+    pub limit: Option<u8>,
+    /// Pagination cursor
+    pub cursor: Option<String>,
+}
diff --git a/lexica/src/app_bsky/graph.rs b/lexica/src/app_bsky/graph.rs
index a2b6b75b..95670428 100644
--- a/lexica/src/app_bsky/graph.rs
+++ b/lexica/src/app_bsky/graph.rs
@@ -116,7 +116,7 @@ pub struct StarterPackView {
     pub indexed_at: DateTime<Utc>,
 }
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StarterPackViewBasic {
     pub uri: String,
diff --git a/parakeet/src/entities/converters/profile.rs b/parakeet/src/entities/converters/profile.rs
index bc666872..deeb95a7 100644
--- a/parakeet/src/entities/converters/profile.rs
+++ b/parakeet/src/entities/converters/profile.rs
@@ -2,7 +2,7 @@
 ///
 /// This replaces the complex hydration layer with simple, direct conversions
 
-use crate::entities::core::ProfileEntity;
+use crate::entities::core::{ProfileEntity, PostEntity, StarterpackEntity};
 use parakeet_db::models::Actor;
 use lexica::app_bsky::actor::{
     ProfileView, ProfileViewDetailed, ProfileViewBasic,
@@ -10,6 +10,7 @@ use lexica::app_bsky::actor::{
     ProfileAssociatedActivitySubscription, ProfileAllowSubscriptions
 };
 use std::str::FromStr;
+use std::sync::Arc;
 
 /// Standalone function for converting Actor to ProfileView
 pub fn actor_to_profile_view(actor: &Actor) -> ProfileView {
@@ -81,11 +82,40 @@ impl ProfileEntity {
             // Additional optional fields
             pronouns: actor.profile_pronouns.clone(),
             website: actor.profile_website.clone(),
+            pinned_post: None,  // Would need pinned post data from actor.pinned_post
+            joined_via_starter_pack: None,  // Would need starter pack data
             verification: None,  // Would need verification data
             status: None,  // Would need status data
         }
     }
 
+    /// Convert an Actor to ProfileViewDetailed with enriched fields (pinned_post, joined_via_starter_pack)
+    ///
+    /// This version fetches additional data if the actor has pinned_post or joined_via_starter_pack
+    pub async fn actor_to_profile_view_detailed_enriched(
+        &self,
+        actor: &Actor,
+        post_entity: Option<&PostEntity>,
+        starterpack_entity: Option<&StarterpackEntity>,
+    ) -> ProfileViewDetailed {
+        let mut profile = self.actor_to_profile_view_detailed(actor);
+
+        // Populate pinned_post if available
+        if let (Some(pinned_rkey), Some(post_entity)) = (actor.profile_pinned_post_rkey, post_entity) {
+            // Use PostEntity's new method to get the post as a StrongRef
+            if let Ok(strong_ref) = post_entity.get_post_strong_ref(actor.id, pinned_rkey).await {
+                profile.pinned_post = strong_ref;
+            }
+        }
+
+        // Populate joined_via_starter_pack if available
+        if let (Some(sp_id), Some(starterpack_entity)) = (actor.profile_joined_sp_id, starterpack_entity) {
+            profile.joined_via_starter_pack = starterpack_entity.get_by_id(sp_id).await.ok().flatten();
+        }
+
+        profile
+    }
+
     /// Convert an Actor to ProfileView (simpler variant)
     pub fn actor_to_profile_view(&self, actor: &Actor) -> ProfileView {
         ProfileView {
@@ -168,6 +198,81 @@ impl ProfileEntity {
         actors.iter().map(|actor| self.actor_to_profile_view_detailed(actor)).collect()
     }
 
+    /// Get multiple ProfileViewDetailed with enriched fields (pinned posts, starter packs)
+    ///
+    /// This batch loads additional data efficiently for multiple profiles
+    pub async fn get_profile_views_detailed_enriched(
+        &self,
+        actor_ids: &[i32],
+        post_entity: Option<Arc<PostEntity>>,
+        starterpack_entity: Option<Arc<StarterpackEntity>>,
+    ) -> Vec<ProfileViewDetailed> {
+        let actors = self.get_profiles_by_ids(actor_ids).await.unwrap_or_default();
+
+        if actors.is_empty() {
+            return vec![];
+        }
+
+        // Collect all pinned post keys for batch loading
+        let mut pinned_post_keys = Vec::new();
+        for actor in &actors {
+            if let Some(rkey) = actor.profile_pinned_post_rkey {
+                pinned_post_keys.push((actor.id, rkey));
+            }
+        }
+
+        // Batch load pinned posts as StrongRefs if we have PostEntity
+        let pinned_posts = if !pinned_post_keys.is_empty() {
+            if let Some(ref post_entity) = post_entity {
+                post_entity.get_posts_strong_refs(&pinned_post_keys).await.unwrap_or_default()
+            } else {
+                std::collections::HashMap::new()
+            }
+        } else {
+            std::collections::HashMap::new()
+        };
+
+        // Collect all starter pack IDs for batch loading BEFORE consuming actors
+        let mut sp_ids = Vec::new();
+        for (i, actor) in actors.iter().enumerate() {
+            if let Some(sp_id) = actor.profile_joined_sp_id {
+                sp_ids.push((i, sp_id));
+            }
+        }
+
+        // Convert actors to ProfileViewDetailed with enriched data
+        let mut profiles = Vec::with_capacity(actors.len());
+        for actor in actors {
+            let mut profile = self.actor_to_profile_view_detailed(&actor);
+
+            // Add pinned post if available
+            if let Some(pinned_rkey) = actor.profile_pinned_post_rkey {
+                if let Some(strong_ref) = pinned_posts.get(&(actor.id, pinned_rkey)) {
+                    profile.pinned_post = Some(strong_ref.clone());
+                }
+            }
+
+            profiles.push(profile);
+        }
+
+        // Batch load starter packs if we have StarterpackEntity
+        if !sp_ids.is_empty() {
+            if let Some(ref starterpack_entity) = starterpack_entity {
+                let ids_to_fetch: Vec<i64> = sp_ids.iter().map(|(_, id)| *id).collect();
+                if let Ok(mut sp_map) = starterpack_entity.get_by_ids(&ids_to_fetch).await {
+                    // Update profiles with starter pack data
+                    for (profile_index, sp_id) in sp_ids {
+                        if let Some(sp_view) = sp_map.remove(&sp_id) {
+                            profiles[profile_index].joined_via_starter_pack = Some(sp_view);
+                        }
+                    }
+                }
+            }
+        }
+
+        profiles
+    }
+
     /// Resolve identifier and get ProfileViewDetailed
     pub async fn resolve_and_get_profile_view_detailed(&self, identifier: &str) -> Option<ProfileViewDetailed> {
         let actor_id = self.resolve_identifier(identifier).await.ok()?;
@@ -180,6 +285,17 @@ impl ProfileEntity {
         self.get_profile_views_detailed(&actor_ids).await
     }
 
+    /// Batch resolve identifiers and get ProfileViewDetailed with enriched fields
+    pub async fn resolve_and_get_profile_views_detailed_enriched(
+        &self,
+        identifiers: &[String],
+        post_entity: Option<Arc<PostEntity>>,
+        starterpack_entity: Option<Arc<StarterpackEntity>>,
+    ) -> Vec<ProfileViewDetailed> {
+        let actor_ids = self.resolve_identifiers(identifiers).await.unwrap_or_default();
+        self.get_profile_views_detailed_enriched(&actor_ids, post_entity, starterpack_entity).await
+    }
+
     /// Get ProfileView by actor_id
     pub async fn get_profile_view(&self, actor_id: i32) -> Option<ProfileView> {
         let actor = self.get_profile_by_id(actor_id).await.ok()?;
diff --git a/parakeet/src/entities/core/post.rs b/parakeet/src/entities/core/post.rs
index a7043f54..d7c7a9ee 100644
--- a/parakeet/src/entities/core/post.rs
+++ b/parakeet/src/entities/core/post.rs
@@ -8,6 +8,7 @@ use eyre::Result;
 use lexica::app_bsky::feed::{PostView, PostViewerState};
 use lexica::app_bsky::RecordStats;
 use lexica::app_bsky::embed::{Embed, ImageView, External};
+use lexica::StrongRef;
 use parakeet_db::models::{Post, Actor};
 use std::sync::Arc;
 use std::collections::HashMap;
@@ -63,6 +64,23 @@ pub struct PostData {
     pub author: Actor,
 }
 
+impl PostData {
+    /// Convert this post data to a StrongRef (AT URI + CID)
+    pub fn to_strong_ref(&self) -> Option<StrongRef> {
+        // Convert the CID bytes to the proper string format
+        let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&self.post.cid)?;
+
+        // Build the AT URI
+        let uri = format!(
+            "at://{}/app.bsky.feed.post/{}",
+            self.author.did,
+            parakeet_db::tid_util::encode_tid(self.post.rkey)
+        );
+
+        StrongRef::new_from_str(uri, &cid_str).ok()
+    }
+}
+
 impl PostEntity {
     /// Create a new PostEntity with the given configuration
     pub fn new(
@@ -151,6 +169,12 @@ impl PostEntity {
         Ok(key)
     }
 
+    /// Get a post as a StrongRef by actor_id and rkey
+    pub async fn get_post_strong_ref(&self, actor_id: i32, rkey: i64) -> Result<Option<StrongRef>> {
+        let post_data = self.get_post_by_key(actor_id, rkey).await?;
+        Ok(post_data.to_strong_ref())
+    }
+
     /// Get a post by composite key
     #[instrument(skip(self))]
     pub async fn get_post_by_key(&self, actor_id: i32, rkey: i64) -> Result<PostData> {
@@ -177,6 +201,22 @@ impl PostEntity {
         Ok(post_data)
     }
 
+    /// Batch load multiple posts as StrongRefs
+    /// Returns a map from (actor_id, rkey) to StrongRef for posts that exist
+    pub async fn get_posts_strong_refs(&self, keys: &[(i32, i64)]) -> Result<HashMap<(i32, i64), StrongRef>> {
+        let posts = self.get_posts_by_keys(keys).await?;
+        let mut result = HashMap::new();
+
+        for post_data in posts {
+            if let Some(strong_ref) = post_data.to_strong_ref() {
+                let key = (post_data.post.actor_id, post_data.post.rkey);
+                result.insert(key, strong_ref);
+            }
+        }
+
+        Ok(result)
+    }
+
     /// Batch get posts by composite keys
     #[instrument(skip(self))]
     pub async fn get_posts_by_keys(&self, keys: &[(i32, i64)]) -> Result<Vec<PostData>> {
diff --git a/parakeet/src/entities/core/starterpack.rs b/parakeet/src/entities/core/starterpack.rs
index 60cc8d14..72420a9a 100644
--- a/parakeet/src/entities/core/starterpack.rs
+++ b/parakeet/src/entities/core/starterpack.rs
@@ -35,6 +35,8 @@ pub struct StarterpackKey {
 /// Raw starterpack data from database
 #[derive(Debug, Clone, QueryableByName)]
 pub struct StarterpackData {
+    #[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::BigInt>)]
+    pub id: Option<i64>,  // Optional, only used when we need to track the DB ID
     #[diesel(sql_type = diesel::sql_types::Integer)]
     pub actor_id: i32,
     #[diesel(sql_type = diesel::sql_types::BigInt)]
@@ -161,6 +163,7 @@ impl StarterpackEntity {
 
         let query = format!(
             "SELECT
+                NULL::bigint as id,
                 actor_id, rkey, cid,
                 owner_actor_id,
                 name, description, description_facets,
@@ -222,6 +225,7 @@ impl StarterpackEntity {
 
         let query = format!(
             "SELECT
+                NULL::bigint as id,
                 actor_id, rkey, cid,
                 owner_actor_id,
                 name, description, description_facets,
@@ -443,6 +447,85 @@ impl StarterpackEntity {
         }
     }
 
+    /// Get a StarterPackViewBasic by database ID (not actor_id/rkey)
+    pub async fn get_by_id(&self, sp_id: i64) -> eyre::Result<Option<StarterPackViewBasic>> {
+        let mut conn = self.db_pool.get().await
+            .map_err(|e| diesel::result::Error::DatabaseError(
+                diesel::result::DatabaseErrorKind::UnableToSendCommand,
+                Box::new(e.to_string())
+            ))?;
+
+        let query = format!(
+            "SELECT
+                id,
+                actor_id, rkey, cid,
+                owner_actor_id,
+                name, description, description_facets,
+                list_actor_id, list_rkey::text as list_rkey
+             FROM starterpacks
+             WHERE id = {}",
+            sp_id
+        );
+
+        let data: Vec<StarterpackData> = diesel::sql_query(&query)
+            .load(&mut conn)
+            .await?;
+
+        if let Some(data) = data.into_iter().next() {
+            let view = self.build_starterpack_view_basic(data).await?;
+            Ok(Some(view))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Get multiple StarterPackViewBasic by database IDs
+    /// Returns a HashMap mapping database ID to StarterPackViewBasic
+    pub async fn get_by_ids(&self, sp_ids: &[i64]) -> eyre::Result<HashMap<i64, StarterPackViewBasic>> {
+        if sp_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let mut conn = self.db_pool.get().await
+            .map_err(|e| diesel::result::Error::DatabaseError(
+                diesel::result::DatabaseErrorKind::UnableToSendCommand,
+                Box::new(e.to_string())
+            ))?;
+
+        // Build query to load all starterpacks by IDs
+        let id_list = sp_ids.iter()
+            .map(|id| id.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        let query = format!(
+            "SELECT
+                id,
+                actor_id, rkey, cid,
+                owner_actor_id,
+                name, description, description_facets,
+                list_actor_id, list_rkey::text as list_rkey
+             FROM starterpacks
+             WHERE id IN ({})",
+            id_list
+        );
+
+        let starterpack_data: Vec<StarterpackData> = diesel::sql_query(&query)
+            .load(&mut conn)
+            .await?;
+
+        // Convert to StarterPackViewBasic and map by ID
+        let mut results = HashMap::new();
+        for data in starterpack_data {
+            if let Some(db_id) = data.id {
+                let view = self.build_starterpack_view_basic(data).await?;
+                results.insert(db_id, view);
+            }
+        }
+
+        Ok(results)
+    }
+
     /// Get all starterpacks with their owners
     pub async fn get_all_starterpacks_with_owners(
         &self,
diff --git a/parakeet/src/xrpc/app_bsky/actor.rs b/parakeet/src/xrpc/app_bsky/actor.rs
index 24e6f873..fdc5ac46 100644
--- a/parakeet/src/xrpc/app_bsky/actor.rs
+++ b/parakeet/src/xrpc/app_bsky/actor.rs
@@ -5,7 +5,13 @@ use axum::extract::{Query, State};
 use axum::response::{IntoResponse as _, Response};
 use axum::Json;
 use axum_extra::extract::Query as ExtraQuery;
-use lexica::app_bsky::actor::ProfileViewDetailed;
+use lexica::app_bsky::actor::{
+    ProfileView, ProfileViewBasic, ProfileViewDetailed,
+    GetProfilesResponse, GetProfilesParams,
+    SearchActorsResponse, SearchActorsParams,
+    SearchActorsTypeaheadResponse, SearchActorsTypeaheadParams,
+    GetSuggestionsResponse, GetSuggestionsParams,
+};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -16,32 +22,38 @@ pub struct ActorQuery {
 
 /// Handles the app.bsky.actor.getProfile endpoint
 ///
-/// Fetches a user's profile from our database using ProfileEntity with direct conversion.
+/// Fetches a user's profile from our database using ProfileEntity with enriched fields.
 pub async fn get_profile(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(_labelers): AtpAcceptLabelers,
     _maybe_auth: Option<AtpAuth>,
     Query(query): Query<ActorQuery>,
 ) -> XrpcResult<Response> {
-    // Use ProfileEntity with direct conversion (no hydration needed)
-    let profile = state.profile_entity
-        .resolve_and_get_profile_view_detailed(&query.actor)
+    // First resolve the actor ID
+    let actor_id = state.profile_entity
+        .resolve_identifier(&query.actor)
         .await
-        .ok_or_else(Error::not_found)?;
+        .map_err(|_| Error::not_found())?;
 
-    Ok(Json(profile).into_response())
-}
+    // Get the actor data
+    let actor = state.profile_entity
+        .get_profile_by_id(actor_id)
+        .await
+        .map_err(|_| Error::not_found())?;
 
-#[derive(Debug, Deserialize)]
-pub struct ActorsQuery {
-    pub actors: Vec<String>,
-}
+    // Convert with enriched fields (pinned post, starter pack)
+    let profile = state.profile_entity
+        .actor_to_profile_view_detailed_enriched(
+            &actor,
+            Some(&state.post_entity),
+            Some(&state.starterpack_entity),
+        )
+        .await;
 
-#[derive(Debug, Serialize)]
-pub struct GetProfilesRes {
-    profiles: Vec<ProfileViewDetailed>,
+    Ok(Json(profile).into_response())
 }
 
+
 /// Handles the app.bsky.actor.getProfiles endpoint
 ///
 /// Returns detailed profile information for multiple actors using ProfileEntity with direct conversion.
@@ -49,41 +61,24 @@ pub async fn get_profiles(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(_labelers): AtpAcceptLabelers,
     _maybe_auth: Option<AtpAuth>,
-    ExtraQuery(query): ExtraQuery<ActorsQuery>,
+    ExtraQuery(query): ExtraQuery<GetProfilesParams>,
 ) -> XrpcResult<Response> {
-    // Use ProfileEntity with direct conversion (no hydration needed)
+    // Use ProfileEntity with enriched conversion to include pinned posts
     let profiles = state.profile_entity
-        .resolve_and_get_profile_views_detailed(&query.actors)
+        .resolve_and_get_profile_views_detailed_enriched(
+            &query.actors,
+            Some(state.post_entity.clone()),
+            Some(state.starterpack_entity.clone()),
+        )
         .await;
 
-    Ok(Json(GetProfilesRes { profiles }).into_response())
+    Ok(Json(GetProfilesResponse { profiles }).into_response())
 }
 
 // ============================================================================
 // Search Endpoints
 // ============================================================================
 
-#[derive(Debug, Deserialize)]
-pub struct SearchActorsQuery {
-    pub q: Option<String>,
-    pub term: Option<String>, // Legacy parameter
-    #[serde(default)]
-    pub limit: Option<u8>,
-    pub cursor: Option<String>, // Only used by searchActors
-}
-
-#[derive(Debug, Serialize)]
-pub struct SearchActorsResponse {
-    pub actors: Vec<ProfileViewDetailed>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cursor: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct SearchActorsTypeaheadResponse {
-    pub actors: Vec<ProfileViewDetailed>,
-}
-
 /// Handles the app.bsky.actor.searchActors endpoint
 ///
 /// Full-text search across handles, display names, and descriptions.
@@ -92,7 +87,7 @@ pub async fn search_actors(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(_labelers): AtpAcceptLabelers,
     _maybe_auth: Option<AtpAuth>,
-    Query(query): Query<SearchActorsQuery>,
+    Query(query): Query<SearchActorsParams>,
 ) -> XrpcResult<Response> {
     // Get search term from either q or term parameter
     let search_term = query.q.or(query.term).ok_or_else(|| {
@@ -140,10 +135,10 @@ pub async fn search_actors(
         &results[..]
     };
 
-    // Get ProfileViewDetailed for each DID from search results
+    // Get ProfileView for each DID from search results
     let dids: Vec<String> = results_to_return.iter().map(|r| r.did.clone()).collect();
     let actors = state.profile_entity
-        .resolve_and_get_profile_views_detailed(&dids)
+        .resolve_and_get_profile_views(&dids)
         .await;
 
     // Calculate cursor (rank of last result)
@@ -164,7 +159,7 @@ pub async fn search_actors_typeahead(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(_labelers): AtpAcceptLabelers,
     _maybe_auth: Option<AtpAuth>,
-    Query(query): Query<SearchActorsQuery>,
+    Query(query): Query<SearchActorsTypeaheadParams>,
 ) -> XrpcResult<Response> {
     // Get search term
     let search_term = query.q.or(query.term).ok_or_else(|| {
@@ -199,9 +194,9 @@ pub async fn search_actors_typeahead(
             )
         })?;
 
-    // Get ProfileViewDetailed for each actor_id (maintaining order)
+    // Get ProfileViewBasic for each actor_id (typeahead returns basic views)
     let actors = state.profile_entity
-        .get_profile_views_detailed(&results)
+        .get_profile_views_basic(&results)
         .await;
 
     Ok(Json(SearchActorsTypeaheadResponse { actors }).into_response())
@@ -211,20 +206,6 @@ pub async fn search_actors_typeahead(
 // Suggestions (Discovery)
 // ============================================================================
 
-#[derive(Debug, Deserialize)]
-pub struct GetSuggestionsQuery {
-    #[serde(default)]
-    pub limit: Option<u16>,
-    pub cursor: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct GetSuggestionsRes {
-    pub actors: Vec<ProfileViewDetailed>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cursor: Option<String>,
-}
-
 /// Handles the app.bsky.actor.getSuggestions endpoint
 ///
 /// Returns popular, high-quality accounts for discovery and onboarding.
@@ -233,7 +214,7 @@ pub async fn get_suggestions(
     State(state): State<GlobalState>,
     AtpAcceptLabelers(labelers): AtpAcceptLabelers,
     maybe_auth: Option<AtpAuth>,
-    Query(query): Query<GetSuggestionsQuery>,
+    Query(query): Query<GetSuggestionsParams>,
 ) -> XrpcResult<Response> {
     let limit = query.limit.unwrap_or(25).clamp(1, 100) as usize;
     let offset = query
@@ -251,7 +232,7 @@ pub async fn get_suggestions(
         .map_err(|e| Error::server_error(Some(&e.to_string())))?;
 
     if all_dids.is_empty() {
-        return Ok(Json(GetSuggestionsRes {
+        return Ok(Json(GetSuggestionsResponse {
             actors: Vec::new(),
             cursor: None,
         })
@@ -336,20 +317,20 @@ pub async fn get_suggestions(
 
     // Use ProfileEntity with direct conversion
     let profiles_vec = state.profile_entity
-        .resolve_and_get_profile_views_detailed(&page_dids)
+        .resolve_and_get_profile_views(&page_dids)
         .await;
 
     // Create map for order preservation
-    let mut profiles_map: HashMap<String, ProfileViewDetailed> = profiles_vec
+    let mut profiles_map: HashMap<String, ProfileView> = profiles_vec
         .into_iter()
         .map(|profile| (profile.did.clone(), profile))
         .collect();
 
     // Maintain pagination order
-    let actors: Vec<ProfileViewDetailed> = page_dids
+    let actors: Vec<ProfileView> = page_dids
         .into_iter()
         .filter_map(|did| profiles_map.remove(&did))
         .collect();
 
-    Ok(Json(GetSuggestionsRes { actors, cursor }).into_response())
+    Ok(Json(GetSuggestionsResponse { actors, cursor }).into_response())
 }