chore: rearranging parakeet-db

consumer/src/database_writer/bulk_processor.rs

···
             if let RecordTypes::AppBskyFeedPost(ref post) = record {
                 // Resolve parent author
                 let parent_author = if let Some(ref reply) = post.reply {
-                    let parent_did = parakeet_db::at_uri_util::extract_did(&reply.parent.uri);
+                    let parent_did = parakeet_db::utils::at_uri::extract_did(&reply.parent.uri);
                     if let Some(did) = parent_did {
                         let (aid, _, _) = crate::db::operations::feed::get_actor_id(conn, did).await?;
                         Some(aid)
···
                 // Resolve root author (if different from parent)
                 let root_author = if let Some(ref reply) = post.reply {
                     if reply.root.uri != reply.parent.uri {
-                        let root_did = parakeet_db::at_uri_util::extract_did(&reply.root.uri);
+                        let root_did = parakeet_db::utils::at_uri::extract_did(&reply.root.uri);
                         if let Some(did) = root_did {
                             let (aid, _, _) = crate::db::operations::feed::get_actor_id(conn, did).await?;
                             Some(aid)
···
                         };
 
                         if let Some(uri) = quote_uri {
-                            let quoted_did = parakeet_db::at_uri_util::extract_did(uri);
+                            let quoted_did = parakeet_db::utils::at_uri::extract_did(uri);
                             if let Some(did) = quoted_did {
                                 let (aid, _, _) = crate::db::operations::feed::get_actor_id(conn, did).await?;
                                 Some(aid)
···
         // Resolve via_repost natural key if present (for likes and reposts that came via a repost)
         let via_repost_key = if let (Some(via_uri), Some(via_cid)) = (&refs.via_uri, &refs.via_cid) {
             // Extract the DID and rkey from the via URI
-            if let Some((via_did, via_rkey, _collection)) = parakeet_db::at_uri_util::parse_at_uri(via_uri) {
+            if let Some((via_did, via_rkey, _collection)) = parakeet_db::utils::at_uri::parse_at_uri(via_uri) {
                 // Ensure the via repost actor exists
                 let (via_actor_id, _, _) = crate::db::operations::feed::get_actor_id(conn, via_did).await?;
 
···
     let labeler_dids: Vec<&str> = labeler_likes.iter()
         .filter_map(|&i| {
             let uri = &likes[i].record.subject.uri;
-            parakeet_db::at_uri_util::extract_did(uri)
+            parakeet_db::utils::at_uri::extract_did(uri)
         })
         .collect();
     let resolved_labelers = if !labeler_dids.is_empty() {
···
         } else if subject_uri.contains("/app.bsky.labeler.service/") {
             // Labeler like - only include if labeler exists (no auto-stubbing)
             // Extract DID from labeler AT URI
-            if let Some(labeler_did) = parakeet_db::at_uri_util::extract_did(subject_uri) {
+            if let Some(labeler_did) = parakeet_db::utils::at_uri::extract_did(subject_uri) {
                 if let Some(&labeler_actor_id) = resolved_labelers.get(labeler_did) {
                     labeler_like_data.push(LabelerLikeCopyData {
                         actor_id,
···
 
         // Get CID digest (real CID for reposts)
         let cid_bytes = repost.cid.to_bytes();
-        let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+        let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
             .ok_or_else(|| eyre::eyre!("Invalid CID for repost"))?;
 
         // Resolve via_repost natural keys if present
···
 
         // Extract CID digest
         let cid_bytes = cid.to_bytes();
-        let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+        let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
             .expect("Valid CID should have digest");
 
         // Resolve parent and root post natural keys

consumer/src/database_writer/bulk_types.rs

···
     pub tokens: Vec<String>,           // Search tokens
 
     // Composite type columns (stored directly in posts table)
-    pub ext_embed: Option<parakeet_db::composite_types::ExtEmbed>,
-    pub video_embed: Option<parakeet_db::composite_types::VideoEmbed>,
-    pub image_1: Option<parakeet_db::composite_types::ImageEmbed>,
-    pub image_2: Option<parakeet_db::composite_types::ImageEmbed>,
-    pub image_3: Option<parakeet_db::composite_types::ImageEmbed>,
-    pub image_4: Option<parakeet_db::composite_types::ImageEmbed>,
+    pub ext_embed: Option<parakeet_db::composite::ExtEmbed>,
+    pub video_embed: Option<parakeet_db::composite::VideoEmbed>,
+    pub image_1: Option<parakeet_db::composite::ImageEmbed>,
+    pub image_2: Option<parakeet_db::composite::ImageEmbed>,
+    pub image_3: Option<parakeet_db::composite::ImageEmbed>,
+    pub image_4: Option<parakeet_db::composite::ImageEmbed>,
     pub embedded_post_actor_id: Option<i32>,  // For quote posts (natural key part 1)
     pub embedded_post_rkey: Option<i64>,      // For quote posts (natural key part 2)
     pub record_detached: Option<bool>,    // For quote posts
-    pub facet_1: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_2: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_3: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_4: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_5: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_6: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_7: Option<parakeet_db::composite_types::FacetEmbed>,
-    pub facet_8: Option<parakeet_db::composite_types::FacetEmbed>,
+    pub facet_1: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_2: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_3: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_4: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_5: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_6: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_7: Option<parakeet_db::composite::FacetEmbed>,
+    pub facet_8: Option<parakeet_db::composite::FacetEmbed>,
     pub mentions: Option<Vec<Option<i32>>>,  // Mention actor IDs array
 }
 

consumer/src/database_writer/operations/executor.rs

···
                     // Parse reason_subject URI early for thread mute check and notification
                     // Format: at://did:plc:xyz/app.bsky.feed.post/rkey
                     let subject_rkey_str = reason_subject.split('/').next_back().unwrap_or("");
-                    let subject_rkey_i64 = match parakeet_db::tid_util::decode_tid(subject_rkey_str) {
+                    let subject_rkey_i64 = match parakeet_db::utils::tid::decode_tid(subject_rkey_str) {
                         Ok(rkey) => rkey,
                         Err(e) => {
                             tracing::warn!("Invalid subject TID in reason_subject: {} - {}", subject_rkey_str, e);
···
                         // Create PostgreSQL notification for this ancestor
                         // Extract rkey from reply_uri (at://did/app.bsky.feed.post/rkey)
                         let reply_rkey_str = reply_uri.split('/').next_back().unwrap_or("");
-                        let reply_rkey_i64 = match parakeet_db::tid_util::decode_tid(reply_rkey_str) {
+                        let reply_rkey_i64 = match parakeet_db::utils::tid::decode_tid(reply_rkey_str) {
                             Ok(rkey) => rkey,
                             Err(e) => {
                                 tracing::warn!("Invalid reply TID: {} - {}", reply_rkey_str, e);
···
                         let cid_digest = match Cid::try_from(cid.as_str()) {
                             Ok(cid_obj) => {
                                 let cid_bytes = cid_obj.to_bytes();
-                                match parakeet_db::cid_util::cid_to_digest_owned(&cid_bytes) {
+                                match parakeet_db::utils::cid::cid_to_digest_owned(&cid_bytes) {
                                     Some(digest) => digest,
                                     None => {
                                         tracing::warn!("Invalid CID digest for CID: {}", cid);
···
                 }
                 CollectionType::BskyFeedGen => {
                     // Feedgens use arbitrary string rkeys - extract from at_uri
-                    let rkey_str = parakeet_db::at_uri_util::extract_rkey(&at_uri)
+                    let rkey_str = parakeet_db::utils::at_uri::extract_rkey(&at_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid at_uri: missing rkey"))?;
                     let rows = db::feedgen_delete(conn, actor_id, rkey_str).await?;
                     if rows > 0 {
···
                 }
                 CollectionType::BskyList => {
                     // Lists use arbitrary string rkeys - extract from at_uri
-                    let rkey_str = parakeet_db::at_uri_util::extract_rkey(&at_uri)
+                    let rkey_str = parakeet_db::utils::at_uri::extract_rkey(&at_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid at_uri: missing rkey"))?;
 
                     let rows = db::list_delete(conn, actor_id, rkey_str).await?;

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

···
     let target_actor_id = ctx.subject_actor_id.expect("subject_actor_id required for notification");
 
     // Extract CID digest (32 bytes)
-    let cid_digest = parakeet_db::cid_util::cid_to_digest_owned(&ctx.cid.to_bytes())
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest_owned(&ctx.cid.to_bytes())
         .expect("Valid CID should have digest");
 
     operations.push(crate::database_writer::operations::create_follow_notification(

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

···
     // Create notification for the post author (if post author actor is known)
     if let Some(post_author_actor_id) = ctx.subject_actor_id {
         // Extract rkey from the post URI and convert to i64
-        if let Some(post_rkey_str) = parakeet_db::at_uri_util::extract_rkey(&subject_uri) {
-            if let Ok(post_rkey_i64) = parakeet_db::tid_util::decode_tid(post_rkey_str) {
+        if let Some(post_rkey_str) = parakeet_db::utils::at_uri::extract_rkey(&subject_uri) {
+            if let Ok(post_rkey_i64) = parakeet_db::utils::tid::decode_tid(post_rkey_str) {
                 // Generate synthetic CID digest
                 operations.push(crate::database_writer::operations::create_like_notification(
                     rkey_i64,           // Already converted above

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

···
         .expect("TID validation passed, conversion should succeed");
 
     // Extract CID digest (32 bytes) - will be used for notifications
-    let cid_digest = parakeet_db::cid_util::cid_to_digest_owned(&cid.to_bytes())
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest_owned(&cid.to_bytes())
         .expect("Valid CID should have digest");
 
     // Create notification for the quoted post author
···
             // Don't notify if quoting self
             if quoted_author_id != actor_id {
                 // Extract rkey from quoted post URI and convert to i64
-                if let Some(quoted_rkey_str) = parakeet_db::at_uri_util::extract_rkey(embed_uri) {
-                    if let Ok(quoted_rkey_i64) = parakeet_db::tid_util::decode_tid(quoted_rkey_str) {
+                if let Some(quoted_rkey_str) = parakeet_db::utils::at_uri::extract_rkey(embed_uri) {
+                    if let Ok(quoted_rkey_i64) = parakeet_db::utils::tid::decode_tid(quoted_rkey_str) {
                         operations.push(crate::database_writer::operations::create_quote_notification(
                             rkey_i64,           // Already converted above
                             actor_id,
···
         let mut notified_actor_ids = std::collections::HashSet::new();
 
         // Extract rkeys from parent and root URIs and convert to i64
-        let parent_rkey_str = parakeet_db::at_uri_util::extract_rkey(parent_uri);
-        let root_rkey_str = maybe_root.as_ref().and_then(|uri| parakeet_db::at_uri_util::extract_rkey(uri));
+        let parent_rkey_str = parakeet_db::utils::at_uri::extract_rkey(parent_uri);
+        let root_rkey_str = maybe_root.as_ref().and_then(|uri| parakeet_db::utils::at_uri::extract_rkey(uri));
 
         if let Some(parent_rkey_str) = parent_rkey_str {
-            if let Ok(parent_rkey_i64) = parakeet_db::tid_util::decode_tid(parent_rkey_str) {
+            if let Ok(parent_rkey_i64) = parakeet_db::utils::tid::decode_tid(parent_rkey_str) {
                 // Convert root rkey to i64 if present
-                let root_rkey_i64 = root_rkey_str.and_then(|s| parakeet_db::tid_util::decode_tid(s).ok());
+                let root_rkey_i64 = root_rkey_str.and_then(|s| parakeet_db::utils::tid::decode_tid(s).ok());
 
                 // Always notify direct parent author
                 if let Some(parent_author_id) = post_ctx.parent_author_actor_id {

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

···
     // Create notification for the post author (if post author actor is known)
     if let Some(post_author_actor_id) = ctx.subject_actor_id {
         // Extract rkey from the post URI and convert to i64
-        if let Some(post_rkey_str) = parakeet_db::at_uri_util::extract_rkey(&subject_uri) {
-            if let Ok(post_rkey_i64) = parakeet_db::tid_util::decode_tid(post_rkey_str) {
+        if let Some(post_rkey_str) = parakeet_db::utils::at_uri::extract_rkey(&subject_uri) {
+            if let Ok(post_rkey_i64) = parakeet_db::utils::tid::decode_tid(post_rkey_str) {
                 // Extract CID digest (32 bytes)
-                let cid_digest = parakeet_db::cid_util::cid_to_digest_owned(&ctx.cid.to_bytes())
+                let cid_digest = parakeet_db::utils::cid::cid_to_digest_owned(&ctx.cid.to_bytes())
                     .expect("Valid CID should have digest");
 
                 operations.push(crate::database_writer::operations::create_repost_notification(

consumer/src/database_writer/operations/notifications.rs

···
 
 use super::DatabaseOperation;
 use chrono::{DateTime, Utc};
-use parakeet_db::notifications::reasons;
+use parakeet_db::domain::notification::reasons;
 
 /// Create a notification for a like
 ///
···
     created_at: DateTime<Utc>,
 ) -> DatabaseOperation {
     // Generate synthetic CID digest for the like
-    let cid_digest = parakeet_db::cid_util::generate_like_cid_digest(liker_actor_id, like_rkey);
+    let cid_digest = parakeet_db::utils::cid::generate_like_cid_digest(liker_actor_id, like_rkey);
 
     DatabaseOperation::InsertNotification {
         recipient_actor_id: post_author_actor_id,

consumer/src/database_writer/reference_extraction.rs

···
         // 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.as_str()) {
+            let mut refs = if let Some(subject_did) = parakeet_db::utils::at_uri::extract_did(rec.subject.uri.as_str()) {
                 RecordReferences::with_subject(subject_did.to_string())
             } else {
                 RecordReferences::empty()
···
         // 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.as_str()) {
+            let mut refs = if let Some(subject_did) = parakeet_db::utils::at_uri::extract_did(rec.subject.uri.as_str()) {
                 RecordReferences::with_subject(subject_did.to_string())
             } else {
                 RecordReferences::empty()
···
 
             // Extract reply parent and root authors (for notifications)
             if let Some(reply) = &rec.reply {
-                refs.parent_author_did = parakeet_db::at_uri_util::extract_did(&reply.parent.uri)
+                refs.parent_author_did = parakeet_db::utils::at_uri::extract_did(&reply.parent.uri)
                     .map(|s| s.to_string());
-                refs.root_author_did = parakeet_db::at_uri_util::extract_did(&reply.root.uri)
+                refs.root_author_did = parakeet_db::utils::at_uri::extract_did(&reply.root.uri)
                     .map(|s| s.to_string());
             }
 
···
                     match bsky_embed {
                         AppBskyEmbed::Record(record_embed) => {
                             refs.quoted_author_did =
-                                parakeet_db::at_uri_util::extract_did(&record_embed.record.uri)
+                                parakeet_db::utils::at_uri::extract_did(&record_embed.record.uri)
                                     .map(|s| s.to_string());
                         }
                         AppBskyEmbed::RecordWithMedia(rwm) => {
                             refs.quoted_author_did =
-                                parakeet_db::at_uri_util::extract_did(&rwm.record.uri)
+                                parakeet_db::utils::at_uri::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.uri.as_str()) {
+            if let Some(list_did) = parakeet_db::utils::at_uri::extract_did(rec.subject.uri.as_str()) {
                 dids.push(list_did.to_string());
             }
             RecordReferences::with_additional(dids)
···
             if let Some(rules) = &rec.allow {
                 for rule in rules {
                     if let ThreadgateRule::List { list } = rule {
-                        if let Some(list_did) = parakeet_db::at_uri_util::extract_did(list) {
+                        if let Some(list_did) = parakeet_db::utils::at_uri::extract_did(list) {
                             dids.push(list_did.to_string());
                         }
                     }

consumer/src/database_writer/workers_tap.rs

···
             // For posts, resolve parent/root/quoted authors
             let (parent_author_actor_id, root_author_actor_id, quoted_author_actor_id, mentioned_actor_ids) =
                 if let crate::relay::types::RecordTypes::AppBskyFeedPost(ref post) = *record {
-                    use parakeet_db::at_uri_util;
-
                     // Resolve parent author
                     let parent_author = if let Some(ref reply) = post.reply {
-                        if let Some(did) = at_uri_util::extract_did(&reply.parent.uri) {
+                        if let Some(did) = utils::at_uri::extract_did(&reply.parent.uri) {
                             let (aid, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, did).await?;
                             Some(aid)
                         } else {
···
                     // Resolve root author
                     let root_author = if let Some(ref reply) = post.reply {
                         if reply.root.uri != reply.parent.uri {
-                            if let Some(did) = at_uri_util::extract_did(&reply.root.uri) {
+                            if let Some(did) = utils::at_uri::extract_did(&reply.root.uri) {
                                 let (aid, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, did).await?;
                                 Some(aid)
                             } else {
···
                             match bsky_embed {
                                 AppBskyEmbed::Record(record_embed) => {
                                     // Extract DID from the quoted post URI
-                                    if let Some(did) = parakeet_db::at_uri_util::extract_did(&record_embed.record.uri) {
+                                    if let Some(did) = parakeet_db::utils::at_uri::extract_did(&record_embed.record.uri) {
                                         let (actor_id, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, did).await?;
                                         Some(actor_id)
                                     } else {
···
                                 },
                                 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.uri) {
+                                    if let Some(did) = parakeet_db::utils::at_uri::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 via_repost if present
             let via_repost_key = if let (Some(via_uri), Some(via_cid)) = (&refs.via_uri, &refs.via_cid) {
-                if let Some((via_did, via_rkey, _)) = parakeet_db::at_uri_util::parse_at_uri(via_uri) {
+                if let Some((via_did, via_rkey, _)) = parakeet_db::utils::at_uri::parse_at_uri(via_uri) {
                     let (via_actor_id, _, _) = crate::db::operations::feed::get_actor_id(&mut conn, via_did).await?;
                     let (key, _) = crate::db::operations::feed::get_repost_id(
                         &mut conn,

consumer/src/db/actor.rs

···
     cid: Cid,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
 
     // Use consolidated ActorUpdate API for repo state update

consumer/src/db/bulk_resolve/mod.rs

···
     let mut dids_set: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for uri in at_uris {
-        let did = parakeet_db::at_uri_util::extract_did(uri)
+        let did = parakeet_db::utils::at_uri::extract_did(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", uri))?;
         let rkey_i64 = parakeet_db::models::tid_to_i64(rkey)
             .map_err(|e| eyre::eyre!("Invalid TID in AT URI {}: {}", uri, e))?;
···
     let mut dids_set: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for uri in at_uris {
-        let did = parakeet_db::at_uri_util::extract_did(uri)
+        let did = parakeet_db::utils::at_uri::extract_did(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", uri))?;
 
         uri_to_did_rkey.insert(uri.to_string(), (did.to_string(), rkey.to_string()));
···
     let mut dids_set: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for uri in at_uris {
-        let did = parakeet_db::at_uri_util::extract_did(uri)
+        let did = parakeet_db::utils::at_uri::extract_did(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", uri))?;
         let rkey_i64 = parakeet_db::models::tid_to_i64(rkey)
             .map_err(|e| eyre::eyre!("Invalid TID in AT URI {}: {}", uri, e))?;
···
     let mut dids_set: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for uri in at_uris {
-        let did = parakeet_db::at_uri_util::extract_did(uri)
+        let did = parakeet_db::utils::at_uri::extract_did(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", uri))?;
 
         uri_to_did_rkey.insert(uri.to_string(), (did.to_string(), rkey.to_string()));

consumer/src/db/composite_builders.rs

···
 //! These functions transform AT Protocol records into the denormalized composite type
 //! structures used in the posts table.
 
-use parakeet_db::composite_types::{ExtEmbed, VideoEmbed, ImageEmbed, FacetEmbed};
+use parakeet_db::composite::{ExtEmbed, VideoEmbed, ImageEmbed, FacetEmbed};
 use parakeet_db::types::{ImageMimeType, VideoMimeType, FacetType};
 use crate::types::records::{AppBskyEmbedImages, AppBskyEmbedVideo, AppBskyEmbedExternal};
 use jacquard_api::app_bsky::richtext::facet::{Facet as FacetMain, FacetFeaturesItem};
···
         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));
+        let cid = cid_bytes.and_then(|b| parakeet_db::utils::cid::cid_to_digest_owned(&b));
         (mime, cid)
     } else {
         (None, None)
···
 
 /// Build video embed composite from AppBskyEmbedVideo
 pub fn build_video_embed(embed: &AppBskyEmbedVideo) -> Option<VideoEmbed> {
-    use parakeet_db::composite_types::VideoCaption;
+    use parakeet_db::composite::VideoCaption;
     use parakeet_db::types::{CaptionMimeType, LanguageCode};
 
     let video = &embed.video;
···
     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)?;
+    let cid = parakeet_db::utils::cid::cid_to_digest_owned(&cid_bytes)?;
 
     // Build caption fields (max 3)
     let mut captions = [None, None, None];
···
             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)?;
+            let caption_cid = parakeet_db::utils::cid::cid_to_digest_owned(&caption_cid_bytes)?;
 
             captions[idx] = Some(VideoCaption {
                 lang,
···
             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) {
+                if let Some(cid) = parakeet_db::utils::cid::cid_to_digest_owned(&cid_bytes) {
                     images[idx] = Some(ImageEmbed {
                         mime_type,
                         cid,

consumer/src/db/gates/queries.rs

···
 
     // OPTIMIZATION 2: Resolve target post natural key directly from database
     let (target_post_actor_id, target_post_rkey) = {
-        let did = parakeet_db::at_uri_util::extract_did(post_uri)
+        let did = parakeet_db::utils::at_uri::extract_did(post_uri)
             .ok_or_else(|| eyre::eyre!("Invalid post URI: missing DID in {}", post_uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(post_uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(post_uri)
             .ok_or_else(|| eyre::eyre!("Invalid post URI: missing rkey in {}", post_uri))?;
         let rkey_i64 = parakeet_db::models::tid_to_i64(rkey)
             .wrap_err_with(|| format!("Invalid TID encoding in rkey: {}", rkey))?;
···
     // OPTIMIZATION 3: Resolve detached post natural keys from database (batch)
     let mut detached_post_keys = Vec::new();
     for uri in detached_uris {
-        let did = parakeet_db::at_uri_util::extract_did(uri)
+        let did = parakeet_db::utils::at_uri::extract_did(uri)
             .ok_or_else(|| eyre::eyre!("Invalid detached URI: missing DID in {}", uri))?;
-        let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+        let rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid detached URI: missing rkey in {}", uri))?;
         let rkey_i64 = parakeet_db::models::tid_to_i64(rkey)
             .wrap_err_with(|| format!("Invalid TID encoding in rkey: {}", rkey))?;

consumer/src/db/id_resolution.rs

···
     at_uri: &str,
 ) -> Result<(i32, i64)> {
     // Parse AT URI: at://did/collection/rkey
-    let did = parakeet_db::at_uri_util::extract_did(at_uri)
+    let did = parakeet_db::utils::at_uri::extract_did(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", at_uri))?;
-    let rkey = parakeet_db::at_uri_util::extract_rkey(at_uri)
+    let rkey = parakeet_db::utils::at_uri::extract_rkey(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", at_uri))?;
     let rkey_i64 = parakeet_db::models::tid_to_i64(rkey)
         .map_err(|e| eyre::eyre!("Invalid TID in AT URI {}: {}", at_uri, e))?;

consumer/src/db/labels.rs

···
     // AT URI format: at://{did}/collection/rkey
     // Actor profiles: at://{did}/app.bsky.actor.profile/self
     // Posts: at://{did}/app.bsky.feed.post/{rkey}
-    let (did, collection, rkey) = parakeet_db::at_uri_util::parse_at_uri(at_uri)
+    let (did, collection, rkey) = parakeet_db::utils::at_uri::parse_at_uri(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: {}", at_uri))?;
 
     // Build labels array values
···
     } else if collection == "app.bsky.feed.post" {
         // Update post labels array
         // Convert TID string to INT8 for rkey lookup
-        let rkey_i64 = parakeet_db::tid_util::decode_tid(rkey)?;
+        let rkey_i64 = parakeet_db::utils::tid::decode_tid(rkey)?;
 
         conn.execute(
             "UPDATE posts p

consumer/src/db/operations/actor.rs

···
     // SCHEMA CHANGE: profiles table dropped, now UPDATE actors.profile_* columns
     // No advisory lock needed - simple UPDATE with PostgreSQL row-level locking
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
     let avatar = blob_to_cid_bytes(rec.avatar.as_ref());
     let banner = blob_to_cid_bytes(rec.banner.as_ref());
···
 
         if collection == Some("app.bsky.feed.post") {
             // Extract and parse rkey
-            parakeet_db::at_uri_util::extract_rkey(uri)
+            parakeet_db::utils::at_uri::extract_rkey(uri)
                 .and_then(|rkey_str| parakeet_db::models::tid_to_i64(rkey_str).ok())
         } else {
             None // Not a post URI, skip
···
 
         if collection == Some("app.bsky.graph.starterpack") {
             // Parse URI components
-            let sp_did = parakeet_db::at_uri_util::extract_did(uri);
-            let sp_rkey = parakeet_db::at_uri_util::extract_rkey(uri)
+            let sp_did = parakeet_db::utils::at_uri::extract_did(uri);
+            let sp_rkey = parakeet_db::utils::at_uri::extract_rkey(uri)
                 .and_then(|rkey_str| parakeet_db::models::tid_to_i64(rkey_str).ok());
 
             if let (Some(sp_did), Some(sp_rkey)) = (sp_did, sp_rkey) {
···
     // SCHEMA CHANGE: statuses table dropped, now UPDATE actors.status_* columns
     // No advisory lock needed - simple UPDATE with PostgreSQL row-level locking
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
 
     let thumb = rec.embed.as_ref().and_then(|v| v.external.thumb.clone());
···
         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)
+        parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
             .expect("CID must be valid AT Protocol CID")
             .to_vec()
     });
···
 
         if collection == Some("app.bsky.feed.post") {
             // Parse URI components
-            let post_did = parakeet_db::at_uri_util::extract_did(uri);
-            let post_rkey_str = parakeet_db::at_uri_util::extract_rkey(uri);
+            let post_did = parakeet_db::utils::at_uri::extract_did(uri);
+            let post_rkey_str = parakeet_db::utils::at_uri::extract_rkey(uri);
 
             // Validate TID length before parsing
             if let (Some(post_did), Some(rkey_str)) = (post_did, post_rkey_str) {

consumer/src/db/operations/community.rs

···
 ) -> Result<u64> {
     // Parse the subject URI to extract (did, collection, rkey)
     let (post_did, collection, post_rkey_str) =
-        parakeet_db::at_uri_util::parse_at_uri(&rec.subject)
+        parakeet_db::utils::at_uri::parse_at_uri(&rec.subject)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: {}", rec.subject))?;
 
     // Validate it's a post URI

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

···
     .await?;
 
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
     let description_facets = rec
         .description_facets

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

···
     let cid = ipld_core::cid::Cid::try_from(cid_str)
         .wrap_err_with(|| format!("Invalid CID format: {}", cid_str))?;
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
 
     // Extract owner DID and rkey from AT URI
-    let did = parakeet_db::at_uri_util::extract_did(at_uri)
+    let did = parakeet_db::utils::at_uri::extract_did(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", at_uri))?;
-    let rkey = parakeet_db::at_uri_util::extract_rkey(at_uri)
+    let rkey = parakeet_db::utils::at_uri::extract_rkey(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", at_uri))?;
 
     // Get/create actor_id for owner
···
     crate::database_writer::locking::acquire_lock(conn, table_id, key_id).await?;
 
     // Extract owner DID and rkey from AT URI
-    let did = parakeet_db::at_uri_util::extract_did(at_uri)
+    let did = parakeet_db::utils::at_uri::extract_did(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing DID in {}", at_uri))?;
-    let rkey = parakeet_db::at_uri_util::extract_rkey(at_uri)
+    let rkey = parakeet_db::utils::at_uri::extract_rkey(at_uri)
         .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", at_uri))?;
 
     // Get/create actor_id for owner

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

···
     let (subject_post_key, subject_feedgen_key, subject_labeler_actor_id, _subject_was_created): (Option<(i32, i64)>, Option<(i32, String)>, Option<i32>, bool) = match subject_collection {
         "app.bsky.feed.post" => {
             let subject_did =
-                parakeet_db::at_uri_util::extract_did(subject_uri).ok_or_else(|| {
+                parakeet_db::utils::at_uri::extract_did(subject_uri).ok_or_else(|| {
                     eyre::eyre!("Invalid subject URI: missing DID in {}", subject_uri)
                 })?;
             let subject_rkey =
-                parakeet_db::at_uri_util::extract_rkey(subject_uri).ok_or_else(|| {
+                parakeet_db::utils::at_uri::extract_rkey(subject_uri).ok_or_else(|| {
                     eyre::eyre!("Invalid subject URI: missing rkey in {}", subject_uri)
                 })?;
             let (subject_actor_id, _, _) = get_actor_id(conn, subject_did).await?;
···
         }
         "app.bsky.labeler.service" => {
             let subject_did =
-                parakeet_db::at_uri_util::extract_did(subject_uri).ok_or_else(|| {
+                parakeet_db::utils::at_uri::extract_did(subject_uri).ok_or_else(|| {
                     eyre::eyre!("Invalid subject URI: missing DID in {}", subject_uri)
                 })?;
             // Note: ensure_labeler_stub doesn't return was_created, so always enqueue labelers
···
         _ => {
             // Fallback: treat as post
             let subject_did =
-                parakeet_db::at_uri_util::extract_did(subject_uri).ok_or_else(|| {
+                parakeet_db::utils::at_uri::extract_did(subject_uri).ok_or_else(|| {
                     eyre::eyre!("Invalid subject URI: missing DID in {}", subject_uri)
                 })?;
             let subject_rkey =
-                parakeet_db::at_uri_util::extract_rkey(subject_uri).ok_or_else(|| {
+                parakeet_db::utils::at_uri::extract_rkey(subject_uri).ok_or_else(|| {
                     eyre::eyre!("Invalid subject URI: missing rkey in {}", subject_uri)
                 })?;
             let (subject_actor_id, _, _) = get_actor_id(conn, subject_did).await?;

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

···
     source: crate::database_writer::EventSource,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
     let (_mentions, tags) = rec
         .facets
···
     // Track whether stubs were created so we only enqueue newly created stubs
     let (parent_post_key, _parent_was_created) =
         if let (Some(parent_uri), Some(parent_cid)) = (&parent_uri, &parent_cid) {
-            let parent_did = parakeet_db::at_uri_util::extract_did(parent_uri)
+            let parent_did = parakeet_db::utils::at_uri::extract_did(parent_uri)
                 .ok_or_else(|| eyre::eyre!("Invalid parent URI: missing DID in {}", parent_uri))?;
-            let parent_rkey = parakeet_db::at_uri_util::extract_rkey(parent_uri)
+            let parent_rkey = parakeet_db::utils::at_uri::extract_rkey(parent_uri)
                 .ok_or_else(|| eyre::eyre!("Invalid parent URI: missing rkey in {}", parent_uri))?;
             let (parent_actor_id, _, _) = get_actor_id(conn, parent_did).await?;
             let (post_key, was_created) =
···
         if let (Some(root_uri), Some(root_cid)) = (&root_uri, &root_cid) {
             // Only get root post natural key if it's different from parent
             if root_uri != parent_uri.as_ref().unwrap_or(&String::new()) {
-                let root_did = parakeet_db::at_uri_util::extract_did(root_uri)
+                let root_did = parakeet_db::utils::at_uri::extract_did(root_uri)
                     .ok_or_else(|| eyre::eyre!("Invalid root URI: missing DID in {}", root_uri))?;
-                let root_rkey = parakeet_db::at_uri_util::extract_rkey(root_uri)
+                let root_rkey = parakeet_db::utils::at_uri::extract_rkey(root_uri)
                     .ok_or_else(|| eyre::eyre!("Invalid root URI: missing rkey in {}", root_uri))?;
                 let (root_actor_id, _, _) = get_actor_id(conn, root_did).await?;
                 let (post_key, was_created) =
···
                     // Get embedded post natural key
                     let embed_uri = record.record.uri.as_str();
                     let embed_cid_str = record.record.cid.to_string();
-                    let embed_did = parakeet_db::at_uri_util::extract_did(embed_uri)
+                    let embed_did = parakeet_db::utils::at_uri::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)
+                    let embed_rkey = parakeet_db::utils::at_uri::extract_rkey(embed_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid embed URI: missing rkey in {}", embed_uri))?;
                     let (embed_actor_id, _, _) = get_actor_id(conn, embed_did).await?;
                     let (embed_post_key, _) = get_post_id(conn, embed_actor_id, embed_rkey, &embed_cid_str).await?;
···
                     // Process record part
                     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)
+                    let embed_did = parakeet_db::utils::at_uri::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)
+                    let embed_rkey = parakeet_db::utils::at_uri::extract_rkey(embed_uri)
                         .ok_or_else(|| eyre::eyre!("Invalid embed URI: missing rkey in {}", embed_uri))?;
                     let (embed_actor_id, _, _) = get_actor_id(conn, embed_did).await?;
                     let (embed_post_key, _) = get_post_id(conn, embed_actor_id, embed_rkey, &embed_cid_str).await?;

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

···
     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.as_str())
+    let post_did = parakeet_db::utils::at_uri::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.as_str())
+    let post_rkey_str = parakeet_db::utils::at_uri::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))?;

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

···
     _source: crate::database_writer::EventSource,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .expect("CID must be valid AT Protocol CID");
 
     let subject_uri = &rec.subject.uri;
···
     // This ensures the FK constraint is satisfied before we reach this point
 
     // Resolve post natural key (no stub creation with natural keys)
-    let subject_did = parakeet_db::at_uri_util::extract_did(subject_uri)
+    let subject_did = parakeet_db::utils::at_uri::extract_did(subject_uri)
         .ok_or_else(|| eyre::eyre!("Invalid subject URI: missing DID in {}", subject_uri))?;
-    let subject_rkey = parakeet_db::at_uri_util::extract_rkey(subject_uri)
+    let subject_rkey = parakeet_db::utils::at_uri::extract_rkey(subject_uri)
         .ok_or_else(|| eyre::eyre!("Invalid subject URI: missing rkey in {}", subject_uri))?;
     let (subject_actor_id, _, _) = get_actor_id(conn, subject_did).await?;
     let ((post_actor_id, post_rkey), _subject_was_created) =

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

···
     // but we extract it from the URI to be safe
     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())
+    let post_did = parakeet_db::utils::at_uri::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())
+    let post_rkey_str = parakeet_db::utils::at_uri::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))?;

consumer/src/db/operations/graph.rs

···
     rec: AppBskyGraphList,
 ) -> Result<bool> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
     let description_facets = rec
         .description_facets
···
     rec: AppBskyGraphListBlock,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
 
     // Parse list URI to get natural keys (list_actor_id, list_rkey)
···
     rec: AppBskyGraphListItem,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
 
     // Acquire advisory lock on record to prevent deadlocks
···
     rec: AppBskyGraphVerification,
 ) -> Result<u64> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
 
     // Acquire advisory lock on record to prevent deadlocks

consumer/src/db/operations/labeler.rs

···
     let cid = ipld_core::cid::Cid::try_from(cid_str)
         .wrap_err_with(|| format!("Invalid CID format: {}", cid_str))?;
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
 
     // Get/create actor_id (discard allowlist status and was_created, not needed for labelers)
···
     crate::database_writer::locking::acquire_lock(conn, table_id, key_id).await?;
 
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
     // Note: reason_types, subject_types, and subject_collections not available in jacquard types
     let reasons: Option<Vec<String>> = None;

consumer/src/db/operations/starter_pack.rs

···
     rec: AppBskyGraphStarterPack,
 ) -> Result<bool> {
     let cid_bytes = cid.to_bytes();
-    let cid_digest = parakeet_db::cid_util::cid_to_digest(&cid_bytes)
+    let cid_digest = parakeet_db::utils::cid::cid_to_digest(&cid_bytes)
         .ok_or_eyre("CID must be valid AT Protocol CID")?;
     let record = serde_json::to_value(&rec).unwrap();
     let description_facets = rec
···
         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.as_str())
+                parakeet_db::utils::at_uri::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/db/record_exists/mod.rs

···
 
 use deadpool_postgres::Object as PgObject;
 use eyre::Result;
-use parakeet_db::tid_util::decode_tid;
+use parakeet_db::utils::tid::decode_tid;
 
 pub mod queries;
 

consumer/src/label_indexer/mod.rs

···
 
     for label in labels {
         // Parse AT URI to determine target
-        let Some((did, collection, rkey)) = parakeet_db::at_uri_util::parse_at_uri(&label.uri) else {
+        let Some((did, collection, rkey)) = parakeet_db::utils::at_uri::parse_at_uri(&label.uri) else {
             tracing::warn!("Invalid AT URI in label: {}", label.uri);
             continue;
         };
···
             actor_labels.entry(did.to_string()).or_default().push(label);
         } else if collection == "app.bsky.feed.post" {
             // Convert TID string to INT8
-            let Some(rkey_i64) = parakeet_db::tid_util::decode_tid(rkey) else {
+            let Some(rkey_i64) = parakeet_db::utils::tid::decode_tid(rkey) else {
                 tracing::warn!("Invalid TID in label URI: {}", label.uri);
                 continue;
             };

consumer/src/utils.rs

···
 /// 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.and_then(|blob| {
-        parakeet_db::cid_util::blob_to_cid_bytes(Some(blob))
+        parakeet_db::utils::cid::blob_to_cid_bytes(Some(blob))
     })
 }
 
 pub fn strongref_to_parts(strongref: Option<&StrongRef>) -> (Option<String>, Option<String>) {
-    parakeet_db::cid_util::strongref_to_parts(strongref)
+    parakeet_db::utils::cid::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>>) {
-    parakeet_db::cid_util::strongref_to_parts_with_digest(strongref)
+    parakeet_db::utils::cid::strongref_to_parts_with_digest(strongref)
 }
 
 pub fn at_uri_is_by(uri: &str, did: &str) -> bool {

consumer/tests/bulk_copy_queries_test.rs

···
     ).await?;
 
     // Create VideoEmbed with all 3 captions to test serialization
-    let video_embed = parakeet_db::composite_types::VideoEmbed {
+    let video_embed = parakeet_db::composite::VideoEmbed {
         mime_type: parakeet_db::types::VideoMimeType::Mp4,
         cid: vec![1u8, 2, 3, 4, 5, 6, 7, 8],
         alt: Some("Test video".to_string()),
         width: Some(1920),
         height: Some(1080),
-        caption_1: Some(parakeet_db::composite_types::VideoCaption {
+        caption_1: Some(parakeet_db::composite::VideoCaption {
             lang: parakeet_db::types::LanguageCode::En,
             mime_type: parakeet_db::types::CaptionMimeType::Vtt,
             cid: vec![11u8, 12, 13, 14],
         }),
-        caption_2: Some(parakeet_db::composite_types::VideoCaption {
+        caption_2: Some(parakeet_db::composite::VideoCaption {
             lang: parakeet_db::types::LanguageCode::Es,
             mime_type: parakeet_db::types::CaptionMimeType::Vtt,
             cid: vec![21u8, 22, 23, 24],
         }),
-        caption_3: Some(parakeet_db::composite_types::VideoCaption {
+        caption_3: Some(parakeet_db::composite::VideoCaption {
             lang: parakeet_db::types::LanguageCode::Fr,
             mime_type: parakeet_db::types::CaptionMimeType::Vtt,
             cid: vec![31u8, 32, 33, 34],
···
         tokens: vec![],
         ext_embed: None,
         video_embed: None,
-        image_1: Some(parakeet_db::composite_types::ImageEmbed {
+        image_1: Some(parakeet_db::composite::ImageEmbed {
             mime_type: parakeet_db::types::ImageMimeType::Jpeg,
             cid: vec![11u8, 12, 13, 14],
             alt: Some("Test image".to_string()),
             width: Some(1920),
             height: Some(1080),
         }),
-        image_2: Some(parakeet_db::composite_types::ImageEmbed {
+        image_2: Some(parakeet_db::composite::ImageEmbed {
             mime_type: parakeet_db::types::ImageMimeType::Png,
             cid: vec![21u8, 22, 23, 24],
             alt: None,
···
         embed_subtype: None,
         violates_threadgate: false,
         tokens: vec![],
-        ext_embed: Some(parakeet_db::composite_types::ExtEmbed {
+        ext_embed: Some(parakeet_db::composite::ExtEmbed {
             uri: "https://example.com".to_string(),
             title: Some("Example Site".to_string()),
             description: Some("Test description".to_string()),
···
         embedded_post_actor_id: None,
         embedded_post_rkey: None,
         record_detached: None,
-        facet_1: Some(parakeet_db::composite_types::FacetEmbed {
+        facet_1: Some(parakeet_db::composite::FacetEmbed {
             facet_type: parakeet_db::types::FacetType::Link,
             index_start: 0,
             index_end: 10,
···
             mention_actor_id: None,
             tag: None,
         }),
-        facet_2: Some(parakeet_db::composite_types::FacetEmbed {
+        facet_2: Some(parakeet_db::composite::FacetEmbed {
             facet_type: parakeet_db::types::FacetType::Mention,
             index_start: 11,
             index_end: 20,
···
             mention_actor_id: Some(mention_actor_id),
             tag: None,
         }),
-        facet_3: Some(parakeet_db::composite_types::FacetEmbed {
+        facet_3: Some(parakeet_db::composite::FacetEmbed {
             facet_type: parakeet_db::types::FacetType::Tag,
             index_start: 21,
             index_end: 30,

consumer/tests/record_exists_queries_test.rs

···
 mod common;
 use common::*;
 use consumer::db::record_exists::queries;
-use parakeet_db::tid_util::decode_tid;
+use parakeet_db::utils::tid::decode_tid;
 use eyre::WrapErr;
 
 // Valid test TID that can be decoded to i64

parakeet-db/src/models.rs

···
-// =============================================================================
-// MODELS.RS - Self-Contained Collection Models for Parakeet
-// =============================================================================
-//
-// This file contains Diesel model definitions that align with the
-// self-contained collections schema where each table stores its own record metadata.
-//
-// KEY PRINCIPLES:
-//
-// 1. **Self-Contained Tables**: Each collection has actor_id, rkey, cid, created_at
-//    - No more record_id FK - data is in the collection table itself
-//    - Single JOIN to actors for DID/handle, no records table JOIN
-//    - 2-3x fewer JOINs in every query
-//
-// 2. **Type Safety via ENUMs**:
-//    - All protocol-defined enums use custom types (not String)
-//    - Diesel custom_types for type safety at query time
-//    - Compile-time validation of enum values
-//
-// 3. **Direct Foreign Keys**:
-//    - post_id: i64 (FK to posts, not records)
-//    - list_id: i64 (FK to lists, not records)
-//    - All FKs reference actual tables, not a central registry
-//
-// 4. **Discriminated Unions for Polymorphism**:
-//    - Likes use subject_type enum (post | feedgen | labeler)
-//    - Notifications use record_type enum (post | like | repost | follow | block)
-//    - 4-byte enum instead of table JOIN for type discrimination
-//
-// 5. **Optimized Binary Data**:
-//    - CIDs stored as Vec<u8> (32-byte digest, header stripped)
-//    - Signatures as Vec<u8>
-//    - No string overhead for binary data
-//
-// =============================================================================
-
-use crate::composite_types::{Block, Bookmark, Follow, LabelerDef, Mute};
-use crate::tid_util::{decode_tid, encode_tid, TidError};
-use crate::types::*;
-use chrono::prelude::*;
-use diesel::prelude::*;
-use serde::{Deserialize, Serialize};
-
-// =============================================================================
-// HELPER TRAITS FOR TID RKEYS
-// =============================================================================
-
-/// Trait for models that have a TID-based rkey (stored as i64)
-pub trait HasTidRkey {
-    /// Get the rkey as a TID string
-    fn rkey_str(&self) -> String;
-
-    /// Get the rkey as i64
-    fn rkey_i64(&self) -> i64;
-}
-
-/// Helper to decode a TID string to i64 for use in queries/inserts
-pub fn tid_to_i64(tid: &str) -> Result<i64, TidError> {
-    decode_tid(tid)
-}
-
-/// Helper to encode an i64 rkey to TID string for use in AT URIs
-pub fn i64_to_tid(value: i64) -> String {
-    encode_tid(value)
-}
-
-// Macro to implement HasTidRkey trait for models
-macro_rules! impl_tid_rkey {
-    ($model:ty) => {
-        impl HasTidRkey for $model {
-            fn rkey_str(&self) -> String {
-                encode_tid(self.rkey)
-            }
-
-            fn rkey_i64(&self) -> i64 {
-                self.rkey
-            }
-        }
-    };
-}
-
-// Macro to implement created_at() method for TID-based models
-// This derives the timestamp from the TID rkey, eliminating need for separate created_at column
-macro_rules! impl_tid_created_at {
-    ($model:ty) => {
-        impl $model {
-            /// Get created_at timestamp derived from TID rkey
-            ///
-            /// TIDs encode a 53-bit microsecond timestamp in their upper bits.
-            /// This method extracts that timestamp, providing the original creation time
-            /// from the AT Protocol record without needing a separate database column.
-            pub fn created_at(&self) -> DateTime<Utc> {
-                crate::tid_util::tid_to_datetime(self.rkey)
-            }
-        }
-    };
-}
-
-// =============================================================================
-// CORE IDENTITY
-// =============================================================================
-
-#[derive(Debug, Clone, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::actors)]
-#[diesel(primary_key(id))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Actor {
-    pub id: i32,                    // PK: Internal actor ID
-    pub did: String,                // Reverse DID lookup
-    pub handle: Option<String>,     // Handle (can change)
-    pub status: ActorStatus,        // ENUM: active | takendown | suspended | deleted | deactivated
-    pub sync_state: ActorSyncState, // ENUM: synced | dirty | partial | processing
-    pub repo_rev: Option<String>,   // Repo revision
-    pub repo_cid: Option<Vec<u8>>,  // Repo root CID (32 bytes)
-    pub last_indexed: Option<DateTime<Utc>>,
-    pub account_created_at: Option<DateTime<Utc>>,
-    // Profile fields (from app.bsky.actor.profile)
-    pub profile_cid: Option<Vec<u8>>,
-    pub profile_created_at: Option<DateTime<Utc>>,
-    pub profile_avatar_cid: Option<Vec<u8>>,
-    pub profile_banner_cid: Option<Vec<u8>>,
-    pub profile_display_name: Option<String>,
-    pub profile_description: Option<String>,
-    pub profile_pinned_post_rkey: Option<i64>,
-    pub profile_joined_sp_id: Option<i64>,
-    pub profile_pronouns: Option<String>,
-    pub profile_website: Option<String>,
-    // Note: profile_search_vector omitted from model (PostgreSQL tsvector, not loaded in Rust)
-    // Status fields (from app.bsky.actor.status)
-    pub status_cid: Option<Vec<u8>>,
-    pub status_created_at: Option<DateTime<Utc>>,
-    pub status_type: Option<StatusType>,
-    pub status_duration: Option<i32>,
-    pub status_embed_post_actor_id: Option<i32>,
-    pub status_embed_post_rkey: Option<i64>,
-    pub status_thumb_mime_type: Option<ImageMimeType>,
-    pub status_thumb_cid: Option<Vec<u8>>,
-    // Chat declaration fields (from app.bsky.chat.declaration)
-    pub chat_allow_incoming: Option<ChatAllowIncoming>,
-    pub chat_created_at: Option<DateTime<Utc>>,
-    // Notification declaration fields (from app.bsky.notification.declaration)
-    pub notif_decl_allow_subscriptions: Option<NotifAllowSubscriptions>,
-    pub notif_decl_created_at: Option<DateTime<Utc>>,
-    // Notification state fields (from notification_state table)
-    pub notif_seen_at: Option<DateTime<Utc>>,
-    pub notif_unread_count: Option<i32>,
-    // Denormalized aggregate stats (from actor_aggregate_stats table)
-    // NULL = 0 for better compression (Gorilla stores NULLs as 1 bit in bitmap)
-    pub followers_count: Option<i32>,
-    pub following_count: Option<i32>,
-    pub posts_count: Option<i32>,
-    pub lists_count: Option<i16>,
-    pub feeds_count: Option<i16>,
-    pub starterpacks_count: Option<i16>,
-    // Labeler fields (from labelers table, denormalized - NULL for non-labelers)
-    pub labeler_cid: Option<Vec<u8>>,
-    pub labeler_created_at: Option<DateTime<Utc>>,
-    pub labeler_reasons: Option<Vec<Option<ReasonType>>>,
-    pub labeler_subject_types: Option<Vec<Option<SubjectType>>>,
-    pub labeler_subject_collections: Option<Vec<Option<String>>>,
-    pub labeler_status: Option<LabelerStatus>,
-    pub labeler_like_count: Option<i32>,
-    pub labeler_defs: Option<Vec<Option<LabelerDef>>>,
-    // Social graph arrays (from follows table, denormalized - bidirectional)
-    pub following: Option<Vec<Option<Follow>>>,  // Who this actor follows
-    pub followers: Option<Vec<Option<Follow>>>,  // Who follows this actor
-    // User preference arrays (from mutes, blocks, bookmarks tables, denormalized)
-    pub mutes: Option<Vec<Option<Mute>>>,        // Muted actors
-    pub blocks: Option<Vec<Option<Block>>>,      // Blocked actors
-    pub bookmarks: Option<Vec<Option<Bookmark>>>, // Bookmarked posts
-
-    // List moderation arrays (from thread_mutes, list_mutes, list_blocks tables, denormalized)
-    pub thread_mutes: Option<Vec<Option<crate::composite_types::ThreadMute>>>, // Muted threads
-    pub list_mutes: Option<Vec<Option<crate::composite_types::ListMute>>>,     // Muted lists
-    pub list_blocks: Option<Vec<Option<crate::composite_types::ListBlock>>>,   // List blocks
-    // Phase 6: RKey arrays for quick lookups
-    pub post_rkeys: Option<Vec<Option<i64>>>,   // All post rkeys owned by this actor
-    pub repost_rkeys: Option<Vec<Option<i64>>>, // All repost rkeys owned by this actor
-    // Phase 7: Labels array (from labels table, denormalized)
-    pub labels: Option<Vec<Option<crate::composite_types::ActorLabelRecord>>>, // Labels applied to this actor
-}
-
-// AllowlistEntry model removed - allowlist table dropped in favor of actors.sync_state
-//
-// Allowlist status is now determined by actors.sync_state:
-// - sync_state IN ('synced', 'dirty', 'processing') = fully allowed
-// - sync_state = 'partial' = not allowed (interacts with allowlisted users)
-//
-// The AllowlistEntry struct is kept in parakeet-db/src/allowlist.rs for API compatibility
-
-// =============================================================================
-// POSTS & CONTENT
-// =============================================================================
-
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::posts)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Post {
-    pub actor_id: i32,                       // PK part 1: FK to actors
-    pub rkey: i64,                           // PK part 2: TID as INT8
-    pub cid: Vec<u8>,                        // 32-byte CID digest
-    pub content: Option<Vec<u8>>,            // Zstd-compressed BYTEA (NULL for stubs)
-    pub langs: array_helpers::LanguageCodeArray, // ENUM array: ISO 639-1 codes (up to 3 per AT Protocol)
-    pub tags: array_helpers::TextArray,      // Hashtags (GIN indexed)
-    pub embed_type: Option<EmbedType>, // ENUM: images | video | external | record | record_with_media
-    pub embed_subtype: Option<EmbedType>, // ENUM: For nested embeds (quote posts)
-    pub violates_threadgate: bool,
-    pub status: PostStatus, // ENUM: complete | stub | deleted | forbidden
-    pub tokens: Option<array_helpers::TextArray>, // Token array for search (GIN indexed, nullable)
-    // Denormalized embed fields (composite types)
-    pub ext_embed: Option<crate::composite_types::ExtEmbed>,
-    pub video_embed: Option<crate::composite_types::VideoEmbed>,
-    // Natural key references to other posts (hypertable → hypertable, NO FK constraints)
-    pub parent_post_actor_id: Option<i32>,   // Parent post reference (for replies)
-    pub parent_post_rkey: Option<i64>,
-    pub root_post_actor_id: Option<i32>,     // Root post reference (for threads)
-    pub root_post_rkey: Option<i64>,
-    pub embedded_post_actor_id: Option<i32>, // Quote post reference
-    pub embedded_post_rkey: Option<i64>,
-    pub record_detached: Option<bool>,
-    pub image_1: Option<crate::composite_types::ImageEmbed>,
-    pub image_2: Option<crate::composite_types::ImageEmbed>,
-    pub image_3: Option<crate::composite_types::ImageEmbed>,
-    pub image_4: Option<crate::composite_types::ImageEmbed>,
-    pub facet_1: Option<crate::composite_types::FacetEmbed>,
-    pub facet_2: Option<crate::composite_types::FacetEmbed>,
-    pub facet_3: Option<crate::composite_types::FacetEmbed>,
-    pub facet_4: Option<crate::composite_types::FacetEmbed>,
-    pub facet_5: Option<crate::composite_types::FacetEmbed>,
-    pub facet_6: Option<crate::composite_types::FacetEmbed>,
-    pub facet_7: Option<crate::composite_types::FacetEmbed>,
-    pub facet_8: Option<crate::composite_types::FacetEmbed>,
-    pub mentions: Option<Vec<Option<i32>>>,  // Array of actor_ids
-    // Embedded engagement arrays (array-only tracking, compute counts via array_length())
-    // Likes: like_actor_ids[i] pairs with like_rkeys[i]
-    pub like_actor_ids: Option<Vec<Option<i32>>>,           // [actor1, actor2, ...] (who liked)
-    pub like_rkeys: Option<Vec<Option<i64>>>,               // [rkey1, rkey2, ...] (when they liked)
-    // Via repost tracking as JSONB: {"30": {"actor_id": 15, "rkey": 999}, ...}
-    // Key: liker's actor_id (as string), Value: {actor_id, rkey} of repost they came via
-    pub like_via_repost_data: Option<serde_json::Value>,
-    // Replies: reply_actor_ids[i] pairs with reply_rkeys[i]
-    pub reply_actor_ids: Option<Vec<Option<i32>>>,          // [actor1, actor2, ...] (who replied)
-    pub reply_rkeys: Option<Vec<Option<i64>>>,              // [rkey1, rkey2, ...] (when they replied)
-    // Quotes: quote_actor_ids[i] pairs with quote_rkeys[i]
-    pub quote_actor_ids: Option<Vec<Option<i32>>>,          // [actor1, actor2, ...] (who quoted)
-    pub quote_rkeys: Option<Vec<Option<i64>>>,              // [rkey1, rkey2, ...] (when they quoted)
-    // Reposts: repost_actor_ids[i] pairs with repost_rkeys[i]
-    pub repost_actor_ids: Option<Vec<Option<i32>>>,         // [actor1, actor2, ...] (who reposted)
-    pub repost_rkeys: Option<Vec<Option<i64>>>,             // [rkey1, rkey2, ...] (when they reposted)
-    // Denormalized threadgate data (from threadgates table + threadgate_hidden_replies junction)
-    pub threadgate_allow: Option<array_helpers::ThreadgateRuleArray>, // Rules (maxLength: 5)
-    pub threadgate_hidden_actor_ids: Option<Vec<Option<i32>>>,        // Hidden reply authors (maxLength: 300)
-    pub threadgate_hidden_rkeys: Option<Vec<Option<i64>>>,            // Hidden reply rkeys (parallel array)
-    // Denormalized postgate data (from postgates table + postgate_detached junction)
-    pub postgate_rules: Option<array_helpers::PostgateRuleArray>,    // Rules (maxLength: 5)
-    pub postgate_detached_actor_ids: Option<Vec<Option<i32>>>,       // Detached embed authors (maxLength: 50)
-    pub postgate_detached_rkeys: Option<Vec<Option<i64>>>,           // Detached embed rkeys (parallel array)
-    // Phase 7: Labels array (from labels table, denormalized)
-    pub labels: Option<Vec<Option<crate::composite_types::PostLabelRecord>>>, // Labels applied to this post
-    // Phase 8: Engagement counts (maintained automatically by triggers)
-    pub like_count: i32,      // Count of likes (maintained by update_post_counts trigger)
-    pub repost_count: i32,    // Count of reposts (maintained by update_post_counts trigger)
-    pub reply_count: i32,     // Count of replies (maintained by update_post_counts trigger)
-    pub quote_count: i32,     // Count of quote posts (maintained by update_post_counts trigger)
-                                                    // Note: created_at derived from TID rkey via created_at() method
-}
-
-impl Post {
-    /// Get a specific like by index position
-    ///
-    /// Returns None if index is out of bounds or arrays are NULL
-    pub fn get_like(&self, idx: usize) -> Option<PostLikeInfo> {
-        let actor_ids = self.like_actor_ids.as_ref()?;
-        let rkeys = self.like_rkeys.as_ref()?;
-
-        let actor_id = *actor_ids.get(idx)?.as_ref()?;
-        let rkey = *rkeys.get(idx)?.as_ref()?;
-
-        // Extract via_repost from JSONB if it exists for this liker
-        let (via_repost_actor_id, via_repost_rkey) = self
-            .like_via_repost_data
-            .as_ref()
-            .and_then(|json| json.get(actor_id.to_string()))
-            .and_then(|data| {
-                let actor = data.get("actor_id")?.as_i64()? as i32;
-                let rkey = data.get("rkey")?.as_i64()?;
-                Some((Some(actor), Some(rkey)))
-            })
-            .unwrap_or((None, None));
-
-        Some(PostLikeInfo {
-            actor_id,
-            rkey,
-            via_repost_actor_id,
-            via_repost_rkey,
-        })
-    }
-
-    /// Check if an actor has liked this post
-    ///
-    /// Returns Some(like_rkey) if the actor has liked, None otherwise
-    pub fn actor_liked(&self, actor_id: i32) -> Option<i64> {
-        let actor_ids = self.like_actor_ids.as_ref()?;
-        let rkeys = self.like_rkeys.as_ref()?;
-
-        actor_ids
-            .iter()
-            .position(|id| id.as_ref() == Some(&actor_id))
-            .and_then(|idx| rkeys.get(idx).and_then(|r| r.as_ref()).copied())
-    }
-
-    /// Get iterator over all likes
-    ///
-    /// Returns empty iterator if post has no likes
-    pub fn likes(&self) -> impl Iterator<Item = PostLikeInfo> + '_ {
-        let count = self
-            .like_actor_ids
-            .as_ref()
-            .map(|v| v.len())
-            .unwrap_or(0);
-
-        (0..count).filter_map(move |i| self.get_like(i))
-    }
-
-    /// Get number of likes from array length (should match like_count)
-    pub fn likes_len(&self) -> usize {
-        self.like_actor_ids
-            .as_ref()
-            .map(|v| v.len())
-            .unwrap_or(0)
-    }
-}
-
-/// Represents a single like extracted from post arrays
-#[derive(Debug, Clone)]
-pub struct PostLikeInfo {
-    pub actor_id: i32,
-    pub rkey: i64,
-    pub via_repost_actor_id: Option<i32>,
-    pub via_repost_rkey: Option<i64>,
-}
-
-impl PostLikeInfo {
-    /// Get created_at timestamp from the like's TID rkey
-    pub fn created_at(&self) -> DateTime<Utc> {
-        crate::tid_util::tid_to_datetime(self.rkey)
-    }
-}
-
-// Stats struct for API responses (replaces parakeet_index::PostStats)
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct PostStats {
-    pub likes: i32,      // Keep as i32 for API compatibility
-    pub replies: i32,
-    pub reposts: i32,
-    pub quotes: i32,
-}
-
-impl PostStats {
-    pub fn from_post(post: &Post) -> Self {
-        Self {
-            likes: post.like_count,
-            replies: post.reply_count,
-            reposts: post.repost_count,
-            quotes: post.quote_count,
-        }
-    }
-
-    pub fn zero() -> Self {
-        Self { likes: 0, replies: 0, reposts: 0, quotes: 0 }
-    }
-}
-
-// Profile stats struct for API responses (replaces parakeet_index::ProfileStats)
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct ProfileStats {
-    pub followers: i32,
-    pub following: i32,
-    pub posts: i32,
-    pub lists: i32,
-    pub feeds: i32,
-    pub starterpacks: i32,
-}
-
-impl ProfileStats {
-    pub fn zero() -> Self {
-        Self {
-            followers: 0,
-            following: 0,
-            posts: 0,
-            lists: 0,
-            feeds: 0,
-            starterpacks: 0,
-        }
-    }
-}
-
-// Post embed tables - reference posts directly
-
-#[derive(Debug, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::uris)]
-#[diesel(primary_key(id))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Uri {
-    pub id: i32,     // PK: Deduplication ID
-    pub uri: String, // Unique URI
-    pub created_at: DateTime<Utc>,
-}
-
-// Postgates
-
-// =============================================================================
-// SOCIAL INTERACTIONS
-// =============================================================================
-
-// Note: Feed Generator Likes table dropped - likes stored as arrays on feedgens table
-// The like_actor_ids[] and like_rkeys[] arrays are maintained on feedgens
-// This follows the same denormalization pattern as posts
-
-// Note: Labeler Likes table dropped - labeler data moved to actors table
-// The labeler_like_count is maintained on actors.labeler_like_count
-// Individual like records (labeler_likes table) were dropped for simplicity
-
-#[derive(Clone, Debug, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::reposts)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Repost {
-    pub actor_id: i32,                    // PK part 1: FK to actors
-    pub rkey: i64,                        // PK part 2: TID as INT8
-    pub cid: Vec<u8>,                     // Real CID - needed for like.via_repost references
-    pub post_actor_id: i32,               // Natural key reference to posts (regular → hypertable FK allowed) - NOT NULL
-    pub post_rkey: i64,                   // Natural key reference to posts - NOT NULL
-    pub via_repost_actor_id: Option<i32>, // Natural key self-reference (quote-repost-of-repost)
-    pub via_repost_rkey: Option<i64>,
-    pub status: RepostStatus,             // ENUM: complete | stub
-                                          // Note: created_at derived from TID rkey via created_at() method
-}
-
-// Follow model removed - follow relationships now stored as follow_record[] arrays on actors table
-// Follow composite type is defined in composite_types.rs
-
-// Block, Mute, Bookmark models removed - user preferences now stored as arrays on actors table
-// Composite types are defined in composite_types.rs
-
-// Profile, NotifDecl, ChatDecl, and Status structs removed - data now consolidated into Actor struct
-// See actors table columns: profile_*, status_*, chat_*, notif_decl_*, notif_seen_at, notif_unread_count
-
-// =============================================================================
-// FEED GENERATORS
-// =============================================================================
-
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::feedgens)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct FeedGen {
-    pub actor_id: i32,                     // PK1: FK to actors
-    pub rkey: String, // PK2: Arbitrary user-chosen string (NOT TID, e.g. "music", "discover")
-    pub cid: Vec<u8>, // 32-byte CID digest
-    pub created_at: DateTime<Utc>, // From AT Protocol record
-    pub owner_actor_id: i32, // FK to actors (denormalized for filtering)
-    pub service_actor_id: i32, // FK to actors (denormalized for resolution)
-    pub content_mode: Option<ContentMode>, // ENUM: contentModeUnspecified | contentModeVideo
-    pub name: Option<String>, // NULL for stubs or deleted feedgens
-    pub description: Option<String>,
-    pub description_facets: Option<serde_json::Value>,
-    pub avatar_cid: Option<Vec<u8>>, // 32-byte CID
-    pub accepts_interactions: bool,
-    pub status: FeedgenStatus, // ENUM: complete | stub | deleted
-    pub like_count: i32, // Aggregated count of likes (maintained by database_writer)
-}
-
-// =============================================================================
-// LISTS
-// =============================================================================
-
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::lists)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct List {
-    pub actor_id: i32,               // PK1: FK to actors
-    pub rkey: String,                // PK2: Can be TID or arbitrary string like "nfb", "bblock"
-    pub cid: Vec<u8>,                // 32-byte CID digest
-    pub owner_actor_id: i32,         // FK to actors (denormalized for filtering)
-    pub list_type: Option<ListType>, // ENUM: curatelist | modlist | referencelist (NULL for stubs)
-    pub name: Option<String>,        // NULL for stubs
-    pub description: Option<String>,
-    pub description_facets: Option<serde_json::Value>,
-    pub avatar_cid: Option<Vec<u8>>, // 32-byte CID
-    pub status: RecordStatus,        // ENUM: complete | stub | deleted | forbidden
-                                     // Note: created_at derived from TID rkey if present, or epoch for non-TID rkeys
-}
-
-#[derive(Debug, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::list_items)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct ListItem {
-    pub actor_id: i32, // PK: FK to actors
-    pub rkey: i64,     // PK: TID as INT8
-    pub cid: Vec<u8>,  // 32-byte CID digest
-    pub subject_actor_id: i32, // FK to actors
-    pub list_owner_actor_id: i32, // FK to lists (natural key 1/2)
-    pub list_rkey: String,        // FK to lists (natural key 2/2)
-                       // Note: created_at derived from TID rkey via created_at() method
-}
-
-// Note: ListBlock, ListMute, ThreadMute models removed
-// List moderation data is now stored as arrays on actors table:
-// - thread_mutes: thread_mute_record[]
-// - list_mutes: list_mute_record[]
-// - list_blocks: list_block_record[]
-// Composite types are defined in composite_types.rs
-
-// =============================================================================
-// STARTER PACKS
-// =============================================================================
-
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::starterpacks)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct StarterPack {
-    pub actor_id: i32,        // PK1: FK to actors
-    pub rkey: i64,            // PK2: TID as INT8
-    pub cid: Vec<u8>,         // 32-byte CID digest
-    pub owner_actor_id: i32,  // FK to actors (denormalized for filtering)
-    pub name: Option<String>, // NULL for stubs
-    pub description: Option<String>,
-    pub description_facets: Option<serde_json::Value>,
-    pub list_actor_id: Option<i32>, // FK to lists (natural key 1/2, nullable)
-    pub list_rkey: Option<String>,  // FK to lists (natural key 2/2, nullable)
-    pub status: RecordStatus, // ENUM: complete | stub | deleted | forbidden
-                      // Note: search_vector omitted from model
-                      // Note: created_at derived from TID rkey via created_at() method
-}
-
-#[derive(Clone, Debug, Queryable, Selectable)]
-#[diesel(table_name = crate::schema::starterpack_feeds)]
-#[diesel(primary_key(starterpack_id, position))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct StarterPackFeed {
-    pub starterpack_id: i64,  // FK to starterpacks
-    pub position: i16,
-    pub feed_actor_id: i32,   // FK to feedgens (natural key 1/2)
-    pub feed_rkey: String,    // FK to feedgens (natural key 2/2)
-}
-
-// =============================================================================
-// THREAD CONTROL
-// =============================================================================
-
-// Threadgate struct for denormalized use (no longer has a separate table)
-// Used only for compatibility with EnrichedThreadgate in parakeet loader
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Threadgate {
-    pub actor_id: i32,                 // Post's actor_id (threadgate typically owned by post author)
-    pub rkey: i64,                     // Post's rkey (synthetic - threadgate has own rkey in reality)
-    pub cid: Vec<u8>,                  // Synthetic CID (deterministic based on post key)
-    pub allow: Option<array_helpers::ThreadgateRuleArray>, // ENUM array: mention | following | list
-    pub post_actor_id: i32,            // Same as actor_id (denormalized in post)
-    pub post_rkey: i64,                // Same as rkey (denormalized in post)
-}
-
-// =============================================================================
-// MODERATION & LABELS
-// =============================================================================
-
-// Note: Labeler and LabelerDef structs removed
-// Labeler data is now stored directly on actors table with labeler_* columns
-// LabelerDef is now a composite type in composite_types.rs, stored as labeler_defs array on actors
-
-#[derive(Clone, Debug)]
-pub struct Label {
-    pub labeler_actor_id: i32, // PK: FK to actors
-    pub label: String,         // PK: Label identifier
-    pub uri: String,           // PK: Labeled URI
-    pub self_label: bool,
-    pub cid: Option<Vec<u8>>, // 32-byte CID
-    pub negated: bool,
-    pub expires: Option<DateTime<Utc>>,
-    pub sig: Option<Vec<u8>>, // Signature
-    pub created_at: DateTime<Utc>,
-    pub labeler: String, // COMPUTED: Labeler DID (fetched via JOIN in loaders)
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::verification)]
-#[diesel(primary_key(id))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Verification {
-    pub id: i64,                // PK: Surrogate key
-    pub actor_id: i32,          // FK to actors
-    pub rkey: i64,              // TID as INT8
-    pub cid: Vec<u8>,           // 32-byte CID digest
-    pub verifier_actor_id: i32, // FK to actors
-    pub subject_actor_id: i32,  // FK to actors
-    pub handle: String,
-    pub display_name: String,
-    // Note: created_at derived from TID rkey via created_at() method
-}
-
-// ChatDecl and Status structs removed - data now consolidated into Actor struct
-// See actors table columns: chat_*, status_*
-
-// =============================================================================
-// HELPER TYPES FOR ARRAYS
-// =============================================================================
-
-// For diesel arrays with nullable elements that we want as Vec<T>
-pub mod array_helpers {
-    use diesel::deserialize::FromSql;
-    use diesel::pg::Pg;
-    use diesel::sql_types::{Array, Nullable, Text};
-    use diesel::{deserialize, FromSqlRow};
-    use serde::{Deserialize, Serialize};
-    use std::ops::{Deref, DerefMut};
-
-    #[derive(Clone, Debug, Default, Serialize, Deserialize, FromSqlRow)]
-    #[diesel(sql_type = Array<Nullable<Text>>)]
-    pub struct TextArray(pub Vec<String>);
-
-    impl FromSql<Array<Nullable<Text>>, Pg> for TextArray {
-        fn from_sql(bytes: diesel::pg::PgValue<'_>) -> deserialize::Result<Self> {
-            let vec_with_nulls =
-                <Vec<Option<String>> as FromSql<Array<Nullable<Text>>, Pg>>::from_sql(bytes)?;
-            Ok(TextArray(vec_with_nulls.into_iter().flatten().collect()))
-        }
-    }
-
-    impl Deref for TextArray {
-        type Target = Vec<String>;
-
-        fn deref(&self) -> &Self::Target {
-            &self.0
-        }
-    }
-
-    impl DerefMut for TextArray {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            &mut self.0
-        }
-    }
-
-    impl From<TextArray> for Vec<String> {
-        fn from(v: TextArray) -> Vec<String> {
-            v.0
-        }
-    }
-
-    // Macro to generate array helper types for ENUMs
-    macro_rules! enum_array {
-        ($name:ident, $enum_type:ty, $sql_type:ty) => {
-            #[derive(Clone, Debug, Default, Serialize, Deserialize, FromSqlRow)]
-            #[diesel(sql_type = Array<Nullable<$sql_type>>)]
-            pub struct $name(pub Vec<$enum_type>);
-
-            impl FromSql<Array<Nullable<$sql_type>>, Pg> for $name {
-                fn from_sql(bytes: diesel::pg::PgValue<'_>) -> deserialize::Result<Self> {
-                    let vec_with_nulls = <Vec<Option<$enum_type>> as FromSql<
-                        Array<Nullable<$sql_type>>,
-                        Pg,
-                    >>::from_sql(bytes)?;
-                    Ok($name(vec_with_nulls.into_iter().flatten().collect()))
-                }
-            }
-
-            impl Deref for $name {
-                type Target = Vec<$enum_type>;
-
-                fn deref(&self) -> &Self::Target {
-                    &self.0
-                }
-            }
-
-            impl DerefMut for $name {
-                fn deref_mut(&mut self) -> &mut Self::Target {
-                    &mut self.0
-                }
-            }
-
-            impl From<$name> for Vec<$enum_type> {
-                fn from(v: $name) -> Vec<$enum_type> {
-                    v.0
-                }
-            }
-        };
-    }
-
-    // ENUM array types
-    enum_array!(
-        PostgateRuleArray,
-        crate::types::PostgateRule,
-        crate::schema::sql_types::PostgateRule
-    );
-    enum_array!(
-        ThreadgateRuleArray,
-        crate::types::ThreadgateRule,
-        crate::schema::sql_types::ThreadgateRule
-    );
-    enum_array!(
-        ReasonTypeArray,
-        crate::types::ReasonType,
-        crate::schema::sql_types::ReasonType
-    );
-    enum_array!(
-        SubjectTypeArray,
-        crate::types::SubjectType,
-        crate::schema::sql_types::SubjectType
-    );
-    enum_array!(
-        LanguageCodeArray,
-        crate::types::LanguageCode,
-        crate::schema::sql_types::LanguageCode
-    );
-}
-
-// =============================================================================
-// TID RKEY IMPLEMENTATIONS
-// =============================================================================
-// Implement HasTidRkey for all models with TID-based rkeys
-
-impl_tid_rkey!(Post);
-// impl_tid_rkey!(FeedgenLike); // Removed - feedgen_likes table dropped, now like_actor_ids[]/like_rkeys[] arrays
-// impl_tid_rkey!(LabelerLike); // Removed - labeler_likes table dropped
-impl_tid_rkey!(Repost);
-// impl_tid_rkey!(Follow); // Removed - follows table dropped, now follow_record[] arrays
-impl_tid_rkey!(Block);
-impl_tid_rkey!(Bookmark);
-// NOTE: FeedGen and List intentionally excluded - use arbitrary String rkeys, not TIDs
-impl_tid_rkey!(ListItem);
-// impl_tid_rkey!(ListBlock); // Removed - list_blocks table dropped, now list_block_record[] arrays
-impl_tid_rkey!(StarterPack);
-impl_tid_rkey!(Verification);
-
-// =============================================================================
-// TID TIMESTAMP IMPLEMENTATIONS
-// =============================================================================
-// Implement created_at() method for models where we derive timestamp from TID
-// This eliminates the need for a separate created_at column in the database
-
-impl_tid_created_at!(Post);
-// impl_tid_created_at!(FeedgenLike); // Removed - feedgen_likes table dropped, now like_actor_ids[]/like_rkeys[] arrays
-// impl_tid_created_at!(LabelerLike); // Removed - labeler_likes table dropped
-impl_tid_created_at!(Repost);
-// impl_tid_created_at!(Follow); // Removed - follows table dropped, now follow_record[] arrays
-impl_tid_created_at!(Block);
-impl_tid_created_at!(Bookmark);
-impl_tid_created_at!(ListItem);
-// impl_tid_created_at!(ListBlock); // Removed - list_blocks table dropped, now list_block_record[] arrays
-// NOTE: List uses String rkey and has custom created_at() implementation
-impl_tid_created_at!(StarterPack);
-impl_tid_created_at!(Verification);
-
-// Custom created_at() implementation for List (String rkey can be TID or arbitrary)
-impl List {
-    /// Get created_at timestamp derived from rkey if it's a TID, or epoch for non-TID rkeys
-    pub fn created_at(&self) -> DateTime<Utc> {
-        crate::models::tid_to_i64(&self.rkey)
-            .map(crate::tid_util::tid_to_datetime)
-            .unwrap_or_else(|_| DateTime::<Utc>::UNIX_EPOCH)
-    }
-}

parakeet/src/common/cache_listener.rs

···
         if let Some((actor_id_str, rkey_str)) = rest.split_once(':') {
             if let Ok(actor_id) = actor_id_str.parse::<i32>() {
                 // Parse TID rkey
-                if let Ok(rkey) = parakeet_db::tid_util::decode_tid(rkey_str) {
+                if let Ok(rkey) = parakeet_db::utils::tid::decode_tid(rkey_str) {
                     // Invalidate StarterpackEntity cache
                     use crate::entities::core::starterpack::StarterpackKey;
                     state.starterpack_entity.invalidate(vec![StarterpackKey {

parakeet/src/common/helpers.rs

···
 /// This matches the official Bluesky API which uses base32-encoded TIDs
 /// like "3m47vaoniuy2d" for pagination cursors.
 pub fn tid_cursor(cursor: Option<&String>) -> Option<i64> {
-    cursor.and_then(|v| parakeet_db::tid_util::decode_tid(v).ok())
+    cursor.and_then(|v| parakeet_db::utils::tid::decode_tid(v).ok())
 }
 
 /// Parses a datetime cursor string (ISO 8601 format) into a DateTime

parakeet/src/entities/converters/post.rs

···
             .quote_count(Some(post_data.post.quote_count as i64))
             .bookmark_count(Some(0))
             .indexed_at(Datetime::new(
-                &parakeet_db::tid_util::tid_to_datetime(post_data.post.rkey)
+                &parakeet_db::utils::tid::tid_to_datetime(post_data.post.rkey)
                     .to_rfc3339_opts(chrono::SecondsFormat::Millis, true)
             ).unwrap())
             .build()
···
         // Build the post URI and CID
         let uri = format!("at://{}/app.bsky.feed.post/{}",
             author_profile.did.as_str(),
-            parakeet_db::tid_util::encode_tid(post_data.post.rkey));
-        let cid = parakeet_db::cid_util::digest_to_blob_cid_string(&post_data.post.cid).unwrap_or_default();
+            parakeet_db::utils::tid::encode_tid(post_data.post.rkey));
+        let cid = parakeet_db::utils::cid::digest_to_blob_cid_string(&post_data.post.cid).unwrap_or_default();
 
         Some(self.post_to_post_view(&post_data, author_profile, &uri, &cid))
     }

parakeet/src/entities/converters/profile.rs

···
 /// This replaces the complex hydration layer with simple, direct conversions
 
 use crate::entities::core::{ProfileEntity, PostEntity, StarterpackEntity};
-use parakeet_db::models::Actor;
+use parakeet_db::domain::Actor;
 use jacquard_api::app_bsky::actor::{
     ProfileView, ProfileViewDetailed, ProfileViewBasic,
     ProfileAssociated, ProfileAssociatedChat,
···
 
     // Keep avatar_url alive for the entire function scope
     let avatar_url = actor.profile_avatar_cid.as_ref()
-        .and_then(|avatar_cid| parakeet_db::cid_util::digest_to_blob_cid_string(avatar_cid))
+        .and_then(|avatar_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(avatar_cid))
         .map(|cid_str| format!("https://cdn.bsky.social/img/avatar/plain/{}/{}@jpeg", actor.did, cid_str));
 
     let mut builder = ProfileView::new()
···
             .and_then(|follows| {
                 follows.iter().flatten().find(|f| f.subject_actor_id == actor.id)
                     .map(|f| format!("at://{}/app.bsky.graph.follow/{}", viewer_did,
-                        parakeet_db::tid_util::encode_tid(f.rkey)))
+                        parakeet_db::utils::tid::encode_tid(f.rkey)))
             });
 
         // Check if this actor follows viewer
···
             .and_then(|follows| {
                 follows.iter().flatten().find(|f| f.subject_actor_id == viewer_actor_id)
                     .map(|f| format!("at://{}/app.bsky.graph.follow/{}", actor.did,
-                        parakeet_db::tid_util::encode_tid(f.rkey)))
+                        parakeet_db::utils::tid::encode_tid(f.rkey)))
             });
 
         // Check if viewer has muted this actor
···
             .and_then(|blocks| {
                 blocks.iter().flatten().find(|b| b.subject_actor_id == actor.id)
                     .map(|b| format!("at://{}/app.bsky.graph.block/{}", viewer_did,
-                        parakeet_db::tid_util::encode_tid(b.rkey)))
+                        parakeet_db::utils::tid::encode_tid(b.rkey)))
             });
 
         Some(ViewerState {
···
 
         // Keep URLs alive for the entire function scope
         let avatar_url = actor.profile_avatar_cid.as_ref()
-            .and_then(|avatar_cid| parakeet_db::cid_util::digest_to_blob_cid_string(avatar_cid))
+            .and_then(|avatar_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(avatar_cid))
             .map(|cid_str| format!("https://cdn.bsky.social/img/avatar/plain/{}/{}@jpeg", actor.did, cid_str));
 
         let banner_url = actor.profile_banner_cid.as_ref()
-            .and_then(|banner_cid| parakeet_db::cid_util::digest_to_blob_cid_string(banner_cid))
+            .and_then(|banner_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(banner_cid))
             .map(|cid_str| format!("https://cdn.bsky.social/img/banner/plain/{}/{}@jpeg", actor.did, cid_str));
 
         let mut builder = ProfileViewDetailed::new()
···
 
         // Keep URLs alive for the entire function scope
         let avatar_url = actor.profile_avatar_cid.as_ref()
-            .and_then(|avatar_cid| parakeet_db::cid_util::digest_to_blob_cid_string(avatar_cid))
+            .and_then(|avatar_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(avatar_cid))
             .map(|cid_str| format!("https://cdn.bsky.social/img/avatar/plain/{}/{}@jpeg", actor.did, cid_str));
 
         let banner_url = actor.profile_banner_cid.as_ref()
-            .and_then(|banner_cid| parakeet_db::cid_util::digest_to_blob_cid_string(banner_cid))
+            .and_then(|banner_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(banner_cid))
             .map(|cid_str| format!("https://cdn.bsky.social/img/banner/plain/{}/{}@jpeg", actor.did, cid_str));
 
         let mut builder = ProfileViewDetailed::new()
···
 
         // Keep avatar_url alive for the entire function scope
         let avatar_url = actor.profile_avatar_cid.as_ref()
-            .and_then(|avatar_cid| parakeet_db::cid_util::digest_to_blob_cid_string(avatar_cid))
+            .and_then(|avatar_cid| parakeet_db::utils::cid::digest_to_blob_cid_string(avatar_cid))
             .map(|cid_str| format!("https://cdn.bsky.social/img/avatar/plain/{}/{}@jpeg", actor.did, cid_str));
 
         let mut builder = ProfileViewBasic::new()

parakeet/src/entities/core/feedgen.rs

···
         };
 
         // Convert CID
-        let cid = parakeet_db::cid_util::digest_to_blob_cid_string(&data.cid);
+        let cid = parakeet_db::utils::cid::digest_to_blob_cid_string(&data.cid);
 
         // Build avatar URL if present
         let avatar = data.avatar_cid.as_ref().and_then(|cid_bytes| {
-            parakeet_db::cid_util::digest_to_blob_cid_string(cid_bytes)
+            parakeet_db::utils::cid::digest_to_blob_cid_string(cid_bytes)
                 .map(|avatar_cid| format!("{}/avatar/{}", self.cdn_base, avatar_cid))
         });
 

parakeet/src/entities/core/list.rs

···
         let creator_view = crate::entities::converters::profile::actor_to_profile_view(&creator);
 
         // Convert CID
-        let cid = parakeet_db::cid_util::digest_to_blob_cid_string(data.cid());
+        let cid = parakeet_db::utils::cid::digest_to_blob_cid_string(data.cid());
 
         // Build avatar URL if present
         let avatar = data.avatar_cid().and_then(|cid_bytes| {
-            parakeet_db::cid_util::digest_to_blob_cid_string(cid_bytes)
+            parakeet_db::utils::cid::digest_to_blob_cid_string(cid_bytes)
                 .map(|avatar_cid| format!("{}/avatar/{}", self.cdn_base, avatar_cid))
         });
 
···
         let mut processed = Vec::new();
         for row in results {
             // Decode TID from string to get timestamp
-            if let Ok(tid) = parakeet_db::tid_util::decode_tid(&row.rkey) {
-                let created_at = parakeet_db::tid_util::tid_to_datetime(tid);
+            if let Ok(tid) = parakeet_db::utils::tid::decode_tid(&row.rkey) {
+                let created_at = parakeet_db::utils::tid::tid_to_datetime(tid);
 
                 // Apply cursor filter in Rust
                 if let Some(cursor_ts) = cursor {
···
         let mut processed = Vec::new();
         for row in results {
             // Convert TID to timestamp
-            let created_at = parakeet_db::tid_util::tid_to_datetime(row.rkey);
+            let created_at = parakeet_db::utils::tid::tid_to_datetime(row.rkey);
 
             // Apply cursor filter in Rust
             if let Some(cursor_ts) = cursor {

parakeet/src/entities/core/notification.rs

···
 
         let mut map = std::collections::HashMap::new();
         for r in results {
-            let encoded_rkey = parakeet_db::tid_util::encode_tid(r.subject_rkey);
+            let encoded_rkey = parakeet_db::utils::tid::encode_tid(r.subject_rkey);
             let subject_uri = format!("at://{}/app.bsky.feed.post/{}", r.subject_did, encoded_rkey);
             map.insert((r.actor_id, r.rkey), (subject_uri, r.created_at));
         }
···
 
         let mut map = std::collections::HashMap::new();
         for r in results {
-            let encoded_rkey = parakeet_db::tid_util::encode_tid(r.post_rkey);
+            let encoded_rkey = parakeet_db::utils::tid::encode_tid(r.post_rkey);
             let post_uri = format!("at://{}/app.bsky.feed.post/{}", r.post_did, encoded_rkey);
             map.insert((r.actor_id, r.rkey), (post_uri, r.created_at));
         }

parakeet/src/entities/core/post.rs

···
 use jacquard_common::types::string::{AtUri, Cid, Datetime};
 use jacquard_common::types::value::Data;
 use jacquard_common::IntoStatic;
-use parakeet_db::models::{Post, Actor};
+use parakeet_db::domain::{Post, Actor};
 use std::sync::Arc;
 use std::collections::HashMap;
 use std::time::Duration;
···
     /// Convert this post data to a StrongRef (AT URI + CID)
     pub fn to_strong_ref(&self) -> Option<StrongRef<'static>> {
         // Convert the CID bytes to the proper string format
-        let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&self.post.cid)?;
+        let cid_str = parakeet_db::utils::cid::digest_to_record_cid_string(&self.post.cid)?;
 
         // Build the AT URI
         let uri = format!(
             "at://{}/app.bsky.feed.post/{}",
             self.author.did,
-            parakeet_db::tid_util::encode_tid(self.post.rkey)
+            parakeet_db::utils::tid::encode_tid(self.post.rkey)
         );
 
         StrongRef::new_from_str(uri, &cid_str).ok().map(|sr| sr.into_static())
···
             let uri = format!(
                 "at://{}/app.bsky.feed.post/{}",
                 post_data.author.did,
-                parakeet_db::tid_util::encode_tid(post_data.post.rkey)
+                parakeet_db::utils::tid::encode_tid(post_data.post.rkey)
             );
             self.uri_to_key.invalidate(&uri).await;
         }
···
         let tid_str = parts[2];
 
         // Decode the TID to get rkey
-        let rkey = parakeet_db::tid_util::decode_tid(tid_str)
+        let rkey = parakeet_db::utils::tid::decode_tid(tid_str)
             .map_err(|_| eyre::eyre!("Invalid TID in URI"))?;
 
         // Get actor_id from ProfileEntity (uses its cache)
···
         let uri = format!(
             "at://{}/app.bsky.feed.post/{}",
             post_data.author.did,
-            parakeet_db::tid_util::encode_tid(post_data.post.rkey)
+            parakeet_db::utils::tid::encode_tid(post_data.post.rkey)
         );
         self.uri_to_key.insert(uri, key).await;
         self.post_cache.insert(key, post_data.clone()).await;
···
                 let uri = format!(
                     "at://{}/app.bsky.feed.post/{}",
                     post_data.author.did,
-                    parakeet_db::tid_util::encode_tid(post_data.post.rkey)
+                    parakeet_db::utils::tid::encode_tid(post_data.post.rkey)
                 );
                 self.uri_to_key.insert(uri, key).await;
                 self.post_cache.insert(key, post_data.clone()).await;
···
         let uri = format!(
             "at://{}/app.bsky.feed.post/{}",
             data.author.did,
-            parakeet_db::tid_util::encode_tid(data.post.rkey)
+            parakeet_db::utils::tid::encode_tid(data.post.rkey)
         );
 
-        let cid = parakeet_db::cid_util::digest_to_blob_cid_string(&data.post.cid)
+        let cid = parakeet_db::utils::cid::digest_to_blob_cid_string(&data.post.cid)
             .unwrap_or_else(|| "bafyreiunknown".to_string());
 
         // Extract text from content if available
···
         };
 
         // Get created_at from TID rkey
-        let created_at = parakeet_db::tid_util::tid_to_datetime(data.post.rkey);
+        let created_at = parakeet_db::utils::tid::tid_to_datetime(data.post.rkey);
 
         // Compute viewer state if viewer is provided
         let viewer = if let Some(viewer_id) = viewer_actor_id {
···
             // Build viewer state with like/repost URIs if applicable
             let like_uri = if like {
                 // Generate proper like URI with TID
-                let like_tid = parakeet_db::tid_util::timestamp_to_tid(chrono::Utc::now());
+                let like_tid = parakeet_db::utils::tid::timestamp_to_tid(chrono::Utc::now());
                 let viewer_did = viewer_actor.as_ref().map(|a| a.did.clone()).unwrap_or_else(|| "unknown".to_string());
                 Some(format!("at://{}/app.bsky.feed.like/{}", viewer_did, like_tid))
             } else {
···
 
             let repost_uri = if repost {
                 // Generate proper repost URI with TID
-                let repost_tid = parakeet_db::tid_util::timestamp_to_tid(chrono::Utc::now());
+                let repost_tid = parakeet_db::utils::tid::timestamp_to_tid(chrono::Utc::now());
                 let viewer_did = viewer_actor.as_ref().map(|a| a.did.clone()).unwrap_or_else(|| "unknown".to_string());
                 Some(format!("at://{}/app.bsky.feed.repost/{}", viewer_did, repost_tid))
             } else {
···
                 // Check each image field
                 for img_opt in [&data.post.image_1, &data.post.image_2, &data.post.image_3, &data.post.image_4] {
                     if let Some(img) = img_opt {
-                        if let Some(cid_str) = parakeet_db::cid_util::digest_to_blob_cid_string(&img.cid) {
+                        if let Some(cid_str) = parakeet_db::utils::cid::digest_to_blob_cid_string(&img.cid) {
                             images.push(ImageView {
                                 thumb: format!("https://cdn.bsky.social/img/feed_thumbnail/plain/{}/{}@jpeg",
                                     data.author.did, cid_str),
···
                             title: ext.title.clone().unwrap_or_default(),
                             description: ext.description.clone().unwrap_or_default(),
                             thumb: ext.thumb_cid.as_ref()
-                                .and_then(|cid| parakeet_db::cid_util::digest_to_blob_cid_string(cid))
+                                .and_then(|cid| parakeet_db::utils::cid::digest_to_blob_cid_string(cid))
                                 .map(|cid_str| format!("https://cdn.bsky.social/img/feed_thumbnail/plain/{}/{}@jpeg",
                                     data.author.did, cid_str)),
                         }
···
                     let parent_uri = format!(
                         "at://{}/app.bsky.feed.post/{}",
                         parent_did,
-                        parakeet_db::tid_util::encode_tid(parent_rkey)
+                        parakeet_db::utils::tid::encode_tid(parent_rkey)
                     );
                     ReplyRefPost::NotFound {
                         uri: parent_uri,
···
                             let root_uri = format!(
                                 "at://{}/app.bsky.feed.post/{}",
                                 root_did,
-                                parakeet_db::tid_util::encode_tid(root_rkey)
+                                parakeet_db::utils::tid::encode_tid(root_rkey)
                             );
                             ReplyRefPost::NotFound {
                                 uri: root_uri,
···
                             // If we can't build root URI, create NotFound with placeholder
                             ReplyRefPost::NotFound {
                                 uri: format!("at://unknown/app.bsky.feed.post/{}",
-                                    parakeet_db::tid_util::encode_tid(root_rkey)),
+                                    parakeet_db::utils::tid::encode_tid(root_rkey)),
                                 not_found: true,
                             }
                         }
···
             for (like_actor_id, like_rkey) in actor_ids.into_iter().zip(rkeys.into_iter()) {
                 // Skip None values
                 if let (Some(actor_id), Some(rkey)) = (like_actor_id, like_rkey) {
-                    let timestamp = parakeet_db::tid_util::tid_to_datetime(rkey);
+                    let timestamp = parakeet_db::utils::tid::tid_to_datetime(rkey);
 
                     // Apply cursor filter
                     if let Some(cursor_ts) = cursor {
···
             .optional()?;
 
         Ok(result.map(|(post_actor_id, post_rkey)| {
-            let timestamp = parakeet_db::tid_util::tid_to_datetime(rkey);
+            let timestamp = parakeet_db::utils::tid::tid_to_datetime(rkey);
             (post_actor_id, post_rkey, timestamp)
         }))
     }
···
         Ok(results
             .into_iter()
             .map(|r| {
-                let encoded_rkey = parakeet_db::tid_util::encode_tid(r.rkey);
+                let encoded_rkey = parakeet_db::utils::tid::encode_tid(r.rkey);
                 let uri = format!("at://{}/app.bsky.feed.post/{}", r.did, encoded_rkey);
                 ((r.actor_id, r.rkey), uri)
             })

parakeet/src/entities/core/profile.rs

···
         actor_id: i32,
         cursor_ts: Option<&chrono::DateTime<chrono::Utc>>,
         limit: u8,
-    ) -> Result<Vec<parakeet_db::composite_types::Block>> {
+    ) -> Result<Vec<parakeet_db::composite::Block>> {
         // If the actor doesn't exist, they have no blocks
         let actor = match self.get_profile_by_id(actor_id).await {
             Ok(a) => a,
             Err(_) => return Ok(Vec::new()),
         };
 
-        let blocks: Vec<parakeet_db::composite_types::Block> = actor.blocks
+        let blocks: Vec<parakeet_db::composite::Block> = actor.blocks
             .as_ref()
             .map(|blocks| blocks.iter().flatten().cloned().collect())
             .unwrap_or_default();
···
         let filtered: Vec<_> = if let Some(cursor) = cursor_ts {
             blocks.into_iter()
                 .filter(|b| {
-                    let dt = parakeet_db::tid_util::tid_to_datetime(b.rkey);
+                    let dt = parakeet_db::utils::tid::tid_to_datetime(b.rkey);
                     dt < *cursor
                 })
                 .take(limit as usize + 1)
···
         actor_id: i32,
         cursor_ts: Option<&chrono::DateTime<chrono::Utc>>,
         limit: u8,
-    ) -> Result<Vec<parakeet_db::composite_types::Mute>> {
+    ) -> Result<Vec<parakeet_db::composite::Mute>> {
         // If the actor doesn't exist, they have no mutes
         let actor = match self.get_profile_by_id(actor_id).await {
             Ok(a) => a,
             Err(_) => return Ok(Vec::new()),
         };
 
-        let mutes: Vec<parakeet_db::composite_types::Mute> = actor.mutes
+        let mutes: Vec<parakeet_db::composite::Mute> = actor.mutes
             .as_ref()
             .map(|mutes| mutes.iter().flatten().cloned().collect())
             .unwrap_or_default();
···
         actor_id: i32,
         cursor_ts: Option<&chrono::DateTime<chrono::Utc>>,
         limit: u8,
-    ) -> Result<Vec<parakeet_db::composite_types::ListMute>> {
+    ) -> Result<Vec<parakeet_db::composite::ListMute>> {
         // If the actor doesn't exist, they have no muted lists
         let actor = match self.get_profile_by_id(actor_id).await {
             Ok(a) => a,
             Err(_) => return Ok(Vec::new()),
         };
 
-        let list_mutes: Vec<parakeet_db::composite_types::ListMute> = actor.list_mutes
+        let list_mutes: Vec<parakeet_db::composite::ListMute> = actor.list_mutes
             .as_ref()
             .map(|mutes| mutes.iter().flatten().cloned().collect())
             .unwrap_or_default();
···
         actor_id: i32,
         cursor_ts: Option<&chrono::DateTime<chrono::Utc>>,
         limit: u8,
-    ) -> Result<Vec<parakeet_db::composite_types::Follow>> {
+    ) -> Result<Vec<parakeet_db::composite::Follow>> {
         // If the actor doesn't exist, they follow nobody
         let actor = match self.get_profile_by_id(actor_id).await {
             Ok(a) => a,
             Err(_) => return Ok(Vec::new()),
         };
 
-        let follows: Vec<parakeet_db::composite_types::Follow> = actor.following
+        let follows: Vec<parakeet_db::composite::Follow> = actor.following
             .as_ref()
             .map(|follows| follows.iter().flatten().cloned().collect())
             .unwrap_or_default();
···
         let filtered: Vec<_> = if let Some(cursor) = cursor_ts {
             follows.into_iter()
                 .filter(|f| {
-                    let dt = parakeet_db::tid_util::tid_to_datetime(f.rkey);
+                    let dt = parakeet_db::utils::tid::tid_to_datetime(f.rkey);
                     dt < *cursor
                 })
                 .take(limit as usize + 1)
···
         // If we have a cursor, filter out posts created before it
         if let Some(cursor_ts) = cursor {
             posts_liked.retain(|(_, rkey)| {
-                let timestamp = parakeet_db::tid_util::tid_to_datetime(*rkey);
+                let timestamp = parakeet_db::utils::tid::tid_to_datetime(*rkey);
                 timestamp > *cursor_ts
             });
         }

parakeet/src/entities/core/starterpack.rs

···
         let actor_id = self.profile_entity.resolve_identifier(did).await.ok()?;
 
         // Parse TID rkey
-        let rkey = parakeet_db::tid_util::decode_tid(rkey_str).ok()?;
+        let rkey = parakeet_db::utils::tid::decode_tid(rkey_str).ok()?;
 
         Some((actor_id, rkey))
     }
···
                 .await
                 .unwrap_or_else(|_| view.creator.did.to_string());
 
-            let rkey_str = parakeet_db::tid_util::encode_tid(keys.iter()
+            let rkey_str = parakeet_db::utils::tid::encode_tid(keys.iter()
                 .find(|(_, k)| k.actor_id == actor_id)
                 .map(|(_, k)| k.rkey)
                 .unwrap_or(0));
···
         let creator_view = self.profile_entity.actor_to_profile_view_basic(&creator, None).await;
 
         // Convert CID
-        let cid = parakeet_db::cid_util::digest_to_blob_cid_string(&data.cid);
+        let cid = parakeet_db::utils::cid::digest_to_blob_cid_string(&data.cid);
 
         // Parse description facets
         let description_facets: Option<Vec<jacquard_api::app_bsky::richtext::facet::Facet>> = data.description_facets.and_then(|v| {
···
         });
 
         // Build the URI
-        let rkey_str = parakeet_db::tid_util::encode_tid(data.rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(data.rkey);
         let uri = format!("at://{}/app.bsky.graph.starterpack/{}", creator.did, rkey_str);
 
         // Get indexed_at - use current time for now
···
         let (list_item_count, joined_week_count, joined_all_time_count) =
             if let (Some(list_actor_id), Some(list_rkey_str)) = (data.list_actor_id, &data.list_rkey) {
                 // Decode the base32 rkey to i64
-                let list_rkey = parakeet_db::tid_util::decode_tid(list_rkey_str).unwrap_or(0);
+                let list_rkey = parakeet_db::utils::tid::decode_tid(list_rkey_str).unwrap_or(0);
                 self.get_list_counts(list_actor_id, list_rkey).await.unwrap_or((0, 0, 0))
             } else {
                 (0, 0, 0)
···
 
         Ok(rows.into_iter()
             .map(|r| {
-                let encoded_rkey = parakeet_db::tid_util::encode_tid(r.rkey);
+                let encoded_rkey = parakeet_db::utils::tid::encode_tid(r.rkey);
                 let at_uri = format!("at://{}/app.bsky.graph.starterpack/{}", r.did, encoded_rkey);
                 (at_uri, r.owner, r.name, r.description)
             })
···
                     if let Ok(item_owner_did) = self.profile_entity.get_did_by_id(item_actor_id).await {
                         let item_uri = format!("at://{}/app.bsky.graph.listitem/{}",
                             item_owner_did,
-                            parakeet_db::tid_util::encode_tid(item_rkey));
+                            parakeet_db::utils::tid::encode_tid(item_rkey));
 
                         let subject = self.profile_entity.actor_to_profile_view(subject_actor);
                         use jacquard_common::IntoStatic;

parakeet/src/entities/ext/actor.rs

···
 use parakeet_db::{
     models::Actor,
     types::ActorSyncState,
-    composite_types::Follow,
+    composite::Follow,
 };
 
 /// Extension trait for Actor to add convenience methods and AT Protocol conversions
···
 
     fn pinned_post_uri(&self) -> Option<String> {
         self.profile_pinned_post_rkey.map(|rkey| {
-            let tid = parakeet_db::tid_util::encode_tid(rkey);
+            let tid = parakeet_db::utils::tid::encode_tid(rkey);
             format!("at://{}/app.bsky.feed.post/{}", self.did, tid)
         })
     }

parakeet/src/entities/ext/post.rs

···
-use parakeet_db::models::Post;
+use parakeet_db::domain::Post;
 
 /// Extension trait for Post to add convenience methods and AT Protocol conversions
 pub trait PostExt {
···
         format!(
             "at://{}/app.bsky.feed.post/{}",
             author_did,
-            parakeet_db::tid_util::encode_tid(self.rkey)
+            parakeet_db::utils::tid::encode_tid(self.rkey)
         )
     }
 

parakeet/src/xrpc/app_bsky/bookmark.rs

···
         .map_err(|_| StatusCode::NOT_FOUND)?;
 
     // Decode TID
-    let rkey = parakeet_db::tid_util::decode_tid(rkey_str)
+    let rkey = parakeet_db::utils::tid::decode_tid(rkey_str)
         .map_err(|_| StatusCode::BAD_REQUEST)?;
 
     // Update bookmarks array on actor
···
 
     // Create new bookmark composite type
     let new_bookmark = format!("({},{},{})",
-        parakeet_db::tid_util::decode_tid(&parakeet_db::tid_util::timestamp_to_tid(chrono::Utc::now())).unwrap_or(0),  // Generate new rkey for the bookmark
+        parakeet_db::utils::tid::decode_tid(&parakeet_db::utils::tid::timestamp_to_tid(chrono::Utc::now())).unwrap_or(0),  // Generate new rkey for the bookmark
         post_actor_id,
         rkey
     );
···
         .map_err(|_| StatusCode::NOT_FOUND)?;
 
     // Decode TID
-    let rkey = parakeet_db::tid_util::decode_tid(rkey_str)
+    let rkey = parakeet_db::utils::tid::decode_tid(rkey_str)
         .map_err(|_| StatusCode::BAD_REQUEST)?;
 
     // Remove bookmark from actor's array
···
         let uri = format!(
             "at://{}/app.bsky.feed.post/{}",
             post_did,
-            parakeet_db::tid_util::encode_tid(post_rkey)
+            parakeet_db::utils::tid::encode_tid(post_rkey)
         );
 
         // Create StrongRef for the subject
         // Convert CID bytes to string, then parse to Cid
-        let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&cid)
+        let cid_str = parakeet_db::utils::cid::digest_to_record_cid_string(&cid)
             .unwrap_or_else(|| "bafyreigrey4aogz7sq5bxfaiwlcieaivxscvgs5ivgqczecmvz6jhmnxq".to_string()); // Default CID
 
         use jacquard_common::IntoStatic;

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

···
         .map(|c| c.as_ref())
         .and_then(|c| datetime_cursor(Some(&c.to_string())))
         .map(|dt| {
-            let tid_str = parakeet_db::tid_util::timestamp_to_tid(dt);
-            parakeet_db::tid_util::decode_tid(&tid_str).unwrap_or(0)
+            let tid_str = parakeet_db::utils::tid::timestamp_to_tid(dt);
+            parakeet_db::utils::tid::decode_tid(&tid_str).unwrap_or(0)
         });
 
     // Get followed profiles with their post rkeys (all cached)
···
     // Build cursor from last item (if we have more pages)
     let cursor = if has_next && timeline_items.len() > limit as usize {
         let last_rkey = timeline_items[limit as usize - 1].0;
-        let timestamp = parakeet_db::tid_util::tid_to_datetime(last_rkey);
+        let timestamp = parakeet_db::utils::tid::tid_to_datetime(last_rkey);
         Some(timestamp.to_rfc3339_opts(chrono::SecondsFormat::Millis, true))
     } else {
         None
···
                                         uri: Some(jacquard_common::types::aturi::AtUri::new(&format!(
                                             "at://{}/app.bsky.feed.repost/{}",
                                             reposter.did,
-                                            parakeet_db::tid_util::encode_tid(rkey)
+                                            parakeet_db::utils::tid::encode_tid(rkey)
                                         )).unwrap()),
                                         cid: None, // TODO: Add CID if needed
                                         indexed_at: jacquard_common::types::datetime::Datetime::from(indexed_at.fixed_offset()),
···
         .map(|c| c.as_ref())
         .and_then(|c| datetime_cursor(Some(&c.to_string())))
         .map(|dt| {
-            let tid_str = parakeet_db::tid_util::timestamp_to_tid(dt);
-            parakeet_db::tid_util::decode_tid(&tid_str).unwrap_or(0)
+            let tid_str = parakeet_db::utils::tid::timestamp_to_tid(dt);
+            parakeet_db::utils::tid::decode_tid(&tid_str).unwrap_or(0)
         });
 
     // Use ProfileEntity to get author's posts
···
     // Build cursor from last post
     let cursor = if has_next && posts_to_return.len() == limit as usize {
         let last_rkey = posts_to_return[posts_to_return.len() - 1].1;
-        let timestamp = parakeet_db::tid_util::tid_to_datetime(last_rkey);
+        let timestamp = parakeet_db::utils::tid::tid_to_datetime(last_rkey);
         Some(timestamp.to_rfc3339_opts(chrono::SecondsFormat::Millis, true))
     } else {
         None

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

···
         .last()
         .map(|(_, rkey)| {
             // Convert TID to timestamp for cursor
-            let dt = parakeet_db::tid_util::tid_to_datetime(*rkey);
+            let dt = parakeet_db::utils::tid::tid_to_datetime(*rkey);
             dt.to_rfc3339_opts(chrono::SecondsFormat::Millis, true)
         });
 
···
     for (post_actor_id, post_rkey) in &results {
         let post_did = state.profile_entity.get_did_by_id(*post_actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", post_actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(*post_rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(*post_rkey);
         let uri = format!("at://{}/app.bsky.feed.post/{}", post_did, rkey_str);
         post_uris.push(uri);
     }
···
         .map_err(|_| Error::not_found())?;
 
     // Decode TID
-    let post_rkey = parakeet_db::tid_util::decode_tid(post_rkey_str)
+    let post_rkey = parakeet_db::utils::tid::decode_tid(post_rkey_str)
         .map_err(|_| Error::invalid_request(Some("Invalid TID".to_string())))?;
 
     // Parse cursor as timestamp

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

···
         .map_err(|_| crate::common::errors::Error::not_found())?;
 
     // Decode rkey
-    let embed_rkey = parakeet_db::tid_util::decode_tid(embed_rkey_str)
+    let embed_rkey = parakeet_db::utils::tid::decode_tid(embed_rkey_str)
         .map_err(|_| crate::common::errors::Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
     // Parse cursor
···
         let uri = format!(
             "at://{}/app.bsky.feed.post/{}",
             author_did,
-            parakeet_db::tid_util::encode_tid(*rkey)
+            parakeet_db::utils::tid::encode_tid(*rkey)
         );
 
         // Get post view
···
         .map_err(|_| crate::common::errors::Error::not_found())?;
 
     // Decode rkey
-    let post_rkey = parakeet_db::tid_util::decode_tid(post_rkey_str)
+    let post_rkey = parakeet_db::utils::tid::decode_tid(post_rkey_str)
         .map_err(|_| crate::common::errors::Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
     // Parse cursor

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

···
     let anchor_actor_id = state.profile_entity.resolve_identifier(anchor_did).await
         .map_err(|_| Error::actor_not_found(anchor_did))?;
 
-    let anchor_rkey = parakeet_db::tid_util::decode_tid(anchor_rkey_base32)
+    let anchor_rkey = parakeet_db::utils::tid::decode_tid(anchor_rkey_base32)
         .map_err(|_| Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
     // Get root info for parent query filtering
···
             let root_actor_id = state.profile_entity.resolve_identifier(root_did).await
                 .map_err(|_| Error::actor_not_found(root_did))?;
 
-            let root_rkey = parakeet_db::tid_util::decode_tid(root_rkey_base32).ok();
+            let root_rkey = parakeet_db::utils::tid::decode_tid(root_rkey_base32).ok();
             root_rkey.map(|rkey| (root_actor_id, rkey))
         } else {
             None
···
     for item in &parents {
         let did = state.profile_entity.get_did_by_id(item.actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", item.actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(item.rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(item.rkey);
         all_uris.push(format!("at://{}/app.bsky.feed.post/{}", did, rkey_str));
     }
 
···
     for item in &children {
         let did = state.profile_entity.get_did_by_id(item.actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", item.actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(item.rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(item.rkey);
         all_uris.push(format!("at://{}/app.bsky.feed.post/{}", did, rkey_str));
     }
 

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

···
     for (actor_id, rkey) in &results {
         let did = state.profile_entity.get_did_by_id(*actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(*rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(*rkey);
         post_uris.push(format!("at://{}/app.bsky.feed.post/{}", did, rkey_str));
     }
 
···
     for (actor_id, rkey) in results {
         let author_did = state.profile_entity.get_did_by_id(actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(rkey);
         let uri = format!("at://{}/app.bsky.feed.post/{}", author_did, rkey_str);
         posts.push(uri);
     }

parakeet/src/xrpc/app_bsky/graph/lists.rs

···
         .ok_or_else(|| Error::not_found())?;
 
     // Parse the list URI to get actor_id and rkey for querying items
-    let (did, _collection, rkey_str) = parakeet_db::at_uri_util::parse_at_uri(&query.list)
+    let (did, _collection, rkey_str) = parakeet_db::utils::at_uri::parse_at_uri(&query.list)
         .ok_or_else(|| Error::not_found())?;
 
     // Resolve DID to actor_id
···
             let item_uri = format!(
                 "at://{}/app.bsky.graph.listitem/{}",
                 item_did,
-                parakeet_db::tid_util::encode_tid(rkey)
+                parakeet_db::utils::tid::encode_tid(rkey)
             );
 
             Some(ListItemView {

parakeet/src/xrpc/app_bsky/graph/relations.rs

···
 
     // Build cursor from last result
     let cursor = blocks.last().and_then(|b| {
-        let dt = parakeet_db::tid_util::tid_to_datetime(b.rkey);
+        let dt = parakeet_db::utils::tid::tid_to_datetime(b.rkey);
         Some(dt.timestamp_millis().to_string())
     });
 
···
     if let Some(cursor_ts) = cursor_value {
         followers.retain(|f| {
             // f.rkey is a TID that needs conversion
-            let dt = parakeet_db::tid_util::tid_to_datetime(f.rkey);
+            let dt = parakeet_db::utils::tid::tid_to_datetime(f.rkey);
             dt < cursor_ts
         });
     }
···
     let cursor = if has_next {
         followers.last().map(|f| {
             // Convert TID to timestamp for cursor
-            let dt = parakeet_db::tid_util::tid_to_datetime(f.rkey);
+            let dt = parakeet_db::utils::tid::tid_to_datetime(f.rkey);
             dt.timestamp_millis().to_string()
         })
     } else {
···
 
     // Build cursor from last result
     let cursor = results.last().map(|f| {
-        let dt = parakeet_db::tid_util::tid_to_datetime(f.rkey);
+        let dt = parakeet_db::utils::tid::tid_to_datetime(f.rkey);
         dt.timestamp_millis().to_string()
     });
 

parakeet/src/xrpc/app_bsky/graph/starter_packs.rs

···
     let uris: Vec<String> = results
         .iter()
         .map(|r| {
-            let rkey_str = parakeet_db::tid_util::encode_tid(r.2);
+            let rkey_str = parakeet_db::utils::tid::encode_tid(r.2);
             format!("at://{}/app.bsky.graph.starterpack/{}", actor_did, rkey_str)
         })
         .collect();

parakeet/src/xrpc/app_bsky/graph/thread_mutes.rs

···
     let (root_did, _collection, rkey_str) = (parts[0], parts[1], parts[2]);
 
     // Get root post's actor_id and rkey (natural keys)
-    let rkey_bigint = parakeet_db::tid_util::decode_tid(rkey_str)
+    let rkey_bigint = parakeet_db::utils::tid::decode_tid(rkey_str)
         .map_err(|_| Error::invalid_request(Some("Invalid TID in root URI".into())))?;
 
     let root_post_actor_id = state.profile_entity.resolve_identifier(root_did).await
···
     let (root_did, _collection, rkey_str) = (parts[0], parts[1], parts[2]);
 
     // Get root post's actor_id and rkey (natural keys)
-    let rkey_bigint = parakeet_db::tid_util::decode_tid(rkey_str)
+    let rkey_bigint = parakeet_db::utils::tid::decode_tid(rkey_str)
         .map_err(|_| Error::invalid_request(Some("Invalid TID in root URI".into())))?;
 
     let root_post_actor_id = state.profile_entity.resolve_identifier(root_did).await

parakeet/src/xrpc/app_bsky/notification.rs

···
             uri: jacquard_common::types::string::AtUri::new(&uri).unwrap().into_static(),
             // Use the real CID from database (already stored for all record types)
             cid: jacquard_common::types::string::Cid::new(
-                parakeet_db::cid_util::digest_to_record_cid_string(&notif.record_cid)
+                parakeet_db::utils::cid::digest_to_record_cid_string(&notif.record_cid)
                     .unwrap_or_else(|| String::from("bafyrei_invalid_cid"))
                     .as_bytes()
             ).unwrap().into_static(),
···
     use parakeet_db::types::NotificationRecordType;
 
     // Calculate created_at from record rkey for all record types
-    let created_at = parakeet_db::tid_util::tid_to_datetime(notif.record_rkey);
+    let created_at = parakeet_db::utils::tid::tid_to_datetime(notif.record_rkey);
 
     match notif.record_type {
         NotificationRecordType::Like => {
             // Construct subject URI from notification's subject fields
             if let (Some(subject_actor_id), Some(subject_rkey)) = (notif.subject_actor_id, notif.subject_rkey) {
                 if let Some(subject_did) = actor_did_map.get(&subject_actor_id) {
-                    let encoded_rkey = parakeet_db::tid_util::encode_tid(subject_rkey);
+                    let encoded_rkey = parakeet_db::utils::tid::encode_tid(subject_rkey);
                     let subject_uri = format!("at://{}/app.bsky.feed.post/{}", subject_did, encoded_rkey);
 
                     return serde_json::json!({
···
             // Construct subject post URI from notification's subject fields
             if let (Some(subject_actor_id), Some(subject_rkey)) = (notif.subject_actor_id, notif.subject_rkey) {
                 if let Some(subject_did) = actor_did_map.get(&subject_actor_id) {
-                    let encoded_rkey = parakeet_db::tid_util::encode_tid(subject_rkey);
+                    let encoded_rkey = parakeet_db::utils::tid::encode_tid(subject_rkey);
                     let post_uri = format!("at://{}/app.bsky.feed.post/{}", subject_did, encoded_rkey);
 
                     return serde_json::json!({
···
                 let parent_uri = match (parent_actor_id, parent_rkey) {
                     (Some(actor_id), Some(rkey)) => {
                         actor_did_map.get(actor_id).map(|did| {
-                            let encoded_rkey = parakeet_db::tid_util::encode_tid(*rkey);
+                            let encoded_rkey = parakeet_db::utils::tid::encode_tid(*rkey);
                             format!("at://{}/app.bsky.feed.post/{}", did, encoded_rkey)
                         })
                     }
···
                 let root_uri = match (root_actor_id, root_rkey) {
                     (Some(actor_id), Some(rkey)) => {
                         actor_did_map.get(actor_id).map(|did| {
-                            let encoded_rkey = parakeet_db::tid_util::encode_tid(*rkey);
+                            let encoded_rkey = parakeet_db::utils::tid::encode_tid(*rkey);
                             format!("at://{}/app.bsky.feed.post/{}", did, encoded_rkey)
                         })
                     }

parakeet/src/xrpc/app_bsky/unspecced/handlers.rs

···
 use jacquard_api::app_bsky::feed::GeneratorView;
 use jacquard_api::app_bsky::graph::StarterPackViewBasic;
 use jacquard_common::IntoStatic;
-use parakeet_db::models::ProfileStats;
+use parakeet_db::domain::ProfileStats;
 use serde::{Deserialize, Serialize};
 
 // ======== getTrendingTopics ========

parakeet/src/xrpc/app_bsky/unspecced/thread_v2/other_replies.rs

···
     // Get actor_id from cache (should be cached after hydrate_post)
     let cached_actor = state.id_cache.get_actor_id(anchor_did).await
         .ok_or_else(|| Error::server_error(Some("Actor not in cache")))?;
-    let anchor_rkey = parakeet_db::tid_util::decode_tid(anchor_rkey_base32)
+    let anchor_rkey = parakeet_db::utils::tid::decode_tid(anchor_rkey_base32)
         .map_err(|_| Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
     // Get additional replies that weren't included in the main thread view
···
     for item in &replies {
         let did = state.profile_entity.get_did_by_id(item.actor_id).await
             .unwrap_or_else(|_| format!("did:plc:unknown{}", item.actor_id));
-        let rkey_str = parakeet_db::tid_util::encode_tid(item.rkey);
+        let rkey_str = parakeet_db::utils::tid::encode_tid(item.rkey);
         reply_uris.push(format!("at://{}/app.bsky.feed.post/{}", did, rkey_str));
     }
     let replies_hydrated = std::collections::HashMap::new(); // TODO: Fix hydration
···
                 // Build parent URI
                 let parent_did = state.profile_entity.get_did_by_id(parent_actor_id).await
                     .unwrap_or_else(|_| format!("did:plc:unknown{}", parent_actor_id));
-                let parent_rkey_str = parakeet_db::tid_util::encode_tid(parent_rkey);
+                let parent_rkey_str = parakeet_db::utils::tid::encode_tid(parent_rkey);
                 let parent_uri = format!("at://{}/app.bsky.feed.post/{}", parent_did, parent_rkey_str);
 
                 // Build this post's URI
                 let did = state.profile_entity.get_did_by_id(reply.actor_id).await
                     .unwrap_or_else(|_| format!("did:plc:unknown{}", reply.actor_id));
-                let rkey_str = parakeet_db::tid_util::encode_tid(reply.rkey);
+                let rkey_str = parakeet_db::utils::tid::encode_tid(reply.rkey);
                 let at_uri = format!("at://{}/app.bsky.feed.post/{}", did, rkey_str);
 
                 replies_by_parent

parakeet/src/xrpc/app_bsky/unspecced/thread_v2/thread_builder.rs

···
             let cached_actor = self.id_cache.get_actor_id(anchor_did).await
                 .ok_or_else(|| crate::common::errors::Error::server_error(Some("Actor not in cache")))?;
 
-            let anchor_rkey = parakeet_db::tid_util::decode_tid(anchor_rkey_base32)
+            let anchor_rkey = parakeet_db::utils::tid::decode_tid(anchor_rkey_base32)
                 .map_err(|_| crate::common::errors::Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
             // Get root actor_id if we have a root URI
···
                     let root_rkey_base32 = root_parts[2];
                     let root_cached = self.id_cache.get_actor_id(root_did).await
                         .ok_or_else(|| crate::common::errors::Error::server_error(Some("Root actor not in cache")))?;
-                    let root_rkey = parakeet_db::tid_util::decode_tid(root_rkey_base32)
+                    let root_rkey = parakeet_db::utils::tid::decode_tid(root_rkey_base32)
                         .map_err(|_| crate::common::errors::Error::invalid_request(Some("Invalid root rkey".to_string())))?;
                     (root_cached.actor_id, root_rkey)
                 } else {
···
         for item in &parents {
             let did = self.profile_entity.get_did_by_id(item.actor_id).await
                 .unwrap_or_else(|_| format!("did:plc:unknown{}", item.actor_id));
-            let rkey_str = parakeet_db::tid_util::encode_tid(item.rkey);
+            let rkey_str = parakeet_db::utils::tid::encode_tid(item.rkey);
             let uri = format!("at://{}/app.bsky.feed.post/{}", did, rkey_str);
             parent_uris.push(uri.clone());
             parent_uri_by_index.push(uri);
···
             let cached_actor = self.id_cache.get_actor_id(anchor_did).await
                 .ok_or_else(|| crate::common::errors::Error::server_error(Some("Actor not in cache")))?;
 
-            let anchor_rkey = parakeet_db::tid_util::decode_tid(anchor_rkey_base32)
+            let anchor_rkey = parakeet_db::utils::tid::decode_tid(anchor_rkey_base32)
                 .map_err(|_| crate::common::errors::Error::invalid_request(Some("Invalid rkey".to_string())))?;
 
             self.post_entity.get_thread_children_by_arrays(
···
         for item in &replies {
             let did = self.profile_entity.get_did_by_id(item.actor_id).await
                 .unwrap_or_else(|_| format!("did:plc:unknown{}", item.actor_id));
-            let rkey_str = parakeet_db::tid_util::encode_tid(item.rkey);
+            let rkey_str = parakeet_db::utils::tid::encode_tid(item.rkey);
             let uri = format!("at://{}/app.bsky.feed.post/{}", did, rkey_str);
             reply_uris.push(uri.clone());
             reply_uri_map.insert((item.actor_id, item.rkey), uri);
···
                     // Build parent URI
                     let parent_did = self.profile_entity.get_did_by_id(parent_actor_id).await
                         .unwrap_or_else(|_| format!("did:plc:unknown{}", parent_actor_id));
-                    let parent_rkey_str = parakeet_db::tid_util::encode_tid(parent_rkey);
+                    let parent_rkey_str = parakeet_db::utils::tid::encode_tid(parent_rkey);
                     let parent_uri = format!("at://{}/app.bsky.feed.post/{}", parent_did, parent_rkey_str);
 
                     let child_uri = reply_uri_map.get(&(reply.actor_id, reply.rkey))

parakeet/src/xrpc/com_atproto/repo.rs

···
             }
 
             // Decode base32 TID to bigint
-            let rkey_bigint = parakeet_db::tid_util::decode_tid(&query.rkey)
+            let rkey_bigint = parakeet_db::utils::tid::decode_tid(&query.rkey)
                 .map_err(|_| Error::invalid_request(Some("Invalid rkey format".to_string())))?;
 
             let result: FeedGenRecord = diesel_async::RunQueryDsl::get_result(
···
             )
             .await?;
 
-            let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&result.cid)
+            let cid_str = parakeet_db::utils::cid::digest_to_record_cid_string(&result.cid)
                 .unwrap_or_else(|| String::from("bafyrei_invalid_cid"));
 
             (
···
         }
         "app.bsky.feed.post" => {
             // Decode base32 TID to bigint
-            let rkey_bigint = parakeet_db::tid_util::decode_tid(&query.rkey)
+            let rkey_bigint = parakeet_db::utils::tid::decode_tid(&query.rkey)
                 .map_err(|_| Error::invalid_request(Some("Invalid rkey format".to_string())))?;
 
             // Use raw SQL to get CID and record from posts table
···
             .await?;
 
             // Convert real CID from database to string
-            let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&result.cid)
+            let cid_str = parakeet_db::utils::cid::digest_to_record_cid_string(&result.cid)
                 .unwrap_or_else(|| String::from("bafyrei_invalid_cid"));
 
             (cid_str, result.record)
···
             }
 
             // Decode base32 TID to bigint
-            let rkey_bigint = parakeet_db::tid_util::decode_tid(&query.rkey)
+            let rkey_bigint = parakeet_db::utils::tid::decode_tid(&query.rkey)
                 .map_err(|_| Error::invalid_request(Some("Invalid rkey format".to_string())))?;
 
             let result: StarterPackRecord = diesel_async::RunQueryDsl::get_result(
···
             )
             .await?;
 
-            let cid_str = parakeet_db::cid_util::digest_to_record_cid_string(&result.cid)
+            let cid_str = parakeet_db::utils::cid::digest_to_record_cid_string(&result.cid)
                 .unwrap_or_else(|| String::from("bafyrei_invalid_cid"));
 
             (cid_str, result.record)

parakeet/src/xrpc/community_lexicon/bookmarks.rs

···
 
     impl BookmarkRecord {
         fn created_at(&self) -> chrono::DateTime<chrono::Utc> {
-            parakeet_db::tid_util::tid_to_datetime(self.rkey)
+            parakeet_db::utils::tid::tid_to_datetime(self.rkey)
         }
     }