documentation: updating project readme files

CLAUDE.md

···
 ## Overview
 QuickDID is a high-performance AT Protocol identity resolution service written in Rust. It provides handle-to-DID resolution with Redis-backed caching and queue processing.
 
+## Configuration
+
+QuickDID follows the 12-factor app methodology and uses environment variables exclusively for configuration. There are no command-line arguments except for `--version` and `--help`.
+
+Configuration is validated at startup, and the service will exit with specific error codes if validation fails:
+- `error-quickdid-config-1`: Missing required environment variable
+- `error-quickdid-config-2`: Invalid configuration value  
+- `error-quickdid-config-3`: Invalid TTL value (must be positive)
+- `error-quickdid-config-4`: Invalid timeout value (must be positive)
+
 ## Common Commands
 
 ### Building and Running
···
 # Build the project
 cargo build
 
-# Run in debug mode
-cargo run
+# Run in debug mode (requires environment variables)
+HTTP_EXTERNAL=localhost:3007 SERVICE_KEY=did:key:z42tmZxD2mi1TfMKSFrsRfednwdaaPNZiiWHP4MPgcvXkDWK cargo run
 
 # Run tests
 cargo test
···
 # Type checking
 cargo check
 
-# Run with environment variables
-HTTP_EXTERNAL=localhost:3007 SERVICE_KEY=did:key:z42tmZxD2mi1TfMKSFrsRfednwdaaPNZiiWHP4MPgcvXkDWK cargo run
+# Linting
+cargo clippy
+
+# Show version
+cargo run -- --version
+
+# Show help
+cargo run -- --help
 ```
 
 ### Development with VS Code
···
 
 ### Core Components
 
-1. **Handle Resolution** (`src/handle_resolver.rs`)
+1. **Handle Resolution** (`src/handle_resolver/`)
    - `BaseHandleResolver`: Core resolution using DNS and HTTP
-   - `RateLimitedHandleResolver`: Semaphore-based rate limiting for concurrent resolutions
+   - `RateLimitedHandleResolver`: Semaphore-based rate limiting with optional timeout
    - `CachingHandleResolver`: In-memory caching layer
-   - `RedisHandleResolver`: Redis-backed persistent caching with 90-day TTL
+   - `RedisHandleResolver`: Redis-backed persistent caching
    - `SqliteHandleResolver`: SQLite-backed persistent caching
    - Uses binary serialization via `HandleResolutionResult` for space efficiency
+   - Resolution stack: Cache → RateLimited (optional) → Base → DNS/HTTP
 
 2. **Binary Serialization** (`src/handle_resolution_result.rs`)
    - Compact storage format using bincode
    - Strips DID prefixes for did:web and did:plc methods
    - Stores: timestamp (u64), method type (i16), payload (String)
 
-3. **Queue System** (`src/queue_adapter.rs`)
-   - Supports MPSC (in-process) and Redis adapters
+3. **Queue System** (`src/queue/`)
+   - Supports MPSC (in-process), Redis, SQLite, and no-op adapters
    - `HandleResolutionWork` items processed asynchronously
    - Redis uses reliable queue pattern (LPUSH/RPOPLPUSH/LREM)
+   - SQLite provides persistent queue with work shedding capabilities
 
 4. **HTTP Server** (`src/http/`)
    - XRPC endpoints for AT Protocol compatibility
···
 
 ### Handle Resolution Flow
 1. Check cache (Redis/SQLite/in-memory based on configuration)
-2. If not cached, acquire rate limit permit (if rate limiting enabled)
+2. If cache miss and rate limiting enabled:
+   - Acquire semaphore permit (with optional timeout)
+   - If timeout configured and exceeded, return error
 3. Perform DNS TXT lookup or HTTP well-known query
 4. Cache result with appropriate TTL
 5. Return DID or error
···
 - `HTTP_PORT`: Server port (default: 8080)
 - `PLC_HOSTNAME`: PLC directory hostname (default: plc.directory)
 - `REDIS_URL`: Redis connection URL for caching
-- `QUEUE_ADAPTER`: Queue type - 'mpsc', 'redis', 'sqlite', or 'noop' (default: mpsc)
+- `SQLITE_URL`: SQLite database URL for caching (e.g., `sqlite:./quickdid.db`)
+- `QUEUE_ADAPTER`: Queue type - 'mpsc', 'redis', 'sqlite', 'noop', or 'none' (default: mpsc)
 - `QUEUE_REDIS_PREFIX`: Redis key prefix for queues (default: queue:handleresolver:)
-- `QUEUE_WORKER_ID`: Worker ID for Redis queue (default: worker1)
+- `QUEUE_WORKER_ID`: Worker ID for queue operations (default: worker1)
+- `QUEUE_BUFFER_SIZE`: Buffer size for MPSC queue (default: 1000)
+- `QUEUE_SQLITE_MAX_SIZE`: Max queue size for SQLite work shedding (default: 10000)
+- `CACHE_TTL_MEMORY`: TTL for in-memory cache in seconds (default: 600)
+- `CACHE_TTL_REDIS`: TTL for Redis cache in seconds (default: 7776000)
+- `CACHE_TTL_SQLITE`: TTL for SQLite cache in seconds (default: 7776000)
+- `QUEUE_REDIS_TIMEOUT`: Redis blocking timeout in seconds (default: 5)
 - `RESOLVER_MAX_CONCURRENT`: Maximum concurrent handle resolutions (default: 0 = disabled)
+- `RESOLVER_MAX_CONCURRENT_TIMEOUT_MS`: Timeout for acquiring rate limit permit in ms (default: 0 = no timeout)
 - `RUST_LOG`: Logging level (e.g., debug, info)
 
 ## Error Handling
···
 
     error-quickdid-<domain>-<number> <message>: <details>
 
-Example errors:
+Current error domains and examples:
 
-* error-quickdid-resolve-1 Multiple DIDs resolved for method
-* error-quickdid-plc-1 HTTP request failed: https://google.com/ Not Found
-* error-quickdid-key-1 Error decoding key: invalid
+* `config`: Configuration errors (e.g., error-quickdid-config-1 Missing required environment variable)
+* `resolve`: Handle resolution errors (e.g., error-quickdid-resolve-1 Failed to resolve subject)
+* `queue`: Queue operation errors (e.g., error-quickdid-queue-1 Failed to push to queue)
+* `cache`: Cache-related errors (e.g., error-quickdid-cache-1 Redis pool creation failed)
+* `result`: Serialization errors (e.g., error-quickdid-result-1 System time error)
+* `task`: Task processing errors (e.g., error-quickdid-task-1 Queue adapter health check failed)
 
 Errors should be represented as enums using the `thiserror` library.
 
···
 ## Development Patterns
 
 ### Error Handling
-- Uses `anyhow::Result` for error propagation
-- Graceful fallbacks when Redis is unavailable
+- Uses strongly-typed errors with `thiserror` for all modules
+- Each error has a unique identifier following the pattern `error-quickdid-<domain>-<number>`
+- Graceful fallbacks when Redis/SQLite is unavailable
 - Detailed tracing for debugging
+- Avoid using `anyhow!()` or `bail!()` macros - use proper error types instead
 
 ### Performance Optimizations
 - Binary serialization reduces storage by ~40%
···
 3. Add test cases for the new method type
 
 ### Modifying Cache TTL
-- For in-memory: Pass TTL to `CachingHandleResolver::new()`
-- For Redis: Modify `RedisHandleResolver::ttl_seconds()`
+- For in-memory: Set `CACHE_TTL_MEMORY` environment variable
+- For Redis: Set `CACHE_TTL_REDIS` environment variable
+- For SQLite: Set `CACHE_TTL_SQLITE` environment variable
 
 ### Debugging Resolution Issues
 1. Enable debug logging: `RUST_LOG=debug`
 2. Check Redis cache: `redis-cli GET "handle:<hash>"`
-3. Monitor queue processing in logs
-4. Verify DNS/HTTP connectivity to AT Protocol infrastructure
+3. Check SQLite cache: `sqlite3 quickdid.db "SELECT * FROM handle_resolution_cache;"`
+4. Monitor queue processing in logs
+5. Check rate limiting: Look for "Rate limit permit acquisition timed out" errors
+6. Verify DNS/HTTP connectivity to AT Protocol infrastructure
 
 ## Dependencies
 - `atproto-identity`: Core AT Protocol identity resolution

README.md

···
 # QuickDID
 
-QuickDID is a high-performance AT Protocol identity resolution service written in Rust. It provides blazing-fast handle-to-DID resolution with intelligent caching strategies, supporting both in-memory and Redis-backed persistent caching with binary serialization for optimal storage efficiency.
+QuickDID is a high-performance AT Protocol identity resolution service written in Rust. It provides blazing-fast handle-to-DID resolution with intelligent caching strategies, supporting in-memory, Redis-backed, and SQLite-backed persistent caching with binary serialization for optimal storage efficiency.
 
-Built with minimal dependencies and optimized for production use, QuickDID delivers exceptional performance while maintaining a lean footprint.
+Built following the 12-factor app methodology with minimal dependencies and optimized for production use, QuickDID delivers exceptional performance while maintaining a lean footprint. Configuration is handled exclusively through environment variables, with only `--version` and `--help` command-line arguments supported.
 
 ## ⚠️ Production Disclaimer
 
 **This project is a release candidate and has not been fully vetted for production use.** While it includes comprehensive error handling and has been designed with production features in mind, more thorough testing is necessary before deploying in critical environments. Use at your own risk and conduct appropriate testing for your use case.
 
+## Performance
+
+QuickDID is designed for high throughput and low latency:
+
+- **Binary serialization** reduces cache storage by ~40% compared to JSON
+- **Rate limiting** protects upstream services from being overwhelmed
+- **Work shedding** in SQLite queue adapter prevents unbounded growth
+- **Configurable TTLs** allow fine-tuning cache freshness vs. performance
+- **Connection pooling** for Redis minimizes connection overhead
+
 ## Features
 
 - **Fast Handle Resolution**: Resolves AT Protocol handles to DIDs using DNS TXT records and HTTP well-known endpoints
-- **Multi-Layer Caching**: In-memory caching with configurable TTL and Redis-backed persistent caching (90-day TTL)
+- **Multi-Layer Caching**: Flexible caching with three tiers:
+  - In-memory caching with configurable TTL (default: 600 seconds)
+  - Redis-backed persistent caching (default: 90-day TTL)
+  - SQLite-backed persistent caching (default: 90-day TTL)
+- **Rate Limiting**: Semaphore-based concurrency control with optional timeout to protect upstream services
 - **Binary Serialization**: Compact storage format reduces cache size by ~40% compared to JSON
-- **Queue Processing**: Asynchronous handle resolution with support for MPSC, Redis, and no-op queue adapters
+- **Queue Processing**: Asynchronous handle resolution with multiple adapters:
+  - MPSC (in-memory, default)
+  - Redis (distributed)
+  - SQLite (persistent with work shedding)
+  - No-op (testing)
 - **AT Protocol Compatible**: Implements XRPC endpoints for seamless integration with AT Protocol infrastructure
-- **Comprehensive Error Handling**: Includes health checks and graceful shutdown support
+- **Comprehensive Error Handling**: Structured errors with unique identifiers (e.g., `error-quickdid-config-1`), health checks, and graceful shutdown
+- **12-Factor App**: Environment-based configuration following cloud-native best practices
 - **Minimal Dependencies**: Optimized dependency tree for faster compilation and reduced attack surface
-- **Predictable Worker IDs**: Simple default worker identification for distributed deployments
 
 ## Building
 
···
 
 - Rust 1.70 or later
 - Redis (optional, for persistent caching and distributed queuing)
+- SQLite 3.35+ (optional, for single-instance persistent caching)
 
 ### Build Commands
 
···
 
 ## Minimum Configuration
 
-QuickDID requires the following environment variables to run:
+QuickDID requires the following environment variables to run. Configuration is validated at startup, and the service will exit with specific error codes if validation fails.
 
 ### Required
 
···
 
 This will start QuickDID with:
 - HTTP server on port 8080 (default)
-- In-memory caching only (300-second TTL)
+- In-memory caching only (600-second TTL default)
 - MPSC queue adapter for async processing
 - Default worker ID: "worker1"
 - Connection to plc.directory for DID resolution
+- Rate limiting disabled (default)
 
 ### Optional Configuration
 
 For production deployments, consider these additional environment variables:
 
+#### Network & Service
 - `HTTP_PORT`: Server port (default: 8080)
-- `REDIS_URL`: Redis connection URL for persistent caching (e.g., `redis://localhost:6379`)
-- `QUEUE_ADAPTER`: Queue type - 'mpsc', 'redis', or 'noop' (default: mpsc)
-- `QUEUE_WORKER_ID`: Worker identifier for distributed queue processing (default: worker1)
 - `PLC_HOSTNAME`: PLC directory hostname (default: plc.directory)
+- `USER_AGENT`: HTTP User-Agent for outgoing requests
+- `DNS_NAMESERVERS`: Custom DNS servers (comma-separated)
+
+#### Caching
+- `REDIS_URL`: Redis connection URL (e.g., `redis://localhost:6379`)
+- `SQLITE_URL`: SQLite database URL (e.g., `sqlite:./quickdid.db`)
+- `CACHE_TTL_MEMORY`: In-memory cache TTL in seconds (default: 600)
+- `CACHE_TTL_REDIS`: Redis cache TTL in seconds (default: 7776000 = 90 days)
+- `CACHE_TTL_SQLITE`: SQLite cache TTL in seconds (default: 7776000 = 90 days)
+
+#### Queue Processing
+- `QUEUE_ADAPTER`: Queue type - 'mpsc', 'redis', 'sqlite', 'noop', or 'none' (default: mpsc)
+- `QUEUE_WORKER_ID`: Worker identifier (default: worker1)
+- `QUEUE_BUFFER_SIZE`: MPSC queue buffer size (default: 1000)
+- `QUEUE_REDIS_PREFIX`: Redis key prefix for queues (default: queue:handleresolver:)
+- `QUEUE_REDIS_TIMEOUT`: Redis blocking timeout in seconds (default: 5)
+- `QUEUE_SQLITE_MAX_SIZE`: Max SQLite queue size for work shedding (default: 10000)
+
+#### Rate Limiting
+- `RESOLVER_MAX_CONCURRENT`: Maximum concurrent handle resolutions (default: 0 = disabled)
+- `RESOLVER_MAX_CONCURRENT_TIMEOUT_MS`: Timeout for acquiring rate limit permit in ms (default: 0 = no timeout)
+
+#### Logging
 - `RUST_LOG`: Logging level (e.g., debug, info, warn, error)
 
-### Production Example
+### Production Examples
 
+#### Redis-based (Multi-instance/HA)
 ```bash
 HTTP_EXTERNAL=quickdid.example.com \
 SERVICE_KEY=did:key:yourkeyhere \
 HTTP_PORT=3000 \
 REDIS_URL=redis://localhost:6379 \
+CACHE_TTL_REDIS=86400 \
 QUEUE_ADAPTER=redis \
 QUEUE_WORKER_ID=prod-worker-1 \
+RESOLVER_MAX_CONCURRENT=100 \
+RESOLVER_MAX_CONCURRENT_TIMEOUT_MS=5000 \
 RUST_LOG=info \
 ./target/release/quickdid
 ```
 
+#### SQLite-based (Single-instance)
+```bash
+HTTP_EXTERNAL=quickdid.example.com \
+SERVICE_KEY=did:key:yourkeyhere \
+HTTP_PORT=3000 \
+SQLITE_URL=sqlite:./quickdid.db \
+CACHE_TTL_SQLITE=86400 \
+QUEUE_ADAPTER=sqlite \
+QUEUE_SQLITE_MAX_SIZE=10000 \
+RESOLVER_MAX_CONCURRENT=50 \
+RUST_LOG=info \
+./target/release/quickdid
+```
+
+## Architecture
+
+QuickDID uses a layered architecture for optimal performance:
+
+```
+Request → Cache Layer → Rate Limiter → Base Resolver → DNS/HTTP
+           ↓               ↓                ↓
+        Memory/Redis/   Semaphore      AT Protocol
+          SQLite        (optional)     Infrastructure
+```
+
+### Cache Priority
+QuickDID checks caches in this order:
+1. Redis (if configured) - Best for distributed deployments
+2. SQLite (if configured) - Best for single-instance with persistence
+3. In-memory (fallback) - Always available
+
+### Deployment Strategies
+
+- **Single-instance**: Use SQLite for both caching and queuing
+- **Multi-instance/HA**: Use Redis for distributed caching and queuing
+- **Development**: Use in-memory caching with MPSC queuing
+
 ## API Endpoints
 
 - `GET /_health` - Health check endpoint
 - `GET /xrpc/com.atproto.identity.resolveHandle` - Resolve handle to DID
 - `GET /.well-known/atproto-did` - Serve DID document for the service
+
+## Docker Deployment
+
+QuickDID can be deployed using Docker. See the [production deployment guide](docs/production-deployment.md) for detailed Docker and Docker Compose configurations.
+
+### Quick Docker Setup
+
+```bash
+# Build the image
+docker build -t quickdid:latest .
+
+# Run with environment file
+docker run -d \
+  --name quickdid \
+  --env-file .env \
+  -p 8080:8080 \
+  quickdid:latest
+```
+
+## Documentation
+
+- [Configuration Reference](docs/configuration-reference.md) - Complete list of all configuration options
+- [Production Deployment Guide](docs/production-deployment.md) - Docker, monitoring, and production best practices
+- [Development Guide](CLAUDE.md) - Architecture details and development patterns
 
 ## License
 

src/bin/quickdid.rs

···
         create_base_resolver, create_caching_resolver, create_rate_limited_resolver_with_timeout,
         create_redis_resolver_with_ttl, create_sqlite_resolver_with_ttl,
     },
-    sqlite_schema::create_sqlite_pool,
     handle_resolver_task::{HandleResolverTaskConfig, create_handle_resolver_task_with_config},
     http::{AppContext, create_router},
     queue::{
         HandleResolutionWork, QueueAdapter, create_mpsc_queue_from_channel, create_noop_queue,
         create_redis_queue, create_sqlite_queue, create_sqlite_queue_with_max_size,
     },
+    sqlite_schema::create_sqlite_pool,
     task_manager::spawn_cancellable_task,
 };
 use serde_json::json;
···
 /// Simple command-line argument handling for --version and --help
 fn handle_simple_args() -> bool {
     let args: Vec<String> = std::env::args().collect();
-    
+
     if args.len() > 1 {
         match args[1].as_str() {
             "--version" | "-V" => {
···
                 println!();
                 println!("ENVIRONMENT VARIABLES:");
                 println!("    SERVICE_KEY         Private key for service identity (required)");
-                println!("    HTTP_EXTERNAL       External hostname for service endpoints (required)");
+                println!(
+                    "    HTTP_EXTERNAL       External hostname for service endpoints (required)"
+                );
                 println!("    HTTP_PORT           HTTP server port (default: 8080)");
                 println!("    PLC_HOSTNAME        PLC directory hostname (default: plc.directory)");
-                println!("    USER_AGENT          HTTP User-Agent header (auto-generated with version)");
+                println!(
+                    "    USER_AGENT          HTTP User-Agent header (auto-generated with version)"
+                );
                 println!("    DNS_NAMESERVERS     Custom DNS nameservers (comma-separated IPs)");
-                println!("    CERTIFICATE_BUNDLES Additional CA certificates (comma-separated paths)");
+                println!(
+                    "    CERTIFICATE_BUNDLES Additional CA certificates (comma-separated paths)"
+                );
                 println!();
                 println!("    CACHING:");
                 println!("    REDIS_URL           Redis URL for handle resolution caching");
-                println!("    SQLITE_URL          SQLite database URL for handle resolution caching");
-                println!("    CACHE_TTL_MEMORY    TTL for in-memory cache in seconds (default: 600)");
-                println!("    CACHE_TTL_REDIS     TTL for Redis cache in seconds (default: 7776000)");
-                println!("    CACHE_TTL_SQLITE    TTL for SQLite cache in seconds (default: 7776000)");
+                println!(
+                    "    SQLITE_URL          SQLite database URL for handle resolution caching"
+                );
+                println!(
+                    "    CACHE_TTL_MEMORY    TTL for in-memory cache in seconds (default: 600)"
+                );
+                println!(
+                    "    CACHE_TTL_REDIS     TTL for Redis cache in seconds (default: 7776000)"
+                );
+                println!(
+                    "    CACHE_TTL_SQLITE    TTL for SQLite cache in seconds (default: 7776000)"
+                );
                 println!();
                 println!("    QUEUE CONFIGURATION:");
-                println!("    QUEUE_ADAPTER       Queue adapter: 'mpsc', 'redis', 'sqlite', 'noop' (default: mpsc)");
+                println!(
+                    "    QUEUE_ADAPTER       Queue adapter: 'mpsc', 'redis', 'sqlite', 'noop' (default: mpsc)"
+                );
                 println!("    QUEUE_REDIS_URL     Redis URL for queue adapter");
-                println!("    QUEUE_REDIS_PREFIX  Redis key prefix for queues (default: queue:handleresolver:)");
+                println!(
+                    "    QUEUE_REDIS_PREFIX  Redis key prefix for queues (default: queue:handleresolver:)"
+                );
                 println!("    QUEUE_REDIS_TIMEOUT Queue blocking timeout in seconds (default: 5)");
                 println!("    QUEUE_WORKER_ID     Worker ID for Redis queue (default: worker1)");
                 println!("    QUEUE_BUFFER_SIZE   Buffer size for MPSC queue (default: 1000)");
                 println!("    QUEUE_SQLITE_MAX_SIZE Maximum SQLite queue size (default: 10000)");
                 println!();
                 println!("    RATE LIMITING:");
-                println!("    RESOLVER_MAX_CONCURRENT Maximum concurrent resolutions (default: 0 = disabled)");
-                println!("    RESOLVER_MAX_CONCURRENT_TIMEOUT_MS Timeout for acquiring permits in ms (default: 0 = no timeout)");
+                println!(
+                    "    RESOLVER_MAX_CONCURRENT Maximum concurrent resolutions (default: 0 = disabled)"
+                );
+                println!(
+                    "    RESOLVER_MAX_CONCURRENT_TIMEOUT_MS Timeout for acquiring permits in ms (default: 0 = no timeout)"
+                );
                 println!();
-                println!("For more information, visit: https://github.com/smokesignal.events/quickdid");
+                println!(
+                    "For more information, visit: https://github.com/smokesignal.events/quickdid"
+                );
                 return true;
             }
             _ => {}
         }
     }
-    
+
     false
 }
 
···
     let dns_resolver_arc = Arc::new(dns_resolver);
 
     // Create base handle resolver using factory function
-    let mut base_handle_resolver = create_base_resolver(dns_resolver_arc.clone(), http_client.clone());
+    let mut base_handle_resolver =
+        create_base_resolver(dns_resolver_arc.clone(), http_client.clone());
 
     // Apply rate limiting if configured
     if config.resolver_max_concurrent > 0 {
···
             timeout_info
         );
         base_handle_resolver = create_rate_limited_resolver_with_timeout(
-            base_handle_resolver, 
+            base_handle_resolver,
             config.resolver_max_concurrent,
-            config.resolver_max_concurrent_timeout_ms
+            config.resolver_max_concurrent_timeout_ms,
         );
     }
 
···
                             create_sqlite_queue::<HandleResolutionWork>(pool)
                         }
                     } else {
-                        tracing::warn!("Failed to create SQLite pool for queue, falling back to MPSC queue adapter");
+                        tracing::warn!(
+                            "Failed to create SQLite pool for queue, falling back to MPSC queue adapter"
+                        );
                         // Fall back to MPSC if SQLite fails
                         let (handle_sender, handle_receiver) =
                             tokio::sync::mpsc::channel::<HandleResolutionWork>(

src/config.rs

···
 }
 
 /// Helper function to parse an environment variable as a specific type
-fn parse_env<T: std::str::FromStr>(key: &str, default: T) -> Result<T, ConfigError> 
+fn parse_env<T: std::str::FromStr>(key: &str, default: T) -> Result<T, ConfigError>
 where
     T::Err: std::fmt::Display,
 {
     match env::var(key) {
-        Ok(val) if !val.is_empty() => val.parse::<T>()
+        Ok(val) if !val.is_empty() => val
+            .parse::<T>()
             .map_err(|e| ConfigError::InvalidValue(format!("{}: {}", key, e))),
         _ => Ok(default),
     }
···
             sqlite_url: get_env_or_default("SQLITE_URL", None),
             queue_adapter: get_env_or_default("QUEUE_ADAPTER", Some("mpsc")).unwrap(),
             queue_redis_url: get_env_or_default("QUEUE_REDIS_URL", None),
-            queue_redis_prefix: get_env_or_default("QUEUE_REDIS_PREFIX", Some("queue:handleresolver:")).unwrap(),
+            queue_redis_prefix: get_env_or_default(
+                "QUEUE_REDIS_PREFIX",
+                Some("queue:handleresolver:"),
+            )
+            .unwrap(),
             queue_worker_id: get_env_or_default("QUEUE_WORKER_ID", Some("worker1")).unwrap(),
             queue_buffer_size: parse_env("QUEUE_BUFFER_SIZE", 1000)?,
             cache_ttl_memory: parse_env("CACHE_TTL_MEMORY", 600)?,

src/handle_resolver/memory.rs

···
 use super::errors::HandleResolverError;
 use super::traits::HandleResolver;
 use async_trait::async_trait;
-use std::time::{SystemTime, UNIX_EPOCH};
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::RwLock;
 
 /// Result of a handle resolution cached in memory.

src/handle_resolver/rate_limited.rs

···
 pub(super) struct RateLimitedHandleResolver {
     /// Inner resolver that performs actual resolution.
     inner: Arc<dyn HandleResolver>,
-    
+
     /// Semaphore for limiting concurrent resolutions.
     semaphore: Arc<Semaphore>,
-    
+
     /// Optional timeout for acquiring permits (in milliseconds).
     /// When None or 0, no timeout is applied.
     timeout_ms: Option<u64>,
···
             timeout_ms: None,
         }
     }
-    
+
     /// Create a new rate-limited resolver with timeout.
     ///
     /// # Arguments
···
     /// * `inner` - The inner resolver to wrap
     /// * `max_concurrent` - Maximum number of concurrent resolutions allowed
     /// * `timeout_ms` - Timeout in milliseconds for acquiring permits (0 = no timeout)
-    pub fn new_with_timeout(inner: Arc<dyn HandleResolver>, max_concurrent: usize, timeout_ms: u64) -> Self {
+    pub fn new_with_timeout(
+        inner: Arc<dyn HandleResolver>,
+        max_concurrent: usize,
+        timeout_ms: u64,
+    ) -> Self {
         Self {
             inner,
             semaphore: Arc::new(Semaphore::new(max_concurrent)),
-            timeout_ms: if timeout_ms > 0 { Some(timeout_ms) } else { None },
+            timeout_ms: if timeout_ms > 0 {
+                Some(timeout_ms)
+            } else {
+                None
+            },
         }
     }
 }
···
                     Ok(Ok(permit)) => permit,
                     Ok(Err(e)) => {
                         // Semaphore error (e.g., closed)
-                        return Err(HandleResolverError::ResolutionFailed(
-                            format!("Failed to acquire rate limit permit: {}", e)
-                        ));
+                        return Err(HandleResolverError::ResolutionFailed(format!(
+                            "Failed to acquire rate limit permit: {}",
+                            e
+                        )));
                     }
                     Err(_) => {
                         // Timeout occurred
-                        return Err(HandleResolverError::ResolutionFailed(
-                            format!("Rate limit permit acquisition timed out after {}ms", timeout_ms)
-                        ));
+                        return Err(HandleResolverError::ResolutionFailed(format!(
+                            "Rate limit permit acquisition timed out after {}ms",
+                            timeout_ms
+                        )));
                     }
                 }
             }
             _ => {
                 // No timeout configured, wait indefinitely
-                self.semaphore.acquire().await
-                    .map_err(|e| HandleResolverError::ResolutionFailed(
-                        format!("Failed to acquire rate limit permit: {}", e)
-                    ))?
+                self.semaphore.acquire().await.map_err(|e| {
+                    HandleResolverError::ResolutionFailed(format!(
+                        "Failed to acquire rate limit permit: {}",
+                        e
+                    ))
+                })?
             }
         };
-        
+
         // With permit acquired, forward to inner resolver
         self.inner.resolve(s).await
     }
···
     max_concurrent: usize,
     timeout_ms: u64,
 ) -> Arc<dyn HandleResolver> {
-    Arc::new(RateLimitedHandleResolver::new_with_timeout(inner, max_concurrent, timeout_ms))
-}
+    Arc::new(RateLimitedHandleResolver::new_with_timeout(
+        inner,
+        max_concurrent,
+        timeout_ms,
+    ))
+}

src/handle_resolver/redis.rs

···
         });
 
         // Create Redis-backed resolver with a unique key prefix for testing
-        let test_prefix = format!("test:handle:{}:", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
+        let test_prefix = format!(
+            "test:handle:{}:",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        );
         let redis_resolver = RedisHandleResolver::with_full_config(
             mock_resolver,
             pool.clone(),
···
         });
 
         // Create Redis-backed resolver with a unique key prefix for testing
-        let test_prefix = format!("test:handle:{}:", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
+        let test_prefix = format!(
+            "test:handle:{}:",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        );
         let redis_resolver = RedisHandleResolver::with_full_config(
             mock_resolver,
             pool.clone(),

src/handle_resolver/sqlite.rs

···
         let key = self.make_key(&handle) as i64; // SQLite uses signed integers
 
         // Try to get from SQLite cache first
-        let cached_result = sqlx::query(
-            "SELECT result, updated FROM handle_resolution_cache WHERE key = ?1"
-        )
-        .bind(key)
-        .fetch_optional(&self.pool)
-        .await;
+        let cached_result =
+            sqlx::query("SELECT result, updated FROM handle_resolution_cache WHERE key = ?1")
+                .bind(key)
+                .fetch_optional(&self.pool)
+                .await;
 
         match cached_result {
             Ok(Some(row)) => {
···
                     ON CONFLICT(key) DO UPDATE SET 
                         result = excluded.result,
                         updated = excluded.updated
-                    "#
+                    "#,
                 )
                 .bind(key)
                 .bind(&bytes)
···
         assert_eq!(result1, "did:plc:testuser123");
 
         // Verify record was inserted
-        let count_after_first: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to query count after first resolution");
+        let count_after_first: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
+                .fetch_one(&pool)
+                .await
+                .expect("Failed to query count after first resolution");
         assert_eq!(count_after_first, 1);
 
         // Verify the cached record has correct key and non-empty result
-        let cached_record = sqlx::query("SELECT key, result, created, updated FROM handle_resolution_cache WHERE key = ?1")
-            .bind(expected_key)
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to fetch cached record");
-        
+        let cached_record = sqlx::query(
+            "SELECT key, result, created, updated FROM handle_resolution_cache WHERE key = ?1",
+        )
+        .bind(expected_key)
+        .fetch_one(&pool)
+        .await
+        .expect("Failed to fetch cached record");
+
         let cached_key: i64 = cached_record.get("key");
         let cached_result: Vec<u8> = cached_record.get("result");
         let cached_created: i64 = cached_record.get("created");
         let cached_updated: i64 = cached_record.get("updated");
 
         assert_eq!(cached_key, expected_key);
-        assert!(!cached_result.is_empty(), "Cached result should not be empty");
+        assert!(
+            !cached_result.is_empty(),
+            "Cached result should not be empty"
+        );
         assert!(cached_created > 0, "Created timestamp should be positive");
         assert!(cached_updated > 0, "Updated timestamp should be positive");
-        assert_eq!(cached_created, cached_updated, "Created and updated should be equal on first insert");
+        assert_eq!(
+            cached_created, cached_updated,
+            "Created and updated should be equal on first insert"
+        );
 
         // Verify we can deserialize the cached result
-        let resolution_result = crate::handle_resolution_result::HandleResolutionResult::from_bytes(&cached_result)
-            .expect("Failed to deserialize cached result");
+        let resolution_result =
+            crate::handle_resolution_result::HandleResolutionResult::from_bytes(&cached_result)
+                .expect("Failed to deserialize cached result");
         let cached_did = resolution_result.to_did().expect("Should have a DID");
         assert_eq!(cached_did, "did:plc:testuser123");
 
···
         assert_eq!(result2, "did:plc:testuser123");
 
         // Verify count hasn't changed (cache hit, no new insert)
-        let count_after_second: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to query count after second resolution");
+        let count_after_second: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
+                .fetch_one(&pool)
+                .await
+                .expect("Failed to query count after second resolution");
         assert_eq!(count_after_second, 1);
     }
 
···
         // First resolution - should fail and cache the failure
         let result1 = sqlite_resolver.resolve(test_handle).await;
         assert!(result1.is_err());
-        
+
         // Match the specific error type we expect
         match result1 {
-            Err(HandleResolverError::MockResolutionFailure) => {},
+            Err(HandleResolverError::MockResolutionFailure) => {}
             other => panic!("Expected MockResolutionFailure, got {:?}", other),
         }
 
         // Verify the failure was cached
-        let count_after_first: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to query count after first resolution");
+        let count_after_first: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
+                .fetch_one(&pool)
+                .await
+                .expect("Failed to query count after first resolution");
         assert_eq!(count_after_first, 1);
 
         // Verify the cached error record
-        let cached_record = sqlx::query("SELECT key, result, created, updated FROM handle_resolution_cache WHERE key = ?1")
-            .bind(expected_key)
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to fetch cached error record");
-        
+        let cached_record = sqlx::query(
+            "SELECT key, result, created, updated FROM handle_resolution_cache WHERE key = ?1",
+        )
+        .bind(expected_key)
+        .fetch_one(&pool)
+        .await
+        .expect("Failed to fetch cached error record");
+
         let cached_key: i64 = cached_record.get("key");
         let cached_result: Vec<u8> = cached_record.get("result");
         let cached_created: i64 = cached_record.get("created");
         let cached_updated: i64 = cached_record.get("updated");
 
         assert_eq!(cached_key, expected_key);
-        assert!(!cached_result.is_empty(), "Cached error result should not be empty");
+        assert!(
+            !cached_result.is_empty(),
+            "Cached error result should not be empty"
+        );
         assert!(cached_created > 0, "Created timestamp should be positive");
         assert!(cached_updated > 0, "Updated timestamp should be positive");
-        assert_eq!(cached_created, cached_updated, "Created and updated should be equal on first insert");
+        assert_eq!(
+            cached_created, cached_updated,
+            "Created and updated should be equal on first insert"
+        );
 
         // Verify we can deserialize the cached error result
-        let resolution_result = crate::handle_resolution_result::HandleResolutionResult::from_bytes(&cached_result)
-            .expect("Failed to deserialize cached error result");
+        let resolution_result =
+            crate::handle_resolution_result::HandleResolutionResult::from_bytes(&cached_result)
+                .expect("Failed to deserialize cached error result");
         let cached_did = resolution_result.to_did();
         assert!(cached_did.is_none(), "Error result should have no DID");
 
         // Second resolution - should hit cache with error (no additional database operations)
         let result2 = sqlite_resolver.resolve(test_handle).await;
         assert!(result2.is_err());
-        
+
         // Match the specific error type we expect from cache
         match result2 {
-            Err(HandleResolverError::HandleNotFound) => {}, // Cache returns HandleNotFound for "not resolved"
+            Err(HandleResolverError::HandleNotFound) => {} // Cache returns HandleNotFound for "not resolved"
             other => panic!("Expected HandleNotFound from cache, got {:?}", other),
         }
 
         // Verify count hasn't changed (cache hit, no new operations)
-        let count_after_second: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
-            .fetch_one(&pool)
-            .await
-            .expect("Failed to query count after second resolution");
+        let count_after_second: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM handle_resolution_cache")
+                .fetch_one(&pool)
+                .await
+                .expect("Failed to query count after second resolution");
         assert_eq!(count_after_second, 1);
     }
-}
+}

src/http/server.rs

···
 use axum::{
     Router,
     extract::State,
+    http::StatusCode,
     response::{Html, IntoResponse, Json, Response},
     routing::get,
-    http::StatusCode,
 };
 use serde_json::json;
 use std::sync::Arc;

src/queue/adapter.rs

···
 //! This module defines the core `QueueAdapter` trait that provides a common
 //! interface for different queue implementations (MPSC, Redis, SQLite, etc.).
 
-use async_trait::async_trait;
 use super::error::Result;
+use async_trait::async_trait;
 
 /// Generic trait for queue adapters that can work with any work type.
 ///
···
     #[tokio::test]
     async fn test_default_trait_methods() {
         let queue = MockQueue::<String>::new();
-        
+
         // Test default ack implementation
         assert!(queue.ack(&"test".to_string()).await.is_ok());
-        
+
         // Test default try_push implementation
         assert!(queue.try_push("test".to_string()).await.is_ok());
-        
+
         // Test default depth implementation
         assert_eq!(queue.depth().await, None);
-        
+
         // Test default is_healthy implementation
         assert!(queue.is_healthy().await);
     }
-}
+}

src/queue/error.rs

···
 
     /// Redis operation failed.
     #[error("error-quickdid-queue-5 Redis operation failed: {operation}: {details}")]
-    RedisOperationFailed { 
+    RedisOperationFailed {
         /// The Redis operation that failed
-        operation: String, 
+        operation: String,
         /// Details about the failure
-        details: String 
+        details: String,
     },
 
     /// Failed to serialize an item for storage.
···
         assert!(err.to_string().contains("LPUSH"));
         assert!(err.to_string().contains("connection timeout"));
     }
-}
+}

src/queue/factory.rs

···
 use tokio::sync::mpsc;
 
 use super::{
-    adapter::QueueAdapter,
-    mpsc::MpscQueueAdapter,
-    noop::NoopQueueAdapter,
-    redis::RedisQueueAdapter,
-    sqlite::SqliteQueueAdapter,
+    adapter::QueueAdapter, mpsc::MpscQueueAdapter, noop::NoopQueueAdapter,
+    redis::RedisQueueAdapter, sqlite::SqliteQueueAdapter,
 };
 
 // ========= MPSC Queue Factories =========
···
     #[tokio::test]
     async fn test_create_mpsc_queue() {
         let queue = create_mpsc_queue::<String>(10);
-        
+
         queue.push("test".to_string()).await.unwrap();
         let item = queue.pull().await;
         assert_eq!(item, Some("test".to_string()));
···
     async fn test_create_mpsc_queue_from_channel() {
         let (sender, receiver) = mpsc::channel(5);
         let queue = create_mpsc_queue_from_channel(sender.clone(), receiver);
-        
+
         // Send via original sender
         sender.send("external".to_string()).await.unwrap();
-        
+
         // Receive via queue
         let item = queue.pull().await;
         assert_eq!(item, Some("external".to_string()));
···
     #[tokio::test]
     async fn test_create_noop_queue() {
         let queue = create_noop_queue::<String>();
-        
+
         // Should accept pushes
         queue.push("ignored".to_string()).await.unwrap();
-        
+
         // Should report as healthy
         assert!(queue.is_healthy().await);
-        
+
         // Should report depth as 0
         assert_eq!(queue.depth().await, Some(0));
     }
···
             .expect("Failed to create schema");
 
         let queue = create_sqlite_queue::<HandleResolutionWork>(pool);
-        
+
         let work = HandleResolutionWork::new("test.example.com".to_string());
         queue.push(work.clone()).await.unwrap();
-        
+
         let pulled = queue.pull().await;
         assert_eq!(pulled, Some(work));
     }
···
 
         // Create queue with small max size
         let queue = create_sqlite_queue_with_max_size::<HandleResolutionWork>(pool, 5);
-        
+
         // Push items
         for i in 0..10 {
             let work = HandleResolutionWork::new(format!("test-{}.example.com", i));
             queue.push(work).await.unwrap();
         }
-        
+
         // Should have limited items due to work shedding
         let depth = queue.depth().await.unwrap();
-        assert!(depth <= 5, "Queue should have at most 5 items after work shedding");
+        assert!(
+            depth <= 5,
+            "Queue should have at most 5 items after work shedding"
+        );
     }
 
     #[tokio::test]
···
                 .as_nanos()
         );
 
-        let queue = create_redis_queue::<String>(
-            pool,
-            "test-worker".to_string(),
-            test_prefix,
-            1,
-        );
+        let queue = create_redis_queue::<String>(pool, "test-worker".to_string(), test_prefix, 1);
 
         queue.push("test-item".to_string()).await.unwrap();
         let pulled = queue.pull().await;
         assert_eq!(pulled, Some("test-item".to_string()));
     }
-}
+}

src/queue/mod.rs

···
 
 // Re-export factory functions
 pub use factory::{
-    create_mpsc_queue,
-    create_mpsc_queue_from_channel,
-    create_noop_queue,
-    create_redis_queue,
-    create_sqlite_queue,
-    create_sqlite_queue_with_max_size,
+    create_mpsc_queue, create_mpsc_queue_from_channel, create_noop_queue, create_redis_queue,
+    create_sqlite_queue, create_sqlite_queue_with_max_size,
 };
-

src/queue/mpsc.rs

···
 
 use async_trait::async_trait;
 use std::sync::Arc;
-use tokio::sync::{mpsc, Mutex};
+use tokio::sync::{Mutex, mpsc};
 
 use super::adapter::QueueAdapter;
 use super::error::{QueueError, Result};
···
     #[tokio::test]
     async fn test_mpsc_queue_health() {
         let queue = MpscQueueAdapter::<String>::new(10);
-        
+
         // Queue should be healthy initially
         assert!(queue.is_healthy().await);
 
···
         let (sender, receiver) = mpsc::channel::<String>(10);
         drop(receiver);
         let closed_queue = MpscQueueAdapter::from_channel(sender, mpsc::channel(1).1);
-        
+
         // Push should fail on closed queue
         let result = closed_queue.push("test".to_string()).await;
         assert!(result.is_err());
···
         // Ack should always succeed (no-op)
         queue.ack(&item).await.unwrap();
     }
-}
+}

src/queue/noop.rs

···
         queue.ack(&work).await.unwrap();
         assert_eq!(queue.depth().await, Some(0));
     }
-}
+}

src/queue/redis.rs

···
                 .unwrap()
                 .as_nanos()
         );
-        let adapter = RedisQueueAdapter::<String>::new(
-            pool,
-            "test-worker-depth".to_string(),
-            test_prefix,
-            1,
-        );
+        let adapter =
+            RedisQueueAdapter::<String>::new(pool, "test-worker-depth".to_string(), test_prefix, 1);
 
         // Initially empty
         assert_eq!(adapter.depth().await, Some(0));
···
         // Ack
         adapter.ack(&work).await.unwrap();
     }
-}
+}

src/queue/sqlite.rs

···
         let record = match sqlx::query(
             "SELECT id, work FROM handle_resolution_queue 
              ORDER BY queued_at ASC 
-             LIMIT 1"
+             LIMIT 1",
         )
         .fetch_optional(&mut *transaction)
         .await
···
 
         // Optimized approach: Insert first, then check if cleanup needed
         // This avoids counting on every insert
-        sqlx::query(
-            "INSERT INTO handle_resolution_queue (work, queued_at) VALUES (?1, ?2)"
-        )
-        .bind(&work_json)
-        .bind(current_timestamp)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| QueueError::PushFailed(format!("Failed to insert work item: {}", e)))?;
+        sqlx::query("INSERT INTO handle_resolution_queue (work, queued_at) VALUES (?1, ?2)")
+            .bind(&work_json)
+            .bind(current_timestamp)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| QueueError::PushFailed(format!("Failed to insert work item: {}", e)))?;
 
         // Implement optimized work shedding if max_size is configured
         if self.max_size > 0 {
···
             let approx_count: Option<i64> = sqlx::query_scalar(
                 "SELECT COUNT(*) FROM (
                     SELECT 1 FROM handle_resolution_queue LIMIT ?1
-                ) AS limited_count"
+                ) AS limited_count",
             )
             .bind(check_limit)
             .fetch_one(&self.pool)
···
             .map_err(|e| QueueError::PushFailed(format!("Failed to check queue size: {}", e)))?;
 
             // Only perform cleanup if we're definitely over the limit
-            if let Some(count) = approx_count && count >= check_limit {
+            if let Some(count) = approx_count
+                && count >= check_limit
+            {
                 // Perform batch cleanup - delete more than just the excess to reduce frequency
                 // Delete 20% more than needed to avoid frequent shedding
                 let target_size = (self.max_size as f64 * 0.8) as i64; // Keep 80% of max_size
                 let to_delete = count - target_size;
-                
+
                 if to_delete > 0 {
                     // Optimized deletion: First get the cutoff id and timestamp
                     // This avoids the expensive subquery in the DELETE statement
                     let cutoff: Option<(i64, i64)> = sqlx::query_as(
                         "SELECT id, queued_at FROM handle_resolution_queue 
                          ORDER BY queued_at ASC, id ASC 
-                         LIMIT 1 OFFSET ?1"
+                         LIMIT 1 OFFSET ?1",
                     )
                     .bind(to_delete - 1)
                     .fetch_optional(&self.pool)
···
                         let deleted_result = sqlx::query(
                             "DELETE FROM handle_resolution_queue 
                              WHERE queued_at < ?1 
-                                OR (queued_at = ?1 AND id <= ?2)"
+                                OR (queued_at = ?1 AND id <= ?2)",
                         )
                         .bind(cutoff_timestamp)
                         .bind(cutoff_id)
                         .execute(&self.pool)
                         .await
-                        .map_err(|e| QueueError::PushFailed(format!("Failed to delete excess entries: {}", e)))?;
+                        .map_err(|e| {
+                            QueueError::PushFailed(format!(
+                                "Failed to delete excess entries: {}",
+                                e
+                            ))
+                        })?;
 
                         let deleted_count = deleted_result.rows_affected();
                         if deleted_count > 0 {
                             info!(
                                 "Work shedding: deleted {} oldest entries (target size: {}, max: {})",
-                                deleted_count,
-                                target_size,
-                                self.max_size
+                                deleted_count, target_size, self.max_size
                             );
                         }
                     }
···
             }
         }
 
-        debug!("Pushed work item to SQLite queue (max_size: {})", self.max_size);
+        debug!(
+            "Pushed work item to SQLite queue (max_size: {})",
+            self.max_size
+        );
         Ok(())
     }
 
···
     }
 
     async fn depth(&self) -> Option<usize> {
-        match sqlx::query_scalar::<_, i64>(
-            "SELECT COUNT(*) FROM handle_resolution_queue"
-        )
-        .fetch_one(&self.pool)
-        .await
+        match sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM handle_resolution_queue")
+            .fetch_one(&self.pool)
+            .await
         {
             Ok(count) => Some(count as usize),
             Err(e) => {
···
         let adapter = SqliteQueueAdapter::<HandleResolutionWork>::new(pool);
 
         // Push multiple items
-        let handles = vec!["alice.example.com", "bob.example.com", "charlie.example.com"];
+        let handles = vec![
+            "alice.example.com",
+            "bob.example.com",
+            "charlie.example.com",
+        ];
         for handle in &handles {
             let work = HandleResolutionWork::new(handle.to_string());
             adapter.push(work).await.unwrap();
···
     #[tokio::test]
     async fn test_sqlite_queue_work_shedding() {
         let pool = create_test_pool().await;
-        
+
         // Create adapter with small max_size for testing
         let max_size = 10;
-        let adapter = SqliteQueueAdapter::<HandleResolutionWork>::with_max_size(
-            pool.clone(), 
-            max_size
-        );
+        let adapter =
+            SqliteQueueAdapter::<HandleResolutionWork>::with_max_size(pool.clone(), max_size);
 
         // Push items up to the limit (should not trigger shedding)
         for i in 0..max_size {
···
         // After triggering shedding, queue should be around 80% of max_size
         let depth_after_shedding = adapter.depth().await.unwrap();
         let expected_size = (max_size as f64 * 0.8) as usize;
-        
+
         // Allow some variance due to batch deletion
         assert!(
             depth_after_shedding <= expected_size + 1,
···
     #[tokio::test]
     async fn test_sqlite_queue_work_shedding_disabled() {
         let pool = create_test_pool().await;
-        
+
         // Create adapter with max_size = 0 (disabled work shedding)
-        let adapter = SqliteQueueAdapter::<HandleResolutionWork>::with_max_size(
-            pool, 
-            0
-        );
+        let adapter = SqliteQueueAdapter::<HandleResolutionWork>::with_max_size(pool, 0);
 
         // Push many items (should not trigger any shedding)
         for i in 0..100 {
···
         let pulled = adapter.pull().await;
         assert_eq!(pulled, Some(work));
     }
-}
+}

src/queue/work.rs

···
     #[test]
     fn test_handle_resolution_work_serialization() {
         let work = HandleResolutionWork::new("bob.example.com".to_string());
-        
+
         // Test JSON serialization (which is what we actually use in the queue adapters)
         let json = serde_json::to_string(&work).expect("Failed to serialize to JSON");
-        let deserialized: HandleResolutionWork = 
+        let deserialized: HandleResolutionWork =
             serde_json::from_str(&json).expect("Failed to deserialize from JSON");
         assert_eq!(work, deserialized);
-        
+
         // Verify the JSON structure
         let json_value: serde_json::Value = serde_json::from_str(&json).unwrap();
         assert_eq!(json_value["handle"], "bob.example.com");
···
         let work1 = HandleResolutionWork::new("alice.example.com".to_string());
         let work2 = HandleResolutionWork::new("alice.example.com".to_string());
         let work3 = HandleResolutionWork::new("bob.example.com".to_string());
-        
+
         assert_eq!(work1, work2);
         assert_ne!(work1, work3);
     }
-}
+}

src/sqlite_schema.rs

···
 //! schema used by the SQLite-backed handle resolver cache.
 
 use anyhow::Result;
-use sqlx::{SqlitePool, migrate::MigrateDatabase, Sqlite};
+use sqlx::{Sqlite, SqlitePool, migrate::MigrateDatabase};
 use std::path::Path;
 
 /// SQL schema for the handle resolution cache table.
···
     tracing::info!("Initializing SQLite database: {}", database_url);
 
     // Extract the database path from the URL for file-based databases
-    if let Some(path) = database_url.strip_prefix("sqlite:") 
-        && path != ":memory:" 
-        && !path.is_empty() 
+    if let Some(path) = database_url.strip_prefix("sqlite:")
+        && path != ":memory:"
+        && !path.is_empty()
     {
         // Create the database file if it doesn't exist
         if !Sqlite::database_exists(database_url).await? {
···
         }
 
         // Ensure the parent directory exists
-        if let Some(parent) = Path::new(path).parent() 
-            && !parent.exists() 
+        if let Some(parent) = Path::new(path).parent()
+            && !parent.exists()
         {
             tracing::info!("Creating directory: {}", parent.display());
             std::fs::create_dir_all(parent)?;
···
     sqlx::query(CREATE_HANDLE_RESOLUTION_CACHE_TABLE)
         .execute(pool)
         .await?;
-    
+
     sqlx::query(CREATE_HANDLE_RESOLUTION_QUEUE_TABLE)
         .execute(pool)
         .await?;
···
 
     let cutoff_timestamp = current_timestamp - (max_age_seconds as i64);
 
-    let result = sqlx::query(
-        "DELETE FROM handle_resolution_queue WHERE queued_at < ?1"
-    )
-    .bind(cutoff_timestamp)
-    .execute(pool)
-    .await?;
+    let result = sqlx::query("DELETE FROM handle_resolution_queue WHERE queued_at < ?1")
+        .bind(cutoff_timestamp)
+        .execute(pool)
+        .await?;
 
     let deleted_count = result.rows_affected();
     if deleted_count > 0 {
···
         let old_timestamp = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
-            .as_secs() as i64 - 3600; // 1 hour ago
+            .as_secs() as i64
+            - 3600; // 1 hour ago
 
         sqlx::query(
             "INSERT INTO handle_resolution_cache (key, result, created, updated) VALUES (1, ?1, ?2, ?2)"
···
         assert_eq!(total_entries, 1);
         assert!(size_bytes > 0);
     }
-}
+}

src/test_helpers.rs

···
 use deadpool_redis::Pool;
 
 /// Helper function to get a Redis pool for testing.
-/// 
+///
 /// Returns None if TEST_REDIS_URL is not set, logging a skip message.
 /// This consolidates the repeated Redis test setup code.
 pub(crate) fn get_test_redis_pool() -> Option<Pool> {
···
             None => return,
         }
     };
-}
+}