feat: Viewer Interactions

lexica/src/app_bsky/actor.rs

···
 use crate::app_bsky::embed::External;
+use crate::app_bsky::graph::ListViewBasic;
 use crate::com_atproto::label::Label;
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::str::FromStr;
+
+#[derive(Clone, Default, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProfileViewerState {
+    pub muted: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub muted_by_list: Option<ListViewBasic>,
+    pub blocked_by: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub blocking: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub blocking_by_list: Option<ListViewBasic>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    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<()>,
+}
 
 #[derive(Clone, Default, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
···
     pub avatar: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub associated: Option<ProfileAssociated>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<ProfileViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
     #[serde(skip_serializing_if = "Option::is_none")]
···
     pub avatar: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub associated: Option<ProfileAssociated>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<ProfileViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
     #[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 viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<ProfileViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
     // #[serde(skip_serializing_if = "Option::is_none")]

lexica/src/app_bsky/feed.rs

···
 use super::RecordStats;
-use crate::app_bsky::actor::{ProfileView, ProfileViewBasic};
+use crate::app_bsky::actor::{ProfileView, ProfileViewBasic, ProfileViewerState};
 use crate::app_bsky::embed::Embed;
 use crate::app_bsky::graph::ListViewBasic;
 use crate::app_bsky::richtext::FacetMain;
···
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
+#[derive(Clone, Default, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PostViewerState {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub repost: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub like: Option<String>,
+    pub bookmarked: bool,
+    pub thread_muted: bool,
+    pub reply_disabled: bool,
+    pub embedding_disabled: bool,
+    pub pinned: bool,
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PostView {
···
 
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<PostViewerState>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub threadgate: Option<ThreadgateView>,
 
···
 
 #[derive(Clone, Debug, Serialize)]
 pub struct BlockedAuthor {
-    pub uri: String,
-    // pub viewer: Option<()>,
+    pub did: String,
+    pub viewer: Option<ProfileViewerState>,
+}
+
+#[derive(Clone, Default, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GeneratorViewerState {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub like: Option<String>,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     pub accepts_interactions: bool,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<GeneratorViewerState>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub content_mode: Option<GeneratorContentMode>,
 

lexica/src/app_bsky/graph.rs

···
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
+#[derive(Clone, Default, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListViewerState {
+    pub muted: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub blocked: Option<String>,
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListViewBasic {
···
     pub avatar: Option<String>,
     pub list_item_count: i64,
 
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<ListViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
 
···
     pub avatar: Option<String>,
     pub list_item_count: i64,
 
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<ListViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
 

lexica/src/app_bsky/labeler.rs

···
 use chrono::prelude::*;
 use serde::{Deserialize, Serialize};
 
+#[derive(Clone, Default, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LabelerViewerState {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub like: Option<String>,
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LabelerView {
···
     pub creator: ProfileView,
 
     pub like_count: i64,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<LabelerViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
     pub indexed_at: DateTime<Utc>,
···
     pub creator: ProfileView,
 
     pub like_count: i64,
-    // #[serde(skip_serializing_if = "Option::is_none")]
-    // pub viewer: Option<()>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub viewer: Option<LabelerViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
     pub policies: LabelerPolicy,

migrations/2025-09-17-190406_viewer-interactions/down.sql

···
+drop trigger t_profile_state_ins on follows;
+drop trigger t_profile_state_del on follows;
+drop trigger t_profile_state_ins on blocks;
+drop trigger t_profile_state_del on blocks;
+drop trigger t_profile_state_ins on mutes;
+drop trigger t_profile_state_del on mutes;
+
+drop function f_profile_state_ins_follow;
+drop function f_profile_state_del_follow;
+drop function f_profile_state_ins_block;
+drop function f_profile_state_del_block;
+drop function f_profile_state_ins_mute;
+drop function f_profile_state_del_mute;
+
+drop view v_list_mutes_exp;
+drop view v_list_block_exp;
+drop table profile_states;

migrations/2025-09-17-190406_viewer-interactions/up.sql

···
+create table profile_states
+(
+    did       text not null,
+    subject   text not null,
+    muting    bool not null default false, -- subj muted by did
+    blocked   bool not null default false, -- did blocked by subj
+    blocking  text,                        -- subj blocked by did
+    following text,                        -- rkey of follow record (did->subj)
+    followed  text,                        -- rkey of follow record (subj->did)
+
+    primary key (did, subject)
+);
+
+create index profilestates_did_index on profile_states using hash (did);
+create index profilestates_sub_index on profile_states using hash (subject);
+
+create view v_list_block_exp as
+(
+select lb.list_uri, did, li.subject
+from list_blocks lb
+         inner join list_items li on lb.list_uri = li.list_uri
+    );
+
+create view v_list_mutes_exp as
+(
+select lm.list_uri, did, li.subject
+from list_mutes lm
+         inner join list_items li on lm.list_uri = li.list_uri
+    );
+
+-- profile_states follow triggers
+create function f_profile_state_ins_follow() returns trigger
+    language plpgsql as
+$$
+begin
+    insert into profile_states (did, subject, following)
+    VALUES (NEW.did, NEW.subject, NEW.rkey)
+    ON CONFLICT (did, subject) DO UPDATE SET following=excluded.following;
+
+    insert into profile_states (did, subject, followed)
+    VALUES (NEW.subject, NEW.did, NEW.rkey)
+    ON CONFLICT (did, subject) DO UPDATE SET followed=excluded.followed;
+
+    return NEW;
+end;
+$$;
+
+create trigger t_profile_state_ins
+    before insert
+    on follows
+    for each row
+execute procedure f_profile_state_ins_follow();
+
+create function f_profile_state_del_follow() returns trigger
+    language plpgsql as
+$$
+begin
+    update profile_states set following = null where did = OLD.did and subject = OLD.subject;
+    update profile_states set followed = null where did = OLD.subject and subject = OLD.did;
+
+    return OLD;
+end;
+$$;
+
+create trigger t_profile_state_del
+    before delete
+    on follows
+    for each row
+execute procedure f_profile_state_del_follow();
+
+-- profile_states block triggers
+
+create function f_profile_state_ins_block() returns trigger
+    language plpgsql as
+$$
+begin
+    insert into profile_states (did, subject, blocking)
+    VALUES (NEW.did, NEW.subject, NEW.rkey)
+    ON CONFLICT (did, subject) DO UPDATE SET blocking=excluded.blocking;
+
+    insert into profile_states (did, subject, blocked)
+    VALUES (NEW.subject, NEW.did, TRUE)
+    ON CONFLICT (did, subject) DO UPDATE SET blocked=excluded.blocked;
+
+    return NEW;
+end;
+$$;
+
+create trigger t_profile_state_ins
+    before insert
+    on blocks
+    for each row
+execute procedure f_profile_state_ins_block();
+
+create function f_profile_state_del_block() returns trigger
+    language plpgsql as
+$$
+begin
+    update profile_states set blocking = null where did = OLD.did and subject = OLD.subject;
+    update profile_states set blocked = FALSE where did = OLD.subject and subject = OLD.did;
+
+    return OLD;
+end;
+$$;
+
+create trigger t_profile_state_del
+    before delete
+    on blocks
+    for each row
+execute procedure f_profile_state_del_block();
+
+-- profile_states mutes triggers
+
+create function f_profile_state_ins_mute() returns trigger
+    language plpgsql as
+$$
+begin
+    insert into profile_states (did, subject, muting)
+    VALUES (NEW.did, NEW.subject, TRUE)
+    ON CONFLICT (did, subject) DO UPDATE SET muting=excluded.muting;
+
+    return NEW;
+end;
+$$;
+
+create trigger t_profile_state_ins
+    before insert
+    on mutes
+    for each row
+execute procedure f_profile_state_ins_mute();
+
+create function f_profile_state_del_mute() returns trigger
+    language plpgsql as
+$$
+begin
+    update profile_states set muting = false where did = OLD.did and subject = OLD.subject;
+
+    return OLD;
+end;
+$$;
+
+create trigger t_profile_state_del
+    before delete
+    on mutes
+    for each row
+execute procedure f_profile_state_del_mute();

parakeet-db/src/schema.rs

···
 }
 
 diesel::table! {
+    profile_states (did, subject) {
+        did -> Text,
+        subject -> Text,
+        muting -> Bool,
+        blocked -> Bool,
+        blocking -> Nullable<Text>,
+        following -> Nullable<Text>,
+        followed -> Nullable<Text>,
+    }
+}
+
+diesel::table! {
     profiles (did) {
         did -> Text,
         cid -> Text,
···
     post_embed_video_captions,
     postgates,
     posts,
+    profile_states,
     profiles,
     records,
     reposts,

parakeet/src/db.rs

···
 use diesel::prelude::*;
+use diesel::sql_types::{Array, Bool, Nullable, Text};
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use parakeet_db::{schema, types};
 
···
         .await
         .optional()
 }
+
+#[derive(Clone, Debug, QueryableByName)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct ProfileStateRet {
+    #[diesel(sql_type = Text)]
+    pub did: String,
+    #[diesel(sql_type = Text)]
+    pub subject: String,
+    #[diesel(sql_type = Nullable<Bool>)]
+    pub muting: Option<bool>,
+    #[diesel(sql_type = Nullable<Bool>)]
+    pub blocked: Option<bool>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub blocking: Option<String>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub following: Option<String>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub followed: Option<String>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub list_block: Option<String>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub list_mute: Option<String>,
+}
+pub async fn get_profile_state(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    sub: &str,
+) -> QueryResult<Option<ProfileStateRet>> {
+    diesel::sql_query(include_str!("sql/profile_state.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(vec![sub])
+        .get_result::<ProfileStateRet>(conn)
+        .await
+        .optional()
+}
+pub async fn get_profile_states(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    sub: &[String],
+) -> QueryResult<Vec<ProfileStateRet>> {
+    diesel::sql_query(include_str!("sql/profile_state.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(sub)
+        .load::<ProfileStateRet>(conn)
+        .await
+}
+
+#[derive(Clone, Debug, QueryableByName)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct PostStateRet {
+    #[diesel(sql_type = diesel::sql_types::Text)]
+    pub at_uri: String,
+    #[diesel(sql_type = diesel::sql_types::Text)]
+    pub did: String,
+    #[diesel(sql_type = diesel::sql_types::Text)]
+    pub cid: String,
+    #[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::Text>)]
+    pub like_rkey: Option<String>,
+    #[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::Text>)]
+    pub repost_rkey: Option<String>,
+    #[diesel(sql_type = diesel::sql_types::Bool)]
+    pub bookmarked: bool,
+    // #[diesel(sql_type = diesel::sql_types::Bool)]
+    // pub muted: bool,
+    #[diesel(sql_type = diesel::sql_types::Bool)]
+    pub embed_disabled: bool,
+    #[diesel(sql_type = diesel::sql_types::Bool)]
+    pub pinned: bool,
+}
+pub async fn get_post_state(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    subject: &str,
+) -> QueryResult<Option<PostStateRet>> {
+    diesel::sql_query(include_str!("sql/post_state.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(vec![subject])
+        .get_result::<PostStateRet>(conn)
+        .await
+        .optional()
+}
+
+pub async fn get_post_states(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    sub: &[String],
+) -> QueryResult<Vec<PostStateRet>> {
+    diesel::sql_query(include_str!("sql/post_state.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(sub)
+        .load::<PostStateRet>(conn)
+        .await
+}
+
+#[derive(Clone, Debug, QueryableByName)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct ListStateRet {
+    #[diesel(sql_type = Text)]
+    pub at_uri: String,
+    #[diesel(sql_type = Bool)]
+    pub muted: bool,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub block: Option<String>,
+}
+
+pub async fn get_list_state(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    subject: &str,
+) -> QueryResult<Option<ListStateRet>> {
+    diesel::sql_query(include_str!("sql/list_states.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(vec![subject])
+        .get_result::<ListStateRet>(conn)
+        .await
+        .optional()
+}
+
+pub async fn get_list_states(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    sub: &[String],
+) -> QueryResult<Vec<ListStateRet>> {
+    diesel::sql_query(include_str!("sql/list_states.sql"))
+        .bind::<Text, _>(did)
+        .bind::<Array<Text>, _>(sub)
+        .load::<ListStateRet>(conn)
+        .await
+}
+
+pub async fn get_like_state(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    subject: &str,
+) -> QueryResult<Option<(String, String)>> {
+    schema::likes::table
+        .select((schema::likes::did, schema::likes::rkey))
+        .filter(
+            schema::likes::did
+                .eq(did)
+                .and(schema::likes::subject.eq(subject)),
+        )
+        .get_result(conn)
+        .await
+        .optional()
+}
+
+pub async fn get_like_states(
+    conn: &mut AsyncPgConnection,
+    did: &str,
+    sub: &[String],
+) -> QueryResult<Vec<(String, String, String)>> {
+    schema::likes::table
+        .select((
+            schema::likes::subject,
+            schema::likes::did,
+            schema::likes::rkey,
+        ))
+        .filter(
+            schema::likes::did
+                .eq(did)
+                .and(schema::likes::subject.eq_any(sub)),
+        )
+        .load(conn)
+        .await
+}

parakeet/src/hydration/feedgen.rs

···
 use crate::hydration::map_labels;
 use crate::xrpc::cdn::BskyCdn;
 use lexica::app_bsky::actor::ProfileView;
-use lexica::app_bsky::feed::{GeneratorContentMode, GeneratorView};
+use lexica::app_bsky::feed::{GeneratorContentMode, GeneratorView, GeneratorViewerState};
 use parakeet_db::models;
 use std::collections::HashMap;
 use std::str::FromStr;
 
+fn build_viewer((did, rkey): (String, String)) -> GeneratorViewerState {
+    GeneratorViewerState {
+        like: Some(format!("at://{did}/app.bsky.feed.like/{rkey}")),
+    }
+}
+
 fn build_feedgen(
     feedgen: models::FeedGen,
     creator: ProfileView,
     labels: Vec<models::Label>,
     likes: Option<i32>,
+    viewer: Option<GeneratorViewerState>,
     cdn: &BskyCdn,
 ) -> GeneratorView {
     let content_mode = feedgen
···
         like_count: likes.unwrap_or_default() as i64,
         accepts_interactions: feedgen.accepts_interactions,
         labels: map_labels(labels),
+        viewer,
         content_mode,
         indexed_at: feedgen.created_at,
     }
···
 impl super::StatefulHydrator<'_> {
     pub async fn hydrate_feedgen(&self, feedgen: String) -> Option<GeneratorView> {
         let labels = self.get_label(&feedgen).await;
+        let viewer = self.get_feedgen_viewer_state(&feedgen).await;
         let likes = self.loaders.like.load(feedgen.clone()).await;
         let feedgen = self.loaders.feedgen.load(feedgen).await?;
         let profile = self.hydrate_profile(feedgen.owner.clone()).await?;
 
-        Some(build_feedgen(feedgen, profile, labels, likes, &self.cdn))
+        Some(build_feedgen(
+            feedgen, profile, labels, likes, viewer, &self.cdn,
+        ))
     }
 
     pub async fn hydrate_feedgens(&self, feedgens: Vec<String>) -> HashMap<String, GeneratorView> {
         let labels = self.get_label_many(&feedgens).await;
+        let viewers = self.get_feedgen_viewer_states(&feedgens).await;
         let mut likes = self.loaders.like.load_many(feedgens.clone()).await;
         let feedgens = self.loaders.feedgen.load_many(feedgens).await;
 
···
             .into_iter()
             .filter_map(|(uri, feedgen)| {
                 let creator = creators.get(&feedgen.owner).cloned()?;
+                let viewer = viewers.get(&uri).cloned();
                 let labels = labels.get(&uri).cloned().unwrap_or_default();
                 let likes = likes.remove(&uri);
 
                 Some((
                     uri,
-                    build_feedgen(feedgen, creator, labels, likes, &self.cdn),
+                    build_feedgen(feedgen, creator, labels, likes, viewer, &self.cdn),
                 ))
             })
             .collect()
+    }
+
+    async fn get_feedgen_viewer_state(&self, subject: &str) -> Option<GeneratorViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.like_state.get(viewer, subject).await?;
+
+            Some(build_viewer(data))
+        } else {
+            None
+        }
+    }
+
+    async fn get_feedgen_viewer_states(
+        &self,
+        subjects: &[String],
+    ) -> HashMap<String, GeneratorViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.like_state.get_many(viewer, subjects).await;
+
+            data.into_iter()
+                .map(|(k, state)| (k, build_viewer(state)))
+                .collect()
+        } else {
+            HashMap::new()
+        }
     }
 }

parakeet/src/hydration/labeler.rs

···
 use crate::hydration::{map_labels, StatefulHydrator};
 use lexica::app_bsky::actor::ProfileView;
-use lexica::app_bsky::labeler::{LabelerPolicy, LabelerView, LabelerViewDetailed};
+use lexica::app_bsky::labeler::{
+    LabelerPolicy, LabelerView, LabelerViewDetailed, LabelerViewerState,
+};
 use lexica::com_atproto::label::{Blurs, LabelValueDefinition, Severity};
 use lexica::com_atproto::moderation::{ReasonType, SubjectType};
 use parakeet_db::models;
 use std::collections::HashMap;
 use std::str::FromStr;
 
+fn build_viewer((did, rkey): (String, String)) -> LabelerViewerState {
+    LabelerViewerState {
+        like: Some(format!("at://{did}/app.bsky.feed.like/{rkey}")),
+    }
+}
+
 fn build_view(
     labeler: models::LabelerService,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    viewer: Option<LabelerViewerState>,
     likes: Option<i32>,
 ) -> LabelerView {
     LabelerView {
···
         cid: labeler.cid,
         creator,
         like_count: likes.unwrap_or_default() as i64,
+        viewer,
         labels: map_labels(labels),
         indexed_at: labeler.indexed_at.and_utc(),
     }
···
     defs: Vec<models::LabelDefinition>,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    viewer: Option<LabelerViewerState>,
     likes: Option<i32>,
 ) -> LabelerViewDetailed {
     let reason_types = labeler.reasons.map(|v| {
···
         cid: labeler.cid,
         creator,
         like_count: likes.unwrap_or_default() as i64,
+        viewer,
         policies: LabelerPolicy {
             label_values,
             label_value_definitions,
···
 impl StatefulHydrator<'_> {
     pub async fn hydrate_labeler(&self, labeler: String) -> Option<LabelerView> {
         let labels = self.get_label(&labeler).await;
+        let viewer = self.get_labeler_viewer_state(&labeler).await;
         let likes = self.loaders.like.load(make_labeler_uri(&labeler)).await;
         let (labeler, _) = self.loaders.labeler.load(labeler).await?;
         let creator = self.hydrate_profile(labeler.did.clone()).await?;
 
-        Some(build_view(labeler, creator, labels, likes))
+        Some(build_view(labeler, creator, labels, viewer, likes))
     }
 
     pub async fn hydrate_labelers(&self, labelers: Vec<String>) -> HashMap<String, LabelerView> {
···
             .values()
             .map(|(labeler, _)| (labeler.did.clone(), make_labeler_uri(&labeler.did)))
             .unzip::<_, _, Vec<_>, Vec<_>>();
+        let viewers = self.get_labeler_viewer_states(&uris).await;
         let creators = self.hydrate_profiles(creators).await;
         let mut likes = self.loaders.like.load_many(uris.clone()).await;
 
···
                 let creator = creators.get(&labeler.did).cloned()?;
                 let labels = labels.get(&k).cloned().unwrap_or_default();
                 let likes = likes.remove(&make_labeler_uri(&labeler.did));
+                let viewer = viewers.get(&make_labeler_uri(&k)).cloned();
 
-                Some((k, build_view(labeler, creator, labels, likes)))
+                Some((k, build_view(labeler, creator, labels, viewer, likes)))
             })
             .collect()
     }
 
     pub async fn hydrate_labeler_detailed(&self, labeler: String) -> Option<LabelerViewDetailed> {
         let labels = self.get_label(&labeler).await;
+        let viewer = self.get_labeler_viewer_state(&labeler).await;
         let likes = self.loaders.like.load(make_labeler_uri(&labeler)).await;
         let (labeler, defs) = self.loaders.labeler.load(labeler).await?;
         let creator = self.hydrate_profile(labeler.did.clone()).await?;
 
-        Some(build_view_detailed(labeler, defs, creator, labels, likes))
+        Some(build_view_detailed(
+            labeler, defs, creator, labels, viewer, likes,
+        ))
     }
 
     pub async fn hydrate_labelers_detailed(
···
             .values()
             .map(|(labeler, _)| (labeler.did.clone(), make_labeler_uri(&labeler.did)))
             .unzip::<_, _, Vec<_>, Vec<_>>();
+        let viewers = self.get_labeler_viewer_states(&uris).await;
         let creators = self.hydrate_profiles(creators).await;
         let mut likes = self.loaders.like.load_many(uris.clone()).await;
 
···
                 let creator = creators.get(&labeler.did).cloned()?;
                 let labels = labels.get(&k).cloned().unwrap_or_default();
                 let likes = likes.remove(&make_labeler_uri(&labeler.did));
+                let viewer = viewers.get(&make_labeler_uri(&k)).cloned();
 
-                let view = build_view_detailed(labeler, defs, creator, labels, likes);
+                let view = build_view_detailed(labeler, defs, creator, labels, viewer, likes);
 
                 Some((k, view))
             })
             .collect()
+    }
+
+    async fn get_labeler_viewer_state(&self, subject: &str) -> Option<LabelerViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self
+                .loaders
+                .like_state
+                .get(&make_labeler_uri(viewer), subject)
+                .await?;
+
+            Some(build_viewer(data))
+        } else {
+            None
+        }
+    }
+
+    async fn get_labeler_viewer_states(
+        &self,
+        subjects: &[String],
+    ) -> HashMap<String, LabelerViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.like_state.get_many(viewer, subjects).await;
+
+            data.into_iter()
+                .map(|(k, state)| (k, build_viewer(state)))
+                .collect()
+        } else {
+            HashMap::new()
+        }
     }
 }
 

parakeet/src/hydration/list.rs

···
+use crate::db::ListStateRet;
 use crate::hydration::{map_labels, StatefulHydrator};
 use crate::xrpc::cdn::BskyCdn;
 use lexica::app_bsky::actor::ProfileView;
-use lexica::app_bsky::graph::{ListPurpose, ListView, ListViewBasic};
+use lexica::app_bsky::graph::{ListPurpose, ListView, ListViewBasic, ListViewerState};
 use parakeet_db::models;
 use std::collections::HashMap;
 use std::str::FromStr;
 
+fn build_viewer(data: ListStateRet) -> ListViewerState {
+    ListViewerState {
+        muted: data.muted,
+        blocked: data.block,
+    }
+}
+
 fn build_basic(
     list: models::List,
     list_item_count: i64,
     labels: Vec<models::Label>,
+    viewer: Option<ListViewerState>,
     cdn: &BskyCdn,
 ) -> Option<ListViewBasic> {
     let purpose = ListPurpose::from_str(&list.list_type).ok()?;
···
         purpose,
         avatar,
         list_item_count,
+        viewer,
         labels: map_labels(labels),
         indexed_at: list.created_at,
     })
···
     list_item_count: i64,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    viewer: Option<ListViewerState>,
     cdn: &BskyCdn,
 ) -> Option<ListView> {
     let purpose = ListPurpose::from_str(&list.list_type).ok()?;
···
         description_facets,
         avatar,
         list_item_count,
+        viewer,
         labels: map_labels(labels),
         indexed_at: list.created_at,
     })
···
 impl StatefulHydrator<'_> {
     pub async fn hydrate_list_basic(&self, list: String) -> Option<ListViewBasic> {
         let labels = self.get_label(&list).await;
+        let viewer = self.get_list_viewer_state(&list).await;
         let (list, count) = self.loaders.list.load(list).await?;
 
-        build_basic(list, count, labels, &self.cdn)
+        build_basic(list, count, labels, viewer, &self.cdn)
     }
 
     pub async fn hydrate_lists_basic(&self, lists: Vec<String>) -> HashMap<String, ListViewBasic> {
         let labels = self.get_label_many(&lists).await;
+        let viewers = self.get_list_viewer_states(&lists).await;
         let lists = self.loaders.list.load_many(lists).await;
 
         lists
             .into_iter()
             .filter_map(|(uri, (list, count))| {
                 let labels = labels.get(&uri).cloned().unwrap_or_default();
+                let viewer = viewers.get(&uri).cloned();
 
-                build_basic(list, count, labels, &self.cdn).map(|v| (uri, v))
+                build_basic(list, count, labels, viewer, &self.cdn).map(|v| (uri, v))
             })
             .collect()
     }
 
     pub async fn hydrate_list(&self, list: String) -> Option<ListView> {
         let labels = self.get_label(&list).await;
+        let viewer = self.get_list_viewer_state(&list).await;
         let (list, count) = self.loaders.list.load(list).await?;
         let profile = self.hydrate_profile(list.owner.clone()).await?;
 
-        build_listview(list, count, profile, labels, &self.cdn)
+        build_listview(list, count, profile, labels, viewer, &self.cdn)
     }
 
     pub async fn hydrate_lists(&self, lists: Vec<String>) -> HashMap<String, ListView> {
         let labels = self.get_label_many(&lists).await;
+        let viewers = self.get_list_viewer_states(&lists).await;
         let lists = self.loaders.list.load_many(lists).await;
 
         let creators = lists.values().map(|(list, _)| list.owner.clone()).collect();
···
             .into_iter()
             .filter_map(|(uri, (list, count))| {
                 let creator = creators.get(&list.owner)?;
+                let viewer = viewers.get(&uri).cloned();
                 let labels = labels.get(&uri).cloned().unwrap_or_default();
 
-                build_listview(list, count, creator.to_owned(), labels, &self.cdn).map(|v| (uri, v))
+                build_listview(list, count, creator.to_owned(), labels, viewer, &self.cdn)
+                    .map(|v| (uri, v))
             })
             .collect()
+    }
+
+    async fn get_list_viewer_state(&self, subject: &str) -> Option<ListViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.list_state.get(viewer, subject).await?;
+
+            Some(build_viewer(data))
+        } else {
+            None
+        }
+    }
+
+    async fn get_list_viewer_states(
+        &self,
+        subjects: &[String],
+    ) -> HashMap<String, ListViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.list_state.get_many(viewer, subjects).await;
+
+            data.into_iter()
+                .map(|(k, state)| (k, build_viewer(state)))
+                .collect()
+        } else {
+            HashMap::new()
+        }
     }
 }

parakeet/src/hydration/posts.rs

···
+use crate::db::PostStateRet;
 use crate::hydration::{map_labels, StatefulHydrator};
 use lexica::app_bsky::actor::ProfileViewBasic;
 use lexica::app_bsky::embed::Embed;
-use lexica::app_bsky::feed::{FeedViewPost, PostView, ReplyRef, ReplyRefPost, ThreadgateView};
+use lexica::app_bsky::feed::{
+    BlockedAuthor, FeedViewPost, PostView, PostViewerState, ReplyRef, ReplyRefPost, ThreadgateView,
+};
 use lexica::app_bsky::graph::ListViewBasic;
 use lexica::app_bsky::RecordStats;
 use parakeet_db::models;
 use parakeet_index::PostStats;
 use std::collections::HashMap;
 
+fn build_viewer(did: &str, data: PostStateRet) -> PostViewerState {
+    let is_me = did == data.did;
+
+    let repost = data
+        .repost_rkey
+        .map(|rkey| format!("at://{did}/app.bsky.feed.repost/{rkey}"));
+    let like = data
+        .like_rkey
+        .map(|rkey| format!("at://{did}/app.bsky.feed.like/{rkey}"));
+
+    PostViewerState {
+        repost,
+        like,
+        bookmarked: data.bookmarked,
+        thread_muted: false, // todo when we have thread mutes
+        reply_disabled: false,
+        embedding_disabled: data.embed_disabled && !is_me, // poster can always bypass embed disabled.
+        pinned: data.pinned,
+    }
+}
+
 fn build_postview(
     post: models::Post,
     author: ProfileViewBasic,
     labels: Vec<models::Label>,
     embed: Option<Embed>,
     threadgate: Option<ThreadgateView>,
+    viewer: Option<PostViewerState>,
     stats: Option<PostStats>,
 ) -> PostView {
     let stats = stats
···
         embed,
         stats,
         labels: map_labels(labels),
+        viewer,
         threadgate,
         indexed_at: post.created_at,
     }
···
     pub async fn hydrate_post(&self, post: String) -> Option<PostView> {
         let stats = self.loaders.post_stats.load(post.clone()).await;
         let (post, threadgate) = self.loaders.posts.load(post).await?;
+        let viewer = self.get_post_viewer_state(&post.at_uri).await;
         let embed = self.hydrate_embed(post.at_uri.clone()).await;
         let author = self.hydrate_profile_basic(post.did.clone()).await?;
         let threadgate = self.hydrate_threadgate(threadgate).await;
         let labels = self.get_label(&post.at_uri).await;
 
         Some(build_postview(
-            post, author, labels, embed, threadgate, stats,
+            post, author, labels, embed, threadgate, viewer, stats,
         ))
     }
 
···
         let authors = self.hydrate_profiles_basic(authors).await;
 
         let post_labels = self.get_label_many(&post_uris).await;
+        let viewer_data = self.get_post_viewer_states(&post_uris).await;
 
         let threadgates = posts
             .values()
···
                 let threadgate = threadgate.and_then(|tg| threadgates.get(&tg.at_uri).cloned());
                 let labels = post_labels.get(&uri).cloned().unwrap_or_default();
                 let stats = stats.get(&uri).cloned();
+                let viewer = viewer_data.get(&uri).cloned();
 
                 Some((
                     uri,
-                    build_postview(post, author.to_owned(), labels, embed, threadgate, stats),
+                    build_postview(
+                        post,
+                        author.to_owned(),
+                        labels,
+                        embed,
+                        threadgate,
+                        viewer,
+                        stats,
+                    ),
                 ))
             })
             .collect()
···
         let authors = self.hydrate_profiles_basic(authors).await;
 
         let post_labels = self.get_label_many(&post_uris).await;
-
+        let viewer_data = self.get_post_viewer_states(&post_uris).await;
         let embeds = self.hydrate_embeds(post_uris).await;
 
         let reply_refs = posts
···
 
                 let reply = if post.parent_uri.is_some() && post.root_uri.is_some() {
                     Some(ReplyRef {
-                        root: root.cloned().map(ReplyRefPost::Post).unwrap_or(
+                        root: root.cloned().map(postview_to_replyref).unwrap_or(
                             ReplyRefPost::NotFound {
                                 uri: post.root_uri.as_ref().unwrap().clone(),
                                 not_found: true,
                             },
                         ),
-                        parent: parent.cloned().map(ReplyRefPost::Post).unwrap_or(
+                        parent: parent.cloned().map(postview_to_replyref).unwrap_or(
                             ReplyRefPost::NotFound {
                                 uri: post.parent_uri.as_ref().unwrap().clone(),
                                 not_found: true,
···
                 let embed = embeds.get(&post_uri).cloned();
                 let labels = post_labels.get(&post_uri).cloned().unwrap_or_default();
                 let stats = stats.get(&post_uri).cloned();
-                let post = build_postview(post, author.to_owned(), labels, embed, None, stats);
+                let viewer = viewer_data.get(&post_uri).cloned();
+                let post =
+                    build_postview(post, author.to_owned(), labels, embed, None, viewer, stats);
 
                 Some((
                     post_uri,
···
                 ))
             })
             .collect()
+    }
+
+    async fn get_post_viewer_state(&self, subject: &str) -> Option<PostViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.post_state.get(viewer, subject).await?;
+
+            Some(build_viewer(viewer, data))
+        } else {
+            None
+        }
+    }
+
+    async fn get_post_viewer_states(
+        &self,
+        subjects: &[String],
+    ) -> HashMap<String, PostViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.post_state.get_many(viewer, subjects).await;
+
+            data.into_iter()
+                .map(|(k, state)| (k, build_viewer(viewer, state)))
+                .collect()
+        } else {
+            HashMap::new()
+        }
+    }
+}
+
+fn postview_to_replyref(post: PostView) -> ReplyRefPost {
+    match &post.author.viewer {
+        Some(v) if v.blocked_by || v.blocking.is_some() => ReplyRefPost::Blocked {
+            uri: post.uri,
+            blocked: true,
+            author: BlockedAuthor {
+                did: post.author.did.clone(),
+                viewer: post.author.viewer,
+            },
+        },
+        _ => ReplyRefPost::Post(post),
     }
 }

parakeet/src/hydration/profile.rs

···
+use crate::db::ProfileStateRet;
 use crate::hydration::map_labels;
 use crate::loaders::ProfileLoaderRet;
 use crate::xrpc::cdn::BskyCdn;
···
 use chrono::TimeDelta;
 use lexica::app_bsky::actor::*;
 use lexica::app_bsky::embed::External;
+use lexica::app_bsky::graph::ListViewBasic;
 use parakeet_db::models;
 use parakeet_index::ProfileStats;
 use std::collections::HashMap;
···
         })
     } else {
         None
+    }
+}
+
+fn build_viewer(
+    data: ProfileStateRet,
+    list_mute: Option<ListViewBasic>,
+    list_block: Option<ListViewBasic>,
+) -> ProfileViewerState {
+    let following = data
+        .following
+        .map(|rkey| format!("at://{}/app.bsky.graph.follow/{rkey}", data.did));
+    let followed_by = data
+        .followed
+        .map(|rkey| format!("at://{}/app.bsky.graph.follow/{rkey}", data.subject));
+
+    let blocking = data.list_block.or(data.blocking);
+
+    ProfileViewerState {
+        muted: data.muting.unwrap_or_default(),
+        muted_by_list: list_mute,
+        blocked_by: data.blocked.unwrap_or_default(), // TODO: this doesn't factor for blocklists atm
+        blocking,
+        blocking_by_list: list_block,
+        following,
+        followed_by,
     }
 }
 
···
     stats: Option<ProfileStats>,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    viewer: Option<ProfileViewerState>,
     cdn: &BskyCdn,
 ) -> ProfileViewBasic {
     let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
···
         display_name: profile.display_name,
         avatar,
         associated,
+        viewer,
         labels: map_labels(labels),
         verification,
         status,
···
     stats: Option<ProfileStats>,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    viewer: Option<ProfileViewerState>,
     cdn: &BskyCdn,
 ) -> ProfileView {
     let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
···
         description: profile.description,
         avatar,
         associated,
+        viewer,
         labels: map_labels(labels),
         verification,
         status,
···
     stats: Option<ProfileStats>,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    viewer: Option<ProfileViewerState>,
     cdn: &BskyCdn,
 ) -> ProfileViewDetailed {
     let associated = build_associated(chat_decl, is_labeler, stats, notif_decl);
···
         followers_count: stats.map(|v| v.followers as i64).unwrap_or_default(),
         follows_count: stats.map(|v| v.following as i64).unwrap_or_default(),
         associated,
+        viewer,
         labels: map_labels(labels),
         verification,
         status,
···
 impl super::StatefulHydrator<'_> {
     pub async fn hydrate_profile_basic(&self, did: String) -> Option<ProfileViewBasic> {
         let labels = self.get_profile_label(&did).await;
+        let viewer = self.get_profile_viewer_state(&did).await;
         let verif = self.loaders.verification.load(did.clone()).await;
         let stats = self.loaders.profile_stats.load(did.clone()).await;
         let profile_info = self.loaders.profile.load(did).await?;
 
-        Some(build_basic(profile_info, stats, labels, verif, &self.cdn))
+        Some(build_basic(
+            profile_info,
+            stats,
+            labels,
+            verif,
+            viewer,
+            &self.cdn,
+        ))
     }
 
     pub async fn hydrate_profiles_basic(
···
         dids: Vec<String>,
     ) -> HashMap<String, ProfileViewBasic> {
         let labels = self.get_profile_label_many(&dids).await;
+        let viewers = self.get_profile_viewer_states(&dids).await;
         let verif = self.loaders.verification.load_many(dids.clone()).await;
         let stats = self.loaders.profile_stats.load_many(dids.clone()).await;
         let profiles = self.loaders.profile.load_many(dids).await;
···
             .map(|(k, profile_info)| {
                 let labels = labels.get(&k).cloned().unwrap_or_default();
                 let verif = verif.get(&k).cloned();
+                let viewer = viewers.get(&k).cloned();
                 let stats = stats.get(&k).cloned();
 
-                let v = build_basic(profile_info, stats, labels, verif, &self.cdn);
+                let v = build_basic(profile_info, stats, labels, verif, viewer, &self.cdn);
                 (k, v)
             })
             .collect()
···
 
     pub async fn hydrate_profile(&self, did: String) -> Option<ProfileView> {
         let labels = self.get_profile_label(&did).await;
+        let viewer = self.get_profile_viewer_state(&did).await;
         let verif = self.loaders.verification.load(did.clone()).await;
         let stats = self.loaders.profile_stats.load(did.clone()).await;
         let profile_info = self.loaders.profile.load(did).await?;
 
-        Some(build_profile(profile_info, stats, labels, verif, &self.cdn))
+        Some(build_profile(
+            profile_info,
+            stats,
+            labels,
+            verif,
+            viewer,
+            &self.cdn,
+        ))
     }
 
     pub async fn hydrate_profiles(&self, dids: Vec<String>) -> HashMap<String, ProfileView> {
         let labels = self.get_profile_label_many(&dids).await;
+        let viewers = self.get_profile_viewer_states(&dids).await;
         let verif = self.loaders.verification.load_many(dids.clone()).await;
         let stats = self.loaders.profile_stats.load_many(dids.clone()).await;
         let profiles = self.loaders.profile.load_many(dids).await;
···
             .map(|(k, profile_info)| {
                 let labels = labels.get(&k).cloned().unwrap_or_default();
                 let verif = verif.get(&k).cloned();
+                let viewer = viewers.get(&k).cloned();
                 let stats = stats.get(&k).cloned();
 
-                let v = build_profile(profile_info, stats, labels, verif, &self.cdn);
+                let v = build_profile(profile_info, stats, labels, verif, viewer, &self.cdn);
                 (k, v)
             })
             .collect()
···
 
     pub async fn hydrate_profile_detailed(&self, did: String) -> Option<ProfileViewDetailed> {
         let labels = self.get_profile_label(&did).await;
+        let viewer = self.get_profile_viewer_state(&did).await;
         let verif = self.loaders.verification.load(did.clone()).await;
         let stats = self.loaders.profile_stats.load(did.clone()).await;
         let profile_info = self.loaders.profile.load(did).await?;
···
             stats,
             labels,
             verif,
+            viewer,
             &self.cdn,
         ))
     }
···
         dids: Vec<String>,
     ) -> HashMap<String, ProfileViewDetailed> {
         let labels = self.get_profile_label_many(&dids).await;
+        let viewers = self.get_profile_viewer_states(&dids).await;
         let verif = self.loaders.verification.load_many(dids.clone()).await;
         let stats = self.loaders.profile_stats.load_many(dids.clone()).await;
         let profiles = self.loaders.profile.load_many(dids).await;
···
             .map(|(k, profile_info)| {
                 let labels = labels.get(&k).cloned().unwrap_or_default();
                 let verif = verif.get(&k).cloned();
+                let viewer = viewers.get(&k).cloned();
                 let stats = stats.get(&k).cloned();
 
-                let v = build_detailed(profile_info, stats, labels, verif, &self.cdn);
+                let v = build_detailed(profile_info, stats, labels, verif, viewer, &self.cdn);
                 (k, v)
             })
             .collect()
+    }
+
+    async fn get_profile_viewer_state(&self, subject: &str) -> Option<ProfileViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.profile_state.get(viewer, subject).await?;
+
+            let list_block = match &data.list_block {
+                Some(uri) => self.hydrate_list_basic(uri.clone()).await,
+                None => None,
+            };
+            let list_mute = match &data.list_mute {
+                Some(uri) => self.hydrate_list_basic(uri.clone()).await,
+                None => None,
+            };
+
+            Some(build_viewer(data, list_mute, list_block))
+        } else {
+            None
+        }
+    }
+
+    async fn get_profile_viewer_states(
+        &self,
+        dids: &[String],
+    ) -> HashMap<String, ProfileViewerState> {
+        if let Some(viewer) = &self.current_actor {
+            let data = self.loaders.profile_state.get_many(viewer, dids).await;
+            let lists = data
+                .values()
+                .flat_map(|v| [&v.list_block, &v.list_mute])
+                .flatten()
+                .cloned()
+                .collect();
+            let lists = self.hydrate_lists_basic(lists).await;
+
+            data.into_iter()
+                .map(|(k, state)| {
+                    let list_mute = state.list_mute.as_ref().and_then(|v| lists.get(v).cloned());
+                    let list_block = state
+                        .list_block
+                        .as_ref()
+                        .and_then(|v| lists.get(v).cloned());
+
+                    (k, build_viewer(state, list_mute, list_block))
+                })
+                .collect()
+        } else {
+            HashMap::new()
+        }
     }
 }

parakeet/src/loaders.rs

···
 use crate::cache::PrefixedLoaderCache;
+use crate::db;
 use crate::xrpc::extract::LabelConfigItem;
 use dataloader::async_cached::Loader;
 use dataloader::non_cached::Loader as NonCachedLoader;
···
     pub label: LabelLoader,
     pub labeler: CachingLoader<String, LabelServiceLoaderRet, LabelServiceLoader>,
     pub list: CachingLoader<String, ListLoaderRet, ListLoader>,
+    pub list_state: ListStateLoader,
     pub like: NonCachedLoader<String, i32, LikeLoader>,
+    pub like_state: LikeRecordLoader,
     pub posts: CachingLoader<String, PostLoaderRet, PostLoader>,
     pub post_stats: NonCachedLoader<String, parakeet_index::PostStats, PostStatsLoader>,
+    pub post_state: PostStateLoader,
     pub profile: CachingLoader<String, ProfileLoaderRet, ProfileLoader>,
     pub profile_stats: NonCachedLoader<String, parakeet_index::ProfileStats, ProfileStatsLoader>,
+    pub profile_state: ProfileStateLoader,
     pub starterpacks: CachingLoader<String, StarterPackLoaderRet, StarterPackLoader>,
     pub verification: CachingLoader<String, Vec<models::VerificationEntry>, VerificationLoader>,
 }
···
             label: LabelLoader(pool.clone()), // CARE: never cache this.
             labeler: new_plc_loader(LabelServiceLoader(pool.clone(), idxc.clone()), &rc, "labeler", 600),
             like: NonCachedLoader::new(LikeLoader(idxc.clone())),
+            like_state: LikeRecordLoader(pool.clone()),
             list: new_plc_loader(ListLoader(pool.clone()), &rc, "list", 600),
+            list_state: ListStateLoader(pool.clone()),
             posts: new_plc_loader(PostLoader(pool.clone()), &rc, "post", 3600),
             post_stats: NonCachedLoader::new(PostStatsLoader(idxc.clone())),
+            post_state: PostStateLoader(pool.clone()),
             profile: new_plc_loader(ProfileLoader(pool.clone()), &rc, "profile", 3600),
             profile_stats: NonCachedLoader::new(ProfileStatsLoader(idxc.clone())),
+            profile_state: ProfileStateLoader(pool.clone()),
             starterpacks: new_plc_loader(StarterPackLoader(pool.clone()), &rc, "starterpacks", 600),
             verification: new_plc_loader(VerificationLoader(pool.clone()), &rc, "verification", 60),
         }
···
     }
 }
 
+pub struct LikeRecordLoader(Pool<AsyncPgConnection>);
+impl LikeRecordLoader {
+    pub async fn get(&self, did: &str, subject: &str) -> Option<(String, String)> {
+        let mut conn = self.0.get().await.unwrap();
+
+        db::get_like_state(&mut conn, did, subject)
+            .await
+            .unwrap_or_else(|e| {
+                tracing::error!("like state load failed: {e}");
+                None
+            })
+    }
+
+    pub async fn get_many(
+        &self,
+        did: &str,
+        subjects: &[String],
+    ) -> HashMap<String, (String, String)> {
+        let mut conn = self.0.get().await.unwrap();
+
+        match db::get_like_states(&mut conn, did, subjects).await {
+            Ok(res) => {
+                HashMap::from_iter(res.into_iter().map(|(sub, did, rkey)| (sub, (did, rkey))))
+            }
+            Err(e) => {
+                tracing::error!("like state load failed: {e}");
+                HashMap::new()
+            }
+        }
+    }
+}
+
 pub struct HandleLoader(Pool<AsyncPgConnection>);
 impl BatchFn<String, String> for HandleLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, String> {
···
     }
 }
 
+pub struct ProfileStateLoader(Pool<AsyncPgConnection>);
+impl ProfileStateLoader {
+    pub async fn get(&self, did: &str, subject: &str) -> Option<db::ProfileStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        db::get_profile_state(&mut conn, did, subject)
+            .await
+            .unwrap_or_else(|e| {
+                tracing::error!("profile state load failed: {e}");
+                None
+            })
+    }
+
+    pub async fn get_many(
+        &self,
+        did: &str,
+        subjects: &[String],
+    ) -> HashMap<String, db::ProfileStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        match db::get_profile_states(&mut conn, did, subjects).await {
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|v| (v.subject.clone(), v))),
+            Err(e) => {
+                tracing::error!("profile state load failed: {e}");
+                HashMap::new()
+            }
+        }
+    }
+}
+
 pub struct ListLoader(Pool<AsyncPgConnection>);
 type ListLoaderRet = (models::List, i64);
 impl BatchFn<String, ListLoaderRet> for ListLoader {
···
     }
 }
 
+pub struct ListStateLoader(Pool<AsyncPgConnection>);
+impl ListStateLoader {
+    pub async fn get(&self, did: &str, subject: &str) -> Option<db::ListStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        db::get_list_state(&mut conn, did, subject)
+            .await
+            .unwrap_or_else(|e| {
+                tracing::error!("list state load failed: {e}");
+                None
+            })
+    }
+
+    pub async fn get_many(
+        &self,
+        did: &str,
+        subjects: &[String],
+    ) -> HashMap<String, db::ListStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        match db::get_list_states(&mut conn, did, subjects).await {
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|v| (v.at_uri.clone(), v))),
+            Err(e) => {
+                tracing::error!("list state load failed: {e}");
+                HashMap::new()
+            }
+        }
+    }
+}
+
 pub struct FeedGenLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
 impl BatchFn<String, models::FeedGen> for FeedGenLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, models::FeedGen> {
···
             .unwrap()
             .into_inner()
             .entries
+    }
+}
+
+pub struct PostStateLoader(Pool<AsyncPgConnection>);
+impl PostStateLoader {
+    pub async fn get(&self, did: &str, subject: &str) -> Option<db::PostStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        db::get_post_state(&mut conn, did, subject)
+            .await
+            .unwrap_or_else(|e| {
+                tracing::error!("post state load failed: {e}");
+                None
+            })
+    }
+
+    pub async fn get_many(
+        &self,
+        did: &str,
+        subjects: &[String],
+    ) -> HashMap<String, db::PostStateRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        match db::get_post_states(&mut conn, did, subjects).await {
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|v| (v.at_uri.clone(), v))),
+            Err(e) => {
+                tracing::error!("post state load failed: {e}");
+                HashMap::new()
+            }
+        }
     }
 }
 

parakeet/src/sql/list_states.sql

···
+select l.at_uri, lb.at_uri as block, lm.did is not null as muted
+from lists l
+         left join list_blocks lb on l.at_uri = lb.list_uri and lb.did = $1
+         left join list_mutes lm on l.at_uri = lm.list_uri and lm.did = $1
+where l.at_uri = any ($2) and (lm.did is not null or lb.at_uri is not null)

parakeet/src/sql/post_state.sql

···
+select bq.*, coalesce(bq.at_uri = pinned_uri, false) as pinned
+from (select p.at_uri,
+             p.did,
+             p.cid,
+             l.rkey                                                                    as like_rkey,
+             r.rkey                                                                    as repost_rkey,
+             b.did is not null                                                         as bookmarked,
+             coalesce(pg.rules && ARRAY ['app.bsky.feed.postgate#disableRule'], false) as embed_disabled
+      from posts p
+               left join likes l on l.subject = p.at_uri and l.did = $1
+               left join reposts r on r.post = p.at_uri and r.did = $1
+               left join bookmarks b on b.subject = p.at_uri and b.did = $1
+               left join postgates pg on pg.post_uri = p.at_uri
+      where p.at_uri = any ($2)
+        and (l.rkey is not null or r.rkey is not null or b.did is not null or pg.rules is not null)) bq,
+     (select pinned_uri, pinned_cid from profiles where did = $1) pp;

parakeet/src/sql/profile_state.sql

···
+with vlb as (select * from v_list_block_exp where did = $1 and subject = any ($2)),
+     vlm as (select * from v_list_mutes_exp where did = $1 and subject = any ($2)),
+     ps as (select * from profile_states where did = $1 and subject = any ($2)),
+     vlb2 as (select subject as did, did as subject, list_uri is not null as blocked
+              from v_list_block_exp
+              where did = any ($2)
+                and subject = $1)
+select distinct on (did, subject) did,
+                                  subject,
+                                  muting,
+                                  ps.blocked or vlb2.blocked as blocked,
+                                  blocking,
+                                  following,
+                                  followed,
+                                  vlb.list_uri               as list_block,
+                                  vlm.list_uri               as list_mute
+from ps
+         full join vlb using (did, subject)
+         full join vlm using (did, subject)
+         full join vlb2 using (did, subject);

parakeet/src/xrpc/app_bsky/bookmark.rs

···
 use diesel::prelude::*;
 use diesel_async::RunQueryDsl;
 use lexica::app_bsky::bookmark::{BookmarkView, BookmarkViewItem};
+use lexica::app_bsky::feed::{BlockedAuthor, PostView};
 use lexica::StrongRef;
 use parakeet_db::{models, schema};
 use serde::{Deserialize, Serialize};
···
             // otherwise just ditch. we should have one.
             let cid = bookmark.subject_cid.or(maybe_cid)?;
 
-            let item =
-                maybe_item
-                    .map(BookmarkViewItem::Post)
-                    .unwrap_or(BookmarkViewItem::NotFound {
-                        uri: bookmark.subject.clone(),
-                        not_found: true,
-                    });
+            let item = maybe_item
+                .map(postview_to_bvi)
+                .unwrap_or(BookmarkViewItem::NotFound {
+                    uri: bookmark.subject.clone(),
+                    not_found: true,
+                });
 
             let subject = StrongRef::new_from_str(bookmark.subject, &cid).ok()?;
 
···
 
     Ok(Json(GetBookmarksRes { cursor, bookmarks }))
 }
+
+fn postview_to_bvi(post: PostView) -> BookmarkViewItem {
+    match &post.author.viewer {
+        Some(v) if v.blocked_by || v.blocking.is_some() => BookmarkViewItem::Blocked {
+            uri: post.uri,
+            blocked: true,
+            author: BlockedAuthor {
+                did: post.author.did.clone(),
+                viewer: post.author.viewer,
+            },
+        },
+        _ => BookmarkViewItem::Post(post),
+    }
+}

parakeet/src/xrpc/app_bsky/feed/posts.rs

···
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
 use lexica::app_bsky::actor::ProfileView;
 use lexica::app_bsky::feed::{
-    FeedReasonRepost, FeedSkeletonResponse, FeedViewPost, FeedViewPostReason, PostView,
-    SkeletonReason, ThreadViewPost, ThreadViewPostType, ThreadgateView,
+    BlockedAuthor, FeedReasonRepost, FeedSkeletonResponse, FeedViewPost, FeedViewPostReason,
+    PostView, SkeletonReason, ThreadViewPost, ThreadViewPostType, ThreadgateView,
 };
 use parakeet_db::schema;
 use reqwest::Url;
···
     Query(query): Query<GetAuthorFeedQuery>,
 ) -> XrpcResult<Json<FeedRes>> {
     let mut conn = state.pool.get().await?;
-    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, maybe_auth);
 
     let did = get_actor_did(&state.dataloaders, query.actor.clone()).await?;
 
     check_actor_status(&mut conn, &did).await?;
 
+    // check if we block the actor or if they block us
+    if let Some(auth) = &maybe_auth {
+        if let Some(psr) = crate::db::get_profile_state(&mut conn, &auth.0, &did).await? {
+            if psr.blocked.unwrap_or_default() {
+                // they block us
+                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedByActor", None))
+            } else if psr.blocking.is_some() {
+                // we block them
+                return Err(Error::new(StatusCode::BAD_REQUEST, "BlockedActor", None))
+            }
+        }
+    }
+
+    let hyd = StatefulHydrator::new(&state.dataloaders, &state.cdn, &labelers, maybe_auth);
+
     let limit = query.limit.unwrap_or(50).clamp(1, 100);
 
     let mut posts_query = schema::posts::table
···
     let uri = normalise_at_uri(&state.dataloaders, &query.uri).await?;
     let depth = query.depth.unwrap_or(6).clamp(0, 1000);
     let parent_height = query.parent_height.unwrap_or(80).clamp(0, 1000);
+
+    let root = hyd
+        .hydrate_post(uri.clone())
+        .await
+        .ok_or(Error::not_found())?;
+    let threadgate = root.threadgate.clone();
+
+    if let Some(viewer) = &root.author.viewer {
+        if viewer.blocked_by || viewer.blocking.is_some() {
+            return Ok(Json(GetPostThreadRes {
+                thread: ThreadViewPostType::Blocked {
+                    uri,
+                    blocked: true,
+                    author: BlockedAuthor {
+                        did: root.author.did,
+                        viewer: root.author.viewer,
+                    },
+                },
+                threadgate,
+            }));
+        }
+    }
 
     let replies = diesel::sql_query(include_str!("../../../sql/thread.sql"))
         .bind::<diesel::sql_types::Text, _>(&uri)
···
     let reply_uris = replies.iter().map(|item| item.at_uri.clone()).collect();
     let parent_uris = parents.iter().map(|item| item.at_uri.clone()).collect();
 
-    let root = hyd
-        .hydrate_post(uri.clone())
-        .await
-        .ok_or(Error::not_found())?;
     let mut replies_hydrated = hyd.hydrate_posts(reply_uris).await;
     let mut parents_hydrated = hyd.hydrate_posts(parent_uris).await;
 
···
             continue;
         };
 
-        entry.push(ThreadViewPostType::Post(Box::new(ThreadViewPost {
-            post,
-            parent: None,
-            replies: this_post_replies,
-        })));
+        entry.push(postview_to_tvpt(post, None, this_post_replies));
     }
 
     let mut root_parent = None;
···
 
         let parent = parents_hydrated
             .remove(&parent.at_uri)
-            .map(|post| {
-                ThreadViewPostType::Post(Box::new(ThreadViewPost {
-                    post,
-                    parent: p2,
-                    replies: vec![],
-                }))
-            })
+            .map(|post| postview_to_tvpt(post, p2, Vec::default()))
             .unwrap_or(ThreadViewPostType::NotFound {
                 uri: parent.at_uri.clone(),
                 not_found: true,
···
     }
 
     let replies = tmpbuf.remove(&root.uri).unwrap_or_default();
-
-    let threadgate = root.threadgate.clone();
 
     Ok(Json(GetPostThreadRes {
         threadgate,
···
         })
         .collect()
 }
+
+fn postview_to_tvpt(
+    post: PostView,
+    parent: Option<ThreadViewPostType>,
+    replies: Vec<ThreadViewPostType>,
+) -> ThreadViewPostType {
+    match &post.author.viewer {
+        Some(v) if v.blocked_by || v.blocking.is_some() => ThreadViewPostType::Blocked {
+            uri: post.uri.clone(),
+            blocked: true,
+            author: BlockedAuthor {
+                did: post.author.did,
+                viewer: post.author.viewer,
+            },
+        },
+        _ => ThreadViewPostType::Post(Box::new(ThreadViewPost {
+            post,
+            parent,
+            replies,
+        })),
+    }
+}