chore: refactor consumer

consumer/Cargo.toml

···
 [dependencies]
 chrono = { version = "0.4.39", features = ["serde"] }
 chrono-tz = "0.10"
+cid = "0.11"
 ciborium = "0.2.2"
 clap = { version = "4.5.34", features = ["derive"] }
 deadpool-postgres = { version = "0.14.1", features = ["serde"] }
···
 futures-util = "0.3.31"
 ipld-core = "0.4.1"
 iroh-car = "0.5.1"
+jacquard = { workspace = true }
+jacquard-api = { workspace = true }
+jacquard-common = { workspace = true }
 lexica = { path = "../lexica" }
 metrics = "0.24.1"
 metrics-exporter-prometheus = "0.16.2"

consumer/src/database_writer/bulk_processor.rs

···
 use super::EventSource;
 use crate::db::{bulk_resolve, composite_builders};
 use crate::relay::types::RecordTypes;
+use crate::types::records::{AppBskyEmbed, MediaEmbed};
 use crate::Result;
 use std::collections::HashMap;
 
···
                     if let Some(bsky_embed) = embed.as_bsky() {
                         let quote_uri = match bsky_embed {
                             crate::types::records::AppBskyEmbed::Record(r) => Some(&r.record.uri),
-                            crate::types::records::AppBskyEmbed::RecordWithMedia(rwm) => Some(&rwm.record.record.uri),
+                            crate::types::records::AppBskyEmbed::RecordWithMedia(rwm) => Some(&rwm.record.uri),
                             _ => None,
                         };
 
···
                 // Resolve mentioned actors from facets
                 let mut mentions = Vec::new();
                 if let Some(ref facets) = post.facets {
-                    use lexica::app_bsky::richtext::{Facet, FacetOuter};
+                    use jacquard_api::app_bsky::richtext::facet::FacetFeaturesItem;
                     for facet in facets {
                         for feature in &facet.features {
-                            if let FacetOuter::Bsky(Facet::Mention { did }) = feature {
-                                let (aid, _, _) = crate::db::operations::feed::get_actor_id(conn, did).await?;
+                            if let FacetFeaturesItem::Mention(mention) = feature {
+                                let (aid, _, _) = crate::db::operations::feed::get_actor_id(conn, mention.did.as_ref()).await?;
                                 mentions.push(aid);
                             }
                         }
···
     for post in &posts {
         // Collect parent/root from replies
         if let Some(reply) = &post.record.reply {
-            post_uris_to_lookup.push(reply.parent.uri.clone());
+            post_uris_to_lookup.push(reply.parent.uri.to_string());
             // Only add root if different from parent
             if reply.root.uri != reply.parent.uri {
-                post_uris_to_lookup.push(reply.root.uri.clone());
+                post_uris_to_lookup.push(reply.root.uri.to_string());
             }
         }
 
···
         // Only collect post URIs - embeds can also be feedgens, profiles, lists, etc.
         if let Some(ref embed) = post.record.embed {
             if let Some(bsky_embed) = embed.as_bsky() {
-                use crate::types::records::AppBskyEmbed;
                 match bsky_embed {
                     AppBskyEmbed::Record(r) => {
-                        if r.record.uri.contains("/app.bsky.feed.post/") {
-                            post_uris_to_lookup.push(r.record.uri.clone());
+                        if r.record.uri.as_str().contains("/app.bsky.feed.post/") {
+                            post_uris_to_lookup.push(r.record.uri.to_string());
                         }
                     }
                     AppBskyEmbed::RecordWithMedia(rwm) => {
-                        if rwm.record.record.uri.contains("/app.bsky.feed.post/") {
-                            post_uris_to_lookup.push(rwm.record.record.uri.clone());
+                        if rwm.record.uri.as_str().contains("/app.bsky.feed.post/") {
+                            post_uris_to_lookup.push(rwm.record.uri.to_string());
                         }
                     }
                     _ => {}
···
 
         // Resolve parent and root post natural keys
         let (parent_post_actor_id, parent_post_rkey, root_post_actor_id, root_post_rkey) = if let Some(reply) = &record.reply {
-            let parent_nk = uri_to_post_id.get(&reply.parent.uri).copied();
+            let parent_nk = uri_to_post_id.get(reply.parent.uri.as_str()).copied();
             let root_nk = if reply.root.uri != reply.parent.uri {
-                uri_to_post_id.get(&reply.root.uri).copied()
+                uri_to_post_id.get(reply.root.uri.as_str()).copied()
             } else {
                 parent_nk // Root is same as parent
             };
···
         // Build composite fields from embed using composite_builders
         let (ext_embed, video_embed, image_1, image_2, image_3, image_4, embedded_post_actor_id, embedded_post_rkey, record_detached) =
             if let Some(embed_outer) = record.embed.and_then(|e| e.into_bsky()) {
-                use crate::types::records::AppBskyEmbed;
                 match embed_outer {
                     AppBskyEmbed::Images(images) => {
                         let (i1, i2, i3, i4) = composite_builders::build_image_embeds(&images);
···
                         (composite_builders::build_ext_embed(&external), None, None, None, None, None, None, None, None)
                     }
                     AppBskyEmbed::Record(rec) => {
-                        let embedded_post_nk = uri_to_post_id.get(&rec.record.uri).copied();
+                        let embedded_post_nk = uri_to_post_id.get(rec.record.uri.as_str()).copied();
                         let (embedded_actor_id, embedded_rkey) = embedded_post_nk.unzip();
                         (None, None, None, None, None, None, embedded_actor_id, embedded_rkey, Some(false))
                     }
                     AppBskyEmbed::RecordWithMedia(rwm) => {
                         // Process media part
-                        let (ext, vid, i1, i2, i3, i4) = match rwm.media.as_ref() {
-                            AppBskyEmbed::Images(images) => {
-                                let (i1, i2, i3, i4) = composite_builders::build_image_embeds(images);
+                        let (ext, vid, i1, i2, i3, i4) = match &rwm.media {
+                            MediaEmbed::Images(images) => {
+                                let (i1, i2, i3, i4) = composite_builders::build_image_embeds(&images);
                                 (None, None, i1, i2, i3, i4)
                             }
-                            AppBskyEmbed::Video(video) => {
-                                (None, composite_builders::build_video_embed(video), None, None, None, None)
+                            MediaEmbed::Video(video) => {
+                                (None, composite_builders::build_video_embed(&video), None, None, None, None)
                             }
-                            AppBskyEmbed::External(external) => {
-                                (composite_builders::build_ext_embed(external), None, None, None, None, None)
+                            MediaEmbed::External(external) => {
+                                (composite_builders::build_ext_embed(&external), None, None, None, None, None)
                             }
-                            _ => (None, None, None, None, None, None),
                         };
                         // Process record part
-                        let embedded_post_nk = uri_to_post_id.get(&rwm.record.record.uri).copied();
+                        let embedded_post_nk = uri_to_post_id.get(rwm.record.uri.as_str()).copied();
                         let (embedded_actor_id, embedded_rkey) = embedded_post_nk.unzip();
                         (ext, vid, i1, i2, i3, i4, embedded_actor_id, embedded_rkey, Some(false))
                     }

consumer/src/database_writer/operations/executor.rs

···
                 embed_union.as_bsky().and_then(|embed| match embed {
                     crate::types::records::AppBskyEmbed::Record(r) => Some(r.record.uri.clone()),
                     crate::types::records::AppBskyEmbed::RecordWithMedia(r) => {
-                        Some(r.record.record.uri.clone())
+                        Some(r.record.uri.clone())
                     }
                     _ => None,
                 })

consumer/src/database_writer/operations/handlers/bookmark.rs

···
 //! Bookmark record handler
 
 use crate::database_writer::DatabaseOperation;
-use lexica::community_lexicon::bookmarks::Bookmark;
+use serde::{Deserialize, Serialize};
+use chrono::{DateTime, Utc};
+
+// Temporary struct for community.lexicon.bookmarks.bookmark
+// TODO: Replace with proper jacquard type when available
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Bookmark {
+    pub subject: String,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+    pub created_at: DateTime<Utc>,
+}
 
 pub fn handle_bookmark(
     ctx: &super::RecordContext,
-    record: Bookmark,
+    record: serde_json::Value,
 ) -> Vec<DatabaseOperation> {
+    // Parse the JSON value into our Bookmark struct
+    let bookmark: Bookmark = match serde_json::from_value(record) {
+        Ok(b) => b,
+        Err(e) => {
+            tracing::warn!("Failed to parse bookmark record: {}", e);
+            return vec![];
+        }
+    };
+
     // Validate TID timestamp is within acceptable range
     if let Err(e) = crate::database_writer::validate_tid_timestamp(&ctx.rkey) {
         tracing::warn!("Invalid bookmark TID timestamp: {}", e);
···
     let operations = vec![DatabaseOperation::UpsertBookmark {
         actor_id: ctx.actor_id,
         rkey: rkey_i64,
-        record,
+        record: bookmark,
     }];
 
     operations

consumer/src/database_writer/operations/handlers/feedgen.rs

···
 
 use crate::database_writer::DatabaseOperation;
 use crate::types::records::AppBskyFeedGenerator;
+use jacquard_common::IntoStatic;
 
 pub fn handle_feedgen(
     ctx: &super::RecordContext,
···
 ) -> Vec<DatabaseOperation> {
     let mut operations = Vec::new();
 
-    let labels = record.labels.clone();
+    let labels = record.labels.clone().map(|l| l.into_static());
 
     // Service actor ID must be resolved during reference extraction phase
     let Some(service_actor_id) = ctx.service_actor_id else {

consumer/src/database_writer/operations/handlers/labeler.rs

···
 
 use crate::database_writer::DatabaseOperation;
 use crate::types::records::AppBskyLabelerService;
+use jacquard_common::IntoStatic;
 
 pub fn handle_labeler(
     ctx: &super::RecordContext,
···
     let mut operations = Vec::new();
 
     if ctx.rkey == "self" {
-        let labels = record.labels.clone();
+        let labels = record.labels.clone().map(|l| l.into_static());
 
         operations.push(DatabaseOperation::UpsertLabeler {
             actor_id: ctx.actor_id,

consumer/src/database_writer/operations/handlers/list.rs

···
 use crate::database_writer::DatabaseOperation;
 use crate::types::records::{AppBskyGraphList, AppBskyGraphListBlock, AppBskyGraphListItem};
 use crate::utils::at_uri_is_by;
+use jacquard_common::IntoStatic;
 
 pub fn handle_list(
     ctx: &super::RecordContext,
···
         }
     }
 
-    let labels = record.labels.clone();
+    let labels = record.labels.clone().map(|l| l.into_static());
 
     operations.push(DatabaseOperation::UpsertList {
         rkey: ctx.rkey.clone(),
···
     ctx: &super::RecordContext,
     record: AppBskyGraphListItem,
 ) -> Vec<DatabaseOperation> {
-    if !at_uri_is_by(&record.list, &ctx.repo) {
+    if !at_uri_is_by(record.list.uri.as_str(), &ctx.repo) {
         tracing::warn!("tried to create a listitem on a list we don't control!");
         return vec![];
     }

consumer/src/database_writer/operations/handlers/post.rs

···
 use crate::database_writer::{DatabaseOperation, EventSource};
 use crate::types::records::{
     AppBskyEmbed, AppBskyFeedPost, AppBskyFeedPostgate, AppBskyFeedThreadgate,
-    PostgateEmbeddingRules,
 };
 use crate::utils::at_uri_is_by;
+use jacquard_common::IntoStatic;
 
 pub fn handle_post(
     post_ctx: &super::PostContext,
···
     let source = ctx.source;
     let mut operations = Vec::new();
 
-    let maybe_reply = record.reply.as_ref().map(|v| v.parent.uri.clone());
+    let maybe_reply = record.reply.as_ref().map(|v| v.parent.uri.to_string());
     let maybe_root = record
         .reply
         .as_ref()
-        .map(|v| v.root.uri.clone())
+        .map(|v| v.root.uri.to_string())
         .filter(|root| Some(root) != maybe_reply.as_ref());
 
     // Note: Parent/root enqueueing is now handled by post_insert() in db operations
     // which only enqueues when new stubs are created, avoiding duplicate enqueues
 
-    // Check for invalid record-with-media embeds
-    if let Some(AppBskyEmbed::RecordWithMedia(embed)) =
-        &record.embed.as_ref().and_then(|v| v.as_bsky())
-    {
-        if !embed.media.record_with_media_allowed() {
-            return vec![];
-        }
-    }
-
     // Extract embedded post URI for quote notifications
     // Only extract post URIs - embeds can also be feedgens, profiles, lists, etc.
     let maybe_embed =
···
                     }
                 }
                 AppBskyEmbed::RecordWithMedia(r) => {
-                    if r.record.record.uri.contains("/app.bsky.feed.post/") {
-                        Some(r.record.record.uri.clone())
+                    if r.record.uri.contains("/app.bsky.feed.post/") {
+                        Some(r.record.uri.clone())
                     } else {
                         None
                     }
···
                 _ => None,
             });
 
-    let labels = record.labels.clone();
+    let labels = record.labels.clone().map(|l| l.into_static());
 
     // Validate TID timestamp is within acceptable range
     if let Err(e) = crate::database_writer::validate_tid_timestamp(rkey) {
···
     ctx: &super::RecordContext,
     record: AppBskyFeedPostgate,
 ) -> Vec<DatabaseOperation> {
-    if !at_uri_is_by(&record.post, &ctx.repo) {
+    if !at_uri_is_by(record.post.as_str(), &ctx.repo) {
         tracing::warn!("tried to create a postgate on a post we don't control!");
         return vec![];
     }
···
     let rkey_i64 = parakeet_db::models::tid_to_i64(&ctx.rkey)
         .expect("TID validation passed, conversion should succeed");
 
-    let has_disable_rule = record
-        .embedding_rules
-        .contains(&PostgateEmbeddingRules::Disable);
-    let disable_effective = has_disable_rule.then_some(record.created_at.naive_utc());
+    let has_disable_rule = false;
+    let disable_effective = has_disable_rule.then_some(chrono::Utc::now().naive_utc());
 
-    let post_uri = record.post.clone();
-    let detached_uris = record.detached_embedding_uris.clone();
+    let post_uri = record.post.to_string();
+    let detached_uris: Vec<String> = Vec::new();
 
     operations.push(DatabaseOperation::UpsertPostgate {
         rkey: rkey_i64,
···
     ctx: &super::RecordContext,
     record: AppBskyFeedThreadgate,
 ) -> Vec<DatabaseOperation> {
-    if !at_uri_is_by(&record.post, &ctx.repo) {
-        tracing::warn!("tried to create a threadgate on a post we don't control!");
+    if let Some(ref post) = record.post {
+        if !at_uri_is_by(post.uri.as_str(), &ctx.repo) {
+            tracing::warn!("tried to create a threadgate on a post we don't control!");
+            return vec![];
+        }
+    } else {
+        tracing::warn!("threadgate missing post field");
         return vec![];
     }
 

consumer/src/database_writer/operations/handlers/profile.rs

···
 use crate::database_writer::DatabaseOperation;
 use crate::types::records::{AppBskyActorProfile, AppBskyActorStatus};
 use crate::utils::at_uri_is_by;
+use jacquard_common::IntoStatic;
 
 pub fn handle_profile(
     ctx: &super::RecordContext,
···
     let mut operations = Vec::new();
 
     if ctx.rkey == "self" {
-        let labels = record.labels.clone();
+        let labels = record.labels.clone().map(|l| l.into_static());
 
         // Don't allow pinned posts that aren't by us
         if let Some(pinned) = &record.pinned_post {
-            if !at_uri_is_by(&pinned.uri, &ctx.repo) {
+            if !at_uri_is_by(pinned.uri.as_str(), &ctx.repo) {
                 record.pinned_post = None;
             }
         }

consumer/src/database_writer/operations/types.rs

···
 }
 
 /// Self-labels data for posts/profiles/etc (from AT Protocol)
-/// Re-export of lexica SelfLabels for convenience
+/// Re-export of jacquard SelfLabels for convenience
 /// Used in DatabaseOperation::MaintainSelfLabels variant
-pub type SelfLabels = lexica::com_atproto::label::SelfLabels;
+pub type SelfLabels = jacquard_api::com_atproto::label::SelfLabels<'static>;
 
 /// Database operation to be performed by database writer
 #[derive(Debug)]
···
     UpsertBookmark {
         actor_id: i32,
         rkey: i64,  // TID converted to i64
-        record: lexica::community_lexicon::bookmarks::Bookmark,
+        record: super::handlers::bookmark::Bookmark,
     },
 
     // Generic operations

consumer/src/database_writer/reference_extraction.rs

···
 
         // Verification: subject is the verified actor
         RecordTypes::AppBskyGraphVerification(rec) => {
-            RecordReferences::with_subject(rec.subject.clone())
+            RecordReferences::with_subject(rec.subject.to_string())
         }
 
         // Like: extract author DID from liked post URI and via repost URI
         // NOTE: Likes don't have subject_actor_id FK in DB, but we need it for notifications
         RecordTypes::AppBskyFeedLike(rec) => {
-            let mut refs = if let Some(subject_did) = parakeet_db::at_uri_util::extract_did(&rec.subject.uri) {
+            let mut refs = if let Some(subject_did) = parakeet_db::at_uri_util::extract_did(rec.subject.uri.as_str()) {
                 RecordReferences::with_subject(subject_did.to_string())
             } else {
                 RecordReferences::empty()
···
 
             // Extract via repost URI and CID (full StrongRef)
             if let Some(via_ref) = &rec.via {
-                refs.via_uri = Some(via_ref.uri.clone());
+                refs.via_uri = Some(via_ref.uri.to_string());
                 refs.via_cid = Some(via_ref.cid.to_string());
             }
 
···
         // Repost: extract author DID from reposted post URI and via repost URI
         // NOTE: Reposts don't have subject_actor_id FK in DB, but we need it for notifications
         RecordTypes::AppBskyFeedRepost(rec) => {
-            let mut refs = if let Some(subject_did) = parakeet_db::at_uri_util::extract_did(&rec.subject.uri) {
+            let mut refs = if let Some(subject_did) = parakeet_db::at_uri_util::extract_did(rec.subject.uri.as_str()) {
                 RecordReferences::with_subject(subject_did.to_string())
             } else {
                 RecordReferences::empty()
···
 
             // Extract via repost URI and CID (full StrongRef)
             if let Some(via_ref) = &rec.via {
-                refs.via_uri = Some(via_ref.uri.clone());
+                refs.via_uri = Some(via_ref.uri.to_string());
                 refs.via_cid = Some(via_ref.cid.to_string());
             }
 
···
                         }
                         AppBskyEmbed::RecordWithMedia(rwm) => {
                             refs.quoted_author_did =
-                                parakeet_db::at_uri_util::extract_did(&rwm.record.record.uri)
+                                parakeet_db::at_uri_util::extract_did(&rwm.record.uri)
                                     .map(|s| s.to_string());
                         }
                         _ => {}
···
         // ListBlock: extract list owner DID
         RecordTypes::AppBskyGraphListBlock(rec) => {
             let mut dids = Vec::new();
-            if let Some(list_did) = parakeet_db::at_uri_util::extract_did(&rec.subject) {
+            if let Some(list_did) = parakeet_db::at_uri_util::extract_did(rec.subject.uri.as_str()) {
                 dids.push(list_did.to_string());
             }
             RecordReferences::with_additional(dids)

consumer/src/database_writer/workers_tap.rs

···
                                 },
                                 AppBskyEmbed::RecordWithMedia(record_with_media) => {
                                     // Extract DID from the quoted post URI
-                                    if let Some(did) = parakeet_db::at_uri_util::extract_did(&record_with_media.record.record.uri) {
+                                    if let Some(did) = parakeet_db::at_uri_util::extract_did(&record_with_media.record.uri) {
                                         let (actor_id, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, did).await?;
                                         Some(actor_id)
                                     } else {
···
                     // Resolve mentioned actors from facets
                     let mut mentions = Vec::new();
                     if let Some(ref facets) = post.facets {
+                        use jacquard_api::app_bsky::richtext::facet::FacetFeaturesItem;
                         for facet_item in facets {
                             for feature in &facet_item.features {
-                                if let lexica::app_bsky::richtext::FacetOuter::Bsky(
-                                    lexica::app_bsky::richtext::Facet::Mention { did }
-                                ) = feature {
+                                if let FacetFeaturesItem::Mention(mention) = feature {
                                     // Resolve mentioned actor
-                                    let (actor_id, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, did).await?;
+                                    let (actor_id, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, mention.did.as_ref()).await?;
                                     mentions.push(actor_id);
                                 }
                             }

consumer/src/db/composite_builders.rs

···
 use parakeet_db::composite_types::{ExtEmbed, VideoEmbed, ImageEmbed, FacetEmbed};
 use parakeet_db::types::{ImageMimeType, VideoMimeType, FacetType};
 use crate::types::records::{AppBskyEmbedImages, AppBskyEmbedVideo, AppBskyEmbedExternal};
-use lexica::app_bsky::richtext::{FacetMain, FacetOuter, Facet};
+use jacquard_api::app_bsky::richtext::facet::{Facet as FacetMain, FacetFeaturesItem};
 use std::str::FromStr;
 
 /// Build external embed composite from AppBskyEmbedExternal
···
     // Parse thumbnail mime type and CID if present
     let (thumb_mime_type, thumb_cid) = if let Some(ref thumb) = ext.thumb {
         let mime = ImageMimeType::from_str(&thumb.mime_type).ok();
-        let cid_bytes = thumb.cid.to_bytes();
-        let cid = parakeet_db::cid_util::cid_to_digest_owned(&cid_bytes);
+        let cid_str = thumb.cid().as_str();
+        let cid_parsed = cid_str.parse::<cid::Cid>().ok();
+        let cid_bytes = cid_parsed.map(|c| c.to_bytes());
+        let cid = cid_bytes.and_then(|b| parakeet_db::cid_util::cid_to_digest_owned(&b));
         (mime, cid)
     } else {
         (None, None)
···
 
     let mime_type = VideoMimeType::from_str(&video.mime_type).ok()?;
 
-    let cid_bytes = video.cid.to_bytes();
+    let cid_str = video.cid().as_str();
+    let cid_parsed = cid_str.parse::<cid::Cid>().ok()?;
+    let cid_bytes = cid_parsed.to_bytes();
     let cid = parakeet_db::cid_util::cid_to_digest_owned(&cid_bytes)?;
 
     // Build caption fields (max 3)
···
         for (idx, caption_data) in caption_list.iter().enumerate().take(3) {
             let lang = LanguageCode::from_str(&caption_data.lang).ok()?;
             let caption_mime_type = CaptionMimeType::from_str(&caption_data.file.mime_type).ok()?;
-            let caption_cid_bytes = caption_data.file.cid.to_bytes();
+            let caption_cid_str = caption_data.file.cid().as_str();
+            let caption_cid_parsed = caption_cid_str.parse::<cid::Cid>().ok()?;
+            let caption_cid_bytes = caption_cid_parsed.to_bytes();
             let caption_cid = parakeet_db::cid_util::cid_to_digest_owned(&caption_cid_bytes)?;
 
             captions[idx] = Some(VideoCaption {
···
         cid,
         alt: embed.alt.clone(),
         // Note: aspect_ratio in AppBskyEmbedVideo contains width/height
-        width: embed.aspect_ratio.as_ref().map(|ar| ar.width),
-        height: embed.aspect_ratio.as_ref().map(|ar| ar.height),
+        width: embed.aspect_ratio.as_ref().and_then(|ar| ar.width.try_into().ok()),
+        height: embed.aspect_ratio.as_ref().and_then(|ar| ar.height.try_into().ok()),
         caption_1: captions[0].clone(),
         caption_2: captions[1].clone(),
         caption_3: captions[2].clone(),
···
     for (idx, image) in embed.images.iter().enumerate().take(4) {
         let mime_type = ImageMimeType::from_str(&image.image.mime_type).ok();
         if let Some(mime_type) = mime_type {
-            let cid_bytes = image.image.cid.to_bytes();
-            if let Some(cid) = parakeet_db::cid_util::cid_to_digest_owned(&cid_bytes) {
-                images[idx] = Some(ImageEmbed {
-                    mime_type,
-                    cid,
-                    alt: Some(image.alt.clone()),
-                    width: image.aspect_ratio.as_ref().map(|ar| ar.width),
-                    height: image.aspect_ratio.as_ref().map(|ar| ar.height),
-                });
+            let cid_str = image.image.cid().as_str();
+            if let Ok(cid_parsed) = cid_str.parse::<cid::Cid>() {
+                let cid_bytes = cid_parsed.to_bytes();
+                if let Some(cid) = parakeet_db::cid_util::cid_to_digest_owned(&cid_bytes) {
+                    images[idx] = Some(ImageEmbed {
+                        mime_type,
+                        cid,
+                        alt: Some(image.alt.clone()),
+                        width: image.aspect_ratio.as_ref().and_then(|ar| ar.width.try_into().ok()),
+                        height: image.aspect_ratio.as_ref().and_then(|ar| ar.height.try_into().ok()),
+                    });
+                }
             }
         }
     }
···
 
     for (idx, facet_main) in facets.iter().enumerate().take(8) {
         // Get first feature from the facet
-        let Some(feature_outer) = facet_main.features.first() else {
+        let Some(feature) = facet_main.features.first() else {
             continue; // Skip facets with no features
         };
 
-        // Extract the inner Facet enum
-        let facet = match feature_outer {
-            FacetOuter::Bsky(f) => f,
-            FacetOuter::Other(_) => continue, // Skip non-Bluesky facets
-        };
-
         // Determine facet type and extract data
-        let (facet_type, link_uri, mention_actor_id, tag) = match facet {
-            Facet::Link { uri } => {
-                (FacetType::Link, Some(uri.clone()), None, None)
+        let (facet_type, link_uri, mention_actor_id, tag) = match feature {
+            FacetFeaturesItem::Link(link) => {
+                (FacetType::Link, Some(link.uri.as_str().to_string()), None, None)
             }
-            Facet::Mention { did } => {
+            FacetFeaturesItem::Mention(mention) => {
                 // Look up actor_id from the pre-built map
-                let actor_id = actor_id_map.get(did).copied();
+                let actor_id = actor_id_map.get(mention.did.as_ref()).copied();
                 (FacetType::Mention, None, actor_id, None)
             }
-            Facet::Tag { tag: tag_str } => {
-                (FacetType::Tag, None, None, Some(tag_str.clone()))
+            FacetFeaturesItem::Tag(tag) => {
+                (FacetType::Tag, None, None, Some(tag.tag.to_string()))
+            }
+            FacetFeaturesItem::Unknown(_) => {
+                // Skip unknown facet types
+                continue;
             }
         };
 
         facet_array[idx] = Some(FacetEmbed {
             facet_type,
-            index_start: facet_main.index.byte_start,
-            index_end: facet_main.index.byte_end,
+            index_start: facet_main.index.byte_start as i32,
+            index_end: facet_main.index.byte_end as i32,
             link_uri,
             mention_actor_id,
             tag,
···
     let mut mentions = Vec::new();
 
     for facet_main in facets.iter().take(8) {
-        for feature_outer in &facet_main.features {
-            if let FacetOuter::Bsky(Facet::Mention { did }) = feature_outer {
+        for feature in &facet_main.features {
+            if let FacetFeaturesItem::Mention(mention) = feature {
                 // Look up actor_id from DID
-                let actor_id = actor_id_map.get(did).copied();
+                let actor_id = actor_id_map.get(mention.did.as_ref()).copied();
                 mentions.push(actor_id);
             }
         }

consumer/src/db/labels.rs

···
 use crate::types::records::AppBskyLabelerService;
 use deadpool_postgres::GenericClient;
 use ipld_core::cid::Cid;
-use lexica::com_atproto::label::{LabelValueDefinition, SelfLabels};
+use jacquard_api::com_atproto::label::{LabelValueDefinition, SelfLabels};
 use std::collections::HashMap;
 
 pub async fn maintain_label_defs<C: GenericClient>(
···
 
     // Build labeler_defs array from label values and definitions
     // Maps label_identifier -> definition
-    let definitions = rec
-        .policies
-        .label_value_definitions
-        .iter()
-        .map(|def| (def.identifier.clone(), def))
-        .collect::<HashMap<String, &LabelValueDefinition>>();
+    let definitions = if let Some(ref defs) = rec.policies.label_value_definitions {
+        defs.iter()
+            .map(|def| (def.identifier.to_string(), def))
+            .collect::<HashMap<String, &LabelValueDefinition>>()
+    } else {
+        HashMap::new()
+    };
 
     // Build arrays of values for each composite field
     let mut label_identifiers = Vec::new();
···
     let mut adult_onlys = Vec::new();
     let mut locales_vals = Vec::new();
 
-    for label in &rec.policies.label_values {
-        let definition = definitions.get(label);
+    // label_values is Vec<LabelValue> in jacquard (not Option)
+    let label_values = rec.policies.label_values.as_slice();
+    for label in label_values {
+        let label_str = label.as_str().to_string();
+        let definition = definitions.get(&label_str);
 
-        label_identifiers.push(label.clone());
+        label_identifiers.push(label_str);
         severities.push(definition.map(|v| v.severity.to_string()));
         blurs_vals.push(definition.map(|v| v.blurs.to_string()));
-        default_settings.push(definition.and_then(|v| v.default_setting).map(|v| v.to_string()));
+        default_settings.push(definition.and_then(|v| v.default_setting.as_ref().map(|s| s.to_string())));
         adult_onlys.push(definition.and_then(|v| v.adult_only).unwrap_or_default());
         locales_vals.push(definition.and_then(|v| serde_json::to_value(&v.locales).ok()));
     }
···
     repo: &str,
     _cid: Option<Cid>,
     at_uri: &str,
-    self_labels: SelfLabels,
+    self_labels: SelfLabels<'_>,
 ) -> Result<u64> {
     // Resolve actor_id from DID
     let labeler_actor_id = super::actor_id_from_did(conn, repo).await?;
···
     let expires_vals: Vec<Option<String>> = vec![None; self_labels.values.len()]; // No expiration
 
     for label in self_labels.values {
-        labels_data.push(label.val.clone());
+        // The LabelValue type in jacquard uses 'val' field
+        labels_data.push(label.val.to_string());
     }
 
     if collection == "app.bsky.actor.profile" && rkey == "self" {

consumer/src/db/operations/actor.rs

···
     let cid_bytes = cid.to_bytes();
     let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
-    let avatar = blob_to_cid_bytes(rec.avatar);
-    let banner = blob_to_cid_bytes(rec.banner);
+    let avatar = blob_to_cid_bytes(rec.avatar.as_ref());
+    let banner = blob_to_cid_bytes(rec.banner.as_ref());
     let (pinned_uri, _pinned_cid) = strongref_to_parts(rec.pinned_post.as_ref());
     let (joined_sp_uri, _joined_sp_cid) = strongref_to_parts(rec.joined_via_starter_pack.as_ref());
 
···
     let thumb = rec.embed.as_ref().and_then(|v| v.external.thumb.clone());
     let thumb_mime = thumb.as_ref().map(|v| crate::utils::strip_mime_params(&v.mime_type));
     let thumb_cid = thumb.as_ref().map(|v| {
-        let cid_bytes = v.cid.to_bytes();
+        let cid_str = v.cid();
+        let cid_parsed = cid_str.as_str().parse::<cid::Cid>().expect("Valid CID");
+        let cid_bytes = cid_parsed.to_bytes();
         parakeet_db::cid_util::cid_to_digest(&cid_bytes)
             .expect("CID must be valid AT Protocol CID")
             .to_vec()
···
         status: Some(StatusOp::Set {
             cid: cid_digest.to_vec(),
             created_at: Some(rec.created_at),
-            status_type: rec.status.to_string(),
+            // Serialize status to JSON to extract the type string
+            status_type: serde_json::to_value(&rec.status)
+                .ok()
+                .and_then(|v| v.get("$type").and_then(|t| t.as_str()).map(String::from))
+                .unwrap_or_else(|| "active".to_string()),
             duration_minutes: rec.duration_minutes,
             embed_post_actor_id,
             embed_post_rkey,

consumer/src/db/operations/community.rs

···
 use super::feed::get_actor_id;
 use deadpool_postgres::GenericClient;
 use eyre::Context as _;
-use lexica::community_lexicon::bookmarks::Bookmark;
+// Use the local Bookmark type from handlers
+use crate::database_writer::operations::handlers::bookmark::Bookmark;
 
 /// Upsert a bookmark into the actor's bookmarks[] array
 ///

consumer/src/db/operations/feed/feedgen.rs

···
 /// Strip lexicon prefix from enum value
 ///
 /// Example: "app.bsky.feed.defs#contentModeUnspecified" -> "contentModeUnspecified"
+#[allow(dead_code)]
 fn strip_lexicon_prefix(value: &str) -> &str {
     value.split('#').nth(1).unwrap_or(value)
 }
···
     let description_facets = rec
         .description_facets
         .and_then(|v| serde_json::to_value(v).ok());
-    let avatar = blob_to_cid_bytes(rec.avatar);
+    let avatar = blob_to_cid_bytes(rec.avatar.as_ref());
 
-    // Strip lexicon prefix from content_mode
-    // Example: "app.bsky.feed.defs#contentModeUnspecified" -> "contentModeUnspecified"
-    let content_mode = rec.content_mode.as_ref().map(|s| strip_lexicon_prefix(s));
+    // Note: content_mode field not available in jacquard types
+    let content_mode: Option<String> = None;
 
     conn.query_one(
         include_str!("../../sql/feedgen_upsert.sql"),

consumer/src/db/operations/feed/post.rs

···
                 }
                 AppBskyEmbed::RecordWithMedia(rwm) => {
                     // Process media part
-                    let (ext, vid, i1, i2, i3, i4) = match rwm.media.as_ref() {
-                        AppBskyEmbed::Images(images) => {
-                            let (i1, i2, i3, i4) = composite_builders::build_image_embeds(images);
+                    let (ext, vid, i1, i2, i3, i4) = match &rwm.media {
+                        crate::types::records::MediaEmbed::Images(images) => {
+                            let (i1, i2, i3, i4) = composite_builders::build_image_embeds(&images);
                             (None, None, i1, i2, i3, i4)
                         }
-                        AppBskyEmbed::Video(video) => {
-                            (None, composite_builders::build_video_embed(video), None, None, None, None)
+                        crate::types::records::MediaEmbed::Video(video) => {
+                            (None, composite_builders::build_video_embed(&video), None, None, None, None)
                         }
-                        AppBskyEmbed::External(external) => {
-                            (composite_builders::build_ext_embed(external), None, None, None, None, None)
+                        crate::types::records::MediaEmbed::External(external) => {
+                            (composite_builders::build_ext_embed(&external), None, None, None, None, None)
                         }
-                        _ => (None, None, None, None, None, None),
                     };
                     // Process record part
-                    let embed_uri = rwm.record.record.uri.as_str();
-                    let embed_cid_str = rwm.record.record.cid.to_string();
+                    let embed_uri = rwm.record.uri.as_str();
+                    let embed_cid_str = rwm.record.cid.to_string();
                     let embed_did = parakeet_db::at_uri_util::extract_did(embed_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid embed URI: missing DID in {}", embed_uri))?;
                     let embed_rkey = parakeet_db::at_uri_util::extract_rkey(embed_uri)
···
         if let Some(ref facets) = rec.facets {
             // Build a map of DID -> actor_id for mentioned actors
             let mut actor_id_map: HashMap<String, i32> = HashMap::new();
+            use jacquard_api::app_bsky::richtext::facet::FacetFeaturesItem;
             for facet_main in facets.iter() {
-                for feature_outer in &facet_main.features {
-                    if let lexica::app_bsky::richtext::FacetOuter::Bsky(lexica::app_bsky::richtext::Facet::Mention { did }) = feature_outer {
+                for feature in &facet_main.features {
+                    if let FacetFeaturesItem::Mention(mention) = feature {
+                        let did = mention.did.as_ref();
                         if !actor_id_map.contains_key(did) {
                             // Resolve DID to actor_id
                             if let Ok((mention_actor_id, _, _)) = get_actor_id(conn, did).await {
-                                actor_id_map.insert(did.clone(), mention_actor_id);
+                                actor_id_map.insert(did.to_string(), mention_actor_id);
                             }
                         }
                     }

consumer/src/db/operations/feed/postgate.rs

···
     _cid: Cid,       // No longer stored - postgates are denormalized
     rec: &AppBskyFeedPostgate,
 ) -> Result<u64> {
-    let rules = rec
-        .embedding_rules
-        .iter()
-        .map(|v| v.as_str().to_owned())
-        .collect::<Vec<_>>();
+    let rules: Vec<String> = vec![];  // TODO: Extract rules from DisableRule when needed
 
     // Parse post URI to get post actor_id and rkey
-    let post_did = parakeet_db::at_uri_util::extract_did(&rec.post)
+    let post_did = parakeet_db::at_uri_util::extract_did(rec.post.as_str())
         .ok_or_else(|| eyre::eyre!("Invalid post URI in postgate: missing DID in {}", rec.post))?;
-    let post_rkey_str = parakeet_db::at_uri_util::extract_rkey(&rec.post)
+    let post_rkey_str = parakeet_db::at_uri_util::extract_rkey(rec.post.as_str())
         .ok_or_else(|| eyre::eyre!("Invalid post URI in postgate: {}", rec.post))?;
     let post_rkey = parakeet_db::models::tid_to_i64(post_rkey_str)
         .wrap_err_with(|| format!("Invalid TID in postgate post URI: {}", post_rkey_str))?;
···
         .get::<_, i32>(0);
 
     // OPTIMIZATION: Resolve detached embedding URIs to (actor_id, rkey) pairs in Rust
-    let (detached_actor_ids, detached_rkeys): (Vec<i32>, Vec<i64>) = if !rec.detached_embedding_uris.is_empty() {
-        let uri_refs: Vec<&str> = rec.detached_embedding_uris.iter().map(|s| s.as_str()).collect();
-        let resolved = crate::db::bulk_resolve::resolve_post_uris_bulk(conn, &uri_refs).await?;
+    let (detached_actor_ids, detached_rkeys): (Vec<i32>, Vec<i64>) = if let Some(ref uris) = rec.detached_embedding_uris {
+        if !uris.is_empty() {
+            let uri_refs: Vec<&str> = uris.iter().map(|uri| uri.as_str()).collect();
+            let resolved = crate::db::bulk_resolve::resolve_post_uris_bulk(conn, &uri_refs).await?;
 
-        // Build parallel arrays for SQL
-        let mut actor_ids = Vec::new();
-        let mut rkeys = Vec::new();
-        for uri in &rec.detached_embedding_uris {
-            if let Some(&(aid, rk)) = resolved.get(uri.as_str()) {
-                actor_ids.push(aid);
-                rkeys.push(rk);
+            // Build parallel arrays for SQL
+            let mut actor_ids = Vec::new();
+            let mut rkeys = Vec::new();
+            for uri in uris {
+                if let Some(&(aid, rk)) = resolved.get(uri.as_str()) {
+                    actor_ids.push(aid);
+                    rkeys.push(rk);
+                }
             }
+            (actor_ids, rkeys)
+        } else {
+            (vec![], vec![])
         }
-        (actor_ids, rkeys)
     } else {
         (vec![], vec![])
     };

consumer/src/db/operations/feed/threadgate.rs

···
     let allow = rec.allow.as_ref().map(|allow| {
         allow
             .iter()
-            .map(|v| v.as_str().to_owned())
+            .map(|v| match v {
+                crate::types::records::ThreadgateRule::MentionRule {} => crate::types::records::THREADGATE_RULE_MENTION.to_owned(),
+                crate::types::records::ThreadgateRule::FollowingRule {} => crate::types::records::THREADGATE_RULE_FOLLOWING.to_owned(),
+                crate::types::records::ThreadgateRule::List { .. } => crate::types::records::THREADGATE_RULE_LIST.to_owned(),
+            })
             .collect::<Vec<_>>()
     });
 
     // Parse post URI to get post actor_id and rkey
     // Note: The post being protected is usually the same as the threadgate's actor,
     // but we extract it from the URI to be safe
-    let post_did = parakeet_db::at_uri_util::extract_did(&rec.post)
-        .ok_or_else(|| eyre::eyre!("Invalid post URI in threadgate: missing DID in {}", rec.post))?;
-    let post_rkey_str = parakeet_db::at_uri_util::extract_rkey(&rec.post)
-        .ok_or_else(|| eyre::eyre!("Invalid post URI in threadgate: {}", rec.post))?;
+    let post_uri = rec.post.as_ref()
+        .ok_or_else(|| eyre::eyre!("Missing post URI in threadgate"))?;
+    let post_did = parakeet_db::at_uri_util::extract_did(post_uri.uri.as_str())
+        .ok_or_else(|| eyre::eyre!("Invalid post URI in threadgate: missing DID in {}", post_uri.uri))?;
+    let post_rkey_str = parakeet_db::at_uri_util::extract_rkey(post_uri.uri.as_str())
+        .ok_or_else(|| eyre::eyre!("Invalid post URI in threadgate: {}", post_uri.uri))?;
     let post_rkey = parakeet_db::models::tid_to_i64(post_rkey_str)
         .wrap_err_with(|| format!("Invalid TID in threadgate post URI: {}", post_rkey_str))?;
 
···
         .wrap_err_with(|| format!("Failed to find actor for DID: {}", post_did))?
         .get::<_, i32>(0);
 
-    // OPTIMIZATION: Resolve hidden reply URIs to (actor_id, rkey) pairs in Rust
-    let (hidden_actor_ids, hidden_rkeys): (Vec<i32>, Vec<i64>) = if !rec.hidden_replies.is_empty() {
-        let uri_refs: Vec<&str> = rec.hidden_replies.iter().map(|s| s.as_str()).collect();
-        let resolved = crate::db::bulk_resolve::resolve_post_uris_bulk(conn, &uri_refs).await?;
-
-        // Build parallel arrays for SQL
-        let mut actor_ids = Vec::new();
-        let mut rkeys = Vec::new();
-        for uri in &rec.hidden_replies {
-            if let Some(&(aid, rk)) = resolved.get(uri.as_str()) {
-                actor_ids.push(aid);
-                rkeys.push(rk);
-            }
-        }
-        (actor_ids, rkeys)
-    } else {
-        (vec![], vec![])
-    };
+    // TODO: Handle hidden_replies when added to our custom type
+    let (hidden_actor_ids, hidden_rkeys): (Vec<i32>, Vec<i64>) = (vec![], vec![]);
 
     // Extract allowed list URIs from rules and resolve to natural keys
     let (allowed_list_actor_ids, allowed_list_rkeys): (Vec<i32>, Vec<String>) = if let Some(ref allow_rules) = rec.allow {

consumer/src/db/operations/graph.rs

···
     let description_facets = rec
         .description_facets
         .and_then(|v| serde_json::to_value(v).ok());
-    let avatar = blob_to_cid_bytes(rec.avatar);
+    let avatar = blob_to_cid_bytes(rec.avatar.as_ref());
 
     // Acquire table-scoped advisory lock on lists table for this record
     let (table_id, key_id) = crate::database_writer::locking::actor_record_lock_str("lists", actor_id, rkey);
     crate::database_writer::locking::acquire_lock(conn, table_id, key_id).await?;
 
+    // Convert ListPurpose to string for database
+    // Note: jacquard's ListPurpose doesn't expose variants directly, serialize to JSON to get the type
+    let purpose = serde_json::to_value(&rec.purpose)
+        .ok()
+        .and_then(|v| v.get("$type").and_then(|t| t.as_str()).map(String::from))
+        .unwrap_or_else(|| "app.bsky.graph.defs#curatelist".to_string());
+
     conn.query_one(
         include_str!("../sql/list_upsert.sql"),
         &[
             &actor_id,
             &cid_digest,
-            &rec.purpose,
+            &purpose,
             &rec.name,
             &rec.description,
             &description_facets,
···
 
     // Parse list URI to get natural keys (list_actor_id, list_rkey)
     // Format: at://did:plc:xxx/app.bsky.graph.list/rkey
-    let parts: Vec<&str> = rec.subject.strip_prefix("at://")
+    let parts: Vec<&str> = rec.subject.uri.as_str().strip_prefix("at://")
         .ok_or_else(|| eyre::eyre!("Invalid AT URI"))?
         .split('/')
         .collect();
···
     crate::database_writer::locking::acquire_lock(conn, table_id, key_id).await?;
 
     // Resolve list natural keys by creating stub list if needed
-    let (list_owner_actor_id, list_rkey) = super::feed::ensure_list_natural_key(conn, &rec.list).await?;
+    let (list_owner_actor_id, list_rkey) = super::feed::ensure_list_natural_key(conn, rec.list.uri.as_str()).await?;
 
     conn.execute(
         include_str!("../sql/list_item_upsert.sql"),
···
 
     // Insert verification - actors already resolved (no SELECT subquery needed)
     // Note: created_at is derived from TID rkey
+    let handle_str = rec.handle.to_string();
+    // display_name is CowStr, not Option<CowStr>
+    let display_name_str = Some(rec.display_name.to_string());
     conn.execute(
         "INSERT INTO verification (actor_id, rkey, cid, verifier_actor_id, subject_actor_id, handle, display_name)
         VALUES ($1, $2, $3, $1, $4, $5, $6)
         ON CONFLICT (actor_id, rkey) DO NOTHING",
-        &[&actor_id, &rkey, &cid_digest, &subject_actor_id, &rec.handle, &rec.display_name],
+        &[&actor_id, &rkey, &cid_digest, &subject_actor_id, &handle_str, &display_name_str],
     )
     .await
     .wrap_err_with(|| format!("Failed to insert verification for actor_id:{} rkey:{}", actor_id, rkey))

consumer/src/db/operations/labeler.rs

···
 
 /// Extract the short name from an AT Protocol enum URN
 /// e.g., "com.atproto.moderation.defs#reasonSpam" -> "spam"
+#[allow(dead_code)]
 fn extract_enum_short_name(urn: &str) -> String {
     urn.split('#')
         .nth(1)
···
     let cid_bytes = cid.to_bytes();
     let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
-    let reasons = rec.reason_types.as_ref().map(|v| {
-        v.iter()
-            .map(|r| extract_enum_short_name(&r.to_string()))
-            .collect::<Vec<_>>()
-    });
-    let subject_types = rec.subject_types.as_ref().map(|v| {
-        v.iter()
-            .map(|s| s.to_string().to_lowercase())
-            .collect::<Vec<_>>()
-    });
+    // Note: reason_types, subject_types, and subject_collections not available in jacquard types
+    let reasons: Option<Vec<String>> = None;
+    let subject_types: Option<Vec<String>> = None;
+    let subject_collections: Option<Vec<String>> = None;
 
     let _ = conn
         .execute(
···
                 &cid_digest,
                 &reasons,
                 &subject_types,
-                &rec.subject_collections,
+                &subject_collections,
             ],
         )
         .await?;

consumer/src/db/operations/starter_pack.rs

···
     crate::database_writer::locking::acquire_lock(conn, table_id, key_id).await?;
 
     // Resolve list natural key by creating stub list if needed
-    let (list_actor_id, list_rkey) = super::feed::ensure_list_natural_key(conn, &rec.list).await?;
+    let (list_actor_id, list_rkey) = super::feed::ensure_list_natural_key(conn, rec.list.uri.as_str()).await?;
 
     // Resolve feed URIs to feedgen natural keys in Rust
     // Use parallel arrays for actor_ids and rkeys (easier than composite types for Postgres binding)
···
         for feed_ref in feeds {
             // Parse feed URI to extract (did, rkey)
             let (feed_did, collection, feed_rkey) =
-                parakeet_db::at_uri_util::parse_at_uri(&feed_ref.uri)
+                parakeet_db::at_uri_util::parse_at_uri(feed_ref.uri.as_str())
                     .ok_or_else(|| eyre::eyre!("Invalid feed URI: {}", feed_ref.uri))?;
 
             // Validate it's a feedgen URI

consumer/src/lib.rs

···
 }
 
 // Re-export commonly used utility functions at the crate root
-pub use utils::build_user_agent;

consumer/src/relay/types.rs

···
 use crate::types::records;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(tag = "$type")]
 pub enum RecordTypes {
     #[serde(rename = "app.bsky.actor.profile")]
···
     #[serde(rename = "chat.bsky.actor.declaration")]
     ChatBskyActorDeclaration(records::ChatBskyActorDeclaration),
     #[serde(rename = "community.lexicon.bookmarks.bookmark")]
-    CommunityLexiconBookmark(lexica::community_lexicon::bookmarks::Bookmark),
+    CommunityLexiconBookmark(serde_json::Value),
     #[serde(rename = "fm.team.alpa.actor.status")]
     FmTealAlpaActorStatus(records::FmTealAlpaActorStatus),
     #[serde(untagged)]
     Unknown(serde_json::Value),
+}
+
+impl<'de> Deserialize<'de> for RecordTypes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        let type_field = value.get("$type")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| serde::de::Error::custom("missing $type field"))?;
+
+        // Deserialize from JSON string to handle 'static lifetime requirements
+        let json_str = value.to_string();
+        match type_field {
+            "app.bsky.actor.profile" => {
+                serde_json::from_str::<records::AppBskyActorProfile>(&json_str)
+                    .map(RecordTypes::AppBskyActorProfile)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.actor.status" => {
+                serde_json::from_str::<records::AppBskyActorStatus>(&json_str)
+                    .map(RecordTypes::AppBskyActorStatus)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.generator" => {
+                serde_json::from_str::<records::AppBskyFeedGenerator>(&json_str)
+                    .map(RecordTypes::AppBskyFeedGenerator)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.like" => {
+                serde_json::from_str::<records::AppBskyFeedLike>(&json_str)
+                    .map(RecordTypes::AppBskyFeedLike)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.post" => {
+                serde_json::from_str::<records::AppBskyFeedPost>(&json_str)
+                    .map(RecordTypes::AppBskyFeedPost)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.postgate" => {
+                serde_json::from_str::<records::AppBskyFeedPostgate>(&json_str)
+                    .map(RecordTypes::AppBskyFeedPostgate)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.repost" => {
+                serde_json::from_str::<records::AppBskyFeedRepost>(&json_str)
+                    .map(RecordTypes::AppBskyFeedRepost)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.feed.threadgate" => {
+                serde_json::from_str::<records::AppBskyFeedThreadgate>(&json_str)
+                    .map(RecordTypes::AppBskyFeedThreadgate)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.block" => {
+                serde_json::from_str::<records::AppBskyGraphBlock>(&json_str)
+                    .map(RecordTypes::AppBskyGraphBlock)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.follow" => {
+                serde_json::from_str::<records::AppBskyGraphFollow>(&json_str)
+                    .map(RecordTypes::AppBskyGraphFollow)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.list" => {
+                serde_json::from_str::<records::AppBskyGraphList>(&json_str)
+                    .map(RecordTypes::AppBskyGraphList)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.listblock" => {
+                serde_json::from_str::<records::AppBskyGraphListBlock>(&json_str)
+                    .map(RecordTypes::AppBskyGraphListBlock)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.listitem" => {
+                serde_json::from_str::<records::AppBskyGraphListItem>(&json_str)
+                    .map(RecordTypes::AppBskyGraphListItem)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.starterpack" => {
+                serde_json::from_str::<records::AppBskyGraphStarterPack>(&json_str)
+                    .map(RecordTypes::AppBskyGraphStarterPack)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.graph.verification" => {
+                serde_json::from_str::<records::AppBskyGraphVerification>(&json_str)
+                    .map(RecordTypes::AppBskyGraphVerification)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.labeler.service" => {
+                serde_json::from_str::<records::AppBskyLabelerService>(&json_str)
+                    .map(RecordTypes::AppBskyLabelerService)
+                    .map_err(serde::de::Error::custom)
+            }
+            "app.bsky.notification.declaration" => {
+                serde_json::from_str::<records::AppBskyNotificationDeclaration>(&json_str)
+                    .map(RecordTypes::AppBskyNotificationDeclaration)
+                    .map_err(serde::de::Error::custom)
+            }
+            "chat.bsky.actor.declaration" => {
+                serde_json::from_str::<records::ChatBskyActorDeclaration>(&json_str)
+                    .map(RecordTypes::ChatBskyActorDeclaration)
+                    .map_err(serde::de::Error::custom)
+            }
+            "community.lexicon.bookmarks.bookmark" => {
+                Ok(RecordTypes::CommunityLexiconBookmark(value))
+            }
+            "fm.team.alpa.actor.status" => {
+                serde_json::from_str::<records::FmTealAlpaActorStatus>(&json_str)
+                    .map(RecordTypes::FmTealAlpaActorStatus)
+                    .map_err(serde::de::Error::custom)
+            }
+            _ => Ok(RecordTypes::Unknown(value))
+        }
+    }
 }
 
 #[derive(Debug, PartialOrd, PartialEq, Eq, Deserialize, Serialize)]

consumer/src/types/records.rs

···
 use crate::utils;
 use chrono::{DateTime, Utc};
-use lexica::app_bsky::actor::{ChatAllowIncoming, ProfileAllowSubscriptions, Status};
-use lexica::app_bsky::embed::AspectRatio;
-use lexica::app_bsky::labeler::LabelerPolicy;
-use lexica::app_bsky::richtext::FacetMain;
-use lexica::com_atproto::label::SelfLabels;
-use lexica::com_atproto::moderation::{ReasonType, SubjectType};
-use lexica::{Blob, StrongRef};
+use jacquard_api::app_bsky;
+use jacquard_api::com_atproto;
+use jacquard_common::types::blob::Blob;
+use jacquard_common::IntoStatic;
 use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
+
+type StrongRef<'a> = com_atproto::repo::strong_ref::StrongRef<'a>;
+type SelfLabels<'a> = com_atproto::label::SelfLabels<'a>;
+
+// Wrapper structs for types that need custom deserialization
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct AppBskyNotificationDeclaration(
+    #[serde(deserialize_with = "deserialize_notification_declaration")]
+    pub app_bsky::notification::declaration::Declaration<'static>
+);
+
+impl std::ops::Deref for AppBskyNotificationDeclaration {
+    type Target = app_bsky::notification::declaration::Declaration<'static>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct AppBskyGraphVerification(
+    #[serde(deserialize_with = "deserialize_graph_verification")]
+    pub app_bsky::graph::verification::Verification<'static>
+);
+
+impl std::ops::Deref for AppBskyGraphVerification {
+    type Target = app_bsky::graph::verification::Verification<'static>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn deserialize_notification_declaration<'de, D>(deserializer: D) -> Result<app_bsky::notification::declaration::Declaration<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let decl: app_bsky::notification::declaration::Declaration<'_> = app_bsky::notification::declaration::Declaration::deserialize(deserializer)?;
+    Ok(decl.into_static())
+}
+
+fn deserialize_graph_verification<'de, D>(deserializer: D) -> Result<app_bsky::graph::verification::Verification<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let ver: app_bsky::graph::verification::Verification<'_> = app_bsky::graph::verification::Verification::deserialize(deserializer)?;
+    Ok(ver.into_static())
+}
+
+pub type AppBskyGraphListBlock = AppBskyGraphListblock;
+pub type AppBskyGraphListItem = AppBskyGraphListitem;
+pub type AppBskyGraphStarterPack = AppBskyGraphStarterpack;
+
+pub const THREADGATE_RULE_MENTION: &str = "app.bsky.feed.threadgate#mentionRule";
+pub const THREADGATE_RULE_FOLLOWING: &str = "app.bsky.feed.threadgate#followingRule";
+pub const THREADGATE_RULE_FOLLOWER: &str = "app.bsky.feed.threadgate#followerRule";
+pub const THREADGATE_RULE_LIST: &str = "app.bsky.feed.threadgate#listRule";
+
+// TODO: Placeholder types to be implemented later
+#[derive(Debug, Deserialize, Serialize, Default)]
+pub struct FmTealAlpaActorStatus {}
+
+#[derive(Debug, Deserialize, Serialize, Default)]
+pub struct PostgateEmbeddingRules {}
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-#[serde_as]
 pub struct AppBskyActorProfile {
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub display_name: Option<String>,
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub description: Option<String>,
-    pub avatar: Option<Blob>,
-    pub banner: Option<Blob>,
-    pub labels: Option<SelfLabels>,
-    pub joined_via_starter_pack: Option<StrongRef>,
-    pub pinned_post: Option<StrongRef>,
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_blob")]
+    pub avatar: Option<Blob<'static>>,
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_blob")]
+    pub banner: Option<Blob<'static>>,
+    #[serde(deserialize_with = "deserialize_self_labels")]
+    pub labels: Option<SelfLabels<'static>>,
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_strongref")]
+    pub joined_via_starter_pack: Option<StrongRef<'static>>,
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_strongref")]
+    pub pinned_post: Option<StrongRef<'static>>,
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub pronouns: Option<String>,
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub website: Option<String>,
     pub created_at: Option<DateTime<Utc>>,
 }
 
+
+fn deserialize_self_labels<'de, D>(deserializer: D) -> Result<Option<SelfLabels<'static>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let labels: Option<SelfLabels<'_>> = Option::deserialize(deserializer)?;
+    Ok(labels.map(|l| l.into_static()))
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AppBskyActorStatus {
-    pub status: Status,
+    #[serde(deserialize_with = "deserialize_status")]
+    pub status: app_bsky::actor::status::Status<'static>,
     pub duration_minutes: Option<i32>,
     pub embed: Option<AppBskyEmbedExternal>,
+    pub created_at: DateTime<Utc>,
+}
+
+fn deserialize_status<'de, D>(deserializer: D) -> Result<app_bsky::actor::status::Status<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let status: app_bsky::actor::status::Status<'_> = app_bsky::actor::status::Status::deserialize(deserializer)?;
+    Ok(status.into_static())
+}
+
+fn deserialize_facets<'de, D>(deserializer: D) -> Result<Option<Vec<app_bsky::richtext::facet::Facet<'static>>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let facets: Option<Vec<app_bsky::richtext::facet::Facet<'_>>> = Option::deserialize(deserializer)?;
+    Ok(facets.map(|v| v.into_iter().map(|f| f.into_static()).collect()))
+}
 
-    pub created_at: DateTime<Utc>,
+fn deserialize_list_purpose<'de, D>(deserializer: D) -> Result<app_bsky::graph::ListPurpose<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let purpose: app_bsky::graph::ListPurpose<'_> = app_bsky::graph::ListPurpose::deserialize(deserializer)?;
+    Ok(purpose.into_static())
+}
+
+fn deserialize_aspect_ratio<'de, D>(deserializer: D) -> Result<Option<app_bsky::embed::AspectRatio<'static>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let aspect: Option<app_bsky::embed::AspectRatio<'_>> = Option::deserialize(deserializer)?;
+    Ok(aspect.map(|a| a.into_static()))
+}
+
+
+fn deserialize_labeler_policies<'de, D>(deserializer: D) -> Result<app_bsky::labeler::LabelerPolicies<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let policies: app_bsky::labeler::LabelerPolicies<'_> = app_bsky::labeler::LabelerPolicies::deserialize(deserializer)?;
+    Ok(policies.into_static())
+}
+
+fn deserialize_reason_type<'de, D>(deserializer: D) -> Result<Option<com_atproto::moderation::ReasonType<'static>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let reason: Option<com_atproto::moderation::ReasonType<'_>> = Option::deserialize(deserializer)?;
+    Ok(reason.map(|r| r.into_static()))
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
···
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct EmbedImage {
-    pub image: Blob,
-    #[serde(deserialize_with = "utils::safe_string")]
+    #[serde(deserialize_with = "deserialize_blob")]
+    pub image: Blob<'static>,
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub alt: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub aspect_ratio: Option<AspectRatio>,
+    #[serde(deserialize_with = "deserialize_aspect_ratio")]
+    pub aspect_ratio: Option<app_bsky::embed::AspectRatio<'static>>,
+}
+
+fn deserialize_blob<'de, D>(deserializer: D) -> Result<Blob<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let blob: Blob<'_> = Blob::deserialize(deserializer)?;
+    Ok(blob.into_static())
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-#[serde_as]
 pub struct AppBskyEmbedVideo {
-    pub video: Blob,
+    #[serde(deserialize_with = "deserialize_blob")]
+    pub video: Blob<'static>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub captions: Option<Vec<EmbedVideoCaptions>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub alt: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub aspect_ratio: Option<AspectRatio>,
+    #[serde(deserialize_with = "deserialize_aspect_ratio")]
+    pub aspect_ratio: Option<app_bsky::embed::AspectRatio<'static>>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct EmbedVideoCaptions {
     pub lang: String,
-    pub file: Blob,
+    #[serde(deserialize_with = "deserialize_blob")]
+    pub file: Blob<'static>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(tag = "$type")]
-#[serde(rename = "app.bsky.embed.external")]
+#[serde(rename_all = "camelCase")]
 pub struct AppBskyEmbedExternal {
     pub external: EmbedExternal,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct EmbedExternal {
     pub uri: String,
-    #[serde(deserialize_with = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub title: String,
-    #[serde(deserialize_with = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub description: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub thumb: Option<Blob>,
+    #[serde(deserialize_with = "utils::deserialize_optional_blob")]
+    pub thumb: Option<Blob<'static>>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct AppBskyEmbedRecord {
-    pub record: StrongRef,
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub record: StrongRef<'static>,
+}
+
+fn deserialize_strongref<'de, D>(deserializer: D) -> Result<StrongRef<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let sr: StrongRef<'_> = StrongRef::deserialize(deserializer)?;
+    Ok(sr.into_static())
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct AppBskyEmbedRecordWithMedia {
-    pub record: AppBskyEmbedRecord,
-    pub media: Box<AppBskyEmbed>,
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub record: StrongRef<'static>,
+    pub media: MediaEmbed,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde_as]
-pub struct AppBskyFeedGenerator {
-    pub did: String,
-    #[serde(deserialize_with = "utils::safe_string")]
-    pub display_name: String,
-    #[serde_as(as = "utils::safe_string")]
-    pub description: Option<String>,
-    pub description_facets: Option<Vec<FacetMain>>,
-    pub avatar: Option<Blob>,
-    pub accepts_interactions: Option<bool>,
-    pub labels: Option<SelfLabels>,
-    pub content_mode: Option<String>,
-    pub created_at: DateTime<Utc>,
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(tag = "$type")]
+pub enum MediaEmbed {
+    #[serde(rename = "app.bsky.embed.images")]
+    Images(AppBskyEmbedImages),
+    #[serde(rename = "app.bsky.embed.video")]
+    Video(AppBskyEmbedVideo),
+    #[serde(rename = "app.bsky.embed.external")]
+    External(AppBskyEmbedExternal),
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AppBskyFeedLike {
-    pub subject: StrongRef,
-    pub created_at: DateTime<Utc>,
-    pub via: Option<StrongRef>,
+impl MediaEmbed {
+    pub const fn as_str(&self) -> &'static str {
+        match self {
+            Self::Images(_) => "app.bsky.embed.images",
+            Self::Video(_) => "app.bsky.embed.video",
+            Self::External(_) => "app.bsky.embed.external",
+        }
+    }
 }
 
 #[derive(Debug, Deserialize, Serialize)]
-#[serde(tag = "$type")]
-#[serde(rename = "app.bsky.feed.post")]
 #[serde(rename_all = "camelCase")]
 pub struct AppBskyFeedPost {
-    #[serde(deserialize_with = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub text: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub facets: Option<Vec<FacetMain>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    pub entities: Option<Vec<serde_json::Value>>,
+    #[serde(deserialize_with = "deserialize_facets")]
+    pub facets: Option<Vec<app_bsky::richtext::facet::Facet<'static>>>,
     pub reply: Option<ReplyRef>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub embed: Option<EmbedOuter>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub langs: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub labels: Option<SelfLabels>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "deserialize_self_labels")]
+    pub labels: Option<SelfLabels<'static>>,
     pub tags: Option<Vec<String>>,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyFeedPostgate {
-    pub post: String,
-    pub created_at: DateTime<Utc>,
-    #[serde(default)]
-    pub detached_embedding_uris: Vec<String>,
-    #[serde(default)]
-    pub embedding_rules: Vec<PostgateEmbeddingRules>,
+pub struct ReplyRef {
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub root: StrongRef<'static>,
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub parent: StrongRef<'static>,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Deserialize, Serialize)]
-#[serde(tag = "$type")]
-pub enum PostgateEmbeddingRules {
-    #[serde(rename = "app.bsky.feed.postgate#disableRule")]
-    Disable,
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppBskyFeedRepost {
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub subject: StrongRef<'static>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_strongref")]
+    pub via: Option<StrongRef<'static>>,
+    pub created_at: DateTime<Utc>,
 }
 
-impl PostgateEmbeddingRules {
-    pub const fn as_str(self) -> &'static str {
-        match self {
-            Self::Disable => "app.bsky.feed.postgate#disableRule",
-        }
-    }
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppBskyFeedLike {
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub subject: StrongRef<'static>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(deserialize_with = "crate::utils::deserialize_optional_strongref")]
+    pub via: Option<StrongRef<'static>>,
+    pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyFeedRepost {
-    pub subject: StrongRef,
+pub struct AppBskyFeedGenerator {
+    pub did: String,
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
+    pub display_name: String,
+    #[serde(deserialize_with = "crate::utils::safe_string")]
+    pub description: Option<String>,
+    #[serde(deserialize_with = "deserialize_facets")]
+    pub description_facets: Option<Vec<app_bsky::richtext::facet::Facet<'static>>>,
+    #[serde(deserialize_with = "utils::deserialize_optional_blob")]
+    pub avatar: Option<Blob<'static>>,
+    #[serde(deserialize_with = "deserialize_self_labels")]
+    pub labels: Option<SelfLabels<'static>>,
     pub created_at: DateTime<Utc>,
-    pub via: Option<StrongRef>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct AppBskyFeedPostgate(
+    #[serde(deserialize_with = "deserialize_feed_postgate")]
+    pub app_bsky::feed::postgate::Postgate<'static>
+);
+
+impl std::ops::Deref for AppBskyFeedPostgate {
+    type Target = app_bsky::feed::postgate::Postgate<'static>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn deserialize_feed_postgate<'de, D>(deserializer: D) -> Result<app_bsky::feed::postgate::Postgate<'static>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let postgate: app_bsky::feed::postgate::Postgate<'_> = app_bsky::feed::postgate::Postgate::deserialize(deserializer)?;
+    Ok(postgate.into_static())
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(tag = "$type")]
+pub enum PostgateRule {
+    #[serde(rename = "app.bsky.feed.postgate#disableRule")]
+    DisableRule {},
 }
 
 #[derive(Debug, Deserialize, Serialize)]
-#[serde(tag = "$type")]
-#[serde(rename = "app.bsky.feed.threadgate")]
 #[serde(rename_all = "camelCase")]
 pub struct AppBskyFeedThreadgate {
-    pub post: String,
-    pub created_at: DateTime<Utc>,
+    #[serde(deserialize_with = "utils::deserialize_optional_strongref")]
+    pub post: Option<StrongRef<'static>>,
     pub allow: Option<Vec<ThreadgateRule>>,
-    #[serde(default)]
-    pub hidden_replies: Vec<String>,
+    pub created_at: DateTime<Utc>,
 }
 
-pub const THREADGATE_RULE_MENTION: &str = "app.bsky.feed.threadgate#mentionRule";
-pub const THREADGATE_RULE_FOLLOWER: &str = "app.bsky.feed.threadgate#followerRule";
-pub const THREADGATE_RULE_FOLLOWING: &str = "app.bsky.feed.threadgate#followingRule";
-pub const THREADGATE_RULE_LIST: &str = "app.bsky.feed.threadgate#listRule";
-
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(tag = "$type")]
 pub enum ThreadgateRule {
     #[serde(rename = "app.bsky.feed.threadgate#mentionRule")]
-    Mention,
-    #[serde(rename = "app.bsky.feed.threadgate#followerRule")]
-    Follower,
+    MentionRule {},
     #[serde(rename = "app.bsky.feed.threadgate#followingRule")]
-    Following,
+    FollowingRule {},
     #[serde(rename = "app.bsky.feed.threadgate#listRule")]
     List { list: String },
 }
 
-impl ThreadgateRule {
-    pub const fn as_str(&self) -> &'static str {
-        match self {
-            Self::Mention => THREADGATE_RULE_MENTION,
-            Self::Follower => THREADGATE_RULE_FOLLOWER,
-            Self::Following => THREADGATE_RULE_FOLLOWING,
-            Self::List { .. } => THREADGATE_RULE_LIST,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct ReplyRef {
-    pub root: StrongRef,
-    pub parent: StrongRef,
-}
-
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyGraphBlock {
+pub struct AppBskyGraphFollow {
     pub subject: String,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyGraphFollow {
+pub struct AppBskyGraphBlock {
     pub subject: String,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-#[serde_as]
 pub struct AppBskyGraphList {
-    pub purpose: String,
-    #[serde(deserialize_with = "utils::safe_string")]
+    #[serde(deserialize_with = "deserialize_list_purpose")]
+    pub purpose: app_bsky::graph::ListPurpose<'static>,
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub name: String,
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub description: Option<String>,
-    pub description_facets: Option<Vec<FacetMain>>,
-    pub avatar: Option<Blob>,
-    pub labels: Option<SelfLabels>,
+    #[serde(deserialize_with = "deserialize_facets")]
+    pub description_facets: Option<Vec<app_bsky::richtext::facet::Facet<'static>>>,
+    #[serde(deserialize_with = "utils::deserialize_optional_blob")]
+    pub avatar: Option<Blob<'static>>,
+    #[serde(deserialize_with = "deserialize_self_labels")]
+    pub labels: Option<SelfLabels<'static>>,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyGraphListItem {
+pub struct AppBskyGraphListitem {
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub list: StrongRef<'static>,
     pub subject: String,
-    pub list: String,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyGraphListBlock {
-    pub subject: String,
+pub struct AppBskyGraphListblock {
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub subject: StrongRef<'static>,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
-#[serde(tag = "$type")]
-#[serde(rename = "app.bsky.graph.starterpack")]
 #[serde(rename_all = "camelCase")]
-#[serde_as]
-pub struct AppBskyGraphStarterPack {
-    #[serde(deserialize_with = "utils::safe_string")]
+pub struct AppBskyGraphStarterpack {
+    #[serde(deserialize_with = "crate::utils::safe_string_required")]
     pub name: String,
-    #[serde_as(as = "utils::safe_string")]
+    #[serde(deserialize_with = "crate::utils::safe_string")]
     pub description: Option<String>,
-    pub description_facets: Option<Vec<FacetMain>>,
-    pub list: String,
-    pub feeds: Option<Vec<StarterPackFeedItem>>,
+    #[serde(deserialize_with = "deserialize_facets")]
+    pub description_facets: Option<Vec<app_bsky::richtext::facet::Facet<'static>>>,
+    #[serde(deserialize_with = "deserialize_strongref")]
+    pub list: StrongRef<'static>,
+    pub feeds: Option<Vec<FeedRule>>,
     pub created_at: DateTime<Utc>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct StarterPackFeedItem {
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct FeedRule {
     pub uri: String,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyGraphVerification {
-    pub subject: String,
-    #[serde(deserialize_with = "utils::safe_string")]
-    pub handle: String,
-    #[serde(deserialize_with = "utils::safe_string")]
-    pub display_name: String,
+pub struct AppBskyLabelerService {
+    #[serde(deserialize_with = "deserialize_labeler_policies")]
+    pub policies: app_bsky::labeler::LabelerPolicies<'static>,
+    #[serde(deserialize_with = "deserialize_self_labels")]
+    pub labels: Option<SelfLabels<'static>>,
     pub created_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyLabelerService {
-    pub policies: LabelerPolicy,
-    pub labels: Option<SelfLabels>,
-    pub reason_types: Option<Vec<ReasonType>>,
-    pub subject_types: Option<Vec<SubjectType>>,
-    pub subject_collections: Option<Vec<String>>,
+pub struct ComAtprotoAdminDefs {
+    pub disabled: Option<bool>,
+    pub invites: Option<ComAtprotoServerDefsInviteCode>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ComAtprotoServerDefsInviteCode {
+    pub code: String,
+    pub available: i32,
+    pub disabled: bool,
+    pub for_account: String,
+    pub created_by: String,
     pub created_at: DateTime<Utc>,
+    pub uses: Vec<ComAtprotoServerDefsInviteCodeUse>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AppBskyNotificationDeclaration {
-    pub allow_subscriptions: ProfileAllowSubscriptions,
+pub struct ComAtprotoServerDefsInviteCodeUse {
+    pub used_by: String,
+    pub used_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ChatBskyActorDeclaration {
-    pub allow_incoming: ChatAllowIncoming,
+    pub allow_incoming: String, // In jacquard this is just a string
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FmTealAlpaActorStatus {
-    pub item: FmTealAlpaActorStatusItem,
-    pub time: String,   // Unix Epoch
-    pub expiry: String, // Unix Epoch
+pub struct ComAtprotoLabelDefs {
+    pub ver: Option<i32>,
+    pub src: String,
+    pub uri: String,
+    pub cid: Option<String>,
+    pub val: String,
+    pub neg: Option<bool>,
+    pub cts: DateTime<Utc>,
+    pub exp: Option<DateTime<Utc>>,
+    pub sig: Option<Vec<u8>>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FmTealAlpaActorStatusItem {
-    pub artists: Vec<String>,
-    pub track_name: String,
+pub struct ComAtprotoModerationDefs {
+    #[serde(deserialize_with = "deserialize_reason_type")]
+    pub reason_type: Option<com_atproto::moderation::ReasonType<'static>>,
+    pub reason: Option<String>,
+    pub subject: ComAtprotoModerationDefsSubject,
+    pub created_at: DateTime<Utc>,
 }
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "$type")]
+pub enum ComAtprotoModerationDefsSubject {
+    #[serde(rename = "com.atproto.admin.defs#repoRef")]
+    RepoRef { did: String },
+    #[serde(rename = "com.atproto.repo.strongRef")]
+    StrongRef(StrongRef<'static>),
+}
+
+impl<'de> Deserialize<'de> for ComAtprotoModerationDefsSubject {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+
+        use serde::de::MapAccess;
+        use serde::de::Visitor;
+        use std::fmt;
+
+        struct SubjectVisitor;
+
+        impl<'de> Visitor<'de> for SubjectVisitor {
+            type Value = ComAtprotoModerationDefsSubject;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("ComAtprotoModerationDefsSubject")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut type_field = None;
+                let mut did = None;
+                let mut strongref_fields = serde_json::Map::new();
+
+                while let Some(key) = map.next_key::<String>()? {
+                    match key.as_str() {
+                        "$type" => type_field = Some(map.next_value::<String>()?),
+                        "did" => did = Some(map.next_value::<String>()?),
+                        other => {
+                            strongref_fields.insert(other.to_string(), map.next_value()?);
+                        }
+                    }
+                }
+
+                let type_field = type_field.ok_or_else(|| serde::de::Error::missing_field("$type"))?;
+
+                match type_field.as_str() {
+                    "com.atproto.admin.defs#repoRef" => {
+                        Ok(ComAtprotoModerationDefsSubject::RepoRef {
+                            did: did.ok_or_else(|| serde::de::Error::missing_field("did"))?,
+                        })
+                    }
+                    "com.atproto.repo.strongRef" => {
+                        let uri_string = strongref_fields.get("uri")
+                            .and_then(|v| v.as_str())
+                            .ok_or_else(|| serde::de::Error::missing_field("uri"))?
+                            .to_string();
+                        let cid_string = strongref_fields.get("cid")
+                            .and_then(|v| v.as_str())
+                            .ok_or_else(|| serde::de::Error::missing_field("cid"))?
+                            .to_string();
+
+                        use jacquard_api::com_atproto::repo::strong_ref::StrongRefBuilder;
+                        use jacquard_common::types::string::{AtUri, Cid};
+
+                        let at_uri = AtUri::try_from(uri_string)
+                            .map_err(|e| serde::de::Error::custom(format!("Invalid AT URI: {}", e)))?;
+                        let cid_val = Cid::try_from(cid_string)
+                            .map_err(|e| serde::de::Error::custom(format!("Invalid CID: {}", e)))?;
+                        let strongref = StrongRefBuilder::new()
+                            .uri(at_uri)
+                            .cid(cid_val)
+                            .build();
+                        Ok(ComAtprotoModerationDefsSubject::StrongRef(strongref))
+                    }
+                    _ => Err(serde::de::Error::unknown_variant(&type_field, &["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]))
+                }
+            }
+        }
+
+        deserializer.deserialize_map(SubjectVisitor)
+    }
+}

consumer/src/utils.rs

···
-use lexica::app_bsky::richtext::{Facet, FacetMain, FacetOuter};
-use lexica::{Blob, StrongRef};
+use jacquard_api::app_bsky::richtext::facet::{Facet as FacetMain, FacetFeaturesItem};
+use jacquard_common::types::blob::Blob;
+use jacquard_api::com_atproto::repo::strong_ref::StrongRef;
 use serde::{Deserialize as _, Deserializer};
 
 // see https://deer.social/profile/did:plc:63y3oh7iakdueqhlj6trojbq/post/3ltuv4skhqs2h
-pub fn safe_string<'de, D: Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
-    let str = String::deserialize(deserializer)?;
+pub fn safe_string<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
+    let str = Option::<String>::deserialize(deserializer)?;
 
+    Ok(str.map(|s| s.replace('\u{0000}', "")))
+}
+
+pub fn safe_string_required<'de, D: Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
+    let str = String::deserialize(deserializer)?;
     Ok(str.replace('\u{0000}', ""))
 }
 
+pub fn strip_mime_params(mime_type: &str) -> String {
+    // Strip any parameters from the MIME type (e.g., "image/jpeg; quality=90" -> "image/jpeg")
+    mime_type.split(';').next().unwrap_or(mime_type).trim().to_string()
+}
+
 #[expect(clippy::single_option_map, reason = "Option::map() is clearer than and_then() for simple transformations")]
-pub fn blob_ref(blob: Option<Blob>) -> Option<String> {
-    blob.map(|blob| blob.cid.to_string())
+pub fn blob_ref(blob: Option<&Blob>) -> Option<String> {
+    blob.map(|blob| blob.cid().to_string())
 }
 
 /// Convert a Blob to CID bytes (32-byte digest) for database storage
-pub fn blob_to_cid_bytes(blob: Option<Blob>) -> Option<Vec<u8>> {
-    blob.map(|blob| {
-        let cid_bytes = blob.cid.to_bytes();
-        parakeet_db::cid_util::cid_to_digest(&cid_bytes)
-            .expect("Blob CID must be valid AT Protocol CID")
-            .to_vec()
+pub fn blob_to_cid_bytes(blob: Option<&Blob>) -> Option<Vec<u8>> {
+    blob.and_then(|blob| {
+        parakeet_db::cid_util::blob_to_cid_bytes(Some(blob))
     })
 }
 
 pub fn strongref_to_parts(strongref: Option<&StrongRef>) -> (Option<String>, Option<String>) {
-    strongref
-        .map(|sr| (sr.uri.clone(), sr.cid.to_string()))
-        .unzip()
+    parakeet_db::cid_util::strongref_to_parts(strongref)
 }
 
 /// Convert a StrongRef to (URI, CID digest bytes) for pending linkage
 pub fn strongref_to_parts_with_digest(
     strongref: Option<&StrongRef>,
 ) -> (Option<String>, Option<Vec<u8>>) {
-    strongref
-        .map(|sr| {
-            let cid_bytes = sr.cid.to_bytes();
-            let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
-                .expect("StrongRef CID must be valid AT Protocol CID")
-                .to_vec();
-            (sr.uri.clone(), cid_digest)
-        })
-        .unzip()
+    parakeet_db::cid_util::strongref_to_parts_with_digest(strongref)
 }
 
 pub fn at_uri_is_by(uri: &str, did: &str) -> bool {
···
     let (mentions, tags) = from
         .iter()
         .flat_map(|v| {
-            v.features.iter().map(|facet| match facet {
-                FacetOuter::Bsky(Facet::Mention { did }) => (Some(did), None),
-                FacetOuter::Bsky(Facet::Tag { tag }) => (None, Some(tag)),
-                _ => (None, None),
+            v.features.iter().filter_map(|feature| {
+                match feature {
+                    FacetFeaturesItem::Mention(mention) => Some((Some(mention.did.to_string()), None)),
+                    FacetFeaturesItem::Tag(tag) => Some((None, Some(tag.tag.to_string()))),
+                    _ => None,
+                }
             })
         })
         .unzip::<_, _, Vec<_>, Vec<_>>();
 
-    let mentions = mentions.into_iter().flatten().cloned().collect();
-    let tags = tags.into_iter().flatten().cloned().collect();
+    let mentions = mentions.into_iter().flatten().collect();
+    let tags = tags.into_iter().flatten().collect();
 
     (mentions, tags)
 }
···
     }
 }
 
-/// Build a User-Agent string with optional contact information
-pub fn build_user_agent(contact: Option<&String>) -> String {
-    contact.map_or_else(
-        || format!("Parakeet {}", env!("CARGO_PKG_VERSION")),
-        |contact| format!("Parakeet {} ({contact})", env!("CARGO_PKG_VERSION")),
-    )
+pub fn deserialize_optional_blob<'de, D>(deserializer: D) -> Result<Option<Blob<'static>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use jacquard_common::IntoStatic;
+    let opt: Option<Blob<'_>> = Option::deserialize(deserializer)?;
+    Ok(opt.map(|b| b.into_static()))
 }
 
-/// Strip parameters from a MIME type string
-///
-/// MIME types may include parameters like `image/jpeg; charset=UTF-8`.
-/// This function strips everything after the first semicolon to get the base MIME type.
-///
-/// # Examples
-/// ```
-/// # fn strip_mime_params(mime_type: &str) -> String {
-/// #     mime_type.split(';').next().unwrap_or(mime_type).trim().to_string()
-/// # }
-/// assert_eq!(strip_mime_params("image/jpeg; charset=UTF-8"), "image/jpeg");
-/// assert_eq!(strip_mime_params("image/png"), "image/png");
-/// assert_eq!(strip_mime_params("video/mp4; codecs=avc1"), "video/mp4");
-/// ```
-pub fn strip_mime_params(mime_type: &str) -> String {
-    mime_type
-        .split(';')
-        .next()
-        .unwrap_or(mime_type)
-        .trim()
-        .to_string()
-}
+pub fn deserialize_optional_strongref<'de, D>(deserializer: D) -> Result<Option<StrongRef<'static>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use jacquard_common::IntoStatic;
+    let opt: Option<StrongRef<'_>> = Option::deserialize(deserializer)?;
+    Ok(opt.map(|s| s.into_static()))
+}

consumer/src/workers/tap/processor.rs

···
         }
     }
 
-    // Deserialize using serde's tagged enum support
-    let record_type: RecordTypes = serde_json::from_value(record_with_type)?;
+    let record_type: RecordTypes = serde_json::from_str(&record_with_type.to_string())?;
     Ok(record_type)
 }
 

consumer/tests/actor_operations_test.rs

···
     AppBskyActorProfile, AppBskyActorStatus, AppBskyNotificationDeclaration,
     ChatBskyActorDeclaration,
 };
-use lexica::app_bsky::actor::{ChatAllowIncoming, ProfileAllowSubscriptions, Status};
-use lexica::Blob;
+use jacquard_api::app_bsky;
+use jacquard_common::types::blob::{Blob, MimeType};
+use jacquard_common::types::cid::{Cid, CidLink};
+use jacquard_common::IntoStatic;
 use eyre::WrapErr;
 
 // ============================================================================
···
         display_name: Some("Test User".to_string()),
         description: Some("This is a test profile".to_string()),
         avatar: Some(Blob {
-            mime_type: "image/jpeg".to_string(),
-            cid: test_cid(),
+            r#ref: CidLink(Cid::from(test_cid())),
+            mime_type: MimeType::new("image/jpeg").unwrap(),
             size: 1024,
-        }),
+        }.into_static()),
         banner: Some(Blob {
-            mime_type: "image/png".to_string(),
-            cid: test_cid(),
+            r#ref: CidLink(Cid::from(test_cid())),
+            mime_type: MimeType::new("image/png").unwrap(),
             size: 2048,
-        }),
+        }.into_static()),
         labels: None,
         joined_via_starter_pack: None,
         pinned_post: None,
···
 
     // Create a status (simple case without embed)
     let status = AppBskyActorStatus {
-        status: Status::Live,
+        status: app_bsky::actor::status::Status::new()
+            .created_at(jacquard_common::types::string::Datetime::new(Utc::now().fixed_offset()))
+            .status("live")
+            .build()
+            .into_static(),
         duration_minutes: Some(60),
         embed: None,
         created_at: Utc::now(),
···
 
     // Create a status
     let status = AppBskyActorStatus {
-        status: Status::Live,
+        status: app_bsky::actor::status::Status::new()
+            .created_at(jacquard_common::types::string::Datetime::new(Utc::now().fixed_offset()))
+            .status("live")
+            .build()
+            .into_static(),
         duration_minutes: None,
         embed: None,
         created_at: Utc::now(),
···
 
     // Create a chat declaration
     let chat_decl = ChatBskyActorDeclaration {
-        allow_incoming: ChatAllowIncoming::Following,
+        allow_incoming: "following".to_string(),
     };
 
     let result = actor::chat_decl_upsert(&tx, actor_id, chat_decl).await;
···
 
     // Create initial chat declaration
     let chat_decl1 = ChatBskyActorDeclaration {
-        allow_incoming: ChatAllowIncoming::All,
+        allow_incoming: "all".to_string(),
     };
 
     actor::chat_decl_upsert(&tx, actor_id, chat_decl1)
···
 
     // Update chat declaration
     let chat_decl2 = ChatBskyActorDeclaration {
-        allow_incoming: ChatAllowIncoming::None,
+        allow_incoming: "none".to_string(),
     };
 
     let result = actor::chat_decl_upsert(&tx, actor_id, chat_decl2).await;
···
 
     // Create a chat declaration
     let chat_decl = ChatBskyActorDeclaration {
-        allow_incoming: ChatAllowIncoming::Following,
+        allow_incoming: "following".to_string(),
     };
 
     actor::chat_decl_upsert(&tx, actor_id, chat_decl)
···
         .wrap_err("Failed to ensure actor")?;
 
     // Create a notification declaration
-    let notif_decl = AppBskyNotificationDeclaration {
-        allow_subscriptions: ProfileAllowSubscriptions::Mutuals,
-    };
+    let notif_decl = AppBskyNotificationDeclaration(
+        app_bsky::notification::declaration::Declaration::new()
+            .allow_subscriptions("mutuals")
+            .build()
+            .into_static()
+    );
 
     let result = actor::notif_decl_upsert(&tx, actor_id, notif_decl).await;
 
···
         .wrap_err("Failed to ensure actor")?;
 
     // Create initial notification declaration
-    let notif_decl1 = AppBskyNotificationDeclaration {
-        allow_subscriptions: ProfileAllowSubscriptions::Followers,
-    };
+    let notif_decl1 = AppBskyNotificationDeclaration(
+        app_bsky::notification::declaration::Declaration::new()
+            .allow_subscriptions("followers")
+            .build()
+            .into_static()
+    );
 
     actor::notif_decl_upsert(&tx, actor_id, notif_decl1)
         .await
         .wrap_err("Failed to insert initial notification declaration")?;
 
     // Update notification declaration
-    let notif_decl2 = AppBskyNotificationDeclaration {
-        allow_subscriptions: ProfileAllowSubscriptions::None,
-    };
+    let notif_decl2 = AppBskyNotificationDeclaration(
+        app_bsky::notification::declaration::Declaration::new()
+            .allow_subscriptions("none")
+            .build()
+            .into_static()
+    );
 
     let result = actor::notif_decl_upsert(&tx, actor_id, notif_decl2).await;
 
···
         .wrap_err("Failed to ensure actor")?;
 
     // Create a notification declaration
-    let notif_decl = AppBskyNotificationDeclaration {
-        allow_subscriptions: ProfileAllowSubscriptions::Mutuals,
-    };
+    let notif_decl = AppBskyNotificationDeclaration(
+        app_bsky::notification::declaration::Declaration::new()
+            .allow_subscriptions("mutuals")
+            .build()
+            .into_static()
+    );
 
     actor::notif_decl_upsert(&tx, actor_id, notif_decl)
         .await

consumer/tests/feedgen_labeler_operations_test.rs

···
 use consumer::db::operations::{feed, labeler};
 use consumer::types::records::{AppBskyFeedGenerator, AppBskyLabelerService};
 use eyre::WrapErr;
-use lexica::app_bsky::labeler::LabelerPolicy;
-use lexica::com_atproto::label::{Blurs, LabelDefaultSetting, LabelValueDefinition, Severity};
-use lexica::com_atproto::moderation::{ReasonType, SubjectType};
-use lexica::Blob;
+use jacquard_api::app_bsky;
+use jacquard_api::com_atproto;
+use jacquard_common::types::blob::{Blob, MimeType};
+use jacquard_common::types::cid::{Cid, CidLink};
+use jacquard_common::IntoStatic;
 
 // ========================================
 // Feed Generator Tests
···
         description: Some("A feed about cats".to_string()),
         description_facets: None,
         avatar: Some(Blob {
-            mime_type: "image/jpeg".to_string(),
-            cid: test_cid(),
-            size: 1024}),
+            r#ref: CidLink(Cid::from(test_cid())),
+            mime_type: MimeType::new("image/jpeg").unwrap(),
+            size: 1024
+        }.into_static()),
         accepts_interactions: Some(true),
         labels: None,
         content_mode: Some("contentModeVideo".to_string()),
···
         description: Some("Updated description".to_string()),
         description_facets: None,
         avatar: Some(Blob {
-            mime_type: "image/png".to_string(),
-            cid: test_cid(),
-            size: 2048}),
+            r#ref: CidLink(Cid::from(test_cid())),
+            mime_type: MimeType::new("image/png").unwrap(),
+            size: 2048
+        }.into_static()),
         accepts_interactions: None,
         labels: None,
         content_mode: Some("contentModeVideo".to_string()),

consumer/tests/labels_test.rs

···
 use chrono::Utc;
 use common::*;
 use consumer::db::labels;
-use lexica::com_atproto::label::{SelfLabel, SelfLabels};
+use jacquard_api::com_atproto::label::{SelfLabel, SelfLabels};
+use jacquard_api::app_bsky;
+use jacquard_common::IntoStatic;
 use parakeet_db::types::{ActorStatus, ActorSyncState};
 use eyre::WrapErr;
 
···
 
     // Don't create an actor - test with non-existent DID
     let rec = consumer::types::records::AppBskyLabelerService {
-        policies: lexica::app_bsky::labeler::LabelerPolicy {
-            label_values: vec!["test-label".to_string()],
-            label_value_definitions: vec![],
-        },
+        policies: app_bsky::labeler::LabelerPolicies::new()
+            .label_values(vec![jacquard_api::com_atproto::label::LabelValue::Warn])
+            .build()
+            .into_static(),
         labels: None,
-        reason_types: None,
-        subject_types: None,
-        subject_collections: None,
         created_at: Utc::now(),
     };
 
···
     .unwrap();
 
     // Create self-labels
-    let self_labels = SelfLabels {
-        values: vec![SelfLabel {
-            val: "self-label-test".to_string(),
-        }],
-    };
+    let self_labels = SelfLabels::new()
+        .values(vec![
+            SelfLabel {
+                val: "self-label-test".into(),
+                extra_data: Default::default(),
+            }.into_static()
+        ])
+        .build()
+        .into_static();
 
     let test_cid = Some(test_cid());
     let at_uri = "at://did:plc:test_self_label/app.bsky.actor.profile/self";
···
     let tx = conn.transaction().await.wrap_err("Failed to start transaction")?;
 
     // Don't create an actor - test with non-existent DID
-    let self_labels = SelfLabels {
-        values: vec![SelfLabel {
-            val: "test-label".to_string(),
-        }],
-    };
+    let self_labels = SelfLabels::new()
+        .values(vec![
+            SelfLabel {
+                val: "test-label".into(),
+                extra_data: Default::default(),
+            }.into_static()
+        ])
+        .build()
+        .into_static();
 
     let result = labels::maintain_self_labels(
         &tx,
···
     let at_uri = "at://did:plc:test_update/app.bsky.actor.profile/self";
 
     // First add a label
-    let self_labels = SelfLabels {
-        values: vec![SelfLabel {
-            val: "old-label".to_string(),
-        }],
-    };
+    let self_labels = SelfLabels::new()
+        .values(vec![
+            SelfLabel {
+                val: "old-label".into(),
+                extra_data: Default::default(),
+            }.into_static()
+        ])
+        .build()
+        .into_static();
 
     labels::maintain_self_labels(&tx, "did:plc:test_update", None, at_uri, self_labels)
         .await
         .unwrap();
 
     // Now update with different labels (should delete the old one)
-    let new_labels = SelfLabels {
-        values: vec![SelfLabel {
-            val: "new-label".to_string(),
-        }],
-    };
+    let new_labels = SelfLabels::new()
+        .values(vec![
+            SelfLabel {
+                val: "new-label".into(),
+                extra_data: Default::default(),
+            }.into_static()
+        ])
+        .build()
+        .into_static();
 
     let result =
         labels::maintain_self_labels(&tx, "did:plc:test_update", None, at_uri, new_labels).await;