cargo fix

src/actor_store/blob/reader.rs

···
 use crate::config::BlobConfig;
 
 /// Reader for blob data in the actor store.
-pub struct BlobReader {
+pub(super) struct BlobReader {
     /// Database connection.
     pub db: SqlitePool,
     /// Configuration for blob storage.
···
 
 impl BlobReader {
     /// Create a new blob reader.
-    pub fn new(db: SqlitePool, config: BlobConfig, did: String) -> Self {
+    pub(super) fn new(db: SqlitePool, config: BlobConfig, did: String) -> Self {
         Self { db, config, did }
     }
 
     /// Get metadata for a blob.
-    pub async fn get_blob_metadata(&self, cid: &Cid) -> Result<Option<BlobMetadata>> {
+    pub(super) async fn get_blob_metadata(&self, cid: &Cid) -> Result<Option<BlobMetadata>> {
         let cid_str = cid.to_string();
         let result = sqlx::query!(
             r#"SELECT size, mimeType, takedownRef FROM blob WHERE cid = ?"#,
···
     }
 
     /// Get a blob's full data and metadata.
-    pub async fn get_blob(&self, cid: &Cid) -> Result<Option<BlobData>> {
+    pub(super) async fn get_blob(&self, cid: &Cid) -> Result<Option<BlobData>> {
         // First check the metadata
         let metadata = match self.get_blob_metadata(cid).await? {
             Some(meta) => meta,
···
     }
 
     /// List blobs for a repository.
-    pub async fn list_blobs(&self, opts: ListBlobsOptions) -> Result<Vec<String>> {
+    pub(super) async fn list_blobs(&self, opts: ListBlobsOptions) -> Result<Vec<String>> {
         let mut query = sqlx::QueryBuilder::new("SELECT cid FROM blob");
 
         // Add filters for since revision
···
     }
 
     /// Get takedown status for a blob.
-    pub async fn get_blob_takedown_status(&self, cid: &Cid) -> Result<Option<String>> {
+    pub(super) async fn get_blob_takedown_status(&self, cid: &Cid) -> Result<Option<String>> {
         let cid_str = cid.to_string();
         let result = sqlx::query!(r#"SELECT takedownRef FROM blob WHERE cid = ?"#, cid_str)
             .fetch_optional(&self.db)
···
     }
 
     /// Get records that reference a blob.
-    pub async fn get_records_for_blob(&self, cid: &Cid) -> Result<Vec<String>> {
+    pub(super) async fn get_records_for_blob(&self, cid: &Cid) -> Result<Vec<String>> {
         let cid_str = cid.to_string();
         let records = sqlx::query!(
             r#"SELECT recordUri FROM record_blob WHERE blobCid = ?"#,
···
     }
 
     /// Get blobs referenced by a record.
-    pub async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
+    pub(super) async fn get_blobs_for_record(&self, record_uri: &str) -> Result<Vec<String>> {
         let blobs = sqlx::query!(
             r#"SELECT blobCid FROM record_blob WHERE recordUri = ?"#,
             record_uri
···
     }
 
     /// Count total blobs.
-    pub async fn blob_count(&self) -> Result<i64> {
+    pub(super) async fn blob_count(&self) -> Result<i64> {
         let result = sqlx::query!(r#"SELECT COUNT(*) as count FROM blob"#)
             .fetch_one(&self.db)
             .await
···
     }
 
     /// Count distinct blobs referenced by records.
-    pub async fn record_blob_count(&self) -> Result<i64> {
+    pub(super) async fn record_blob_count(&self) -> Result<i64> {
         let result = sqlx::query!(r#"SELECT COUNT(DISTINCT blobCid) as count FROM record_blob"#)
             .fetch_one(&self.db)
             .await
···
     }
 
     /// List blobs that are referenced but missing from storage.
-    pub async fn list_missing_blobs(
+    pub(super) async fn list_missing_blobs(
         &self,
         opts: ListMissingBlobsOptions,
     ) -> Result<Vec<MissingBlob>> {
···
     }
 
     /// Register a new blob in the database (without file storage)
-    pub async fn register_blob(&self, cid: String, mime_type: String, size: i64) -> Result<()> {
+    pub(super) async fn register_blob(&self, cid: String, mime_type: String, size: i64) -> Result<()> {
         let now = chrono::Utc::now().to_rfc3339();
         sqlx::query!(
             r#"
···
 
 /// Metadata about a blob.
 #[derive(Debug, Clone)]
-pub struct BlobMetadata {
+pub(super) struct BlobMetadata {
     /// The CID of the blob.
     pub cid: Cid,
     /// The size of the blob in bytes.
···
 
 /// Complete blob data with content.
 #[derive(Debug)]
-pub struct BlobData {
+pub(super) struct BlobData {
     /// Metadata about the blob.
     pub metadata: BlobMetadata,
     /// The actual content of the blob, if available.
···
 
 /// Options for listing blobs.
 #[derive(Debug, Clone)]
-pub struct ListBlobsOptions {
+pub(super) struct ListBlobsOptions {
     /// Optional revision to list blobs since.
     pub since: Option<String>,
     /// Optional cursor for pagination.
···
 
 /// Options for listing missing blobs.
 #[derive(Debug, Clone)]
-pub struct ListMissingBlobsOptions {
+pub(super) struct ListMissingBlobsOptions {
     /// Optional cursor for pagination.
     pub cursor: Option<String>,
     /// Maximum number of missing blobs to return.
···
 
 /// Information about a missing blob.
 #[derive(Debug, Clone)]
-pub struct MissingBlob {
+pub(super) struct MissingBlob {
     /// CID of the missing blob.
     pub cid: String,
     /// URI of the record referencing the missing blob.

src/actor_store/blob/transactor.rs

···
 
 /// Blob metadata for a newly uploaded blob.
 #[derive(Debug, Clone)]
-pub struct BlobMetadata {
+pub(super) struct BlobMetadata {
     /// Temporary key for the blob during upload.
     pub temp_key: String,
     /// Size of the blob in bytes.
···
 }
 
 /// Transactor for blob operations.
-pub struct BlobTransactor {
+pub(super) struct BlobTransactor {
     /// The blob reader.
     pub reader: BlobReader,
     /// The blob storage directory.
···
 
 impl BlobTransactor {
     /// Create a new blob transactor.
-    pub fn new(db: SqlitePool, config: BlobConfig, did: String) -> Self {
+    pub(super) fn new(db: SqlitePool, config: BlobConfig, did: String) -> Self {
         Self {
             reader: BlobReader::new(db, config.clone(), did),
             blobs_dir: config.path.clone(),
···
     }
 
     /// Register blob associations with records.
-    pub async fn insert_blobs(&self, record_uri: &str, blobs: &[Blob]) -> Result<()> {
+    pub(super) async fn insert_blobs(&self, record_uri: &str, blobs: &[Blob]) -> Result<()> {
         if blobs.is_empty() {
             return Ok(());
         }
···
     }
 
     /// Upload a blob and get its metadata.
-    pub async fn upload_blob_and_get_metadata(
+    pub(super) async fn upload_blob_and_get_metadata(
         &self,
         mime_type: &str,
         data: &[u8],
···
     }
 
     /// Track a new blob that's not yet associated with a record.
-    pub async fn track_untethered_blob(&self, metadata: &BlobMetadata) -> Result<Blob> {
+    pub(super) async fn track_untethered_blob(&self, metadata: &BlobMetadata) -> Result<Blob> {
         let cid_str = metadata.cid.to_string();
 
         // Check if blob exists and is taken down
···
     }
 
     /// Process blobs for a repository write operation.
-    pub async fn process_write_blobs(
+    pub(super) async fn process_write_blobs(
         &self,
         _rev: &str,
         blobs: &[Blob],
···
     }
 
     /// Delete blobs that are no longer referenced by any record.
-    pub async fn delete_dereferenced_blobs(&self, updated_uris: &[String]) -> Result<()> {
+    pub(super) async fn delete_dereferenced_blobs(&self, updated_uris: &[String]) -> Result<()> {
         if updated_uris.is_empty() {
             return Ok(());
         }
···
     }
 
     /// Verify a blob's integrity and move it from temporary to permanent storage.
-    pub async fn verify_blob_and_make_permanent(&self, blob: &Blob) -> Result<()> {
+    pub(super) async fn verify_blob_and_make_permanent(&self, blob: &Blob) -> Result<()> {
         let cid_str = blob.r#ref.0.to_string();
 
         // Get blob from database
···
     }
 
     /// Register a blob in the database
-    pub async fn register_blob(&self, cid: String, mime_type: String, size: u64) -> Result<()> {
+    pub(super) async fn register_blob(&self, cid: String, mime_type: String, size: u64) -> Result<()> {
         self.reader.register_blob(cid, mime_type, size as i64).await
     }
 
     /// Associate a blob with a record
-    pub async fn associate_blob(&self, cid: &str, record_uri: &str) -> Result<()> {
+    pub(super) async fn associate_blob(&self, cid: &str, record_uri: &str) -> Result<()> {
         sqlx::query!(
             r#"
             INSERT INTO record_blob (blobCid, recordUri)

src/actor_store/db/migrations.rs

···
 //! Database migrations for the actor store.
-use anyhow::{Context as _, Result};
+use anyhow::Result;
 
 use crate::actor_store::db::ActorDb;
 

src/actor_store/db/mod.rs

···
 }
 
 // Re-export commonly used types
-pub(crate) use schema::{AccountPref, Backlink, Blob, Record, RecordBlob, RepoBlock, RepoRoot};

src/actor_store/mod.rs

···
 use std::sync::Arc;
 
 use anyhow::{Context as _, Result};
-use atrium_crypto::keypair::{Did as _, Export as _, Secp256k1Keypair};
+use atrium_crypto::keypair::{Export as _, Secp256k1Keypair};
 use sqlx::SqlitePool;
 
 use crate::config::RepoConfig;
···
             .context("failed to create SQLite database")?;
 
         // Create database schema
-        self::db::create_tables(&db).await?;
+        db::create_tables(&db).await?;
 
         Ok(())
     }