Initial commit, rust reimplementation

.dockerignore

···
+target/
+.env
+.env.*
+!.env.example
+.git/
+.gitignore
+*.md
+!CLAUDE.md
+.DS_Store
+firehose_cursor.db

.env.example

···
+# PDS Configuration
+PDS_ENDPOINT=https://bsky.social
+
+# PLC Configuration
+PLC_ENDPOINT=https://plc.directory
+
+# Automod Account Configuration (REQUIRED)
+# The automod account has moderator permissions and is used for authentication
+# DID is automatically sourced from the agent session after login
+AUTOMOD_HANDLE=your-automod.bsky.social
+AUTOMOD_PASSWORD=your-app-password-here
+
+# Ozone Configuration (REQUIRED)
+OZONE_URL=https://ozone.skywatch.blue
+OZONE_PDS=https://blewit.us-west.host.bsky.network
+
+# Labeler Configuration (REQUIRED)
+# This is the DID of your main labeler account (e.g., skywatch.blue)
+# NOT the automod account, NOT the ozone service
+LABELER_DID=did:plc:your-labeler-did-here
+RATE_LIMIT_MS=100
+
+# Jetstream Configuration
+JETSTREAM_URL=wss://jetstream2.us-east.bsky.network
+CURSOR_UPDATE_INTERVAL=10000
+
+# Redis Configuration
+REDIS_URL=redis://localhost:6379
+
+# Cache Configuration
+CACHE_ENABLED=true
+CACHE_TTL_SECONDS=86400
+
+# Processing Configuration
+PROCESSING_CONCURRENCY=4
+RETRY_ATTEMPTS=3
+RETRY_DELAY_MS=1000
+
+# Phash Configuration
+PHASH_HAMMING_THRESHOLD=5

.envrc

···
+use flake

.gitignore

···
+/target
+/result
+/result-lib
+.direnv
+.claude
+/.pre-commit-config.yaml
+CLAUDE.md
+AGENTS.md
+crates/jacquard-lexicon/target
+/plans
+/docs
+/binaries/releases/
+rustdoc-host.nix
+**/**.car
+cursor.txt
+.session
+.env
+firehose_cursor.db

.zed/settings.json

···
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "rust": {
+          "analyzerTargetDir": true
+        },
+        "cargo": {
+          "allFeatures": true
+        }
+      }
+    }
+  }
+}

ARCHITECTURE.md

···
+# Skywatch-Phash: Complete Architecture & Implementation Guide
+
+## Overview
+
+**skywatch-phash** is a real-time perceptual hash-based image moderation service for Bluesky/ATProto. It:
+1. Subscribes to the Bluesky firehose (Jetstream) in real-time
+2. Extracts images from posts and computes perceptual hashes (phash)
+3. Compares against known harmful image hashes using Hamming distance
+4. Automatically applies moderation labels and reports to Bluesky Ozone moderators
+
+**Tech Stack:** Bun/TypeScript, Redis, Jetstream, ATProto API, Sharp (image processing)
+
+---
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Main Application                         │
+│  (main.ts - Jetstream event handler + orchestrator)         │
+└─────────────────┬───────────────────────────────────────────┘
+                  │
+        ┌─────────┼─────────┐
+        │         │         │
+   ┌────▼──┐  ┌──▼────┐ ┌──▼─────────┐
+   │Redis  │  │ Jet-  │ │ Moderation │
+   │Queue  │  │stream │ │  Agent     │
+   └────┬──┘  └───┬───┘ └──┬─────────┘
+        │         │        │
+        └─────────┼────────┘
+                  │
+        ┌─────────▼──────────────┐
+        │   Queue Worker         │
+        │  (concurrency control) │
+        └─────────┬──────────────┘
+                  │
+        ┌─────────▼──────────────────────────┐
+        │   Image Processor                  │
+        │  (phash + matching logic)          │
+        ├─────────────────────────────────────┤
+        │ ▪ Phash Computation (Sharp)         │
+        │ ▪ Hamming Distance Matching         │
+        │ ▪ Redis Phash Cache                 │
+        │ ▪ Moderation Claims Deduplication   │
+        └────────────────────────────────────┘
+```
+
+---
+
+## 1. Entry Point & Main Event Loop
+
+### File: `src/main.ts`
+
+**Responsibilities:**
+- Jetstream connection management
+- Cursor persistence (recovery from crashes)
+- Queue/worker initialization
+- Moderation action dispatch
+
+**Key Flow:**
+
+```typescript
+// 1. Load cursor from disk (enables resuming from last processed event)
+cursor = fs.readFileSync("cursor.txt") || Math.floor(Date.now() * 1000)
+
+// 2. Connect to Jetstream
+jetstream = new Jetstream({ 
+  endpoint: "wss://jetstream1.us-east.fire.hose.cam/subscribe",
+  cursor,
+  wantedCollections: ["app.bsky.feed.post"]
+})
+
+// 3. Register handler for new posts
+jetstream.onCreate("app.bsky.feed.post", async (event) => {
+  // Extract image blobs (CIDs) from post
+  const blobs = extractBlobsFromEvent(event)
+  
+  // Enqueue for processing
+  const job = { postUri, postCid, postDid, blobs, timestamp, attempts: 0 }
+  await queue.enqueue(job)
+})
+
+// 4. Start processing
+await worker.start()
+jetstream.start()
+
+// 5. On match found, execute moderation actions
+worker.onMatchFound((postUri, postCid, postDid, match) => {
+  if (match.matchedCheck.toLabel) 
+    await createPostLabel(...)
+  if (match.matchedCheck.reportPost)
+    await createPostReport(...)
+  if (match.matchedCheck.labelAcct)
+    await createAccountLabel(...)
+  if (match.matchedCheck.reportAcct)
+    await createAccountReport(...)
+})
+```
+
+**Cursor Handling (CRITICAL):**
+- Cursor is microsecond timestamp (µs, not ms) from Jetstream
+- Saved every 10 seconds (configurable via `CURSOR_UPDATE_INTERVAL`)
+- On restart, reads from `cursor.txt` to resume from last processed event
+- **This prevents duplicate processing of same posts**
+
+**Graceful Shutdown:**
+- Saves cursor before exit
+- Waits for active jobs to complete
+- Closes all connections
+
+---
+
+## 2. Jetstream Connection & Event Processing
+
+### Event Structure
+
+Posts with embedded images trigger:
+
+```typescript
+CommitCreateEvent<"app.bsky.feed.post"> {
+  did: string                    // Author DID
+  commit: {
+    cid: string                  // Post CID
+    collection: "app.bsky.feed.post"
+    rkey: string                 // Post key
+    record: {
+      embed: {
+        images?: [{image: {ref: {$link: CID}, mimeType}}]
+        media?: {images: [...]}
+      }
+    }
+  }
+}
+```
+
+**Image Extraction Logic:**
+- Handles both `embed.images` and `embed.media.images` (both are valid)
+- Filters out SVG and non-image types
+- Extracts CID from nested `ref.$link` field
+
+---
+
+## 3. Perceptual Hash Algorithm (CRITICAL - Exact Implementation)
+
+### File: `src/hasher/phash.ts`
+
+```typescript
+async function computePerceptualHash(buffer: Buffer): Promise<string> {
+  // Step 1: Decode image via Sharp
+  const image = sharp(buffer)
+  const metadata = await image.metadata()
+  
+  // Step 2: Resize to 8x8 grayscale
+  // CRITICAL: fit: "fill" preserves aspect ratio, may add padding
+  const resized = await image
+    .resize(8, 8, { fit: "fill" })
+    .grayscale()
+    .raw()
+    .toBuffer()
+  
+  // Step 3: Extract pixel values (Uint8Array, 0-255 range)
+  const pixels = new Uint8Array(resized)
+  
+  // Step 4: Compute average brightness
+  const avg = pixels.reduce((sum, val) => sum + val, 0) / pixels.length
+  
+  // Step 5: Create 64-bit hash (8x8 = 64 pixels)
+  let hash = ""
+  for (let i = 0; i < pixels.length; i++) {
+    hash += pixels[i] > avg ? "1" : "0"
+  }
+  
+  // Step 6: Convert binary string to hex (16 character string)
+  return BigInt(`0b${hash}`).toString(16).padStart(16, "0")
+}
+```
+
+**Output Format:**
+- **Exactly 16 hex characters** (64 bits for 8x8 image)
+- Lowercase
+- Zero-padded
+
+**Example:** `"a1b2c3d4e5f6a7b8"`
+
+**Important Details:**
+
+1. **Sharp resize behavior:**
+   - `fit: "fill"` = no cropping, may add padding to preserve aspect ratio
+   - This is intentional - handles images of any aspect ratio
+   - Padding typically adds uniform brightness which affects hash slightly
+
+2. **Grayscale conversion:**
+   - Sharp converts RGB to single channel (standard luminosity formula)
+   - Range: 0-255
+
+3. **No normalization:** 
+   - Raw pixel values compared to mean (not normalized)
+   - This is correct for perceptual hashing
+
+4. **Deterministic:**
+   - Same image buffer always produces same hash
+   - Different images (even slight variations) can produce different hashes
+   - BUT: Can match within Hamming distance threshold
+
+---
+
+## 4. Hamming Distance Matching
+
+### File: `src/matcher/hamming.ts`
+
+```typescript
+function hammingDistance(hash1: string, hash2: string): number {
+  // Convert hex to BigInt
+  const a = BigInt(`0x${hash1}`)
+  const b = BigInt(`0x${hash2}`)
+  
+  // XOR finds differing bits
+  const xor = a ^ b
+  
+  // Count set bits (Brian Kernighan's algorithm)
+  let count = 0
+  let n = xor
+  while (n > 0n) {
+    count++
+    n &= n - 1n  // Remove rightmost set bit
+  }
+  
+  return count
+}
+
+function findMatch(phash: string, checks: BlobCheck[]): BlobCheck | null {
+  for (const check of checks) {
+    const threshold = check.hammingThreshold ?? 5
+    
+    for (const checkPhash of check.phashes) {
+      const distance = hammingDistance(phash, checkPhash)
+      
+      if (distance <= threshold) {
+        return check  // First match wins
+      }
+    }
+  }
+  
+  return null
+}
+```
+
+**Key Semantics:**
+- Hamming distance = number of differing bits out of 64
+- Range: 0-64
+- Threshold comparison: `distance <= threshold` (inclusive)
+
+**Threshold Guidelines (from README):**
+- `0` = Exact match only (very strict)
+- `1-2` = Nearly identical (minor compression artifacts)
+- `3-4` = Very similar (slight edits, crops)
+- `5-8` = Similar (moderate edits)
+- `10+` = Loosely similar (too permissive)
+
+**Default threshold:** 5 (configurable per check or globally)
+
+---
+
+## 5. Queue & Worker Implementation
+
+### File: `src/queue/redis-queue.ts`
+
+**Redis Keys:**
+```
+phash:queue:pending    → List (FIFO for new jobs)
+phash:queue:processing → List (jobs being worked on)
+phash:queue:failed     → List (jobs that exceeded retries)
+```
+
+**State Transitions:**
+
+```
+Pending → Pop (LPOP) → Processing (RPUSH) → Complete (LREM)
+                       └─→ Retry (RPUSH to Pending)
+                       └─→ Failed (RPUSH to Failed)
+```
+
+**Job Structure:**
+
+```typescript
+interface ImageJob {
+  postUri: string          // "at://did/app.bsky.feed.post/rkey"
+  postCid: string          // CID of the post
+  postDid: string          // Author DID
+  blobs: BlobReference[]   // [{cid, mimeType?}]
+  timestamp: number        // When job was created
+  attempts: number         // Retry counter
+}
+```
+
+### File: `src/queue/worker.ts`
+
+**Worker Configuration:**
+```typescript
+interface WorkerConfig {
+  concurrency: number      // Number of parallel workers (default: 10)
+  retryAttempts: number    // Max retries (default: 3)
+  retryDelay: number       // MS between retries (default: 1000)
+  pollInterval?: number    // MS to wait if queue empty (default: 1000)
+}
+```
+
+**Processing Loop (per worker thread):**
+
+```
+1. Dequeue job
+2. For each blob in job:
+   a. Check cache
+   b. If miss, fetch blob from PDS
+   c. Compute phash
+   d. Store in cache
+   e. Match against checks
+   f. If match, emit onMatchFound event
+3. Mark job complete
+4. If error and retries < max:
+   - Re-enqueue with incremented attempts
+5. If error and retries exhausted:
+   - Move to failed queue
+```
+
+**Error Handling:**
+- Corrupt/invalid images → logged at debug level (expected)
+- Network errors → retry (with backoff)
+- Moderation action failures → logged but don't block further processing
+
+**Concurrency Strategy:**
+- N workers running in parallel (default 10)
+- Each worker independently polls queue
+- Active job count tracked
+- Graceful shutdown waits for all jobs
+
+---
+
+## 6. Image Processing Pipeline
+
+### File: `src/processor/image-processor.ts`
+
+**High-Level Flow:**
+
+```
+1. DID/Check filtering (ignoreDID)
+2. Cache lookup → if hit, use cached phash
+3. Cache miss:
+   a. Resolve PDS endpoint from DID document (PLCy)
+   b. Check if repo has been taken down
+   c. Fetch blob from PDS
+   d. Compute phash
+   e. Cache result
+4. Match against checks
+5. Return MatchResult (if match found)
+```
+
+**Key Implementation Details:**
+
+**DID → PDS Resolution:**
+```typescript
+resolvePds(did: string) {
+  // GET https://plc.directory/{did}
+  // Extract service with id="atproto_pds" and type="AtprotoPersonalDataServer"
+  // Return serviceEndpoint URL
+  
+  // Cached per DID to avoid repeated lookups
+}
+```
+
+**Blob Fetch:**
+```typescript
+// GET {pdsEndpoint}/xrpc/com.atproto.sync.getBlob?did={did}&cid={cid}
+// Returns raw blob data as Buffer
+// Includes redirect: 'follow' to handle PDS redirects
+```
+
+**Taken-Down Repo Check:**
+```typescript
+checkRepoTakendown(did: string, pdsEndpoint: string) {
+  // GET {pdsEndpoint}/xrpc/com.atproto.repo.describeRepo?repo={did}
+  // If error === "RepoTakendown", skip processing
+  // Cached per DID to avoid repeated checks
+}
+```
+
+**MatchResult Creation:**
+```typescript
+createMatchResult(phash: string, check: BlobCheck): MatchResult | null {
+  for (const checkPhash of check.phashes) {
+    const distance = hammingDistance(phash, checkPhash)
+    const threshold = check.hammingThreshold ?? defaultThreshold
+    
+    if (distance <= threshold) {
+      return {
+        phash,
+        matchedCheck: check,
+        matchedPhash: checkPhash,
+        hammingDistance: distance
+      }
+    }
+  }
+  return null
+}
+```
+
+**Caches (in-memory, in ImageProcessor):**
+```typescript
+pdsCache: Map<did, pdsEndpoint|null>     // PDS resolution
+repoTakendownCache: Map<did, boolean>    // Taken-down status
+```
+
+**These are NOT persisted** - they're per-process memory optimization.
+
+---
+
+## 7. Redis Cache Structure
+
+### File: `src/cache/phash-cache.ts`
+
+**Purpose:** Cache computed phashes to avoid re-fetching viral images
+
+**Key Pattern:** `phash:cache:{cid}` → hex string (phash)
+
+**TTL:** Configurable (default: 86400 seconds = 24 hours)
+
+**Operations:**
+- `get(cid)` → returns cached phash or null
+- `set(cid, phash)` → stores with TTL
+- `delete(cid)` → immediate removal
+- `clear()` → remove all cache entries
+- `getStats()` → returns cache size
+
+**Cache Hit Rate:**
+- Metrics track cache hits vs misses
+- Typical: 20-40% hit rate (viral images)
+
+---
+
+## 8. Moderation Claims (Deduplication)
+
+### File: `src/cache/moderation-claims.ts`
+
+**Purpose:** Prevent duplicate moderation actions (labels/reports) within 7 days
+
+**Key Patterns:**
+```
+claim:post:label:{uri}:{label}     → "1" (TTL: 7 days)
+claim:account:label:{did}:{label}  → "1" (TTL: 7 days)
+claim:account:comment:{did}:{uri}  → "1" (TTL: 7 days)
+```
+
+**TTL:** 604800 seconds = 7 days (hardcoded, not configurable)
+
+**Operations (all use SET ... NX):**
+- `tryClaimPostLabel(uri, label)` → tries to acquire claim, returns boolean
+- `tryClaimAccountLabel(did, label)` → tries to acquire claim, returns boolean
+- `tryClaimAccountComment(did, uri)` → tries to acquire claim, returns boolean
+
+**Flow in Moderation Actions:**
+
+```typescript
+// Before creating post label
+const claimed = await claims.tryClaimPostLabel(uri, label)
+if (!claimed) {
+  // Already labeled in past 7 days
+  metrics?.increment("labelsCached")
+  return
+}
+
+// Then check if label already exists in Ozone (race condition safety)
+const hasLabel = await checkRecordLabels(uri, label)
+if (hasLabel) {
+  metrics?.increment("labelsCached")
+  return
+}
+
+// Otherwise, create label via Ozone API
+```
+
+**Why both checks?**
+1. Redis claim = "we acted" (fast, distributed)
+2. Ozone check = "label still exists" (authoritative)
+- This handles race conditions if multiple services label simultaneously
+
+---
+
+## 9. Moderation Action Flows
+
+### File: `src/moderation/post.ts`
+
+**createPostLabel:**
+```typescript
+// 1. Try claim → if fail, exit (already labeled recently)
+// 2. Check if label exists → if yes, exit
+// 3. Emit event via Ozone API:
+//    - $type: "tools.ozone.moderation.defs#modEventLabel"
+//    - subject: {uri, cid} (strongRef)
+//    - createLabelVals: [label]
+//    - comment: "{timestamp}: {comment} at {uri} with phash \"{phash}\""
+// 4. Rate-limited via limit() function
+```
+
+**createPostReport:**
+```typescript
+// Same flow but:
+//    - $type: "tools.ozone.moderation.defs#modEventReport"
+//    - reportType: "com.atproto.moderation.defs#reasonOther"
+//    - No claim check needed (reports can repeat)
+```
+
+### File: `src/moderation/account.ts`
+
+**createAccountLabel:**
+```typescript
+// Similar to post label but:
+//    - subject: {$type: "com.atproto.admin.defs#repoRef", did}
+//    - Claims work per (did, label) pair
+```
+
+**createAccountReport:**
+```typescript
+// Similar to post report but:
+//    - subject: {$type: "com.atproto.admin.defs#repoRef", did}
+```
+
+**createAccountComment:**
+```typescript
+// Comments on account (metadata only, no label)
+// Claims prevent duplicate comments for same (did, uri) pair
+```
+
+**API Headers (All Moderation Calls):**
+```typescript
+{
+  encoding: "application/json",
+  headers: {
+    "atproto-proxy": `${modDid}#atproto_labeler`,
+    "atproto-accept-labelers": "did:plc:ar7c4by46qjdydhdevvrndac;redact"
+  }
+}
+```
+
+**These headers:**
+- Tell Ozone to proxy request through moderation account
+- Request redaction of sensitive PII
+- Are critical for proper audit trails
+
+---
+
+## 10. Rate Limiting
+
+### File: `src/limits.ts`
+
+**Two-Level Strategy:**
+
+**Level 1: Concurrency Control**
+- p-ratelimit library
+- Limits to 24 concurrent requests
+- Prevents overwhelming Ozone API with simultaneous requests
+
+**Level 2: Header-Based Rate Limit Tracking**
+- Ozone API returns headers: `RateLimit-Limit`, `RateLimit-Remaining`, `RateLimit-Reset`
+- Service maintains state and waits if critically low
+- Safety buffer: 5 requests reserved
+- Only waits if `remaining <= 5`
+
+**Dynamic Rate Limit State:**
+```typescript
+interface RateLimitState {
+  limit: number              // e.g., 280 requests per window
+  remaining: number          // Current budget
+  reset: number              // Unix timestamp when resets
+}
+```
+
+**How moderation actions use limits:**
+```typescript
+await limit(async () => {
+  // This will:
+  // 1. Check concurrency (max 24 concurrent)
+  // 2. Check remaining budget (wait if <5 remaining)
+  // 3. Execute request
+  // 4. Parse RateLimit headers and update state
+  return await agent.tools.ozone.moderation.emitEvent(...)
+})
+```
+
+**Prometheus Metrics:**
+- `rate_limit_waits_total` → how many times we waited
+- `rate_limit_wait_duration_seconds` → how long waits took
+- `concurrent_requests` → live count of concurrent calls
+
+---
+
+## 11. Agent & Authentication
+
+### File: `src/agent.ts`
+
+**Session Management:**
+
+```typescript
+// Session file: .session (chmod 600, NOT in git)
+// Contains: {accessJwt, refreshJwt, did, handle, email, ...}
+
+// Login flow:
+1. Try load session from .session file
+2. If loaded, try resume session (verify with getProfile call)
+3. If resume fails or no saved session, perform fresh login
+4. Save session after successful login
+
+// Token refresh:
+- JWT lifetime: 2 hours
+- Refresh scheduled at 80% of lifetime (~96 minutes)
+- On refresh failure, fallback to fresh login with retries
+```
+
+**Retry Strategy:**
+- MAX_LOGIN_RETRIES = 3
+- RETRY_DELAY_MS = 2000
+- If all retries fail, process exits with error
+
+**Undici Configuration:**
+```typescript
+const dispatcher = new Agent({
+  connect: { timeout: 20_000 },
+  keepAliveTimeout: 10_000,
+  keepAliveMaxTimeout: 20_000
+})
+setGlobalDispatcher(dispatcher)
+```
+
+This ensures robust HTTP handling for PDS/Ozone API calls.
+
+---
+
+## 12. Configuration Management
+
+### File: `src/config/index.ts`
+
+**All settings sourced from environment variables:**
+
+```typescript
+// REQUIRED
+LABELER_DID              // e.g., "did:plc:..."
+LABELER_HANDLE           // e.g., "labeler.bsky.social"
+LABELER_PASSWORD         // app password (NOT user password)
+
+// Processing
+JETSTREAM_URL                      // (default: wss://jetstream.atproto.tools/subscribe)
+REDIS_URL                          // (default: redis://localhost:6379)
+PROCESSING_CONCURRENCY             // (default: 10)
+RETRY_ATTEMPTS                     // (default: 3)
+RETRY_DELAY_MS                     // (default: 1000)
+CACHE_ENABLED                      // (default: true)
+CACHE_TTL_SECONDS                  // (default: 86400)
+
+// PDS/Ozone
+PDS_ENDPOINT                       // (default: https://bsky.social)
+OZONE_URL                          // (no default)
+OZONE_PDS                          // (no default - used for agent.service)
+MOD_DID                            // (no default - used in moderation headers)
+
+// Phash
+PHASH_HAMMING_THRESHOLD            // (default: 3)
+
+// Logging
+LOG_LEVEL                          // (default: debug/info)
+NODE_ENV                           // (defaults to production)
+```
+
+---
+
+## 13. Metrics & Observability
+
+### File: `src/metrics/collector.ts`
+
+**Simple in-memory metrics:**
+
+```typescript
+class MetricsCollector {
+  counters: Map<string, number>
+  
+  increment(metric: string, value?: number)
+  get(metric: string): number
+  getAll(): Record<string, number>
+  getWithRates(): Record<string, number|string>
+}
+```
+
+**Key Metrics Tracked:**
+
+```
+postsProcessed          // Jobs completed
+blobsFetched            // Blobs downloaded
+blobsProcessed          // Blobs hashed successfully
+blobsCorrupted          // Invalid images skipped
+fetchErrors             // Blob fetch failures
+cacheHits               // Phash cache hits
+cacheMisses             // Phash cache misses
+matchesFound            // Images matching known phashes
+labelsApplied           // Labels successfully created
+labelsCached            // Labels skipped (already claimed)
+reportsCreated          // Reports successfully created
+```
+
+**Derived Rates (calculated on-demand):**
+```
+postsPerSecond = postsProcessed / uptimeSeconds
+blobsPerSecond = blobsProcessed / uptimeSeconds
+cacheHitRate = cacheHits / (cacheHits + cacheMisses) * 100
+matchRate = matchesFound / blobsProcessed * 100
+```
+
+**Prometheus Integration:**
+- Rate limit metrics via prom-client
+- Not exposed as metrics server (would need HTTP server)
+
+**Stats Logged:**
+- Every 60 seconds to logger
+- Includes worker stats, cache stats, metrics with rates
+
+---
+
+## 14. Logging
+
+### File: `src/logger/index.ts`
+
+**Pino-based structured logging:**
+
+```typescript
+logger.debug(...)  // Development details
+logger.info(...)   // Normal operation milestones
+logger.warn(...)   // Unexpected but recoverable
+logger.error(...)  // Errors (usually don't stop service)
+```
+
+**Development Mode:**
+- Pretty-printed output
+- Colors, timestamps, field names
+- Ignores pid/hostname
+
+**Production Mode:**
+- JSON logs (newline-delimited)
+- Parse with jq or log aggregators
+- Structured for monitoring
+
+**Log Levels:**
+- `process` field added manually to track sub-components
+- Examples: `{process: "MAIN"}`, `{process: "MODERATION"}`
+
+---
+
+## 15. Rules Configuration
+
+### File: `rules/blobs.ts`
+
+**BlobCheck structure:**
+
+```typescript
+interface BlobCheck {
+  phashes: string[]              // List of known bad phashes
+  label: string                  // Label to apply (e.g., "troll")
+  comment: string                // Description of harm
+  reportAcct: boolean            // Report the account?
+  labelAcct: boolean             // Label the account?
+  reportPost: boolean            // Report the post?
+  toLabel: boolean               // Label the post?
+  hammingThreshold?: number      // Per-check threshold (overrides default)
+  description?: string           // Internal documentation
+  ignoreDID?: string[]           // Exempt accounts
+}
+```
+
+**Multiple checks evaluated in order:**
+- First match wins (no combining of multiple checks)
+- Each check can independently configure moderation actions
+
+**Example:**
+
+```typescript
+{
+  phashes: ["e0e0e0e0e0fcfefe", "9b9e00008f8fffff"],
+  label: "harassment-image",
+  comment: "Known harassment image",
+  toLabel: true,           // Label post
+  reportPost: false,       // Don't report post
+  labelAcct: true,         // Label account
+  reportAcct: false,       // Don't report account
+  hammingThreshold: 3,     // Strict threshold
+  ignoreDID: ["did:plc:trusted-account"]  // Don't check this account
+}
+```
+
+---
+
+## 16. Critical Gotchas & Nuances for Rust Rewrite
+
+### 1. **Phash Algorithm Details**
+- Output MUST be exactly 16 hex chars (64-bit)
+- Lowercase
+- Zero-padded
+- Grayscale conversion via luminosity formula (not simple average)
+- 8x8 resize with aspect-ratio preservation
+
+### 2. **Hamming Distance**
+- Uses Brian Kernighan's bit-counting algorithm
+- Range 0-64
+- Threshold comparison is `distance <= threshold` (INCLUSIVE)
+
+### 3. **Cursor Persistence**
+- Is microsecond timestamp (NOT millisecond)
+- Must persist every 10 seconds
+- Resume from cursor prevents duplicate processing
+- Write to `cursor.txt` in working directory
+
+### 4. **Queue State Machine**
+- Never lose jobs mid-processing
+- Pending → Processing → Complete is atomic per job
+- On crash, jobs in Processing list are reprocessed on restart
+- Failed queue accumulates jobs beyond retry limit
+
+### 5. **Blob Fetch Strategy**
+- Requires PDS resolution from PLCy first
+- Many PDSes redirect blob endpoints
+- Must follow redirects
+- Check repo.takedown status before fetching
+- Cache both PDS endpoint and takedown status (per process)
+
+### 6. **Moderation Claims Dedup**
+- 7-day TTL (hardcoded in moderation-claims.ts)
+- Uses Redis SET ... NX (atomic)
+- Must still check Ozone API (race condition safety)
+- Account claims are per (did, label) pair
+
+### 7. **Rate Limiting**
+- TWO separate mechanisms (concurrency + header-based)
+- Only waits when `remaining <= 5` (safety buffer)
+- Ozone returns RateLimit headers
+- Conservative defaults: 280 requests per 30-second window
+- Must not block job processing (only moderation action calls)
+
+### 8. **Session Token Management**
+- Tokens live ~2 hours
+- Refresh at 80% of lifetime (~96 minutes)
+- Session saved to `.session` file (must be chmod 600)
+- Resume session before fresh login
+- Multiple login attempts = shared promise (singleton)
+
+### 9. **Image Mime Type Filtering**
+- Skip SVG images
+- Only process image/* types
+- mimeType may be missing (optional field)
+
+### 10. **Error Handling Patterns**
+- Corrupt images → debug log, skip (expected)
+- Network errors → retry with backoff
+- Moderation action failures → log but continue (don't block)
+- Takden-down repos → skip silently
+- Missing PDS → warn and skip blob
+
+### 11. **Config Environment Variables**
+- No defaults for labeler credentials (must be provided)
+- Ozone URL/PDS used differently (URL is separate from service endpoint)
+- OZONE_PDS is the agent.service endpoint
+- OZONE_URL is for display/configuration only
+
+### 12. **Redis Key Patterns**
+```
+phash:queue:pending      → List
+phash:queue:processing   → List
+phash:queue:failed       → List
+phash:cache:{cid}        → String
+claim:post:label:{uri}:{label}     → String
+claim:account:label:{did}:{label}  → String
+claim:account:comment:{did}:{uri}  → String
+```
+
+### 13. **Jetstream Event Structure**
+- Only processes `app.bsky.feed.post` creates
+- Ignores updates/deletes
+- Image extraction handles nested embed structures
+- Blob CID in `ref.$link` field
+
+### 14. **Metrics Naming Conventions**
+- Snake_case for Prometheus metrics
+- Counter suffixes: `_total`
+- Gauge suffixes: none (just name)
+- Histogram suffixes: `_seconds` (for duration)
+
+### 15. **Graceful Shutdown**
+- Saves cursor to disk
+- Waits for active jobs (polling every 100ms)
+- Closes all connections
+- SIGINT/SIGTERM trigger shutdown
+
+---
+
+## Architecture Strengths & Assumptions
+
+**What Works Well:**
+1. ✅ Decoupled Jetstream ingestion from processing (queue isolates)
+2. ✅ Per-job retry strategy with exponential backoff
+3. ✅ Cache hit rate for viral images reduces PDS load
+4. ✅ Redis claims prevent duplicate moderation actions
+5. ✅ Cursor persistence enables recovery
+6. ✅ Rate limiting respects Ozone API limits
+
+**Assumptions/Constraints:**
+1. Redis is always available (no in-memory fallback)
+2. PDS/Ozone/PLCy endpoints are reachable
+3. Jetstream can resume from cursor
+4. Single-process (no distributed workers)
+5. In-memory caches (PDS/takdown) lost on restart
+
+---
+
+## Typical Performance Characteristics
+
+**VM Requirements (from README):**
+- **Minimal:** 2GB RAM, 2 vCPU, 10GB disk
+- **Recommended:** 4GB RAM, 2-4 vCPU, 20GB disk
+
+**Throughput:**
+- Concurrency default: 10 workers
+- Each worker can process ~1-5 images/second (depends on network)
+- Total: 10-50 images/second throughput
+- Cache hit rate: 20-40% (viral images)
+
+**Latency:**
+- Jetstream event → job enqueue: <100ms
+- Job dequeue → phash computed: 200-500ms (depends on network/image size)
+- Phash → moderation action: 100-200ms (rate-limited)
+
+---
+
+## Testing Coverage
+
+**Unit Tests Exist For:**
+- ✅ Phash algorithm (format, determinism, slight variations)
+- ✅ Hamming distance (exact match, thresholds, edge cases)
+- ✅ Cache hit/miss
+- ✅ Queue operations
+- ✅ Image processor logic
+
+**Integration Tests:**
+- ✅ Queue persistence across restart
+- ✅ End-to-end job processing
+
+**No Tests For:**
+- Jetstream connection handling
+- Moderation action API calls
+- Session management
+- Rate limiting
+
+---
+
+## File Structure Summary
+
+```
+src/
+├── main.ts                           # Entry point, Jetstream orchestrator
+├── types.ts                          # Core interfaces (BlobCheck, ImageJob, MatchResult)
+├── agent.ts                          # ATProto agent, session management
+├── session.ts                        # Session file persistence
+├── limits.ts                         # Rate limiting (concurrency + header-based)
+├── config/
+│   └── index.ts                      # Environment variable parsing
+├── logger/
+│   └── index.ts                      # Pino structured logging
+├── hasher/
+│   └── phash.ts                      # Perceptual hash computation
+├── matcher/
+│   └── hamming.ts                    # Hamming distance, match finding
+├── cache/
+│   ├── phash-cache.ts                # Redis phash cache
+│   └── moderation-claims.ts          # Redis deduplication claims
+├── queue/
+│   ├── redis-queue.ts                # Redis job queue
+│   └── worker.ts                     # Worker pool, job processing loop
+├── processor/
+│   └── image-processor.ts            # Blob fetch, phash compute, matching
+├── moderation/
+│   ├── post.ts                       # Post label/report actions
+│   └── account.ts                    # Account label/report/comment actions
+└── metrics/
+    └── collector.ts                  # In-memory metrics
+
+rules/
+└── blobs.ts                          # BlobCheck definitions
+
+tests/
+├── unit/
+│   ├── phash.test.ts
+│   ├── hamming.test.ts
+│   ├── phash-cache.test.ts
+│   └── image-processor.test.ts
+└── integration/
+    └── queue.test.ts
+```
+
+---
+
+## Entry Point Summary
+
+The entire system starts with:
+
+1. **main.ts** loads config, connects Redis, logs in to Ozone
+2. **Jetstream** connects and starts emitting post events
+3. **Queue** receives jobs (post + blob CIDs)
+4. **Worker pool** dequeues jobs and processes them in parallel
+5. **ImageProcessor** fetches blobs, computes phashes, finds matches
+6. **Moderation** actions (label/report) triggered on matches
+7. **Metrics/Logging** tracked throughout
+8. **Graceful shutdown** saves cursor and exits cleanly
+
+This is a **real-time, event-driven system** - no polling, no batch processing. Every post on Bluesky is potentially seen and processed within seconds.
+

Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "abnf"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "087113bd50d9adce24850eed5d0476c7d199d532fce8fab5173650331e09033a"
+dependencies = [
+ "abnf-core",
+ "nom 7.1.3",
+]
+
+[[package]]
+name = "abnf-core"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c44e09c43ae1c368fb91a03a566472d0087c26cf7e1b9e8e289c14ede681dd7d"
+dependencies = [
+ "nom 7.1.3",
+]
+
+[[package]]
+name = "addr2line"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "adler32"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "aliasable"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
+
+[[package]]
+name = "aligned-vec"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b"
+dependencies = [
+ "equator",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+
+[[package]]
+name = "arc-swap"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
+
+[[package]]
+name = "arg_enum_proc_macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "ascii"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"
+
+[[package]]
+name = "assert-json-diff"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "async-compression"
+version = "0.4.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a89bce6054c720275ac2432fbba080a66a2106a44a1b804553930ca6909f4e0"
+dependencies = [
+ "compression-codecs",
+ "compression-core",
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "av1-grain"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "log",
+ "nom 8.0.0",
+ "num-rational",
+ "v_frame",
+]
+
+[[package]]
+name = "avif-serialize"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47c8fbc0f831f4519fe8b810b6a7a91410ec83031b8233f730a0480029f6a23f"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "backon"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef"
+dependencies = [
+ "fastrand",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "backtrace-ext"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"
+dependencies = [
+ "backtrace",
+]
+
+[[package]]
+name = "base-x"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base256emoji"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e9430d9a245a77c92176e649af6e275f20839a48389859d1661e9a128d077c"
+dependencies = [
+ "const-str",
+ "match-lookup",
+]
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
+
+[[package]]
+name = "bit_field"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "bitstream-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6099cdc01846bc367c4e7dd630dc5966dccf36b652fae7a74e17b640411a91b2"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bon"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebeb9aaf9329dff6ceb65c689ca3db33dbf15f324909c60e4e5eef5701ce31b1"
+dependencies = [
+ "bon-macros",
+ "rustversion",
+]
+
+[[package]]
+name = "bon-macros"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77e9d642a7e3a318e37c2c9427b5a6a48aa1ad55dcd986f3034ab2239045a645"
+dependencies = [
+ "darling",
+ "ident_case",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "borsh"
+version = "1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce"
+dependencies = [
+ "cfg_aliases",
+]
+
+[[package]]
+name = "brotli"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "btree-range-map"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1be5c9672446d3800bcbcaabaeba121fe22f1fb25700c4562b22faf76d377c33"
+dependencies = [
+ "btree-slab",
+ "cc-traits",
+ "range-traits",
+ "serde",
+ "slab",
+]
+
+[[package]]
+name = "btree-slab"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2b56d3029f075c4fa892428a098425b86cef5c89ae54073137ece416aef13c"
+dependencies = [
+ "cc-traits",
+ "slab",
+ "smallvec",
+]
+
+[[package]]
+name = "buf_redux"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f"
+dependencies = [
+ "memchr",
+ "safemem",
+]
+
+[[package]]
+name = "built"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ed6191a7e78c36abdb16ab65341eefd73d64d303fffccdbb00d51e4205967b"
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "bytemuck"
+version = "1.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cbor4ii"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544cf8c89359205f4f990d0e6f3828db42df85b5dac95d09157a250eb0749c4"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cc-traits"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "060303ef31ef4a522737e1b1ab68c67916f2a787bb2f4f54f383279adba962b5"
+dependencies = [
+ "slab",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "chunked_transfer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "cid"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3147d8272e8fa0ccd29ce51194dd98f79ddfb8191ba9e3409884e751798acf3a"
+dependencies = [
+ "core2",
+ "multibase",
+ "multihash",
+ "serde",
+ "serde_bytes",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "colored"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "compression-codecs"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef8a506ec4b81c460798f572caead636d57d3d7e940f998160f52bd254bf2d23"
+dependencies = [
+ "compression-core",
+ "flate2",
+ "memchr",
+]
+
+[[package]]
+name = "compression-core"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-str"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f421161cb492475f1661ddc9815a745a1c894592070661180fdec3d4872e9c3"
+
+[[package]]
+name = "cordyceps"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "688d7fbb8092b8de775ef2536f36c8c31f2bc4006ece2e8d8ad2d17d00ce0a2a"
+dependencies = [
+ "loom",
+ "tracing",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core2"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
+[[package]]
+name = "data-encoding-macro"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47ce6c96ea0102f01122a185683611bd5ac8d99e62bc59dd12e6bda344ee673d"
+dependencies = [
+ "data-encoding",
+ "data-encoding-macro-internal",
+]
+
+[[package]]
+name = "data-encoding-macro-internal"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d162beedaa69905488a8da94f5ac3edb4dd4788b732fadb7bd120b2625c1976"
+dependencies = [
+ "data-encoding",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "deflate"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c86f7e25f518f4b81808a2cf1c50996a61f5c2eb394b2393bd87f2a4780a432f"
+dependencies = [
+ "adler32",
+ "gzip-header",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "unicode-xid",
+]
+
+[[package]]
+name = "diatomic-waker"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab03c107fafeb3ee9f5925686dbb7a73bc76e3932abb0d2b365cb64b169cf04c"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pem-rfc7468",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "equator"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc"
+dependencies = [
+ "equator-macro",
+]
+
+[[package]]
+name = "equator-macro"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "exr"
+version = "1.73.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83197f59927b46c04a183a619b7c29df34e63e63c7869320862268c0ef687e0"
+dependencies = [
+ "bit_field",
+ "half",
+ "lebe",
+ "miniz_oxide",
+ "rayon-core",
+ "smallvec",
+ "zune-inflate",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fax"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05de7d48f37cd6730705cbca900770cab77a89f413d23e100ad7fad7795a0ab"
+dependencies = [
+ "fax_derive",
+]
+
+[[package]]
+name = "fax_derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0aca10fb742cb43f9e7bb8467c91aa9bcb8e3ffbc6a6f7389bb93ffc920577d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
+[[package]]
+name = "flate2"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843"
+dependencies = [
+ "mac",
+ "new_debug_unreachable",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-buffered"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8e0e1f38ec07ba4abbde21eed377082f17ccb988be9d988a5adbf4bafc118fd"
+dependencies = [
+ "cordyceps",
+ "diatomic-waker",
+ "futures-core",
+ "pin-project-lite",
+ "spin 0.10.0",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generator"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "605183a538e3e2a9c1038635cc5c2d194e2ee8fd0d1b66b8349fad7dbacce5a2"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "log",
+ "rustversion",
+ "windows",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "gif"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae047235e33e2829703574b54fdec96bfbad892062d97fed2f76022287de61b"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
+[[package]]
+name = "gimli"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+
+[[package]]
+name = "governor"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be93b4ec2e4710b04d9264c0c7350cdd62a8c20e5e4ac732552ebb8f0debe8eb"
+dependencies = [
+ "cfg-if",
+ "dashmap",
+ "futures-sink",
+ "futures-timer",
+ "futures-util",
+ "getrandom 0.3.4",
+ "no-std-compat",
+ "nonzero_ext",
+ "parking_lot",
+ "portable-atomic",
+ "quanta",
+ "rand 0.9.2",
+ "smallvec",
+ "spinning_top",
+ "web-time",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "gzip-header"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95cc527b92e6029a62960ad99aa8a6660faa4555fe5f731aab13aa6a921795a2"
+dependencies = [
+ "crc32fast",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex_fmt"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b07f60793ff0a4d9cef0f18e63b5357e06209987153a64648c972c1e5aff336f"
+
+[[package]]
+name = "hickory-proto"
+version = "0.24.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92652067c9ce6f66ce53cc38d1169daa36e6e7eb7dd3b63b5103bd9d97117248"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna",
+ "ipnet",
+ "once_cell",
+ "rand 0.8.5",
+ "thiserror 1.0.69",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-resolver"
+version = "0.24.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbb117a1ca520e111743ab2f6688eddee69db4e0ea242545a604dce8a66fd22e"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-proto",
+ "ipconfig",
+ "lru-cache",
+ "once_cell",
+ "parking_lot",
+ "rand 0.8.5",
+ "resolv-conf",
+ "smallvec",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "home"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "html5ever"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13771afe0e6e846f1e67d038d4cb29998a6779f93c809212e4e9c32efd244d4"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "http"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower-service",
+ "webpki-roots",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2 0.6.1",
+ "system-configuration",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "windows-registry",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "image"
+version = "0.25.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "529feb3e6769d234375c4cf1ee2ce713682b8e76538cb13f9fc23e1400a591e7"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "color_quant",
+ "exr",
+ "gif",
+ "image-webp",
+ "moxcms",
+ "num-traits",
+ "png",
+ "qoi",
+ "ravif",
+ "rayon",
+ "rgb",
+ "tiff",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
+dependencies = [
+ "byteorder-lite",
+ "quick-error 2.0.1",
+]
+
+[[package]]
+name = "image_hasher"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c191dc6138f559a0177b8413eaf2a37784d8e63c697e247aa3740930f1c9364"
+dependencies = [
+ "base64 0.22.1",
+ "image",
+ "rustdct",
+ "serde",
+ "transpose",
+]
+
+[[package]]
+name = "imgref"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c5cedc30da3a610cac6b4ba17597bdf7152cf974e8aab3afb3d54455e371c8"
+
+[[package]]
+name = "indexmap"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.0",
+]
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "interpolate_name"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "ipconfig"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
+dependencies = [
+ "socket2 0.5.10",
+ "widestring",
+ "windows-sys 0.48.0",
+ "winreg",
+]
+
+[[package]]
+name = "ipld-core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "104718b1cc124d92a6d01ca9c9258a7df311405debb3408c445a36452f9bf8db"
+dependencies = [
+ "cid",
+ "serde",
+ "serde_bytes",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iri-string"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "is_ci"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jacquard"
+version = "0.7.0"
+dependencies = [
+ "bon",
+ "bytes",
+ "getrandom 0.2.16",
+ "http",
+ "jacquard-api",
+ "jacquard-common",
+ "jacquard-derive",
+ "jacquard-identity",
+ "jacquard-oauth",
+ "jose-jwk",
+ "miette",
+ "p256",
+ "percent-encoding",
+ "rand_core 0.6.4",
+ "regex",
+ "reqwest",
+ "serde",
+ "serde_html_form",
+ "serde_ipld_dagcbor",
+ "serde_json",
+ "smol_str",
+ "thiserror 2.0.17",
+ "tokio",
+ "trait-variant",
+ "url",
+ "webpage",
+]
+
+[[package]]
+name = "jacquard-api"
+version = "0.7.1"
+dependencies = [
+ "bon",
+ "bytes",
+ "jacquard-common",
+ "jacquard-derive",
+ "miette",
+ "serde",
+ "serde_ipld_dagcbor",
+ "thiserror 2.0.17",
+]
+
+[[package]]
+name = "jacquard-common"
+version = "0.7.0"
+dependencies = [
+ "base64 0.22.1",
+ "bon",
+ "bytes",
+ "chrono",
+ "ciborium",
+ "cid",
+ "futures",
+ "getrandom 0.2.16",
+ "getrandom 0.3.4",
+ "http",
+ "ipld-core",
+ "k256",
+ "langtag",
+ "miette",
+ "multibase",
+ "multihash",
+ "n0-future",
+ "ouroboros",
+ "p256",
+ "rand 0.9.2",
+ "regex",
+ "reqwest",
+ "serde",
+ "serde_html_form",
+ "serde_ipld_dagcbor",
+ "serde_json",
+ "signature",
+ "smol_str",
+ "thiserror 2.0.17",
+ "tokio",
+ "tokio-tungstenite-wasm",
+ "tokio-util",
+ "trait-variant",
+ "url",
+]
+
+[[package]]
+name = "jacquard-derive"
+version = "0.7.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "jacquard-identity"
+version = "0.7.0"
+dependencies = [
+ "bon",
+ "bytes",
+ "hickory-resolver",
+ "http",
+ "jacquard-api",
+ "jacquard-common",
+ "miette",
+ "percent-encoding",
+ "reqwest",
+ "serde",
+ "serde_html_form",
+ "serde_json",
+ "thiserror 2.0.17",
+ "tokio",
+ "trait-variant",
+ "url",
+ "urlencoding",
+]
+
+[[package]]
+name = "jacquard-oauth"
+version = "0.7.0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "chrono",
+ "dashmap",
+ "elliptic-curve",
+ "http",
+ "jacquard-common",
+ "jacquard-identity",
+ "jose-jwa",
+ "jose-jwk",
+ "miette",
+ "p256",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
+ "reqwest",
+ "rouille",
+ "serde",
+ "serde_html_form",
+ "serde_json",
+ "sha2",
+ "signature",
+ "smol_str",
+ "thiserror 2.0.17",
+ "tokio",
+ "trait-variant",
+ "url",
+ "webbrowser",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "jose-b64"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec69375368709666b21c76965ce67549f2d2db7605f1f8707d17c9656801b56"
+dependencies = [
+ "base64ct",
+ "serde",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "jose-jwa"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab78e053fe886a351d67cf0d194c000f9d0dcb92906eb34d853d7e758a4b3a7"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "jose-jwk"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "280fa263807fe0782ecb6f2baadc28dffc04e00558a58e33bfdb801d11fd58e7"
+dependencies = [
+ "jose-b64",
+ "jose-jwa",
+ "p256",
+ "p384",
+ "rsa",
+ "serde",
+ "zeroize",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "sha2",
+]
+
+[[package]]
+name = "langtag"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ecb4c689a30e48ebeaa14237f34037e300dd072e6ad21a9ec72e810ff3c6600"
+dependencies = [
+ "serde",
+ "static-regular-grammar",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+dependencies = [
+ "spin 0.9.8",
+]
+
+[[package]]
+name = "lebe"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5037190e1f70cbeef565bd267599242926f724d3b8a9f510fd7e0b540cfa4404"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
+[[package]]
+name = "libredox"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+dependencies = [
+ "bitflags",
+ "libc",
+ "redox_syscall",
+]
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "loom"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
+dependencies = [
+ "cfg-if",
+ "generator",
+ "scoped-tls",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "loop9"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
+dependencies = [
+ "imgref",
+]
+
+[[package]]
+name = "lru-cache"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "mac"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
+
+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16ce3abbeba692c8b8441d036ef91aea6df8da2c6b6e21c7e14d3c18e526be45"
+dependencies = [
+ "log",
+ "phf",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+ "tendril",
+]
+
+[[package]]
+name = "markup5ever_rcdom"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edaa21ab3701bfee5099ade5f7e1f84553fd19228cf332f13cd6e964bf59be18"
+dependencies = [
+ "html5ever",
+ "markup5ever",
+ "tendril",
+ "xml5ever",
+]
+
+[[package]]
+name = "match-lookup"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1265724d8cb29dbbc2b0f06fffb8bf1a8c0cf73a78eede9ba73a4a66c52a981e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "maybe-rayon"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
+dependencies = [
+ "cfg-if",
+ "rayon",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "miette"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
+dependencies = [
+ "backtrace",
+ "backtrace-ext",
+ "cfg-if",
+ "miette-derive",
+ "owo-colors",
+ "supports-color",
+ "supports-hyperlinks",
+ "supports-unicode",
+ "terminal_size",
+ "textwrap",
+ "unicode-width 0.1.14",
+]
+
+[[package]]
+name = "miette-derive"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "mockito"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7760e0e418d9b7e5777c0374009ca4c93861b9066f18cb334a20ce50ab63aa48"
+dependencies = [
+ "assert-json-diff",
+ "bytes",
+ "colored",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "log",
+ "rand 0.9.2",
+ "regex",
+ "serde_json",
+ "serde_urlencoded",
+ "similar",
+ "tokio",
+]
+
+[[package]]
+name = "moxcms"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c588e11a3082784af229e23e8e4ecf5bcc6fbe4f69101e0421ce8d79da7f0b40"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "multibase"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8694bb4835f452b0e3bb06dbebb1d6fc5385b6ca1caf2e55fd165c042390ec77"
+dependencies = [
+ "base-x",
+ "base256emoji",
+ "data-encoding",
+ "data-encoding-macro",
+]
+
+[[package]]
+name = "multihash"
+version = "0.19.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b430e7953c29dd6a09afc29ff0bb69c6e306329ee6794700aee27b76a1aea8d"
+dependencies = [
+ "core2",
+ "serde",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "multipart"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00dec633863867f29cb39df64a397cdf4a6354708ddd7759f70c7fb51c5f9182"
+dependencies = [
+ "buf_redux",
+ "httparse",
+ "log",
+ "mime",
+ "mime_guess",
+ "quick-error 1.2.3",
+ "rand 0.8.5",
+ "safemem",
+ "tempfile",
+ "twoway",
+]
+
+[[package]]
+name = "n0-future"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb0e5d99e681ab3c938842b96fcb41bf8a7bb4bfdb11ccbd653a7e83e06c794"
+dependencies = [
+ "cfg_aliases",
+ "derive_more",
+ "futures-buffered",
+ "futures-lite",
+ "futures-util",
+ "js-sys",
+ "pin-project",
+ "send_wrapper",
+ "tokio",
+ "tokio-util",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-time",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework 2.11.1",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "no-std-compat"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "nonzero_ext"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bf9645c8b145698bb0b18a4637dcacbc421ea49bef2317e4fd8065a387cf21"
+
+[[package]]
+name = "noop_proc_macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
+dependencies = [
+ "byteorder",
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand 0.8.5",
+ "smallvec",
+ "zeroize",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "openssl"
+version = "0.10.74"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ad14dd45412269e1a30f52ad8f0664f0f4f4a89ee8fe28c3b3527021ebb654"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.110"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a9f0075ba3c21b09f8e8b2026584b1d18d49388648f2fbbf3c97ea8deced8e2"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "ouroboros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0f050db9c44b97a94723127e6be766ac5c340c48f2c4bb3ffa11713744be59"
+dependencies = [
+ "aliasable",
+ "ouroboros_macro",
+ "static_assertions",
+]
+
+[[package]]
+name = "ouroboros_macro"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c7028bdd3d43083f6d8d4d5187680d0d3560d54df4cc9d752005268b41e64d0"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "owo-colors"
+version = "4.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
+
+[[package]]
+name = "p256"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"
+dependencies = [
+ "ecdsa",
+ "elliptic-curve",
+ "primeorder",
+ "sha2",
+]
+
+[[package]]
+name = "p384"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6"
+dependencies = [
+ "elliptic-curve",
+ "primeorder",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der",
+ "pkcs8",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "png"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "primal-check"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
+dependencies = [
+ "num-integer",
+]
+
+[[package]]
+name = "primeorder"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
+dependencies = [
+ "elliptic-curve",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proc-macro2-diagnostics"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "version_check",
+ "yansi",
+]
+
+[[package]]
+name = "profiling"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52717f9a02b6965224f95ca2a81e2e0c5c43baacd28ca057577988930b6c3d5b"
+dependencies = [
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3cbdf373972bf78df4d3b518d07003938e2c7d1fb5891e55f9cb6df57009d84"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "qoi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "quanta"
+version = "0.12.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3ab5a9d756f0d97bdc89019bd2e4ea098cf9cde50ee7564dde6b81ccc8f06c7"
+dependencies = [
+ "crossbeam-utils",
+ "libc",
+ "once_cell",
+ "raw-cpuid",
+ "wasi",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2 0.6.1",
+ "thiserror 2.0.17",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+dependencies = [
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand 0.9.2",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.17",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2 0.6.1",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "range-traits"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d20581732dd76fa913c7dff1a2412b714afe3573e94d41c34719de73337cc8ab"
+
+[[package]]
+name = "rav1e"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+dependencies = [
+ "arbitrary",
+ "arg_enum_proc_macro",
+ "arrayvec",
+ "av1-grain",
+ "bitstream-io",
+ "built",
+ "cfg-if",
+ "interpolate_name",
+ "itertools 0.12.1",
+ "libc",
+ "libfuzzer-sys",
+ "log",
+ "maybe-rayon",
+ "new_debug_unreachable",
+ "noop_proc_macro",
+ "num-derive",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "profiling",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "simd_helpers",
+ "system-deps",
+ "thiserror 1.0.69",
+ "v_frame",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ravif"
+version = "0.11.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5825c26fddd16ab9f515930d49028a630efec172e903483c94796cfe31893e6b"
+dependencies = [
+ "avif-serialize",
+ "imgref",
+ "loop9",
+ "quick-error 2.0.1",
+ "rav1e",
+ "rayon",
+ "rgb",
+]
+
+[[package]]
+name = "raw-cpuid"
+version = "11.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9"
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redis"
+version = "0.27.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d8f99a4090c89cc489a94833c901ead69bfbf3877b4867d5482e321ee875bc"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "backon",
+ "bytes",
+ "combine",
+ "futures",
+ "futures-util",
+ "itertools 0.13.0",
+ "itoa",
+ "num-bigint",
+ "percent-encoding",
+ "pin-project-lite",
+ "ryu",
+ "sha1_smol",
+ "socket2 0.5.10",
+ "tokio",
+ "tokio-util",
+ "url",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "reqwest"
+version = "0.12.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
+dependencies = [
+ "async-compression",
+ "base64 0.22.1",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-rustls",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "webpki-roots",
+]
+
+[[package]]
+name = "resolv-conf"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b3789b30bd25ba102de4beabd95d21ac45b69b1be7d14522bab988c526d6799"
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "rgb"
+version = "0.8.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce"
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.16",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rouille"
+version = "3.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3716fbf57fc1084d7a706adf4e445298d123e4a44294c4e8213caf1b85fcc921"
+dependencies = [
+ "base64 0.13.1",
+ "brotli",
+ "chrono",
+ "deflate",
+ "filetime",
+ "multipart",
+ "percent-encoding",
+ "rand 0.8.5",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha1_smol",
+ "threadpool",
+ "time",
+ "tiny_http",
+ "url",
+]
+
+[[package]]
+name = "rsa"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78928ac1ed176a5ca1d17e578a1825f3d81ca54cf41053a592584b020cfd691b"
+dependencies = [
+ "const-oid",
+ "digest",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "signature",
+ "spki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustdct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b61555105d6a9bf98797c063c362a1d24ed8ab0431655e38f1cf51e52089551"
+dependencies = [
+ "rustfft",
+]
+
+[[package]]
+name = "rustfft"
+version = "6.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "primal-check",
+ "strength_reduce",
+ "transpose",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a9586e9ee2b4f8fab52a0048ca7334d7024eef48e2cb9407e3497bb7cab7fa7"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.5.1",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "safemem"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "serde_html_form"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2f2d7ff8a2140333718bb329f5c40fc5f0865b84c426183ce14c97d2ab8154f"
+dependencies = [
+ "form_urlencoded",
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_ipld_dagcbor"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46182f4f08349a02b45c998ba3215d3f9de826246ba02bb9dddfe9a2a2100778"
+dependencies = [
+ "cbor4ii",
+ "ipld-core",
+ "scopeguard",
+ "serde",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.145"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "simd_helpers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
+dependencies = [
+ "quote",
+]
+
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
+[[package]]
+name = "skywatch-phash-rs"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "dotenvy",
+ "futures",
+ "futures-util",
+ "governor",
+ "image",
+ "image_hasher",
+ "jacquard",
+ "jacquard-api",
+ "jacquard-common",
+ "jacquard-identity",
+ "jacquard-oauth",
+ "miette",
+ "mockito",
+ "redis",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.17",
+ "tokio",
+ "tokio-test",
+ "tracing",
+ "tracing-subscriber",
+ "url",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "smol_str"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3498b0a27f93ef1402f20eefacfaa1691272ac4eca1cdc8c596cb0a245d6cbf5"
+dependencies = [
+ "borsh",
+ "serde_core",
+]
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spin"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591"
+
+[[package]]
+name = "spinning_top"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d96d2d1d716fb500937168cc09353ffdc7a012be8475ac7308e1bdf0e3923300"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "static-regular-grammar"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f4a6c40247579acfbb138c3cd7de3dab113ab4ac6227f1b7de7d626ee667957"
+dependencies = [
+ "abnf",
+ "btree-range-map",
+ "ciborium",
+ "hex_fmt",
+ "indoc",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "sha2",
+ "syn 2.0.108",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strength_reduce"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
+
+[[package]]
+name = "string_cache"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
+ "serde",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c711928715f1fe0fe509c53b43e993a9a557babc2d0a3567d0a3006f1ac931a0"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "supports-color"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6"
+dependencies = [
+ "is_ci",
+]
+
+[[package]]
+name = "supports-hyperlinks"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804f44ed3c63152de6a9f90acbea1a110441de43006ea51bcce8f436196a288b"
+
+[[package]]
+name = "supports-unicode"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml",
+ "version-compare",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tempfile"
+version = "3.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tendril"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0"
+dependencies = [
+ "futf",
+ "mac",
+ "utf-8",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+dependencies = [
+ "rustix",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
+dependencies = [
+ "unicode-linebreak",
+ "unicode-width 0.2.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
+[[package]]
+name = "tiff"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af9605de7fee8d9551863fd692cce7637f548dbd9db9180fcc07ccc6d26c336f"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error 2.0.1",
+ "weezl",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "libc",
+ "num-conv",
+ "num_threads",
+ "powerfmt",
+ "serde",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "tiny_http"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"
+dependencies = [
+ "ascii",
+ "chunked_transfer",
+ "httpdate",
+ "log",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.6.1",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+]
+
+[[package]]
+name = "tokio-tungstenite-wasm"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e21a5c399399c3db9f08d8297ac12b500e86bca82e930253fdc62eaf9c0de6ae"
+dependencies = [
+ "futures-channel",
+ "futures-util",
+ "http",
+ "httparse",
+ "js-sys",
+ "rustls",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-tungstenite",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-serde"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "serde",
+ "serde_json",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-serde",
+]
+
+[[package]]
+name = "trait-variant"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70977707304198400eb4835a78f6a9f928bf41bba420deb8fdb175cd965d77a7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "transpose"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
+dependencies = [
+ "num-integer",
+ "strength_reduce",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 1.0.69",
+ "utf-8",
+]
+
+[[package]]
+name = "twoway"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicase"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"
+
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "unsigned-varint"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "v_frame"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2"
+dependencies = [
+ "aligned-vec",
+ "num-traits",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version-compare"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webbrowser"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db67ae75a9405634f5882791678772c94ff5f16a66535aae186e26aa0841fc8b"
+dependencies = [
+ "core-foundation 0.9.4",
+ "home",
+ "jni",
+ "log",
+ "ndk-context",
+ "objc",
+ "raw-window-handle",
+ "url",
+ "web-sys",
+]
+
+[[package]]
+name = "webpage"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70862efc041d46e6bbaa82bb9c34ae0596d090e86cbd14bd9e93b36ee6802eac"
+dependencies = [
+ "html5ever",
+ "markup5ever_rcdom",
+ "serde_json",
+ "url",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a751b3277700db47d3e574514de2eced5e54dc8a5436a3bf7a0b248b2cee16f3"
+
+[[package]]
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core 0.61.2",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-registry"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+dependencies = [
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "writeable"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+
+[[package]]
+name = "xml5ever"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bbb26405d8e919bc1547a5aa9abc95cbfa438f04844f5fdd9dc7596b748bf69"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever",
+]
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-inflate"
+version = "0.2.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713"
+dependencies = [
+ "zune-core",
+]

Cargo.toml

···
+[package]
+name = "skywatch-phash-rs"
+version = "0.1.0"
+edition = "2024"
+authors = ["Giulia <[e-mail]"]
+description = "Perceptual hash-based image moderation for Bluesky (Rust rewrite)"
+license = "MIT"
+
+[dependencies]
+# Async runtime
+tokio = { version = "1", features = ["full"] }
+futures-util = "0.3"
+
+# ATProto client (Jacquard) - using local path
+jacquard = { path = "../jacquard/crates/jacquard" }
+jacquard-api = { path = "../jacquard/crates/jacquard-api" }
+jacquard-common = { path = "../jacquard/crates/jacquard-common", features = ["websocket"] }
+jacquard-identity = { path = "../jacquard/crates/jacquard-identity" }
+jacquard-oauth = { path = "../jacquard/crates/jacquard-oauth" }
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# HTTP client
+reqwest = { version = "0.12", features = ["json"] }
+
+# Redis
+redis = { version = "0.27", features = ["tokio-comp", "connection-manager"] }
+
+# Image processing
+image = "0.25"
+image_hasher = "3.0"
+
+# Error handling
+miette = { version = "7.6", features = ["fancy"] }
+thiserror = "2.0"
+
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
+
+# Config
+dotenvy = "0.15"
+
+# Utilities
+chrono = "0.4"
+url = "2.5"
+futures = "0.3"
+
+# Rate limiting
+governor = "0.8"
+
+[dev-dependencies]
+mockito = "1"
+tokio-test = "0.4"
+
+[[bin]]
+name = "skywatch-phash"
+path = "src/main.rs"
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+strip = true
+
+[profile.dev]
+opt-level = 0

Dockerfile

···
+FROM rust:1.83 as builder
+
+WORKDIR /usr/src/app
+
+# Copy manifests
+COPY Cargo.toml Cargo.lock ./
+
+# Copy source
+COPY src ./src
+
+# Build release binary
+RUN cargo build --release
+
+# Runtime stage
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy binary from builder
+COPY --from=builder /usr/src/app/target/release/skywatch-phash-rs .
+
+# Copy rules directory
+COPY rules ./rules
+
+CMD ["./skywatch-phash-rs"]

README.md

···
+# skywatch-phash-rs
+
+Rust implementation of Bluesky image moderation service using perceptual hashing (aHash/average hash algorithm).
+
+Monitors Bluesky's Jetstream for posts with images, computes perceptual hashes, matches against known bad images, and takes automated moderation actions (label/report posts and accounts).
+
+## Features
+
+- Real-time Jetstream subscription for post monitoring
+- Perceptual hash (aHash) computation for images
+- Configurable hamming distance thresholds per rule
+- Redis-backed job queue and phash caching
+- Concurrent worker pool for parallel processing
+- Automatic retry with dead letter queue
+- Metrics tracking and logging
+- Graceful shutdown handling
+
+## Prerequisites
+
+- **For Docker deployment:**
+  - Docker and Docker Compose
+- **For local development:**
+  - Nix with flakes enabled (recommended), OR
+  - Rust 1.83+
+- **Required for all:**
+  - Bluesky labeler account with app password
+
+## Quick Start
+
+1. **Clone and setup:**
+   ```bash
+   git clone <repo-url>
+   cd skywatch-phash-rs
+   ```
+
+2. **Configure environment:**
+   ```bash
+   cp .env.example .env
+   # Edit .env and fill in your automod account credentials:
+   # - AUTOMOD_HANDLE
+   # - AUTOMOD_PASSWORD
+   ```
+
+3. **Start the service:**
+   ```bash
+   docker compose up --build
+   ```
+
+4. **Monitor logs:**
+   ```bash
+   docker compose logs -f app
+   ```
+
+5. **Stop the service:**
+   ```bash
+   docker compose down
+   ```
+
+## Phash CLI Tool
+
+Compute perceptual hash for a single image:
+
+```bash
+# Using cargo
+cargo run --bin phash-cli path/to/image.jpg
+
+# Or build and run
+cargo build --release --bin phash-cli
+./target/release/phash-cli image.png
+```
+
+Output is a 16-character hex string (64-bit hash):
+```
+e0e0e0e0e0fcfefe
+```
+
+Use this to generate hashes for your blob check rules.
+
+## Configuration
+
+All configuration is via environment variables (see `.env.example`):
+
+### Required Variables
+
+- `AUTOMOD_HANDLE` - Your automod account handle (e.g., automod.bsky.social)
+- `AUTOMOD_PASSWORD` - App password for automod account
+- `LABELER_DID` - DID of your main labeler account (e.g., skywatch.blue)
+- `OZONE_URL` - Ozone moderation service URL
+- `OZONE_PDS` - Ozone PDS endpoint (for authentication)
+
+### Optional Variables
+
+- `PROCESSING_CONCURRENCY` (default: 4) - Max parallel job processing
+- `PHASH_HAMMING_THRESHOLD` (default: 5) - Global hamming distance threshold
+- `CACHE_ENABLED` (default: true) - Enable Redis phash caching
+- `CACHE_TTL_SECONDS` (default: 86400) - Cache TTL (24 hours)
+- `RETRY_ATTEMPTS` (default: 3) - Max retry attempts for failed jobs
+- `JETSTREAM_URL` - Jetstream websocket URL
+- `REDIS_URL` - Redis connection string
+
+## Blob Check Rules
+
+Rules are defined in `rules/blobs.json`:
+
+```json
+[
+  {
+    "phashes": ["e0e0e0e0e0fcfefe", "9b9e00008f8fffff"],
+    "label": "spam",
+    "comment": "Known spam image detected",
+    "reportAcct": false,
+    "labelAcct": true,
+    "reportPost": true,
+    "toLabel": true,
+    "hammingThreshold": 3,
+    "description": "Optional description",
+    "ignoreDID": ["did:plc:exempted-user"]
+  }
+]
+```
+
+### Rule Fields
+
+- `phashes` - Array of 16-char hex hashes to match against
+- `label` - Label to apply (e.g., "spam", "csam", "troll")
+- `comment` - Comment for reports
+- `reportAcct` - Report the account
+- `labelAcct` - Label the account
+- `reportPost` - Report the post
+- `toLabel` - Label the post
+- `hammingThreshold` - Max hamming distance for match (overrides global)
+- `description` - Optional description (not used by system)
+- `ignoreDID` - Optional array of DIDs to skip
+
+## Architecture
+
+```
+Jetstream WebSocket
+        ↓
+   Job Channel (mpsc)
+        ↓
+   Redis Queue (FIFO)
+        ↓
+   Worker Pool (semaphore-controlled concurrency)
+        ↓
+   ┌─────────────────┐
+   │ For each job:   │
+   │ 1. Check cache  │
+   │ 2. Download blob│
+   │ 3. Compute phash│
+   │ 4. Match rules  │
+   │ 5. Take actions │
+   └─────────────────┘
+        ↓
+   Metrics Tracking
+```
+
+### Components
+
+- **Jetstream Client** - Subscribes to Bluesky firehose, filters posts with images
+- **Job Queue** - Redis-backed FIFO queue with retry logic
+- **Worker Pool** - Configurable concurrency with semaphore control
+- **Phash Cache** - Redis-backed cache for computed hashes (reduces redundant work)
+- **Agent Session** - Authenticated session with automatic token refresh
+- **Metrics** - Lock-free atomic counters for monitoring
+
+## Development
+
+### Using Nix (Recommended)
+
+If you have Nix with flakes enabled:
+
+```bash
+# Enter dev shell with all dependencies
+nix develop
+
+# Or use direnv for automatic environment loading
+direnv allow
+
+# Build the project
+nix build
+
+# Run the binary
+nix run
+```
+
+The Nix flake provides:
+- Rust toolchain (stable latest)
+- Native dependencies (OpenSSL, pkg-config)
+- Development tools (cargo-watch, redis)
+- Reproducible builds across Linux and macOS
+
+### Without Nix
+
+Run locally without Docker:
+
+```bash
+# Start Redis
+docker run -d -p 6379:6379 redis
+
+# Create .env
+cp .env.example .env
+# Edit .env with your credentials
+
+# Run service
+cargo run
+
+# Run tests
+cargo test
+
+# Run specific binary
+cargo run --bin phash-cli image.jpg
+```
+
+## Metrics
+
+Logged every 60 seconds:
+
+- **Jobs**: received, processed, failed, retried
+- **Blobs**: processed, downloaded
+- **Matches**: found
+- **Cache**: hits, misses, hit rate
+- **Moderation**: posts/accounts labeled and reported
+
+Final metrics are logged on graceful shutdown (Ctrl+C).
+
+## License
+
+See LICENSE file.

docker-compose.yml

···
+services:
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+volumes:
+  redis-data:

rules/blobs.json

···
+[
+  {
+    "phashes": [
+      "07870707073f7f7f",
+      "d9794408f1f3fffb",
+      "0f093139797b7967",
+      "fdedc3030100c0fd",
+      "0f7f707dcc0c0600"
+    ],
+    "label": "troll",
+    "comment": "Image is used in harrassment campaign targeting Will Stancil",
+    "reportAcct": false,
+    "labelAcct": true,
+    "reportPost": false,
+    "toLabel": true,
+    "hammingThreshold": 3,
+    "description": "Sample harassment image variants (placeholder hashes)",
+    "ignoreDID": ["did:plc:7umvpuxe2vbrc3zrzuquzniu"]
+  },
+  {
+    "phashes": ["00fffd7cd8da5000"],
+    "label": "maga-trump",
+    "comment": "Pro-trump imagery",
+    "reportAcct": true,
+    "labelAcct": false,
+    "reportPost": false,
+    "toLabel": true,
+    "hammingThreshold": 3,
+    "description": "Sample harassment image variants (placeholder hashes)"
+  },
+  {
+    "phashes": ["3e7e6e561202627c"],
+    "label": "sensual-alf",
+    "comment": "Posting Alf",
+    "reportAcct": false,
+    "labelAcct": false,
+    "reportPost": false,
+    "toLabel": true,
+    "hammingThreshold": 3,
+    "description": "Sample harassment image variants (placeholder hashes)"
+  }
+]

rust-toolchain.toml

···
+[toolchain]
+channel = "stable"
+profile = "default"
+targets = [ "wasm32-unknown-unknown" ]

src/agent/README.md

···
+# Agent Module
+
+## Purpose
+Manages authenticated sessions with the Bluesky PDS (Personal Data Server) for making moderation API calls.
+
+## Key Components
+
+### `session.rs`
+- **`AgentSession`** - Main session management struct
+  - Wraps reqwest Client with automatic token management
+  - Stores session tokens in Arc<RwLock<>> for thread-safe access
+  - Provides automatic token refresh on expiry
+
+### Key Methods
+
+- **`new(config, client)`** - Create new agent session
+- **`login()`** - Authenticate with PDS using handle + password from config
+  - Calls `com.atproto.server.createSession`
+  - Stores `access_jwt` and `refresh_jwt`
+- **`refresh()`** - Refresh expired access token using refresh_jwt
+  - Calls `com.atproto.server.refreshSession`
+- **`get_token()`** - Get valid access token (refreshes if needed)
+  - Used by all moderation functions before making API calls
+- **`did()`** - Get the labeler's DID from current session
+- **`ensure_authenticated()`** - Login if not already authenticated
+
+### Session Flow
+
+```
+1. AgentSession::new() -> Creates empty session
+2. login() -> Authenticates and stores tokens
+3. get_token() -> Returns access_jwt (auto-refreshes if expired)
+4. Moderation functions use access_jwt in Authorization header
+```
+
+### Token Storage
+
+Session tokens are stored in:
+```rust
+Arc<RwLock<Option<CreateSessionResponse>>>
+```
+
+This allows:
+- Thread-safe concurrent access from multiple workers
+- Shared refresh state across all API calls
+- Automatic token updates visible to all workers
+
+## Usage Pattern
+
+```rust
+let agent = AgentSession::new(config, client);
+agent.login().await?;
+
+// Later in worker:
+let token = agent.get_token().await?;
+// Use token in API calls
+```
+
+## Dependencies
+
+- `reqwest::Client` - HTTP client
+- `Config` - Labeler credentials (handle, password, DID)
+- `miette` - Error handling
+
+## Related Modules
+
+- Used by: `queue/worker.rs` - Workers get tokens for moderation actions
+- Uses: `config` - For labeler credentials

src/agent/mod.rs

···
+pub mod session;
+
+pub use session::AgentSession;

src/agent/session.rs

···
+use miette::Result;
+use std::sync::Arc;
+use jacquard::client::{Agent, MemoryCredentialSession};
+use jacquard::CowStr;
+
+use crate::config::Config;
+
+/// Agent session wrapper using Jacquard
+/// All internal types use 'static lifetime to enable Send + Sync across threads
+#[derive(Clone)]
+pub struct AgentSession {
+    agent: Arc<Agent<MemoryCredentialSession>>,
+    did: Arc<str>,
+}
+
+impl AgentSession {
+    /// Create a new agent session by authenticating with handle and password
+    pub async fn new(config: &Config) -> Result<Self> {
+        tracing::info!("Logging in as {}", config.automod.handle);
+
+        let handle = CowStr::from(config.automod.handle.clone());
+        let password = CowStr::from(config.automod.password.clone());
+        let pds = Some(CowStr::from(config.ozone.pds.clone()));
+
+        let (session, auth) = MemoryCredentialSession::authenticated(handle, password, pds).await?;
+
+        tracing::info!("Successfully logged in as {} ({})", auth.handle, auth.did);
+
+        let did: Arc<str> = Arc::from(auth.did.to_string());
+        let agent = Arc::new(Agent::from(session));
+
+        Ok(Self { agent, did })
+    }
+
+    /// Get the authenticated agent
+    pub fn agent(&self) -> &Arc<Agent<MemoryCredentialSession>> {
+        &self.agent
+    }
+
+    /// Get the authenticated DID
+    pub fn did(&self) -> &str {
+        &*self.did
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    // Note: Integration tests require valid credentials
+}

src/bin/phash-cli.rs

···
+use miette::{IntoDiagnostic, Result};
+use std::env;
+use std::fs;
+use std::path::Path;
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() != 2 {
+        eprintln!("Usage: {} <image-path>", args[0]);
+        eprintln!("\nComputes perceptual hash (aHash/average hash) for an image.");
+        eprintln!("Outputs 16-character hex string (64-bit hash).");
+        std::process::exit(1);
+    }
+
+    let image_path = Path::new(&args[1]);
+
+    if !image_path.exists() {
+        eprintln!("Error: File not found: {}", image_path.display());
+        std::process::exit(1);
+    }
+
+    // Read image bytes
+    let image_bytes = fs::read(image_path).into_diagnostic()?;
+
+    // Compute phash
+    let phash = skywatch_phash_rs::processor::phash::compute_phash(&image_bytes)?;
+
+    // Output just the hash
+    println!("{}", phash);
+
+    Ok(())
+}

src/bin/test-image.rs

···
+use miette::{IntoDiagnostic, Result};
+use std::env;
+use std::fs;
+use std::path::Path;
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() != 2 {
+        eprintln!("Usage: {} <image-path>", args[0]);
+        eprintln!("\nTests an image against blob check rules.");
+        eprintln!("Computes phash and checks for matches in rules/blobs.json");
+        std::process::exit(1);
+    }
+
+    let image_path = Path::new(&args[1]);
+
+    if !image_path.exists() {
+        eprintln!("Error: File not found: {}", image_path.display());
+        std::process::exit(1);
+    }
+
+    tokio::runtime::Runtime::new()
+        .into_diagnostic()?
+        .block_on(async {
+            test_image(image_path).await
+        })
+}
+
+async fn test_image(image_path: &Path) -> Result<()> {
+    // Load blob checks
+    let rules_path = Path::new("rules/blobs.json");
+    if !rules_path.exists() {
+        eprintln!("Error: rules/blobs.json not found");
+        std::process::exit(1);
+    }
+
+    println!("Loading rules from rules/blobs.json...");
+    let blob_checks = skywatch_phash_rs::processor::matcher::load_blob_checks(rules_path).await?;
+    println!("Loaded {} blob check rules\n", blob_checks.len());
+
+    // Read and compute phash
+    println!("Computing phash for: {}", image_path.display());
+    let image_bytes = fs::read(image_path).into_diagnostic()?;
+    let phash = skywatch_phash_rs::processor::phash::compute_phash(&image_bytes)?;
+    println!("Computed phash: {}\n", phash);
+
+    // Check against rules
+    println!("Checking against rules...\n");
+    let test_did = "did:plc:test123456789";
+    
+    let mut found_match = false;
+    for check in &blob_checks {
+        // Check if test DID is ignored
+        if let Some(ignore_list) = &check.ignore_did {
+            if ignore_list.contains(&test_did.to_string()) {
+                println!("⏭️  Skipped rule '{}' (test DID is ignored)", check.label);
+                continue;
+            }
+        }
+
+        let threshold = check.hamming_threshold.unwrap_or(5);
+
+        // Check each phash in the rule
+        for check_phash in &check.phashes {
+            match skywatch_phash_rs::processor::phash::hamming_distance(&phash, check_phash) {
+                Ok(distance) => {
+                    if distance <= threshold {
+                        found_match = true;
+                        println!("✅ MATCH FOUND!");
+                        println!("   Rule: {}", check.label);
+                        println!("   Description: {}", check.description.as_ref().unwrap_or(&"N/A".to_string()));
+                        println!("   Matched phash: {}", check_phash);
+                        println!("   Hamming distance: {} (threshold: {})", distance, threshold);
+                        println!("   Actions:");
+                        if check.to_label {
+                            println!("     - Label post with '{}'", check.label);
+                        }
+                        if check.report_post {
+                            println!("     - Report post");
+                        }
+                        if check.label_acct {
+                            println!("     - Label account");
+                        }
+                        if check.report_acct {
+                            println!("     - Report account");
+                        }
+                        println!();
+                    } else {
+                        println!("❌ No match for rule '{}' (distance: {}, threshold: {})", 
+                            check.label, distance, threshold);
+                    }
+                }
+                Err(e) => {
+                    eprintln!("⚠️  Error computing distance for rule '{}': {}", check.label, e);
+                }
+            }
+        }
+    }
+
+    if !found_match {
+        println!("\n🔍 No matches found. This image is not flagged by any rules.");
+    }
+
+    Ok(())
+}

src/cache/README.md

···
+# Cache Module
+
+## Purpose
+Redis-backed cache for perceptual hashes to avoid recomputing hashes for images we've already processed.
+
+## Key Components
+
+### `mod.rs`
+- **`PhashCache`** - Redis connection wrapper for phash storage
+  - Uses CID (Content Identifier) as key
+  - Stores computed phash as value
+  - TTL controlled by `config.cache.ttl`
+
+### Key Methods
+
+- **`new(config)`** - Create cache with Redis connection
+  - Connects to `config.redis.url`
+  - Uses multiplexed async connection for concurrent access
+- **`get(cid)`** - Retrieve cached phash for a CID
+  - Returns `Ok(Some(phash))` if cached
+  - Returns `Ok(None)` if not in cache
+- **`set(cid, phash)`** - Store phash in cache
+  - Sets TTL from config (default 24 hours)
+  - Uses `SET` with `EX` for expiration
+
+### Cache Flow
+
+```
+1. Worker gets job with blob CID
+2. cache.get(cid) -> Check if phash exists
+3. If cache hit:
+   - Use cached phash
+   - Skip download & computation
+4. If cache miss:
+   - Download blob
+   - Compute phash
+   - cache.set(cid, phash) -> Store for next time
+```
+
+### Key Design Decisions
+
+**Why cache by CID?**
+- CIDs are content-addressed (same content = same CID)
+- Same image will always have same CID across all posts
+- Deduplicates work when same image is posted multiple times
+
+**Why use Redis?**
+- Shared cache across all workers
+- Persists across service restarts
+- TTL handles cache invalidation automatically
+
+**TTL Strategy**
+- Default 24 hours (86400 seconds)
+- Balances memory usage vs recomputation
+- Can be disabled with `CACHE_ENABLED=false`
+
+## Performance Impact
+
+With cache enabled:
+- **Cache hit** - ~1ms (Redis lookup)
+- **Cache miss** - ~200-500ms (download + compute + store)
+
+For frequently reposted images (spam), cache hit rate can be >90%, massively reducing load.
+
+## Configuration
+
+```env
+CACHE_ENABLED=true          # Enable/disable cache
+CACHE_TTL_SECONDS=86400     # Cache TTL (24 hours)
+REDIS_URL=redis://localhost:6379
+```
+
+## Dependencies
+
+- `redis` - Async Redis client with tokio support
+- `Config` - Cache settings
+- `miette` - Error handling
+
+## Related Modules
+
+- Used by: `queue/worker.rs` - Workers check cache before processing blobs
+- Uses: `config` - For Redis URL and TTL settings
+- Works with: `metrics` - Tracks cache hit/miss rates

src/cache/mod.rs

···
+use miette::{IntoDiagnostic, Result};
+use redis::AsyncCommands;
+use tracing::{debug, info};
+
+use crate::config::Config;
+
+/// Redis key prefix for phash cache
+const PHASH_CACHE_PREFIX: &str = "phash";
+
+/// Phash cache for storing computed image hashes
+#[derive(Clone)]
+pub struct PhashCache {
+    redis: redis::aio::MultiplexedConnection,
+    ttl: u64,
+    enabled: bool,
+}
+
+impl PhashCache {
+    /// Create a new phash cache
+    pub async fn new(config: &Config) -> Result<Self> {
+        info!("Connecting to Redis: {}", config.redis.url);
+
+        let client = redis::Client::open(config.redis.url.as_str()).into_diagnostic()?;
+        let redis = client
+            .get_multiplexed_async_connection()
+            .await
+            .into_diagnostic()?;
+
+        info!("Connected to Redis, cache enabled: {}", config.cache.enabled);
+
+        Ok(Self {
+            redis,
+            ttl: config.cache.ttl,
+            enabled: config.cache.enabled,
+        })
+    }
+
+    /// Get cached phash for a blob CID
+    pub async fn get(&mut self, cid: &str) -> Result<Option<String>> {
+        if !self.enabled {
+            return Ok(None);
+        }
+
+        let key = format!("{}:{}", PHASH_CACHE_PREFIX, cid);
+
+        let result: Option<String> = self.redis.get(&key).await.into_diagnostic()?;
+
+        if result.is_some() {
+            debug!("Cache hit for CID: {}", cid);
+        } else {
+            debug!("Cache miss for CID: {}", cid);
+        }
+
+        Ok(result)
+    }
+
+    /// Set cached phash for a blob CID
+    pub async fn set(&mut self, cid: &str, phash: &str) -> Result<()> {
+        if !self.enabled {
+            return Ok(());
+        }
+
+        let key = format!("{}:{}", PHASH_CACHE_PREFIX, cid);
+
+        let _: () = self
+            .redis
+            .set_ex(&key, phash, self.ttl)
+            .await
+            .into_diagnostic()?;
+
+        debug!("Cached phash for CID: {} -> {}", cid, phash);
+
+        Ok(())
+    }
+
+    /// Delete cached phash for a blob CID
+    pub async fn delete(&mut self, cid: &str) -> Result<()> {
+        if !self.enabled {
+            return Ok(());
+        }
+
+        let key = format!("{}:{}", PHASH_CACHE_PREFIX, cid);
+
+        let _: () = self.redis.del(&key).await.into_diagnostic()?;
+
+        debug!("Deleted cached phash for CID: {}", cid);
+
+        Ok(())
+    }
+
+    /// Check if cache is enabled
+    pub fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// Get or compute phash with caching
+    pub async fn get_or_compute<F, Fut>(&mut self, cid: &str, compute_fn: F) -> Result<String>
+    where
+        F: FnOnce() -> Fut,
+        Fut: std::future::Future<Output = Result<String>>,
+    {
+        // Try to get from cache
+        if let Some(cached) = self.get(cid).await? {
+            return Ok(cached);
+        }
+
+        // Compute if not cached
+        let phash = compute_fn().await?;
+
+        // Store in cache
+        self.set(cid, &phash).await?;
+
+        Ok(phash)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Note: These are integration tests that require a running Redis instance
+    // Run with: cargo test --test cache -- --ignored
+}

src/config/README.md

···
+# Config Module
+
+## Purpose
+Centralized configuration management from environment variables with sensible defaults.
+
+## Key Components
+
+### `mod.rs`
+- **`Config`** - Root configuration struct containing all sub-configs
+- **Sub-config structs**:
+  - `JetstreamConfig` - Jetstream connection settings
+  - `RedisConfig` - Redis connection
+  - `ProcessingConfig` - Worker pool settings
+  - `CacheConfig` - Cache behavior
+  - `PdsConfig` - PDS endpoint
+  - `PlcConfig` - PLC directory endpoint
+  - `LabelerConfig` - Labeler credentials
+  - `OzoneConfig` - Ozone moderation service
+  - `ModerationConfig` - Moderation behavior
+  - `PhashConfig` - Phash matching settings
+
+### Key Methods
+
+- **`Config::from_env()`** - Load all configuration from environment
+  - Calls `dotenvy::dotenv()` to load `.env` file
+  - Falls back to defaults where provided
+  - Returns error for missing required vars
+
+### Environment Variables
+
+**Required:**
+```env
+LABELER_DID=did:plc:xxxxx        # Your labeler DID
+LABELER_HANDLE=labeler.bsky.social  # Your labeler handle
+LABELER_PASSWORD=xxxx-xxxx-xxxx-xxxx  # App password
+OZONE_URL=https://ozone.example.com
+OZONE_PDS=https://bsky.social
+MOD_DID=did:plc:xxxxx            # Moderator DID
+```
+
+**Optional with defaults:**
+```env
+JETSTREAM_URL=wss://jetstream.atproto.tools/subscribe
+REDIS_URL=redis://localhost:6379
+PDS_ENDPOINT=https://bsky.social
+PLC_ENDPOINT=https://plc.directory
+
+PROCESSING_CONCURRENCY=10        # Max concurrent workers
+RETRY_ATTEMPTS=3                 # Max retries per job
+RETRY_DELAY_MS=1000             # Delay between retries
+RATE_LIMIT_MS=100               # Min ms between API calls
+
+CACHE_ENABLED=true              # Enable phash cache
+CACHE_TTL_SECONDS=86400         # Cache TTL (24h)
+
+PHASH_HAMMING_THRESHOLD=3       # Default hamming threshold
+CURSOR_UPDATE_INTERVAL=10000    # Cursor save interval (ms)
+```
+
+### Helper Functions
+
+- **`get_env(key, default)`** - Get string with optional default
+- **`get_env_u32/u64/usize(key, default)`** - Get numbers with defaults
+- **`get_env_bool(key, default)`** - Parse bool (accepts "true", "1", "yes")
+
+### Configuration Flow
+
+```
+1. Service starts
+2. Config::from_env() loads .env file
+3. Validates required vars exist
+4. Applies defaults for optional vars
+5. Config passed to all modules
+```
+
+### Design Decisions
+
+**Why environment variables?**
+- 12-factor app pattern
+- Easy to configure in Docker/k8s
+- No config files to manage
+- Secrets stay out of code
+
+**Why dotenvy?**
+- Compatible with .env files
+- Only used for local dev (prod uses real env vars)
+- Simplifies local testing
+
+## Usage Pattern
+
+```rust
+// At startup:
+let config = Config::from_env()?;
+
+// Pass to modules:
+let agent = AgentSession::new(config.clone(), client);
+let cache = PhashCache::new(config.clone()).await?;
+```
+
+## Dependencies
+
+- `dotenvy` - .env file loading
+- `miette` - Error handling
+
+## Related Modules
+
+- Used by: All modules - everything needs config
+- Cloned extensively (all fields implement `Clone`)

src/config/mod.rs

···
+use miette::{Context, IntoDiagnostic, Result};
+use std::env;
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub jetstream: JetstreamConfig,
+    pub redis: RedisConfig,
+    pub processing: ProcessingConfig,
+    pub cache: CacheConfig,
+    pub pds: PdsConfig,
+    pub plc: PlcConfig,
+    pub automod: AutomodConfig,
+    pub ozone: OzoneConfig,
+    pub moderation: ModerationConfig,
+    pub phash: PhashConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct JetstreamConfig {
+    pub url: String,
+    pub wanted_collections: Vec<String>,
+    pub cursor_update_interval: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct RedisConfig {
+    pub url: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProcessingConfig {
+    pub concurrency: usize,
+    pub retry_attempts: u32,
+    pub retry_delay: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct CacheConfig {
+    pub enabled: bool,
+    pub ttl: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct PdsConfig {
+    pub endpoint: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct PlcConfig {
+    pub endpoint: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct AutomodConfig {
+    pub handle: String,
+    pub password: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct OzoneConfig {
+    pub url: String,
+    pub pds: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ModerationConfig {
+    pub labeler_did: String,
+    pub rate_limit: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct PhashConfig {
+    pub default_hamming_threshold: u32,
+}
+
+impl Config {
+    /// Load configuration from environment variables
+    pub fn from_env() -> Result<Self> {
+        // Load .env file if it exists (ignore if missing)
+        dotenvy::dotenv().ok();
+
+        Ok(Config {
+            jetstream: JetstreamConfig {
+                url: get_env(
+                    "JETSTREAM_URL",
+                    Some("wss://jetstream.atproto.tools/subscribe"),
+                )?,
+                wanted_collections: vec!["app.bsky.feed.post".to_string()],
+                cursor_update_interval: get_env_u64("CURSOR_UPDATE_INTERVAL", 10_000),
+            },
+            redis: RedisConfig {
+                url: get_env("REDIS_URL", Some("redis://localhost:6379"))?,
+            },
+            processing: ProcessingConfig {
+                concurrency: get_env_usize("PROCESSING_CONCURRENCY", 10),
+                retry_attempts: get_env_u32("RETRY_ATTEMPTS", 3),
+                retry_delay: get_env_u64("RETRY_DELAY_MS", 1000),
+            },
+            cache: CacheConfig {
+                enabled: get_env_bool("CACHE_ENABLED", true),
+                ttl: get_env_u64("CACHE_TTL_SECONDS", 86400),
+            },
+            pds: PdsConfig {
+                endpoint: get_env("PDS_ENDPOINT", Some("https://bsky.social"))?,
+            },
+            plc: PlcConfig {
+                endpoint: get_env("PLC_ENDPOINT", Some("https://plc.directory"))?,
+            },
+            automod: AutomodConfig {
+                handle: get_env("AUTOMOD_HANDLE", None)
+                    .context("AUTOMOD_HANDLE is required for authentication")?,
+                password: get_env("AUTOMOD_PASSWORD", None)
+                    .context("AUTOMOD_PASSWORD is required for authentication")?,
+            },
+            ozone: OzoneConfig {
+                url: get_env("OZONE_URL", None).context("OZONE_URL is required")?,
+                pds: get_env("OZONE_PDS", None).context("OZONE_PDS is required")?,
+            },
+            moderation: ModerationConfig {
+                labeler_did: get_env("LABELER_DID", None).context("LABELER_DID is required")?,
+                rate_limit: get_env_u64("RATE_LIMIT_MS", 100),
+            },
+            phash: PhashConfig {
+                default_hamming_threshold: get_env_u32("PHASH_HAMMING_THRESHOLD", 3),
+            },
+        })
+    }
+}
+
+/// Get environment variable with optional default
+fn get_env(key: &str, default: Option<&str>) -> Result<String> {
+    env::var(key)
+        .into_diagnostic()
+        .or_else(|_| {
+            default
+                .ok_or_else(|| miette::miette!("Missing required environment variable: {}", key))
+                .map(String::from)
+        })
+}
+
+/// Get environment variable as u32 with default
+fn get_env_u32(key: &str, default: u32) -> u32 {
+    env::var(key)
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(default)
+}
+
+/// Get environment variable as u64 with default
+fn get_env_u64(key: &str, default: u64) -> u64 {
+    env::var(key)
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(default)
+}
+
+/// Get environment variable as usize with default
+fn get_env_usize(key: &str, default: usize) -> usize {
+    env::var(key)
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(default)
+}
+
+/// Get environment variable as bool with default
+/// Accepts "true", "1", "yes" (case-insensitive) as true
+fn get_env_bool(key: &str, default: bool) -> bool {
+    env::var(key)
+        .ok()
+        .map(|v| {
+            let v = v.to_lowercase();
+            v == "true" || v == "1" || v == "yes"
+        })
+        .unwrap_or(default)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_env_bool() {
+        unsafe {
+            std::env::set_var("TEST_BOOL_TRUE", "true");
+            std::env::set_var("TEST_BOOL_1", "1");
+            std::env::set_var("TEST_BOOL_YES", "yes");
+            std::env::set_var("TEST_BOOL_FALSE", "false");
+            std::env::set_var("TEST_BOOL_0", "0");
+        }
+
+        assert!(get_env_bool("TEST_BOOL_TRUE", false));
+        assert!(get_env_bool("TEST_BOOL_1", false));
+        assert!(get_env_bool("TEST_BOOL_YES", false));
+        assert!(!get_env_bool("TEST_BOOL_FALSE", true));
+        assert!(!get_env_bool("TEST_BOOL_0", true));
+        assert!(get_env_bool("TEST_BOOL_MISSING", true));
+    }
+
+    #[test]
+    fn test_get_env_u32() {
+        unsafe {
+            std::env::set_var("TEST_U32", "42");
+        }
+        assert_eq!(get_env_u32("TEST_U32", 0), 42);
+        assert_eq!(get_env_u32("TEST_U32_MISSING", 99), 99);
+    }
+}

src/jetstream/README.md

···
+# Jetstream Module
+
+## Purpose
+Connects to Bluesky's Jetstream firehose to receive real-time post events and extract image blobs for processing.
+
+## Key Components
+
+### `mod.rs`
+- **`start_jetstream_client()`** - Main entry point
+  - Establishes WebSocket connection to Jetstream
+  - Subscribes to `app.bsky.feed.post` collection
+  - Sends jobs to processing queue via mpsc channel
+  - Handles cursor persistence for resume capability
+
+### `events.rs`
+- **`JetstreamEvent`** - Deserialized Jetstream message
+  - Contains `did`, `commit.record`, `commit.cid`
+  - Record type: `app.bsky.feed.post`
+- **`extract_blobs()`** - Extract image CIDs from post record
+  - Handles direct post images (`record.embed.images`)
+  - Handles quoted posts with images (`record.embed.record.embed.images`)
+  - Returns `Vec<BlobReference>` with CIDs and mime types
+
+### `cursor.rs`
+- **`CursorManager`** - Persists Jetstream cursor to SQLite
+  - Enables resume from last position after restart
+  - Prevents reprocessing old events
+  - Updates every `config.cursor_update_interval` ms
+
+## Message Flow
+
+```
+1. WebSocket connects to Jetstream
+2. Subscribe to app.bsky.feed.post collection
+3. For each message:
+   a. Deserialize JetstreamEvent
+   b. Extract blobs from post record
+   c. If blobs found:
+      - Create ImageJob
+      - Send to job_tx channel
+   d. Update cursor periodically
+4. On disconnect: Reconnect with last cursor
+```
+
+## Event Filtering
+
+**What gets processed:**
+- Posts with `app.bsky.feed.post` type
+- Contains images in `embed.images` or `embed.record.embed.images`
+- Commit type is "create" (new posts only)
+
+**What gets skipped:**
+- Posts without images
+- Deletes/updates (only creates)
+- Other record types (likes, reposts, etc.)
+
+## Cursor Persistence
+
+The cursor marks our position in the firehose:
+```
+Initial connect -> No cursor (start from now)
+Save cursor     -> Every 10 seconds (configurable)
+Restart         -> Resume from saved cursor
+```
+
+**Storage:** SQLite database (`firehose_cursor.db`)
+**Why:** Prevents missing events during downtime
+
+## Blob Extraction Logic
+
+### Direct Images
+```json
+{
+  "embed": {
+    "$type": "app.bsky.embed.images",
+    "images": [
+      {
+        "image": { "ref": { "$link": "bafkrei..." } },
+        "mimeType": "image/jpeg"
+      }
+    ]
+  }
+}
+```
+
+### Quoted Posts with Images
+```json
+{
+  "embed": {
+    "$type": "app.bsky.embed.record#withMedia",
+    "record": {...},
+    "media": {
+      "images": [...]
+    }
+  }
+}
+```
+
+The `extract_blobs()` function handles both patterns.
+
+## Error Handling
+
+- **WebSocket disconnect** - Auto-reconnect with cursor
+- **Parse errors** - Log and skip message
+- **Channel closed** - Shutdown gracefully
+
+## Configuration
+
+```env
+JETSTREAM_URL=wss://jetstream.atproto.tools/subscribe
+CURSOR_UPDATE_INTERVAL=10000  # Save cursor every 10s
+```
+
+## Dependencies
+
+- `tokio-tungstenite` - WebSocket client
+- `serde_json` - JSON parsing
+- `tokio::sync::mpsc` - Job channel
+- `rusqlite` - Cursor persistence
+
+## Related Modules
+
+- Sends to: `queue` - Jobs sent via mpsc channel
+- Uses: `types::ImageJob` - Job format
+- Uses: `config` - Jetstream URL and settings

src/jetstream/cursor.rs

···
+use miette::{IntoDiagnostic, Result};
+use std::fs;
+use std::path::Path;
+use tracing::{info, warn};
+
+const CURSOR_FILE: &str = "firehose_cursor.db";
+
+/// Read cursor from disk
+pub fn read_cursor() -> Option<i64> {
+    let path = Path::new(CURSOR_FILE);
+    
+    if !path.exists() {
+        info!("No cursor file found, starting from current");
+        return None;
+    }
+    
+    match fs::read_to_string(path) {
+        Ok(content) => {
+            match content.trim().parse::<i64>() {
+                Ok(cursor) => {
+                    info!("Loaded cursor from disk: {}", cursor);
+                    Some(cursor)
+                }
+                Err(e) => {
+                    warn!("Failed to parse cursor file: {}", e);
+                    None
+                }
+            }
+        }
+        Err(e) => {
+            warn!("Failed to read cursor file: {}", e);
+            None
+        }
+    }
+}
+
+/// Write cursor to disk
+pub fn write_cursor(cursor: i64) -> Result<()> {
+    fs::write(CURSOR_FILE, cursor.to_string()).into_diagnostic()?;
+    Ok(())
+}

src/jetstream/events.rs

···
+use miette::Result;
+use serde_json::Value;
+
+use crate::types::BlobReference;
+
+/// Extract blob references from a post record
+///
+/// Handles two cases:
+/// 1. Direct images: record.embed.images[].image.ref.$link
+/// 2. Quote posts with media: record.embed.media.images[].image.ref.$link
+pub fn extract_blobs_from_record(record: &Value) -> Result<Vec<BlobReference>> {
+    let mut blobs = Vec::new();
+
+    let Some(embed) = record.get("embed") else {
+        return Ok(blobs);
+    };
+
+    // Case 1: Direct images (embed.images)
+    if let Some(images) = embed.get("images").and_then(|v| v.as_array()) {
+        for img in images {
+            if let Some(blob_ref) = extract_blob_from_image(img) {
+                blobs.push(blob_ref);
+            }
+        }
+    }
+
+    // Case 2: Quote posts with media (embed.media.images)
+    if let Some(media) = embed.get("media") {
+        if let Some(images) = media.get("images").and_then(|v| v.as_array()) {
+            for img in images {
+                if let Some(blob_ref) = extract_blob_from_image(img) {
+                    blobs.push(blob_ref);
+                }
+            }
+        }
+    }
+
+    Ok(blobs)
+}
+
+/// Extract a single blob reference from an image object
+fn extract_blob_from_image(img: &Value) -> Option<BlobReference> {
+    let image_obj = img.get("image")?;
+    let ref_obj = image_obj.get("ref")?;
+    let cid = ref_obj.get("$link")?.as_str()?;
+
+    let mime_type = image_obj
+        .get("mimeType")
+        .and_then(|v| v.as_str())
+        .map(String::from);
+
+    Some(BlobReference {
+        cid: cid.to_string(),
+        mime_type,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_extract_blobs_direct_images() {
+        let record = json!({
+            "embed": {
+                "$type": "app.bsky.embed.images",
+                "images": [
+                    {
+                        "alt": "Test image",
+                        "image": {
+                            "ref": {
+                                "$link": "bafyreiabc123"
+                            },
+                            "mimeType": "image/jpeg"
+                        }
+                    }
+                ]
+            }
+        });
+
+        let blobs = extract_blobs_from_record(&record).unwrap();
+        assert_eq!(blobs.len(), 1);
+        assert_eq!(blobs[0].cid, "bafyreiabc123");
+        assert_eq!(blobs[0].mime_type.as_deref(), Some("image/jpeg"));
+    }
+
+    #[test]
+    fn test_extract_blobs_quote_with_media() {
+        let record = json!({
+            "embed": {
+                "$type": "app.bsky.embed.recordWithMedia",
+                "media": {
+                    "images": [
+                        {
+                            "alt": "Test image",
+                            "image": {
+                                "ref": {
+                                    "$link": "bafyreiabc456"
+                                },
+                                "mimeType": "image/png"
+                            }
+                        }
+                    ]
+                }
+            }
+        });
+
+        let blobs = extract_blobs_from_record(&record).unwrap();
+        assert_eq!(blobs.len(), 1);
+        assert_eq!(blobs[0].cid, "bafyreiabc456");
+        assert_eq!(blobs[0].mime_type.as_deref(), Some("image/png"));
+    }
+
+    #[test]
+    fn test_extract_blobs_no_embed() {
+        let record = json!({
+            "text": "Just a text post"
+        });
+
+        let blobs = extract_blobs_from_record(&record).unwrap();
+        assert_eq!(blobs.len(), 0);
+    }
+
+    #[test]
+    fn test_extract_blobs_multiple_images() {
+        let record = json!({
+            "embed": {
+                "images": [
+                    {
+                        "image": {
+                            "ref": {
+                                "$link": "bafyreiabc111"
+                            },
+                            "mimeType": "image/jpeg"
+                        }
+                    },
+                    {
+                        "image": {
+                            "ref": {
+                                "$link": "bafyreiabc222"
+                            },
+                            "mimeType": "image/png"
+                        }
+                    }
+                ]
+            }
+        });
+
+        let blobs = extract_blobs_from_record(&record).unwrap();
+        assert_eq!(blobs.len(), 2);
+        assert_eq!(blobs[0].cid, "bafyreiabc111");
+        assert_eq!(blobs[1].cid, "bafyreiabc222");
+    }
+}

src/jetstream/mod.rs

···
+use jacquard_common::jetstream::{CommitOperation, JetstreamMessage, JetstreamParams};
+use jacquard_common::xrpc::{SubscriptionClient, TungsteniteSubscriptionClient};
+use miette::{IntoDiagnostic, Result};
+use futures::StreamExt;
+use tokio::sync::mpsc;
+use tracing::{debug, error, info, warn};
+use url::Url;
+
+use crate::types::ImageJob;
+
+pub mod cursor;
+pub mod events;
+
+pub struct JetstreamClient {
+    url: Url,
+    cursor: Option<i64>,
+}
+
+impl JetstreamClient {
+    pub fn new(url: String, cursor: Option<i64>) -> Result<Self> {
+        let url = Url::parse(&url).into_diagnostic()?;
+        Ok(Self { url, cursor })
+    }
+
+    /// Start jetstream subscription and send jobs to the provided channel
+    pub async fn subscribe(
+        self,
+        job_sender: mpsc::UnboundedSender<ImageJob>,
+        mut shutdown_rx: tokio::sync::oneshot::Receiver<()>,
+    ) -> Result<()> {
+        info!("Connecting to Jetstream: {}", self.url);
+
+        let client = TungsteniteSubscriptionClient::from_base_uri(self.url.clone());
+
+        // Configure subscription parameters
+        let params = JetstreamParams {
+            wanted_collections: Some(vec!["app.bsky.feed.post".to_string().into()]),
+            wanted_dids: None,
+            cursor: self.cursor,
+            compress: None,
+            max_message_size_bytes: None,
+            require_hello: None,
+        };
+
+        let stream = client.subscribe(&params).await.into_diagnostic()?;
+
+        info!("Connected to Jetstream, streaming messages...");
+
+        // Convert to typed message stream
+        let (_sink, mut messages) = stream.into_stream();
+
+        let mut message_count = 0u64;
+        let mut last_cursor: Option<i64> = None;
+        let mut cursor_update_interval = tokio::time::interval(std::time::Duration::from_secs(10));
+
+        loop {
+            tokio::select! {
+                Some(result) = messages.next() => {
+                    match result {
+                        Ok(msg) => {
+                            message_count += 1;
+                            if message_count % 1000 == 0 {
+                                debug!("Processed {} messages", message_count);
+                            }
+
+                            // Extract cursor from message
+                            let cursor = match &msg {
+                                JetstreamMessage::Commit { time_us, .. } => Some(*time_us),
+                                JetstreamMessage::Identity { time_us, .. } => Some(*time_us),
+                                JetstreamMessage::Account { time_us, .. } => Some(*time_us),
+                            };
+
+                            if let Some(c) = cursor {
+                                last_cursor = Some(c);
+                            }
+
+                            if let Err(e) = self.process_message(msg, &job_sender) {
+                                error!("Error processing message: {}", e);
+                            }
+                        }
+                        Err(e) => {
+                            error!("Jetstream error: {}", e);
+                        }
+                    }
+                }
+                _ = cursor_update_interval.tick() => {
+                    if let Some(cursor) = last_cursor {
+                        if let Err(e) = cursor::write_cursor(cursor) {
+                            warn!("Failed to write cursor: {}", e);
+                        } else {
+                            debug!("Wrote cursor: {}", cursor);
+                        }
+                    }
+                }
+                _ = &mut shutdown_rx => {
+                    info!("Shutting down Jetstream client");
+                    info!("Processed {} total messages", message_count);
+
+                    // Write final cursor
+                    if let Some(cursor) = last_cursor {
+                        if let Err(e) = cursor::write_cursor(cursor) {
+                            warn!("Failed to write final cursor: {}", e);
+                        } else {
+                            info!("Wrote final cursor: {}", cursor);
+                        }
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn process_message(
+        &self,
+        msg: JetstreamMessage,
+        job_sender: &mpsc::UnboundedSender<ImageJob>,
+    ) -> Result<()> {
+        match msg {
+            JetstreamMessage::Commit {
+                did,
+                time_us: _,
+                commit,
+            } => {
+                // Only process create operations on posts
+                if commit.collection.as_ref() != "app.bsky.feed.post" {
+                    return Ok(());
+                }
+
+                if !matches!(commit.operation, CommitOperation::Create) {
+                    return Ok(());
+                }
+
+                // Parse record to extract blobs (skip if no record)
+                let Some(record_data) = &commit.record else {
+                    return Ok(());
+                };
+
+                // Convert Data to serde_json::Value
+                let record_value: serde_json::Value =
+                    serde_json::to_value(record_data).into_diagnostic()?;
+                let blobs = events::extract_blobs_from_record(&record_value)?;
+
+                if blobs.is_empty() {
+                    return Ok(());
+                }
+
+                let post_uri = format!("at://{}/{}/{}", did, commit.collection, commit.rkey);
+
+                debug!(
+                    "Post with {} blob(s): {}",
+                    blobs.len(),
+                    post_uri
+                );
+
+                // Create job
+                let post_cid = commit
+                    .cid
+                    .as_ref()
+                    .map(|cid| cid.to_string())
+                    .unwrap_or_default();
+
+                let job = ImageJob {
+                    post_uri: post_uri.clone(),
+                    post_cid,
+                    post_did: did.to_string(),
+                    blobs,
+                    timestamp: chrono::Utc::now().timestamp_millis(),
+                    attempts: 0,
+                };
+
+                // Send to queue
+                if let Err(e) = job_sender.send(job) {
+                    warn!("Failed to send job to queue: {}", e);
+                }
+
+                Ok(())
+            }
+            JetstreamMessage::Identity { .. } => {
+                // Ignore identity updates for now
+                Ok(())
+            }
+            JetstreamMessage::Account { .. } => {
+                // Ignore account updates for now
+                Ok(())
+            }
+        }
+    }
+}

src/lib.rs

···
+// Core modules
+pub mod config;
+pub mod types;
+
+// Processing modules
+pub mod processor;
+
+// Jetstream client
+pub mod jetstream;
+
+// Moderation actions
+pub mod moderation;
+
+// Agent/authentication
+pub mod agent;
+
+// Cache
+pub mod cache;
+
+// Queue
+pub mod queue;
+
+// Metrics
+pub mod metrics;
+
+// Re-export commonly used types
+pub use config::Config;
+pub use types::{BlobCheck, BlobReference, ImageJob, MatchResult};

src/main.rs

···
+use miette::{IntoDiagnostic, Result};
+use reqwest::Client;
+use std::path::Path;
+use std::time::Duration;
+use tokio::sync::mpsc;
+use tokio::time::interval;
+use tracing::{error, info};
+
+use skywatch_phash_rs::{
+    agent::AgentSession,
+    cache::PhashCache,
+    config::Config,
+    jetstream::JetstreamClient,
+    metrics::Metrics,
+    processor::matcher,
+    queue::{JobQueue, WorkerPool},
+};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize tracing/logging
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::from_default_env()
+                .add_directive(tracing::Level::INFO.into()),
+        )
+        .init();
+
+    info!("skywatch-phash-rs starting...");
+
+    // Load configuration
+    let config = Config::from_env()?;
+    info!("Configuration loaded");
+    info!("Jetstream URL: {}", config.jetstream.url);
+    info!("Redis URL: {}", config.redis.url);
+    info!("PDS Endpoint: {}", config.pds.endpoint);
+    info!("Processing concurrency: {}", config.processing.concurrency);
+
+    // Create HTTP client
+    let client = Client::builder()
+        .timeout(Duration::from_secs(30))
+        .build()
+        .into_diagnostic()?;
+
+    // Create and authenticate agent
+    info!("Authenticating labeler agent...");
+    let agent = AgentSession::new(&config).await?;
+    info!("Agent authenticated as {}", config.automod.handle);
+
+    // Load blob checks from rules file
+    let rules_path = Path::new("rules/blobs.json");
+    info!("Loading blob checks from {:?}", rules_path);
+    let blob_checks = matcher::load_blob_checks(rules_path).await?;
+    info!("Loaded {} blob check rules", blob_checks.len());
+
+    // Create metrics tracker
+    let metrics = Metrics::new();
+    info!("Metrics tracker initialized");
+
+    // Create cache
+    let cache = PhashCache::new(&config).await?;
+    info!("Cache initialized (enabled: {})", cache.is_enabled());
+
+    // Create job queue
+    let queue = JobQueue::new(&config).await?;
+    info!("Job queue initialized");
+
+    // Create worker pool
+    let worker_pool = WorkerPool::new(
+        config.clone(),
+        client.clone(),
+        agent.clone(),
+        blob_checks.clone(),
+        metrics.clone(),
+    );
+    info!("Worker pool created with {} workers", config.processing.concurrency);
+
+    // Create shutdown channels
+    let (_shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
+    let (jetstream_shutdown_tx, jetstream_shutdown_rx) = tokio::sync::oneshot::channel::<()>();
+
+    // Create job channel for jetstream -> queue
+    let (job_tx, mut job_rx) = mpsc::unbounded_channel();
+
+    // Load cursor from disk
+    let cursor = skywatch_phash_rs::jetstream::cursor::read_cursor();
+    if let Some(c) = cursor {
+        info!("Resuming from cursor: {}", c);
+    }
+
+    // Start jetstream subscriber
+    info!("Starting Jetstream subscriber...");
+    let jetstream_config = config.clone();
+    let jetstream_handle = tokio::spawn(async move {
+        let jetstream = JetstreamClient::new(jetstream_config.jetstream.url.clone(), cursor)
+            .expect("Failed to create Jetstream client");
+
+        if let Err(e) = jetstream.subscribe(job_tx, jetstream_shutdown_rx).await {
+            error!("Jetstream subscriber failed: {}", e);
+        }
+    });
+
+    // Start job receiver (receives from jetstream, pushes to queue)
+    info!("Starting job receiver...");
+    let mut queue_for_receiver = queue.clone();
+    let receiver_metrics = metrics.clone();
+    let receiver_handle = tokio::spawn(async move {
+        while let Some(job) = job_rx.recv().await {
+            receiver_metrics.inc_jobs_received();
+            if let Err(e) = queue_for_receiver.push(&job).await {
+                error!("Failed to push job to queue: {}", e);
+                receiver_metrics.inc_jobs_failed();
+            }
+        }
+        info!("Job receiver stopped");
+    });
+
+    // Start worker pool with N concurrent workers
+    // Run directly without tokio::spawn to avoid HRTB lifetime issues with MemoryCredentialSession
+    let concurrency = config.processing.concurrency;
+    info!("Starting {} concurrent workers...", concurrency);
+
+    let mut worker_futures = Vec::new();
+    let (broadcast_shutdown_tx, _) = tokio::sync::broadcast::channel(1);
+
+    for worker_id in 0..concurrency {
+        let worker_pool_clone = worker_pool.clone();
+        let queue_clone = queue.clone();
+        let cache_clone = cache.clone();
+        let worker_shutdown = broadcast_shutdown_tx.subscribe();
+
+        let worker_future = async move {
+            info!("Worker {} starting", worker_id);
+            if let Err(e) = worker_pool_clone.start(queue_clone, cache_clone, worker_shutdown).await {
+                error!("Worker {} failed: {}", worker_id, e);
+            }
+            info!("Worker {} stopped", worker_id);
+        };
+
+        worker_futures.push(worker_future);
+    }
+
+    let all_workers_future = futures::future::join_all(worker_futures);
+
+    // Start metrics logger
+    info!("Starting metrics logger...");
+    let metrics_for_logger = metrics.clone();
+    let metrics_handle = tokio::spawn(async move {
+        let mut ticker = interval(Duration::from_secs(60));
+        loop {
+            ticker.tick().await;
+            metrics_for_logger.log_stats();
+        }
+    });
+
+    // Wait for shutdown signal or task completion
+    info!("Service started successfully, waiting for shutdown signal...");
+    tokio::select! {
+        _ = tokio::signal::ctrl_c() => {
+            info!("Received Ctrl+C, initiating graceful shutdown...");
+        }
+        _ = shutdown_rx => {
+            info!("Received shutdown signal");
+        }
+        _ = all_workers_future => {
+            info!("All workers completed");
+        }
+        _ = jetstream_handle => {
+            info!("Jetstream subscriber completed");
+        }
+    }
+
+    // Send shutdown signals to all tasks
+    info!("Shutting down Jetstream subscriber...");
+    let _ = jetstream_shutdown_tx.send(());
+
+    info!("Shutting down workers...");
+    let _ = broadcast_shutdown_tx.send(());
+
+    // Stop metrics logger
+    metrics_handle.abort();
+
+    // Stop job receiver
+    receiver_handle.abort();
+
+    // Log final metrics
+    info!("=== Final Metrics ===");
+    metrics.log_stats();
+
+    info!("Shutdown complete");
+    Ok(())
+}

src/metrics/README.md

···
+# Metrics Module
+
+## Purpose
+Lock-free atomic counters for tracking system performance and moderation actions.
+
+## Key Components
+
+### `mod.rs`
+- **`Metrics`** - Collection of atomic counters
+  - Thread-safe (Arc-wrapped)
+  - Lock-free operations (AtomicU64)
+  - Cheap to clone and share across workers
+
+### Tracked Metrics
+
+**Job Processing:**
+- `jobs_received` - Total jobs from Jetstream
+- `jobs_processed` - Successfully completed jobs
+- `jobs_failed` - Failed jobs (after all retries)
+- `jobs_retried` - Jobs sent to retry queue
+
+**Blob Processing:**
+- `blobs_processed` - Total blobs checked
+- `blobs_downloaded` - Blobs fetched from CDN/PDS
+- `matches_found` - Phashes matching known bad images
+
+**Cache Performance:**
+- `cache_hits` - Phash found in cache
+- `cache_misses` - Phash not in cache (download needed)
+
+**Moderation Actions:**
+- `posts_labeled` - Posts labeled via Ozone
+- `posts_reported` - Posts reported to moderators
+- `accounts_labeled` - Accounts labeled
+- `accounts_reported` - Accounts reported
+
+### Key Methods
+
+**Increment counters:**
+- `inc_jobs_received()`
+- `inc_jobs_processed()`
+- `inc_cache_hits()`
+- etc.
+
+**Read values:**
+- `snapshot()` - Get all current values as `MetricsSnapshot`
+  - Returns struct with all counter values
+  - Used for logging/monitoring
+
+**Computed metrics:**
+- `cache_hit_rate()` - Percentage of cache hits
+  - Returns `hits / (hits + misses)`
+  - 0.0 if no cache operations yet
+
+## Atomic Operations
+
+Uses `AtomicU64` with `Ordering::Relaxed`:
+- **Why Relaxed?** - Only need atomicity, not ordering guarantees
+- **Performance** - Fastest atomic operations
+- **Safe** - Multiple workers can increment concurrently
+
+Example:
+```rust
+// Thread-safe increment from any worker
+metrics.inc_jobs_processed();
+
+// Lock-free read
+let processed = metrics.jobs_processed.load(Ordering::Relaxed);
+```
+
+## Logging Pattern
+
+Metrics are logged:
+1. **Periodically** - Every 60 seconds while running
+2. **On shutdown** - Final totals when service stops
+
+Log format:
+```
+Metrics snapshot:
+  Jobs: received=1234, processed=1200, failed=5, retried=29
+  Blobs: processed=3456, downloaded=890
+  Cache: hits=2566 (74.3%), misses=890
+  Matches: found=42
+  Moderation: posts_labeled=38, posts_reported=42, accounts_labeled=10, accounts_reported=12
+```
+
+## Usage Pattern
+
+```rust
+// Create once at startup
+let metrics = Metrics::new();
+
+// Clone into workers
+let worker_metrics = metrics.clone();
+
+// Increment from workers
+worker_metrics.inc_jobs_processed();
+worker_metrics.inc_cache_hits();
+
+// Read snapshot for logging
+let snapshot = metrics.snapshot();
+info!("Cache hit rate: {:.1}%", snapshot.cache_hit_rate() * 100.0);
+```
+
+## Design Decisions
+
+**Why AtomicU64 instead of Mutex<u64>?**
+- No lock contention across 10+ workers
+- Much faster for increment operations
+- Can't overflow in practice (u64 max = 18 quintillion)
+
+**Why snapshot()?**
+- Get consistent view of all metrics at once
+- Prevents reading torn values during logging
+- Easy to extend with new computed metrics
+
+**Why Relaxed ordering?**
+- Counters are independent
+- Don't need cross-counter synchronization
+- Exact timing doesn't matter (eventually consistent)
+
+## Dependencies
+
+- `std::sync::atomic` - Atomic operations
+- `std::sync::Arc` - Shared ownership
+
+## Related Modules
+
+- Used by: All modules - everything increments metrics
+- Read by: `main.rs` - Periodic logging task

src/metrics/mod.rs

···
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use tracing::info;
+
+/// Global metrics tracker for the service
+#[derive(Clone)]
+pub struct Metrics {
+    inner: Arc<MetricsInner>,
+}
+
+struct MetricsInner {
+    // Job metrics
+    jobs_received: AtomicU64,
+    jobs_processed: AtomicU64,
+    jobs_failed: AtomicU64,
+    jobs_retried: AtomicU64,
+
+    // Blob metrics
+    blobs_processed: AtomicU64,
+    blobs_downloaded: AtomicU64,
+
+    // Match metrics
+    matches_found: AtomicU64,
+
+    // Cache metrics
+    cache_hits: AtomicU64,
+    cache_misses: AtomicU64,
+
+    // Moderation metrics
+    posts_labeled: AtomicU64,
+    posts_reported: AtomicU64,
+    accounts_labeled: AtomicU64,
+    accounts_reported: AtomicU64,
+
+    // Skip metrics (already handled)
+    posts_already_labeled: AtomicU64,
+    posts_already_reported: AtomicU64,
+    accounts_already_labeled: AtomicU64,
+    accounts_already_reported: AtomicU64,
+}
+
+impl Metrics {
+    /// Create a new metrics tracker
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(MetricsInner {
+                jobs_received: AtomicU64::new(0),
+                jobs_processed: AtomicU64::new(0),
+                jobs_failed: AtomicU64::new(0),
+                jobs_retried: AtomicU64::new(0),
+                blobs_processed: AtomicU64::new(0),
+                blobs_downloaded: AtomicU64::new(0),
+                matches_found: AtomicU64::new(0),
+                cache_hits: AtomicU64::new(0),
+                cache_misses: AtomicU64::new(0),
+                posts_labeled: AtomicU64::new(0),
+                posts_reported: AtomicU64::new(0),
+                accounts_labeled: AtomicU64::new(0),
+                accounts_reported: AtomicU64::new(0),
+                posts_already_labeled: AtomicU64::new(0),
+                posts_already_reported: AtomicU64::new(0),
+                accounts_already_labeled: AtomicU64::new(0),
+                accounts_already_reported: AtomicU64::new(0),
+            }),
+        }
+    }
+
+    // Job metrics
+    pub fn inc_jobs_received(&self) {
+        self.inner.jobs_received.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_jobs_processed(&self) {
+        self.inner.jobs_processed.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_jobs_failed(&self) {
+        self.inner.jobs_failed.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_jobs_retried(&self) {
+        self.inner.jobs_retried.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Blob metrics
+    pub fn inc_blobs_processed(&self) {
+        self.inner.blobs_processed.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_blobs_downloaded(&self) {
+        self.inner.blobs_downloaded.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Match metrics
+    pub fn inc_matches_found(&self) {
+        self.inner.matches_found.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Cache metrics
+    pub fn inc_cache_hits(&self) {
+        self.inner.cache_hits.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_cache_misses(&self) {
+        self.inner.cache_misses.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Moderation metrics
+    pub fn inc_posts_labeled(&self) {
+        self.inner.posts_labeled.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_posts_reported(&self) {
+        self.inner.posts_reported.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_accounts_labeled(&self) {
+        self.inner.accounts_labeled.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_accounts_reported(&self) {
+        self.inner.accounts_reported.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Skip metrics
+    pub fn inc_posts_already_labeled(&self) {
+        self.inner.posts_already_labeled.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_posts_already_reported(&self) {
+        self.inner.posts_already_reported.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_accounts_already_labeled(&self) {
+        self.inner.accounts_already_labeled.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn inc_accounts_already_reported(&self) {
+        self.inner.accounts_already_reported.fetch_add(1, Ordering::Relaxed);
+    }
+
+    // Getters
+    pub fn jobs_received(&self) -> u64 {
+        self.inner.jobs_received.load(Ordering::Relaxed)
+    }
+
+    pub fn jobs_processed(&self) -> u64 {
+        self.inner.jobs_processed.load(Ordering::Relaxed)
+    }
+
+    pub fn jobs_failed(&self) -> u64 {
+        self.inner.jobs_failed.load(Ordering::Relaxed)
+    }
+
+    pub fn jobs_retried(&self) -> u64 {
+        self.inner.jobs_retried.load(Ordering::Relaxed)
+    }
+
+    pub fn blobs_processed(&self) -> u64 {
+        self.inner.blobs_processed.load(Ordering::Relaxed)
+    }
+
+    pub fn blobs_downloaded(&self) -> u64 {
+        self.inner.blobs_downloaded.load(Ordering::Relaxed)
+    }
+
+    pub fn matches_found(&self) -> u64 {
+        self.inner.matches_found.load(Ordering::Relaxed)
+    }
+
+    pub fn cache_hits(&self) -> u64 {
+        self.inner.cache_hits.load(Ordering::Relaxed)
+    }
+
+    pub fn cache_misses(&self) -> u64 {
+        self.inner.cache_misses.load(Ordering::Relaxed)
+    }
+
+    pub fn posts_labeled(&self) -> u64 {
+        self.inner.posts_labeled.load(Ordering::Relaxed)
+    }
+
+    pub fn posts_reported(&self) -> u64 {
+        self.inner.posts_reported.load(Ordering::Relaxed)
+    }
+
+    pub fn accounts_labeled(&self) -> u64 {
+        self.inner.accounts_labeled.load(Ordering::Relaxed)
+    }
+
+    pub fn accounts_reported(&self) -> u64 {
+        self.inner.accounts_reported.load(Ordering::Relaxed)
+    }
+
+    pub fn posts_already_labeled(&self) -> u64 {
+        self.inner.posts_already_labeled.load(Ordering::Relaxed)
+    }
+
+    pub fn posts_already_reported(&self) -> u64 {
+        self.inner.posts_already_reported.load(Ordering::Relaxed)
+    }
+
+    pub fn accounts_already_labeled(&self) -> u64 {
+        self.inner.accounts_already_labeled.load(Ordering::Relaxed)
+    }
+
+    pub fn accounts_already_reported(&self) -> u64 {
+        self.inner.accounts_already_reported.load(Ordering::Relaxed)
+    }
+
+    /// Log current metrics
+    pub fn log_stats(&self) {
+        info!("=== Metrics ===");
+        info!("Jobs: received={}, processed={}, failed={}, retried={}",
+            self.jobs_received(),
+            self.jobs_processed(),
+            self.jobs_failed(),
+            self.jobs_retried()
+        );
+        info!("Blobs: processed={}, downloaded={}",
+            self.blobs_processed(),
+            self.blobs_downloaded()
+        );
+        info!("Matches: found={}",
+            self.matches_found()
+        );
+        info!("Cache: hits={}, misses={}, hit_rate={:.2}%",
+            self.cache_hits(),
+            self.cache_misses(),
+            self.cache_hit_rate()
+        );
+        info!("Moderation: posts_labeled={}, posts_reported={}, accounts_labeled={}, accounts_reported={}",
+            self.posts_labeled(),
+            self.posts_reported(),
+            self.accounts_labeled(),
+            self.accounts_reported()
+        );
+        info!("Skipped (deduplication): posts_already_labeled={}, posts_already_reported={}, accounts_already_labeled={}, accounts_already_reported={}",
+            self.posts_already_labeled(),
+            self.posts_already_reported(),
+            self.accounts_already_labeled(),
+            self.accounts_already_reported()
+        );
+    }
+
+    /// Calculate cache hit rate
+    pub fn cache_hit_rate(&self) -> f64 {
+        let hits = self.cache_hits() as f64;
+        let total = (self.cache_hits() + self.cache_misses()) as f64;
+        if total == 0.0 {
+            0.0
+        } else {
+            (hits / total) * 100.0
+        }
+    }
+
+    /// Get snapshot of current metrics
+    pub fn snapshot(&self) -> MetricsSnapshot {
+        MetricsSnapshot {
+            jobs_received: self.jobs_received(),
+            jobs_processed: self.jobs_processed(),
+            jobs_failed: self.jobs_failed(),
+            jobs_retried: self.jobs_retried(),
+            blobs_processed: self.blobs_processed(),
+            blobs_downloaded: self.blobs_downloaded(),
+            matches_found: self.matches_found(),
+            cache_hits: self.cache_hits(),
+            cache_misses: self.cache_misses(),
+            posts_labeled: self.posts_labeled(),
+            posts_reported: self.posts_reported(),
+            accounts_labeled: self.accounts_labeled(),
+            accounts_reported: self.accounts_reported(),
+            posts_already_labeled: self.posts_already_labeled(),
+            posts_already_reported: self.posts_already_reported(),
+            accounts_already_labeled: self.accounts_already_labeled(),
+            accounts_already_reported: self.accounts_already_reported(),
+        }
+    }
+}
+
+impl Default for Metrics {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MetricsSnapshot {
+    pub jobs_received: u64,
+    pub jobs_processed: u64,
+    pub jobs_failed: u64,
+    pub jobs_retried: u64,
+    pub blobs_processed: u64,
+    pub blobs_downloaded: u64,
+    pub matches_found: u64,
+    pub cache_hits: u64,
+    pub cache_misses: u64,
+    pub posts_labeled: u64,
+    pub posts_reported: u64,
+    pub accounts_labeled: u64,
+    pub accounts_reported: u64,
+    pub posts_already_labeled: u64,
+    pub posts_already_reported: u64,
+    pub accounts_already_labeled: u64,
+    pub accounts_already_reported: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_metrics_increment() {
+        let metrics = Metrics::new();
+
+        assert_eq!(metrics.jobs_received(), 0);
+
+        metrics.inc_jobs_received();
+        metrics.inc_jobs_received();
+
+        assert_eq!(metrics.jobs_received(), 2);
+    }
+
+    #[test]
+    fn test_cache_hit_rate() {
+        let metrics = Metrics::new();
+
+        // No cache operations yet
+        assert_eq!(metrics.cache_hit_rate(), 0.0);
+
+        // 3 hits, 1 miss = 75%
+        metrics.inc_cache_hits();
+        metrics.inc_cache_hits();
+        metrics.inc_cache_hits();
+        metrics.inc_cache_misses();
+
+        assert_eq!(metrics.cache_hit_rate(), 75.0);
+    }
+
+    #[test]
+    fn test_metrics_snapshot() {
+        let metrics = Metrics::new();
+
+        metrics.inc_jobs_received();
+        metrics.inc_matches_found();
+
+        let snapshot = metrics.snapshot();
+
+        assert_eq!(snapshot.jobs_received, 1);
+        assert_eq!(snapshot.matches_found, 1);
+    }
+}

src/moderation/README.md

···
+# Moderation Module
+
+## Purpose
+Interacts with Bluesky's Ozone moderation API to take actions (label, report, takedown) on posts and accounts.
+
+## Key Components
+
+### `post.rs`
+Moderation actions on posts:
+- **`label_post()`** - Apply label to post (e.g., "spam", "csam")
+- **`unlabel_post()`** - Remove label from post
+- **`report_post()`** - Report post to moderators
+- **`takedown_post()`** - Takedown/remove post
+
+### `account.rs`
+Moderation actions on accounts:
+- **`label_account()`** - Apply label to account
+- **`unlabel_account()`** - Remove label from account
+- **`report_account()`** - Report account to moderators
+- **`takedown_account()`** - Takedown/suspend account
+
+### `claims.rs`
+Deduplication to prevent duplicate reports:
+- **`claim_post_report()`** - Check if post already reported
+- **`claim_account_report()`** - Check if account already reported
+- Uses Redis to track `post_uri:label` pairs
+- Returns `true` if claim successful (first time), `false` if duplicate
+
+### `rate_limiter.rs`
+Global rate limiting across all workers:
+- **`RateLimiter`** - Thread-safe rate limiter using governor crate
+- **`new(rate_limit_ms)`** - Create limiter (e.g., 100ms = 10 req/sec)
+- **`wait()`** - Block until allowed to make request
+- Enforces global limit across all concurrent workers
+
+## API Endpoints
+
+All functions call Ozone API at `{OZONE_URL}/xrpc/tools.ozone.moderation.emitEvent`:
+
+**Event types:**
+- `tools.ozone.moderation.defs#modEventLabel` - Label action
+- `tools.ozone.moderation.defs#modEventReport` - Report action
+- `tools.ozone.moderation.defs#modEventTakedown` - Takedown action
+
+## Comment Format
+
+All moderation actions include detailed comments:
+```
+{timestamp}: {check_comment} at https://pdsls.dev/{post_uri} with phash "{phash}"
+```
+
+Example:
+```
[phone]T12:34:56Z: Known spam image detected at https://pdsls.dev/at://did:plc:xyz/app.bsky.feed.post/abc with phash "e0e0e0e0e0fcfefe"
+```
+
+This provides:
+- **When** - ISO 8601 timestamp
+- **Why** - Comment from blob check rule
+- **Where** - pdsls.dev link to the post
+- **Evidence** - The phash that matched
+
+## Rate Limiting
+
+**Problem:** 10 workers × 4 actions/match = 40 concurrent requests could overwhelm API
+
+**Solution:** Global rate limiter
+```rust
+// Before each API call:
+rate_limiter.wait().await;  // Blocks until safe to proceed
+// Make request
+```
+
+With `RATE_LIMIT_MS=100`:
+- Maximum 10 requests/second globally
+- All workers share the same limiter
+- Prevents rate limit errors from API
+
+## Deduplication
+
+**Problem:** Same post might match multiple times (retries, multiple rules)
+
+**Solution:** Redis-backed claims
+```rust
+if claim_post_report(redis, post_uri, label).await? {
+    report_post(...).await?;  // First time, do it
+} else {
+    // Already reported, skip
+}
+```
+
+**Storage:** Redis key = `report:post:{post_uri}:{label}` with 24h TTL
+
+## Authentication
+
+All functions require `access_token` from AgentSession:
+```rust
+let token = agent.get_token().await?;
+label_post(client, &token, config, ...).await?;
+```
+
+Token is included in `Authorization: Bearer {token}` header.
+
+## Required Headers
+
+**For Ozone API:**
+```
+Authorization: Bearer {access_token}
+atproto-proxy: {mod_did}#atproto_labeler
+atproto-accept-labelers: did:plc:ar7c4by46qjdydhdevvrndac;redact
+```
+
+## Usage Flow
+
+```
+1. Worker finds match
+2. Get access token from agent
+3. For each configured action:
+   a. Check claim (dedupe)
+   b. Wait for rate limiter
+   c. Call moderation function
+   d. Increment metrics
+```
+
+## Configuration
+
+```env
+MOD_DID=did:plc:xxxxx           # Moderator DID
+OZONE_URL=https://ozone.example.com
+OZONE_PDS=https://bsky.social
+RATE_LIMIT_MS=100               # 10 req/sec max
+```
+
+## Dependencies
+
+- `reqwest::Client` - HTTP client
+- `redis` - Claims storage
+- `governor` - Rate limiting
+- `chrono` - Timestamps
+- `serde_json` - JSON building
+
+## Related Modules
+
+- Used by: `queue/worker.rs` - Takes actions on matches
+- Uses: `agent` - For access tokens
+- Uses: `config` - For Ozone URL and rate limit

src/moderation/account.rs

···
+use jacquard::client::{Agent, MemoryCredentialSession};
+use jacquard_api::com_atproto::admin::RepoRef;
+use jacquard_api::com_atproto::moderation::ReasonType;
+use jacquard_api::tools_ozone::moderation::emit_event::{
+    EmitEvent, EmitEventEvent, EmitEventSubject,
+};
+use jacquard_api::tools_ozone::moderation::{
+    ModEventLabel, ModEventReport, ModEventTakedown, ModTool,
+};
+use jacquard_common::CowStr;
+use jacquard_common::types::string::Did;
+use jacquard_common::types::value::{Data, Object};
+use jacquard_common::xrpc::{CallOptions, XrpcClient};
+
+use jacquard_common::smol_str::SmolStr;
+use miette::{IntoDiagnostic, Result};
+use std::collections::BTreeMap;
+use tracing::{debug, info};
+
+use crate::config::Config;
+use crate::moderation::rate_limiter::RateLimiter;
+
+/// Label an account with a specific label via Ozone moderation API
+pub async fn label_account(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    did: &str,
+    label_val: &str,
+    check_comment: &str,
+    post_uri: &str,
+    phash: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Labeling account {} with label: {}", did, label_val);
+
+    let timestamp = chrono::Utc::now().to_rfc3339();
+    let comment = format!("{}: {}", timestamp, check_comment);
+
+    // Build mod_tool meta
+    let mut meta_map = BTreeMap::new();
+    meta_map.insert(
+        SmolStr::new("externalUrl"),
+        format!("https://pdsls.dev/{}", post_uri).into(),
+    );
+    meta_map.insert(SmolStr::new("phash"), phash.into());
+
+    // Create moderation label event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventLabel(Box::new(
+            ModEventLabel::builder()
+                .create_label_vals(vec![CowStr::from(label_val)])
+                .negate_label_vals(vec![])
+                .comment(CowStr::from(comment))
+                .build(),
+        )))
+        .subject(EmitEventSubject::RepoRef(Box::new(
+            RepoRef::builder()
+                .did(Did::new(did).into_diagnostic()?)
+                .build(),
+        )))
+        .mod_tool(ModTool {
+            name: CowStr::from("skywatch/skywatch-phash-rs"),
+            meta: Some(Data::Object(Object::from(meta_map))),
+            extra_data: BTreeMap::new(),
+        })
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None,
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully labeled account: {}", did);
+
+    Ok(())
+}
+
+/// Report an account to ozone moderation
+pub async fn report_account(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    did: &str,
+    reason: ReasonType<'static>,
+    check_comment: &str,
+    post_uri: &str,
+    phash: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Reporting account {} to ozone: {:?}", did, reason);
+
+    let timestamp = chrono::Utc::now().to_rfc3339();
+    let comment = format!("{}: {}", timestamp, check_comment);
+
+    // Build mod_tool meta
+    let mut meta_map = BTreeMap::new();
+    meta_map.insert(
+        SmolStr::new("externalUrl"),
+        format!("https://pdsls.dev/{}", post_uri).into(),
+    );
+    meta_map.insert(SmolStr::new("phash"), phash.into());
+
+    // Create moderation report event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventReport(Box::new(
+            ModEventReport::builder()
+                .report_type(reason)
+                .comment(CowStr::from(comment))
+                .build(),
+        )))
+        .subject(EmitEventSubject::RepoRef(Box::new(
+            RepoRef::builder()
+                .did(Did::new(did).into_diagnostic()?)
+                .build(),
+        )))
+        .subject_blob_cids(vec![])
+        .mod_tool(ModTool {
+            name: CowStr::from("skywatch/skywatch-phash-rs"),
+            meta: Some(Data::Object(Object::from(meta_map))),
+            extra_data: BTreeMap::new(),
+        })
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None,
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully reported account: {}", did);
+
+    Ok(())
+}
+
+/// Takedown an account via Ozone moderation API
+pub async fn takedown_account(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    did: &str,
+    comment: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Taking down account: {}", did);
+
+    // Create moderation takedown event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventTakedown(Box::new(
+            ModEventTakedown {
+                comment: Some(CowStr::from(comment)),
+                ..Default::default()
+            },
+        )))
+        .subject(EmitEventSubject::RepoRef(Box::new(
+            RepoRef::builder()
+                .did(Did::new(did).into_diagnostic()?)
+                .build(),
+        )))
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None,
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully took down account: {}", did);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    // Note: These are integration tests that require a real client and auth
+    // Unit tests for account operations would require mocking the HTTP client
+}

src/moderation/claims.rs

···
+use miette::{IntoDiagnostic, Result};
+use redis::AsyncCommands;
+use tracing::debug;
+
+/// Redis key prefix for moderation claims
+const CLAIMS_PREFIX: &str = "mod:claims";
+
+/// Redis key prefix for label claims
+const LABEL_PREFIX: &str = "mod:labels";
+
+/// Default TTL for claims (24 hours)
+const DEFAULT_CLAIM_TTL: u64 = 86400;
+
+/// Check if a moderation action has already been claimed
+pub async fn has_claim(
+    redis: &mut redis::aio::MultiplexedConnection,
+    action_type: &str,
+    subject: &str,
+    label: &str,
+) -> Result<bool> {
+    let key = format!("{}:{}:{}:{}", CLAIMS_PREFIX, action_type, subject, label);
+    let exists: bool = redis.exists(&key).await.into_diagnostic()?;
+    Ok(exists)
+}
+
+/// Create a claim for a moderation action
+pub async fn create_claim(
+    redis: &mut redis::aio::MultiplexedConnection,
+    action_type: &str,
+    subject: &str,
+    label: &str,
+    ttl: Option<u64>,
+) -> Result<()> {
+    let key = format!("{}:{}:{}:{}", CLAIMS_PREFIX, action_type, subject, label);
+    let ttl_seconds = ttl.unwrap_or(DEFAULT_CLAIM_TTL);
+
+    // Set with expiration
+    let _: () = redis
+        .set_ex(&key, "1", ttl_seconds)
+        .await
+        .into_diagnostic()?;
+
+    debug!(
+        "Created claim: action={}, subject={}, label={}, ttl={}s",
+        action_type, subject, label, ttl_seconds
+    );
+
+    Ok(())
+}
+
+/// Remove a claim for a moderation action
+pub async fn remove_claim(
+    redis: &mut redis::aio::MultiplexedConnection,
+    action_type: &str,
+    subject: &str,
+    label: &str,
+) -> Result<()> {
+    let key = format!("{}:{}:{}:{}", CLAIMS_PREFIX, action_type, subject, label);
+    let _: () = redis.del(&key).await.into_diagnostic()?;
+
+    debug!(
+        "Removed claim: action={}, subject={}, label={}",
+        action_type, subject, label
+    );
+
+    Ok(())
+}
+
+/// Check if a label has already been applied
+pub async fn has_label(
+    redis: &mut redis::aio::MultiplexedConnection,
+    subject: &str,
+    label: &str,
+) -> Result<bool> {
+    let key = format!("{}:{}:{}", LABEL_PREFIX, subject, label);
+    let exists: bool = redis.exists(&key).await.into_diagnostic()?;
+    Ok(exists)
+}
+
+/// Record that a label has been applied
+pub async fn set_label(
+    redis: &mut redis::aio::MultiplexedConnection,
+    subject: &str,
+    label: &str,
+    ttl: Option<u64>,
+) -> Result<()> {
+    let key = format!("{}:{}:{}", LABEL_PREFIX, subject, label);
+    let ttl_seconds = ttl.unwrap_or(DEFAULT_CLAIM_TTL);
+
+    let _: () = redis
+        .set_ex(&key, "1", ttl_seconds)
+        .await
+        .into_diagnostic()?;
+
+    debug!(
+        "Set label: subject={}, label={}, ttl={}s",
+        subject, label, ttl_seconds
+    );
+
+    Ok(())
+}
+
+/// Remove a label record
+pub async fn remove_label(
+    redis: &mut redis::aio::MultiplexedConnection,
+    subject: &str,
+    label: &str,
+) -> Result<()> {
+    let key = format!("{}:{}:{}", LABEL_PREFIX, subject, label);
+    let _: () = redis.del(&key).await.into_diagnostic()?;
+
+    debug!("Removed label: subject={}, label={}", subject, label);
+
+    Ok(())
+}
+
+/// Claim a post report action (returns true if claimed successfully, false if already claimed)
+pub async fn claim_post_report(
+    redis: &mut redis::aio::MultiplexedConnection,
+    post_uri: &str,
+    label: &str,
+) -> Result<bool> {
+    if has_claim(redis, "report_post", post_uri, label).await? {
+        return Ok(false);
+    }
+    create_claim(redis, "report_post", post_uri, label, None).await?;
+    Ok(true)
+}
+
+/// Claim an account report action (returns true if claimed successfully, false if already claimed)
+pub async fn claim_account_report(
+    redis: &mut redis::aio::MultiplexedConnection,
+    did: &str,
+    label: &str,
+) -> Result<bool> {
+    if has_claim(redis, "report_account", did, label).await? {
+        return Ok(false);
+    }
+    create_claim(redis, "report_account", did, label, None).await?;
+    Ok(true)
+}
+
+#[cfg(test)]
+mod tests {
+    // Note: These are integration tests that require a running Redis instance
+    // Run with: cargo test --test moderation_claims -- --ignored
+}

src/moderation/mod.rs

···
+pub mod account;
+pub mod claims;
+pub mod post;
+pub mod rate_limiter;

src/moderation/post.rs

···
+use jacquard::client::{Agent, MemoryCredentialSession};
+use jacquard_api::com_atproto::admin::RepoRef;
+use jacquard_api::com_atproto::moderation::ReasonType;
+use jacquard_api::com_atproto::repo::strong_ref::StrongRef;
+use jacquard_api::tools_ozone::moderation::emit_event::{
+    EmitEvent, EmitEventEvent, EmitEventSubject,
+};
+use jacquard_api::tools_ozone::moderation::{
+    ModEventLabel, ModEventReport, ModEventTakedown, ModTool,
+};
+use jacquard_common::CowStr;
+use jacquard_common::types::string::{AtUri, Cid, Did};
+use jacquard_common::types::value::{Data, Object};
+use jacquard_common::xrpc::{CallOptions, XrpcClient};
+use miette::{IntoDiagnostic, Result};
+use tracing::{debug, info};
+
+use jacquard_common::smol_str::SmolStr;
+use std::collections::BTreeMap;
+
+use crate::config::Config;
+use crate::moderation::rate_limiter::RateLimiter;
+
+/// Label a post with a specific label via Ozone moderation API
+pub async fn label_post(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    post_uri: &str,
+    post_cid: &str,
+    label_val: &str,
+    check_comment: &str,
+    phash: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Labeling post {} with label: {}", post_uri, label_val);
+
+    let timestamp = chrono::Utc::now().to_rfc3339();
+    let comment = format!("{}: {}", timestamp, check_comment);
+
+    // Build mod_tool meta
+    let mut meta_map = BTreeMap::new();
+    meta_map.insert(
+        SmolStr::new("externalUrl"),
+        format!("https://pdsls.dev/{}", post_uri).into(),
+    );
+    meta_map.insert(SmolStr::new("phash"), phash.into());
+
+    // Create moderation label event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventLabel(Box::new(
+            ModEventLabel::builder()
+                .create_label_vals(vec![CowStr::from(label_val)])
+                .negate_label_vals(vec![])
+                .comment(CowStr::from(comment))
+                .build(),
+        )))
+        .subject(EmitEventSubject::StrongRef(Box::new(
+            StrongRef::builder()
+                .uri(AtUri::new(post_uri).into_diagnostic()?)
+                .cid(Cid::str(post_cid))
+                .build(),
+        )))
+        .mod_tool(ModTool {
+            name: CowStr::from("skywatch/skywatch-phash-rs"),
+            meta: Some(Data::Object(Object::from(meta_map))),
+            extra_data: BTreeMap::new(),
+        })
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None, // Agent handles auth automatically
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully labeled post: {}", post_uri);
+
+    Ok(())
+}
+
+/// Report a post to ozone moderation
+pub async fn report_post(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    post_uri: &str,
+    _post_cid: &str,
+    reason: ReasonType<'static>,
+    check_comment: &str,
+    phash: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Reporting post {} to ozone: {:?}", post_uri, reason);
+
+    let timestamp = chrono::Utc::now().to_rfc3339();
+    let comment = format!("{}: {}", timestamp, check_comment);
+
+    // Extract DID from URI
+    let did_str = extract_did_from_uri(post_uri)?;
+
+    // Build mod_tool meta
+    let mut meta_map = BTreeMap::new();
+    meta_map.insert(
+        SmolStr::new("externalUrl"),
+        format!("https://pdsls.dev/{}", post_uri).into(),
+    );
+    meta_map.insert(SmolStr::new("phash"), phash.into());
+
+    // Create moderation report event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventReport(Box::new(
+            ModEventReport::builder()
+                .report_type(reason)
+                .comment(CowStr::from(comment))
+                .build(),
+        )))
+        .subject(EmitEventSubject::RepoRef(Box::new(
+            RepoRef::builder()
+                .did(Did::new(&did_str).into_diagnostic()?)
+                .build(),
+        )))
+        .subject_blob_cids(vec![])
+        .mod_tool(ModTool {
+            name: CowStr::from("skywatch/skywatch-phash-rs"),
+            meta: Some(Data::Object(Object::from(meta_map))),
+            extra_data: BTreeMap::new(),
+        })
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None,
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully reported post: {}", post_uri);
+
+    Ok(())
+}
+
+/// Takedown a post via Ozone moderation API
+pub async fn takedown_post(
+    agent: &Agent<MemoryCredentialSession>,
+    config: &Config,
+    rate_limiter: &RateLimiter,
+    post_uri: &str,
+    post_cid: &str,
+    comment: &str,
+    created_by: &str,
+) -> Result<()> {
+    // Wait for rate limiter before making request
+    rate_limiter.wait().await;
+
+    info!("Taking down post: {}", post_uri);
+
+    // Create moderation takedown event using jacquard-api types
+    let event = EmitEvent::new()
+        .created_by(Did::new(created_by).into_diagnostic()?)
+        .event(EmitEventEvent::ModEventTakedown(Box::new(
+            ModEventTakedown {
+                comment: Some(CowStr::from(comment)),
+                ..Default::default()
+            },
+        )))
+        .subject(EmitEventSubject::StrongRef(Box::new(
+            StrongRef::builder()
+                .uri(AtUri::new(post_uri).into_diagnostic()?)
+                .cid(Cid::str(post_cid))
+                .build(),
+        )))
+        .build();
+
+    // Build call options with proxy headers
+    let opts = CallOptions {
+        auth: None,
+        atproto_proxy: Some(CowStr::from(format!(
+            "{}#atproto_labeler",
+            config.moderation.labeler_did
+        ))),
+        atproto_accept_labelers: Some(vec![CowStr::from(
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        )]),
+        extra_headers: vec![],
+    };
+
+    // Send request via jacquard agent
+    let _response = agent.send_with_opts(event, opts).await.into_diagnostic()?;
+
+    debug!("Successfully took down post: {}", post_uri);
+
+    Ok(())
+}
+
+/// Parse an AT URI into its components
+/// Format: at://did:plc:xxx/app.bsky.feed.post/rkey
+fn parse_at_uri(uri: &str) -> Result<(String, String, String)> {
+    let uri = uri
+        .strip_prefix("at://")
+        .ok_or_else(|| miette::miette!("Invalid AT URI format: missing 'at://' prefix"))?;
+
+    let parts: Vec<&str> = uri.split('/').collect();
+    if parts.len() != 3 {
+        return Err(miette::miette!(
+            "Invalid AT URI format: expected 3 parts, got {}",
+            parts.len()
+        ));
+    }
+
+    Ok((
+        parts[0].to_string(), // repo (DID)
+        parts[1].to_string(), // collection
+        parts[2].to_string(), // rkey
+    ))
+}
+
+/// Extract DID from AT URI
+fn extract_did_from_uri(uri: &str) -> Result<String> {
+    let (did, _, _) = parse_at_uri(uri)?;
+    Ok(did)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_at_uri() {
+        let uri = "at://did:plc:xyz123/app.bsky.feed.post/abc456";
+        let (repo, collection, rkey) = parse_at_uri(uri).unwrap();
+        assert_eq!(repo, "did:plc:xyz123");
+        assert_eq!(collection, "app.bsky.feed.post");
+        assert_eq!(rkey, "abc456");
+    }
+
+    #[test]
+    fn test_parse_at_uri_invalid() {
+        let uri = "https://example.com/post/123";
+        assert!(parse_at_uri(uri).is_err());
+    }
+
+    #[test]
+    fn test_extract_did_from_uri() {
+        let uri = "at://did:plc:xyz123/app.bsky.feed.post/abc456";
+        let did = extract_did_from_uri(uri).unwrap();
+        assert_eq!(did, "did:plc:xyz123");
+    }
+}

src/moderation/rate_limiter.rs

···
+use governor::{
+    clock::DefaultClock,
+    state::{InMemoryState, NotKeyed},
+    Quota, RateLimiter as GovernorRateLimiter,
+};
+use std::sync::Arc;
+use std::time::Duration;
+
+/// Thread-safe rate limiter for API requests
+#[derive(Clone)]
+pub struct RateLimiter {
+    limiter: Arc<GovernorRateLimiter<NotKeyed, InMemoryState, DefaultClock>>,
+}
+
+impl RateLimiter {
+    /// Create a new rate limiter with the given rate limit in milliseconds
+    /// For example, rate_limit_ms = 100 means 100ms minimum between requests (10 requests per second)
+    pub fn new(rate_limit_ms: u64) -> Self {
+        let duration = if rate_limit_ms == 0 {
+            Duration::from_millis(1)
+        } else {
+            Duration::from_millis(rate_limit_ms)
+        };
+
+        // 1 request per rate_limit_ms duration
+        let quota = Quota::with_period(duration).unwrap();
+        let limiter = GovernorRateLimiter::direct(quota);
+
+        Self {
+            limiter: Arc::new(limiter),
+        }
+    }
+
+    /// Wait until a request can be made according to the rate limit
+    pub async fn wait(&self) {
+        while self.limiter.check().is_err() {
+            tokio::time::sleep(Duration::from_millis(1)).await;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+
+    #[tokio::test]
+    async fn test_rate_limiter() {
+        // 100ms between requests = 10 requests per second
+        let limiter = RateLimiter::new(100);
+
+        let start = Instant::now();
+
+        // Make 3 requests
+        for _ in 0..3 {
+            limiter.wait().await;
+        }
+
+        let elapsed = start.elapsed();
+
+        // Should take at least 200ms (2 intervals between 3 requests)
+        assert!(elapsed >= Duration::from_millis(180));
+    }
+
+    #[tokio::test]
+    async fn test_rate_limiter_concurrent() {
+        // 100ms between requests = 10 requests per second
+        let limiter = RateLimiter::new(100);
+
+        let start = Instant::now();
+
+        // Spawn 5 concurrent tasks
+        let mut handles = vec![];
+        for _ in 0..5 {
+            let limiter_clone = limiter.clone();
+            handles.push(tokio::spawn(async move {
+                limiter_clone.wait().await;
+            }));
+        }
+
+        // Wait for all to complete
+        for handle in handles {
+            handle.await.unwrap();
+        }
+
+        let elapsed = start.elapsed();
+
+        // Should take at least 400ms (4 intervals between 5 requests)
+        assert!(elapsed >= Duration::from_millis(380));
+    }
+}

src/processor/README.md

···
+# Processor Module
+
+## Purpose
+Download images, compute perceptual hashes, and match against known bad image hashes.
+
+## Key Components
+
+### `phash.rs`
+Perceptual hash computation:
+- **`compute_phash(image_bytes)`** - Calculate 64-bit aHash from image
+  - Uses `image_hasher` crate with aHash (average hash) algorithm
+  - Returns 16-character hex string (e.g., "e0e0e0e0e0fcfefe")
+  - Hash size: 8×8 = 64 bits
+- **`hamming_distance(hash1, hash2)`** - Compare two phashes
+  - Counts differing bits between two hashes
+  - Returns u32 (0 = identical, 64 = completely different)
+  - Used to find "similar" images (threshold typically 3-5)
+
+### `matcher.rs`
+Image download and rule matching:
+- **`download_blob(client, config, did, cid)`** - Download image from CDN/PDS
+  - Tries CDN first: `https://cdn.bsky.app/img/feed_fullsize/plain/{did}/{cid}@{format}`
+  - Attempts common formats: jpeg, png, webp
+  - Falls back to PDS: `com.atproto.sync.getBlob`
+  - Returns raw image bytes
+- **`load_blob_checks(path)`** - Load rules from JSON file
+  - Reads `rules/blobs.json`
+  - Deserializes into `Vec<BlobCheck>`
+- **`match_phash(phash, checks, did, threshold)`** - Check if phash matches rules
+  - Compares computed phash against all rules
+  - Checks hamming distance against threshold
+  - Skips DIDs in `ignore_did` list
+  - Returns `Some(MatchResult)` on match, `None` otherwise
+
+## Perceptual Hashing (aHash)
+
+**What is aHash?**
+- Algorithm: Average Hash
+- Process:
+  1. Resize image to 8×8 pixels
+  2. Convert to grayscale
+  3. Calculate average brightness
+  4. For each pixel: bit = 1 if brighter than average, 0 if darker
+  5. Concatenate 64 bits into hash
+
+**Why aHash?**
+- Fast to compute (~50ms)
+- Robust to resizing, cropping, minor edits
+- Not robust to rotation, color changes (by design)
+- Good for finding exact or near-exact reposts
+
+**Example:**
+```
+Original image: 1920×1080 JPEG
+→ Resize: 8×8 grayscale
+→ Average: 128
+→ Bits: [1,0,1,1,0,0,1,1, ...]
+→ Hash: "e0e0e0e0e0fcfefe"
+```
+
+## Hamming Distance
+
+Counts bit differences between two hashes:
+```
+Hash A: 1010
+Hash B: 1100
+XOR:    0110  (2 bits differ)
+Hamming: 2
+```
+
+**Thresholds:**
+- 0 - Exact match (same image)
+- 1-3 - Very similar (minor edits, recompression)
+- 4-8 - Similar (cropping, watermarks)
+- 9+ - Different images
+
+## CDN-First Download Strategy
+
+**Why CDN first?**
+- Faster (geographically distributed)
+- Cached (reduces PDS load)
+- Free (no quota concerns)
+
+**Why try multiple formats?**
+- CDN URL requires format extension (@jpeg, @png, @webp)
+- Blob CID doesn't tell us the format
+- Try common formats until one works
+
+**Flow:**
+```
+1. Try: cdn.bsky.app/.../cid@jpeg
+   → 404
+2. Try: cdn.bsky.app/.../cid@png
+   → 200 OK (download)
+3. Return bytes
+```
+
+**Fallback to PDS:**
+- If all CDN attempts fail
+- Uses getBlob API (format-agnostic)
+- Slower but always works
+
+## Rule Matching Logic
+
+```rust
+for check in blob_checks {
+    // Skip ignored DIDs
+    if check.ignore_did.contains(did) {
+        continue;
+    }
+
+    // Check each known bad hash
+    for bad_hash in check.phashes {
+        let distance = hamming_distance(computed_hash, bad_hash);
+        let threshold = check.hamming_threshold.unwrap_or(default);
+
+        if distance <= threshold {
+            return Some(MatchResult {
+                matched_check: check,
+                matched_phash: bad_hash,
+                hamming_distance: distance,
+                phash: computed_hash,
+            });
+        }
+    }
+}
+```
+
+## Performance
+
+**Typical timings:**
+- Download (cache hit): ~1ms
+- Download (CDN): ~100-200ms
+- Download (PDS fallback): ~200-500ms
+- Compute phash: ~20-50ms
+- Match against 100 rules: ~0.1ms
+
+**Optimization:**
+- Cache phashes by CID (avoid recomputation)
+- CDN preferred over PDS (faster)
+- Hamming distance is bitwise XOR (very fast)
+
+## Dependencies
+
+- `reqwest::Client` - HTTP downloads
+- `image` - Image loading/decoding
+- `image_hasher` - Phash computation
+- `serde_json` - Rule parsing
+
+## Related Modules
+
+- Used by: `queue/worker.rs` - Downloads and matches blobs
+- Returns: `types::MatchResult` - What matched and why
+- Uses: `types::BlobCheck` - Rule definitions

src/processor/matcher.rs

···
+use miette::{IntoDiagnostic, Result};
+use reqwest::Client;
+use std::path::Path;
+use tracing::{debug, info, warn};
+
+use crate::config::Config;
+use crate::processor::phash;
+use crate::types::{BlobCheck, BlobReference, ImageJob, MatchResult};
+
+/// Load blob checks from a JSON file
+pub async fn load_blob_checks(path: &Path) -> Result<Vec<BlobCheck>> {
+    let contents = tokio::fs::read_to_string(path).await.into_diagnostic()?;
+    let checks: Vec<BlobCheck> = serde_json::from_str(&contents).into_diagnostic()?;
+    info!("Loaded {} blob checks from {:?}", checks.len(), path);
+    Ok(checks)
+}
+
+/// Download a blob from the Bluesky CDN, falling back to PDS if necessary
+pub async fn download_blob(
+    client: &Client,
+    config: &Config,
+    did: &str,
+    cid: &str,
+) -> Result<Vec<u8>> {
+    // Try CDN first - attempt common image formats
+    for format in ["jpeg", "png", "webp"] {
+        let cdn_url = format!(
+            "https://cdn.bsky.app/img/feed_fullsize/plain/{}/{}@{}",
+            did, cid, format
+        );
+
+        debug!("Trying CDN download: {}", cdn_url);
+
+        match client.get(&cdn_url).send().await {
+            Ok(response) if response.status().is_success() => {
+                debug!("Successfully downloaded from CDN: did={}, cid={}", did, cid);
+                let bytes = response.bytes().await.into_diagnostic()?;
+                return Ok(bytes.to_vec());
+            }
+            Ok(response) => {
+                debug!("CDN returned status {}, trying next format", response.status());
+            }
+            Err(e) => {
+                debug!("CDN request failed: {}, trying next format", e);
+            }
+        }
+    }
+
+    // Fall back to PDS if CDN fails
+    warn!("CDN failed for did={}, cid={}, falling back to PDS", did, cid);
+
+    let pds_url = format!(
+        "{}/xrpc/com.atproto.sync.getBlob?did={}&cid={}",
+        config.pds.endpoint, did, cid
+    );
+
+    debug!("Downloading from PDS: {}", pds_url);
+
+    let response = client
+        .get(&pds_url)
+        .send()
+        .await
+        .into_diagnostic()?
+        .error_for_status()
+        .into_diagnostic()?;
+
+    let bytes = response.bytes().await.into_diagnostic()?;
+    Ok(bytes.to_vec())
+}
+
+/// Match a computed phash against blob checks
+pub fn match_phash(
+    phash: &str,
+    blob_checks: &[BlobCheck],
+    did: &str,
+    default_threshold: u32,
+) -> Option<MatchResult> {
+    for check in blob_checks {
+        // Check if DID is in ignore list
+        if let Some(ignore_list) = &check.ignore_did {
+            if ignore_list.contains(&did.to_string()) {
+                debug!("Skipping check '{}' for ignored DID: {}", check.label, did);
+                continue;
+            }
+        }
+
+        let threshold = check.hamming_threshold.unwrap_or(default_threshold);
+
+        // Check each phash in the check
+        for check_phash in &check.phashes {
+            match phash::hamming_distance(phash, check_phash) {
+                Ok(distance) => {
+                    if distance <= threshold {
+                        info!(
+                            "Match found! label={}, distance={}, threshold={}",
+                            check.label, distance, threshold
+                        );
+                        return Some(MatchResult {
+                            phash: phash.to_string(),
+                            matched_check: check.clone(),
+                            matched_phash: check_phash.clone(),
+                            hamming_distance: distance,
+                        });
+                    }
+                }
+                Err(e) => {
+                    warn!("Failed to compute hamming distance: {}", e);
+                    continue;
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Process a single blob reference
+pub async fn process_blob(
+    client: &Client,
+    config: &Config,
+    blob_checks: &[BlobCheck],
+    did: &str,
+    blob: &BlobReference,
+) -> Result<Option<MatchResult>> {
+    // Download the blob
+    let image_bytes = download_blob(client, config, did, &blob.cid).await?;
+
+    // Compute phash
+    let phash = phash::compute_phash(&image_bytes)?;
+    debug!("Computed phash for blob {}: {}", blob.cid, phash);
+
+    // Match against checks
+    let match_result = match_phash(&phash, blob_checks, did, config.phash.default_hamming_threshold);
+
+    Ok(match_result)
+}
+
+/// Process an image job - check all blobs and return matches
+pub async fn process_image_job(
+    client: &Client,
+    config: &Config,
+    blob_checks: &[BlobCheck],
+    job: &ImageJob,
+) -> Result<Vec<MatchResult>> {
+    info!(
+        "Processing job: post={}, blobs={}",
+        job.post_uri,
+        job.blobs.len()
+    );
+
+    let mut matches = Vec::new();
+
+    for blob in &job.blobs {
+        match process_blob(client, config, blob_checks, &job.post_did, blob).await {
+            Ok(Some(result)) => {
+                matches.push(result);
+            }
+            Ok(None) => {
+                debug!("No match for blob: {}", blob.cid);
+            }
+            Err(e) => {
+                warn!("Error processing blob {}: {}", blob.cid, e);
+                // Continue processing other blobs
+            }
+        }
+    }
+
+    if !matches.is_empty() {
+        info!(
+            "Found {} match(es) for post: {}",
+            matches.len(),
+            job.post_uri
+        );
+    }
+
+    Ok(matches)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_match_phash_exact() {
+        let checks = vec![BlobCheck {
+            phashes: vec!["deadbeefdeadbeef".to_string()],
+            label: "test-label".to_string(),
+            comment: "Test".to_string(),
+            report_acct: false,
+            label_acct: false,
+            report_post: true,
+            to_label: true,
+            takedown_post: false,
+            takedown_acct: false,
+            hamming_threshold: Some(3),
+            description: None,
+            ignore_did: None,
+        }];
+
+        let result = match_phash("deadbeefdeadbeef", &checks, "did:plc:test", 3);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().hamming_distance, 0);
+    }
+
+    #[test]
+    fn test_match_phash_within_threshold() {
+        let checks = vec![BlobCheck {
+            phashes: vec!["deadbeefdeadbeef".to_string()],
+            label: "test-label".to_string(),
+            comment: "Test".to_string(),
+            report_acct: false,
+            label_acct: false,
+            report_post: true,
+            to_label: true,
+            takedown_post: false,
+            takedown_acct: false,
+            hamming_threshold: Some(3),
+            description: None,
+            ignore_did: None,
+        }];
+
+        // deadbeefdeadbeef vs deadbeefdeadbeee = 1 bit difference in last nibble
+        let result = match_phash("deadbeefdeadbeee", &checks, "did:plc:test", 3);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().hamming_distance, 1);
+    }
+
+    #[test]
+    fn test_match_phash_exceeds_threshold() {
+        let checks = vec![BlobCheck {
+            phashes: vec!["deadbeefdeadbeef".to_string()],
+            label: "test-label".to_string(),
+            comment: "Test".to_string(),
+            report_acct: false,
+            label_acct: false,
+            report_post: true,
+            to_label: true,
+            takedown_post: false,
+            takedown_acct: false,
+            hamming_threshold: Some(1),
+            description: None,
+            ignore_did: None,
+        }];
+
+        // More than 1 bit difference
+        let result = match_phash("deadbeefdeadbee0", &checks, "did:plc:test", 1);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_match_phash_ignored_did() {
+        let checks = vec![BlobCheck {
+            phashes: vec!["deadbeefdeadbeef".to_string()],
+            label: "test-label".to_string(),
+            comment: "Test".to_string(),
+            report_acct: false,
+            label_acct: false,
+            report_post: true,
+            to_label: true,
+            takedown_post: false,
+            takedown_acct: false,
+            hamming_threshold: Some(3),
+            description: None,
+            ignore_did: Some(vec!["did:plc:ignored".to_string()]),
+        }];
+
+        let result = match_phash("deadbeefdeadbeef", &checks, "did:plc:ignored", 3);
+        assert!(result.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_load_real_rules() {
+        let path = std::path::Path::new("rules/blobs.json");
+        if !path.exists() {
+            // Skip test if rules file doesn't exist
+            return;
+        }
+
+        let result = load_blob_checks(path).await;
+        assert!(result.is_ok());
+
+        let checks = result.unwrap();
+        assert!(!checks.is_empty());
+
+        // Verify first check has expected fields
+        let first = &checks[0];
+        assert!(!first.phashes.is_empty());
+        assert!(!first.label.is_empty());
+
+        // Check that ignoreDID alias works
+        if let Some(ignore_list) = &first.ignore_did {
+            assert!(!ignore_list.is_empty());
+        }
+    }
+}

src/processor/mod.rs

···
+pub mod matcher;
+pub mod phash;
+
+// Re-export for convenience
+pub use phash::{compute_phash, compute_phash_from_image, hamming_distance, PhashError};

src/processor/phash.rs

···
+use image::DynamicImage;
+use image_hasher::{HashAlg, HasherConfig, ImageHash};
+use miette::{Diagnostic, IntoDiagnostic, Result};
+use thiserror::Error;
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum PhashError {
+    #[error("Failed to decode image: {0}")]
+    ImageDecodeError(String),
+
+    #[error("Failed to compute hash: {0}")]
+    HashComputeError(String),
+
+    #[error("Invalid hash format: {0}")]
+    InvalidHashFormat(String),
+}
+
+/// Compute perceptual hash for an image using average hash (aHash) algorithm
+///
+/// This matches the TypeScript implementation:
+/// 1. Resize to 8x8 (64 pixels)
+/// 2. Convert to grayscale
+/// 3. Compute average pixel value
+/// 4. Create 64-bit binary: 1 if pixel > avg, 0 otherwise
+/// 5. Convert to hex string (16 chars)
+pub fn compute_phash(image_bytes: &[u8]) -> Result<String> {
+    // Decode image from bytes
+    let img = image::load_from_memory(image_bytes)
+        .into_diagnostic()
+        .map_err(|e| PhashError::ImageDecodeError(e.to_string()))?;
+
+    compute_phash_from_image(&img)
+}
+
+/// Compute perceptual hash from a DynamicImage
+pub fn compute_phash_from_image(img: &DynamicImage) -> Result<String> {
+    // Configure hasher with aHash (Mean) algorithm and 8x8 size
+    let hasher = HasherConfig::new()
+        .hash_alg(HashAlg::Mean) // average hash
+        .hash_size(8, 8) // 64 bits
+        .to_hasher();
+
+    // Compute hash
+    let hash = hasher.hash_image(img);
+
+    // Convert to hex string
+    hash_to_hex(&hash)
+}
+
+/// Convert ImageHash to hex string format (16 chars, matching TS output)
+fn hash_to_hex(hash: &ImageHash) -> Result<String> {
+    // Get hash bytes
+    let bytes = hash.as_bytes();
+
+    // Convert to hex string
+    let hex = bytes
+        .iter()
+        .map(|b| format!("{:02x}", b))
+        .collect::<String>();
+
+    // Ensure it's 16 characters (64 bits = 8 bytes = 16 hex chars)
+    if hex.len() != 16 {
+        return Err(PhashError::InvalidHashFormat(format!(
+            "Expected 16 hex characters, got {}",
+            hex.len()
+        ))
+        .into());
+    }
+
+    Ok(hex)
+}
+
+/// Compute hamming distance between two phash hex strings
+///
+/// Uses Brian Kernighan's algorithm to count set bits
+pub fn hamming_distance(hash1: &str, hash2: &str) -> Result<u32> {
+    // Validate input lengths
+    if hash1.len() != 16 || hash2.len() != 16 {
+        return Err(PhashError::InvalidHashFormat(format!(
+            "Hashes must be 16 hex characters, got {} and {}",
+            hash1.len(),
+            hash2.len()
+        ))
+        .into());
+    }
+
+    // Parse hex strings to u64
+    let a = u64::from_str_radix(hash1, 16)
+        .into_diagnostic()
+        .map_err(|_| PhashError::InvalidHashFormat(format!("Invalid hex string: {}", hash1)))?;
+
+    let b = u64::from_str_radix(hash2, 16)
+        .into_diagnostic()
+        .map_err(|_| PhashError::InvalidHashFormat(format!("Invalid hex string: {}", hash2)))?;
+
+    // XOR to find differing bits
+    let xor = a ^ b;
+
+    // Count set bits using Brian Kernighan's algorithm
+    let mut count = 0u32;
+    let mut n = xor;
+    while n > 0 {
+        count += 1;
+        n &= n - 1; // clear the lowest set bit
+    }
+
+    Ok(count)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hamming_distance_identical() {
+        let hash = "e0e0e0e0e0fcfefe";
+        let distance = hamming_distance(hash, hash).unwrap();
+        assert_eq!(distance, 0);
+    }
+
+    #[test]
+    fn test_hamming_distance_different() {
+        let hash1 = "0000000000000000";
+        let hash2 = "ffffffffffffffff";
+        let distance = hamming_distance(hash1, hash2).unwrap();
+        assert_eq!(distance, 64); // all bits different
+    }
+
+    #[test]
+    fn test_hamming_distance_one_bit() {
+        let hash1 = "0000000000000000";
+        let hash2 = "0000000000000001";
+        let distance = hamming_distance(hash1, hash2).unwrap();
+        assert_eq!(distance, 1);
+    }
+
+    #[test]
+    fn test_hamming_distance_invalid_length() {
+        let hash1 = "e0e0e0e0e0fcfefe";
+        let hash2 = "short";
+        let result = hamming_distance(hash1, hash2);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_hamming_distance_invalid_hex() {
+        let hash1 = "e0e0e0e0e0fcfefe";
+        let hash2 = "gggggggggggggggg";
+        let result = hamming_distance(hash1, hash2);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_phash_format() {
+        // Create a simple test image (1x1 black pixel)
+        let img = DynamicImage::new_luma8(1, 1);
+        let hash = compute_phash_from_image(&img).unwrap();
+
+        // Should be 16 hex characters
+        assert_eq!(hash.len(), 16);
+
+        // Should be valid hex
+        u64::from_str_radix(&hash, 16).unwrap();
+    }
+}

src/queue/README.md

···
+# Queue Module
+
+## Purpose
+Redis-backed job queue with concurrent worker pool for processing image moderation jobs.
+
+## Key Components
+
+### `redis_queue.rs`
+- **`JobQueue`** - Redis-backed FIFO queue
+  - **`push(job)`** - Add job to main queue (`queue:main`)
+  - **`pop(timeout)`** - Block-pop next job from queue
+  - **`retry(job)`** - Add failed job to retry queue
+  - Uses Redis LIST operations (LPUSH/BRPOP)
+- **Dead letter queue** - Jobs that fail after max retries
+  - Stored in `queue:dead_letter`
+  - Can be inspected/reprocessed manually
+
+### `worker.rs`
+Main worker pool implementation:
+- **`WorkerPool`** - Manages concurrent job processing
+  - Semaphore-controlled concurrency (max N workers)
+  - Shared rate limiter across all workers
+  - Each worker gets own Redis connection
+- **`start(queue, cache, shutdown_rx)`** - Main event loop
+  - Pops jobs from queue
+  - Spawns worker tasks up to concurrency limit
+  - Handles graceful shutdown
+- **`process_job()`** - Process single job
+  1. Check cache for each blob
+  2. Download and compute phash if needed
+  3. Match against rules
+  4. Take moderation actions on matches
+- **`process_job_blobs()`** - Download/compute phashes for all blobs
+- **`take_moderation_action()`** - Execute configured actions
+
+## Job Flow
+
+```
+Jetstream → JobQueue.push() → Redis queue:main
+                                      ↓
+                              WorkerPool.start()
+                                      ↓
+                              Semaphore.acquire() (limit concurrency)
+                                      ↓
+                              Spawn worker task
+                                      ↓
+                              process_job()
+                                      ↓
+                        ┌──────────────┴──────────────┐
+                        ↓                             ↓
+                   Success                         Failure
+                        ↓                             ↓
+                  Complete                   JobQueue.retry()
+                                                      ↓
+                                        (job.attempts < max_retries?)
+                                                ↓         ↓
+                                              Yes        No
+                                                ↓         ↓
+                                        queue:main  queue:dead_letter
+```
+
+## Concurrency Control
+
+**Semaphore pattern:**
+```rust
+let semaphore = Arc::new(Semaphore::new(concurrency));
+
+loop {
+    let permit = semaphore.acquire().await;
+    tokio::spawn(async move {
+        process_job(...).await;
+        drop(permit);  // Release permit when done
+    });
+}
+```
+
+**Why semaphore?**
+- Limits max concurrent jobs (prevents resource exhaustion)
+- Workers block when limit reached
+- Auto-released on task completion (even if panics)
+
+**Concurrency setting:**
+- Default: 10 workers
+- Configurable via `PROCESSING_CONCURRENCY`
+- Each worker needs: memory for image, Redis conn, HTTP conn
+
+## Retry Logic
+
+**Retry conditions:**
+- Image download fails
+- Phash computation fails
+- Moderation API returns error
+- Any error in `process_job()`
+
+**Retry mechanism:**
+```rust
+job.attempts += 1;
+if job.attempts < max_retries {
+    queue.retry(job).await?;  // Back to queue:main
+} else {
+    // Move to dead letter queue
+}
+```
+
+**Retry delay:**
+- Controlled by `RETRY_DELAY_MS` (default 1000ms)
+- Applied when job is retried
+- Prevents hammering failing resources
+
+## Worker Task Lifecycle
+
+```
+1. Main loop pops job from queue
+2. Acquire semaphore permit (blocks if at limit)
+3. Clone data for worker (config, client, etc.)
+4. Spawn tokio task with job
+5. Worker creates own Redis connection
+6. Process job (download, compute, match, act)
+7. On success: increment metrics, complete
+8. On failure: retry job, increment failed metrics
+9. Drop permit (allows next worker to start)
+```
+
+## Job Processing Details
+
+### process_job_blobs()
+For each blob in job:
+1. Check cache: `cache.get(cid)`
+2. If cache hit: use cached phash
+3. If cache miss:
+   - Download blob from CDN/PDS
+   - Compute phash
+   - Store in cache: `cache.set(cid, phash)`
+4. Match phash against rules
+5. Collect all matches
+
+### take_moderation_action()
+For each match:
+1. Get access token from agent
+2. Check configured actions (from BlobCheck):
+   - `report_post` → `post::report_post()`
+   - `to_label` → `post::label_post()`
+   - `report_acct` → `account::report_account()`
+   - `label_acct` → `account::label_account()`
+3. Use claims to prevent duplicates
+4. Rate limit before each API call
+5. Increment metrics
+
+## Redis Queues
+
+**Main queue:** `queue:main`
+- All new jobs and retries
+- FIFO order
+- Block-pop with timeout
+
+**Dead letter queue:** `queue:dead_letter`
+- Jobs that failed max_retries times
+- Preserved for manual inspection
+- Never auto-retried
+
+**Storage format:** JSON-serialized `ImageJob`
+
+## Configuration
+
+```env
+PROCESSING_CONCURRENCY=10   # Max concurrent workers
+RETRY_ATTEMPTS=3           # Max retries per job
+RETRY_DELAY_MS=1000        # Delay between retries
+REDIS_URL=redis://localhost:6379
+```
+
+## Dependencies
+
+- `redis` - Queue storage
+- `tokio::sync::Semaphore` - Concurrency control
+- `reqwest::Client` - Image downloads
+- `AgentSession` - Authentication
+- `PhashCache` - Phash caching
+- `Metrics` - Performance tracking
+
+## Related Modules
+
+- Receives from: `jetstream` - Jobs via mpsc channel
+- Uses: `processor` - Download and match blobs
+- Uses: `moderation` - Take actions on matches
+- Uses: `cache` - Phash caching
+- Uses: `agent` - API authentication

src/queue/mod.rs

···
+pub mod redis_queue;
+pub mod worker;
+
+pub use redis_queue::{JobQueue, QueueStats};
+pub use worker::WorkerPool;

src/queue/redis_queue.rs

···
+use miette::{IntoDiagnostic, Result};
+use redis::AsyncCommands;
+use tracing::{debug, info, warn};
+
+use crate::config::Config;
+use crate::types::ImageJob;
+
+/// Redis queue names
+const PENDING_QUEUE: &str = "jobs:pending";
+const PROCESSING_QUEUE: &str = "jobs:processing";
+const DEAD_LETTER_QUEUE: &str = "jobs:dead";
+
+/// Redis-based job queue for ImageJob processing
+#[derive(Clone)]
+pub struct JobQueue {
+    redis: redis::aio::MultiplexedConnection,
+    max_retries: u32,
+}
+
+impl JobQueue {
+    /// Create a new job queue
+    pub async fn new(config: &Config) -> Result<Self> {
+        info!("Connecting to Redis for job queue: {}", config.redis.url);
+
+        let client = redis::Client::open(config.redis.url.as_str()).into_diagnostic()?;
+        let redis = client
+            .get_multiplexed_async_connection()
+            .await
+            .into_diagnostic()?;
+
+        info!("Job queue connected to Redis");
+
+        Ok(Self {
+            redis,
+            max_retries: config.processing.retry_attempts,
+        })
+    }
+
+    /// Push a job to the pending queue
+    pub async fn push(&mut self, job: &ImageJob) -> Result<()> {
+        let job_json = serde_json::to_string(job).into_diagnostic()?;
+
+        let _: () = self
+            .redis
+            .rpush(PENDING_QUEUE, &job_json)
+            .await
+            .into_diagnostic()?;
+
+        debug!("Pushed job to queue: {}", job.post_uri);
+
+        Ok(())
+    }
+
+    /// Pop a job from the pending queue (blocking with timeout)
+    pub async fn pop(&mut self, timeout_secs: usize) -> Result<Option<ImageJob>> {
+        let result: Option<Vec<String>> = self
+            .redis
+            .blpop(PENDING_QUEUE, timeout_secs as f64)
+            .await
+            .into_diagnostic()?;
+
+        match result {
+            Some(items) => {
+                // blpop returns [key, value]
+                if items.len() >= 2 {
+                    let job_json = &items[1];
+                    let job: ImageJob = serde_json::from_str(job_json).into_diagnostic()?;
+                    debug!("Popped job from queue: {}", job.post_uri);
+                    Ok(Some(job))
+                } else {
+                    Ok(None)
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
+    /// Retry a failed job (increment attempts and re-queue)
+    pub async fn retry(&mut self, mut job: ImageJob) -> Result<()> {
+        job.attempts += 1;
+
+        if job.attempts >= self.max_retries {
+            warn!(
+                "Job exceeded max retries ({}), moving to dead letter queue: {}",
+                self.max_retries, job.post_uri
+            );
+            self.move_to_dead_letter(&job).await?;
+        } else {
+            info!(
+                "Retrying job (attempt {}/{}): {}",
+                job.attempts, self.max_retries, job.post_uri
+            );
+            self.push(&job).await?;
+        }
+
+        Ok(())
+    }
+
+    /// Move a job to the dead letter queue
+    async fn move_to_dead_letter(&mut self, job: &ImageJob) -> Result<()> {
+        let job_json = serde_json::to_string(job).into_diagnostic()?;
+
+        let _: () = self
+            .redis
+            .rpush(DEAD_LETTER_QUEUE, &job_json)
+            .await
+            .into_diagnostic()?;
+
+        warn!("Moved job to dead letter queue: {}", job.post_uri);
+
+        Ok(())
+    }
+
+    /// Get queue statistics
+    pub async fn stats(&mut self) -> Result<QueueStats> {
+        let pending: usize = self.redis.llen(PENDING_QUEUE).await.into_diagnostic()?;
+        let processing: usize = self
+            .redis
+            .llen(PROCESSING_QUEUE)
+            .await
+            .into_diagnostic()?;
+        let dead: usize = self.redis.llen(DEAD_LETTER_QUEUE).await.into_diagnostic()?;
+
+        Ok(QueueStats {
+            pending,
+            processing,
+            dead,
+        })
+    }
+
+    /// Clear all queues (for testing/maintenance)
+    pub async fn clear_all(&mut self) -> Result<()> {
+        let _: () = self.redis.del(PENDING_QUEUE).await.into_diagnostic()?;
+        let _: () = self.redis.del(PROCESSING_QUEUE).await.into_diagnostic()?;
+        let _: () = self
+            .redis
+            .del(DEAD_LETTER_QUEUE)
+            .await
+            .into_diagnostic()?;
+
+        info!("Cleared all job queues");
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct QueueStats {
+    pub pending: usize,
+    pub processing: usize,
+    pub dead: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Note: These are integration tests that require a running Redis instance
+    // Run with: cargo test --test queue -- --ignored
+}

src/queue/worker.rs

···
+use miette::Result;
+use reqwest::Client;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
+use tracing::{error, info};
+use jacquard::client::{Agent, MemoryCredentialSession};
+use jacquard_api::com_atproto::moderation::ReasonType;
+
+use crate::agent::AgentSession;
+use crate::cache::PhashCache;
+use crate::config::Config;
+use crate::metrics::Metrics;
+use crate::moderation::{account, claims, post, rate_limiter::RateLimiter};
+use crate::processor::matcher;
+use crate::queue::redis_queue::JobQueue;
+use crate::types::{BlobCheck, ImageJob, MatchResult};
+
+/// Worker pool for processing image jobs
+pub struct WorkerPool {
+    config: Config,
+    client: Client,
+    agent: AgentSession,
+    blob_checks: Vec<BlobCheck>,
+    metrics: Metrics,
+    rate_limiter: RateLimiter,
+}
+
+impl WorkerPool {
+    /// Create a new worker pool
+    pub fn new(
+        config: Config,
+        client: Client,
+        agent: AgentSession,
+        blob_checks: Vec<BlobCheck>,
+        metrics: Metrics,
+    ) -> Self {
+        let rate_limiter = RateLimiter::new(config.moderation.rate_limit);
+
+        Self {
+            config,
+            client,
+            agent,
+            blob_checks,
+            metrics,
+            rate_limiter,
+        }
+    }
+
+    /// Start the worker pool - processes jobs sequentially
+    /// Concurrency is achieved by running multiple instances of this concurrently
+    pub async fn start(
+        &self,
+        mut queue: JobQueue,
+        mut cache: PhashCache,
+        mut shutdown_rx: tokio::sync::broadcast::Receiver<()>,
+    ) -> Result<()> {
+        loop {
+            tokio::select! {
+                _ = shutdown_rx.recv() => {
+                    info!("Worker shutting down");
+                    break;
+                }
+
+                job_result = queue.pop(1) => {
+                    match job_result {
+                        Ok(Some(job)) => {
+                            // Create new redis connection for this job
+                            let redis_client = match redis::Client::open(self.config.redis.url.as_str()) {
+                                Ok(c) => c,
+                                Err(e) => {
+                                    error!("Failed to create Redis client: {}", e);
+                                    continue;
+                                }
+                            };
+
+                            let mut redis_conn = match redis_client.get_multiplexed_async_connection().await {
+                                Ok(conn) => conn,
+                                Err(e) => {
+                                    error!("Failed to connect to Redis: {}", e);
+                                    continue;
+                                }
+                            };
+
+                            // Process job
+                            if let Err(e) = Self::process_job(
+                                &self.config,
+                                &self.client,
+                                self.agent.agent(),
+                                &self.blob_checks,
+                                &self.metrics,
+                                &self.rate_limiter,
+                                &mut cache,
+                                &mut redis_conn,
+                                job,
+                                &mut queue,
+                                self.agent.did(),
+                            )
+                            .await
+                            {
+                                error!("Worker task failed: {}", e);
+                            }
+                        }
+                        Ok(None) => {
+                            // Timeout, continue loop
+                        }
+                        Err(e) => {
+                            error!("Error popping job from queue: {}", e);
+                            sleep(Duration::from_millis(self.config.processing.retry_delay)).await;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Process a single job
+    async fn process_job(
+        config: &Config,
+        client: &Client,
+        agent: &Arc<Agent<MemoryCredentialSession>>,
+        blob_checks: &[BlobCheck],
+        metrics: &Metrics,
+        rate_limiter: &RateLimiter,
+        cache: &mut PhashCache,
+        redis_conn: &mut redis::aio::MultiplexedConnection,
+        job: ImageJob,
+        queue: &mut JobQueue,
+        created_by: &str,
+    ) -> Result<()> {
+        info!("Processing job: {}", job.post_uri);
+
+        // Process all blobs and find matches
+        let matches = Self::process_job_blobs(config, client, blob_checks, metrics, cache, &job).await?;
+
+        if matches.is_empty() {
+            info!("No matches found for job: {}", job.post_uri);
+            metrics.inc_jobs_processed();
+            return Ok(());
+        }
+
+        // Take moderation actions for each match
+        for match_result in matches {
+            if let Err(e) =
+                Self::take_moderation_action(config, agent, metrics, rate_limiter, redis_conn, &job, &match_result, created_by)
+                    .await
+            {
+                error!("Failed to take moderation action: {}", e);
+                metrics.inc_jobs_failed();
+                // Retry the job
+                queue.retry(job.clone()).await?;
+                return Err(e);
+            }
+        }
+
+        info!("Successfully processed job: {}", job.post_uri);
+        metrics.inc_jobs_processed();
+
+        Ok(())
+    }
+
+    /// Process all blobs in a job and return matches
+    async fn process_job_blobs(
+        config: &Config,
+        client: &Client,
+        blob_checks: &[BlobCheck],
+        metrics: &Metrics,
+        cache: &mut PhashCache,
+        job: &ImageJob,
+    ) -> Result<Vec<MatchResult>> {
+        let mut matches = Vec::new();
+
+        for blob in &job.blobs {
+            metrics.inc_blobs_processed();
+
+            // Check cache first
+            let cache_result = cache.get(&blob.cid).await?;
+            let phash = if let Some(cached_phash) = cache_result {
+                metrics.inc_cache_hits();
+                cached_phash
+            } else {
+                metrics.inc_cache_misses();
+                metrics.inc_blobs_downloaded();
+
+                // Download and compute
+                let image_bytes = matcher::download_blob(client, config, &job.post_did, &blob.cid).await?;
+                let computed_phash = crate::processor::phash::compute_phash(&image_bytes)?;
+
+                // Store in cache
+                cache.set(&blob.cid, &computed_phash).await?;
+                computed_phash
+            };
+
+            // Check for matches
+            if let Some(match_result) = matcher::match_phash(
+                &phash,
+                blob_checks,
+                &job.post_did,
+                config.phash.default_hamming_threshold,
+            ) {
+                metrics.inc_matches_found();
+                matches.push(match_result);
+            }
+        }
+
+        Ok(matches)
+    }
+
+    /// Take moderation action based on match result
+    async fn take_moderation_action(
+        config: &Config,
+        agent: &Arc<Agent<MemoryCredentialSession>>,
+        metrics: &Metrics,
+        rate_limiter: &RateLimiter,
+        redis_conn: &mut redis::aio::MultiplexedConnection,
+        job: &ImageJob,
+        match_result: &MatchResult,
+        created_by: &str,
+    ) -> Result<()> {
+        let check = &match_result.matched_check;
+
+        info!(
+            "Taking moderation action for label '{}' on post: {}",
+            check.label, job.post_uri
+        );
+
+        // Report post if configured
+        if check.report_post {
+            if claims::claim_post_report(redis_conn, &job.post_uri, &check.label).await? {
+                post::report_post(
+                    agent.as_ref(),
+                    config,
+                    rate_limiter,
+                    &job.post_uri,
+                    &job.post_cid,
+                    ReasonType::ComAtprotoModerationDefsReasonSpam,
+                    &check.comment,
+                    &match_result.phash,
+                    created_by,
+                )
+                .await?;
+                metrics.inc_posts_reported();
+                info!("Reported post: {}", job.post_uri);
+            } else {
+                metrics.inc_posts_already_reported();
+                info!("Post already reported, skipping: {}", job.post_uri);
+            }
+        }
+
+        // Label post if configured
+        if check.to_label {
+            if !claims::has_label(redis_conn, &job.post_uri, &check.label).await? {
+                post::label_post(
+                    agent.as_ref(),
+                    config,
+                    rate_limiter,
+                    &job.post_uri,
+                    &job.post_cid,
+                    &check.label,
+                    &check.comment,
+                    &match_result.phash,
+                    created_by,
+                )
+                .await?;
+                metrics.inc_posts_labeled();
+                claims::set_label(redis_conn, &job.post_uri, &check.label, None).await?;
+                info!("Labeled post: {}", job.post_uri);
+            } else {
+                metrics.inc_posts_already_labeled();
+                info!("Post already labeled, skipping: {}", job.post_uri);
+            }
+        }
+
+        // Report account if configured
+        if check.report_acct {
+            if claims::claim_account_report(redis_conn, &job.post_did, &check.label).await? {
+                account::report_account(
+                    agent.as_ref(),
+                    config,
+                    rate_limiter,
+                    &job.post_did,
+                    ReasonType::ComAtprotoModerationDefsReasonSpam,
+                    &check.comment,
+                    &job.post_uri,
+                    &match_result.phash,
+                    created_by,
+                )
+                .await?;
+                metrics.inc_accounts_reported();
+                info!("Reported account: {}", job.post_did);
+            } else {
+                metrics.inc_accounts_already_reported();
+                info!("Account already reported, skipping: {}", job.post_did);
+            }
+        }
+
+        // Label account if configured
+        if check.label_acct {
+            if !claims::has_label(redis_conn, &job.post_did, &check.label).await? {
+                account::label_account(
+                    agent.as_ref(),
+                    config,
+                    rate_limiter,
+                    &job.post_did,
+                    &check.label,
+                    &check.comment,
+                    &job.post_uri,
+                    &match_result.phash,
+                    created_by,
+                )
+                .await?;
+                metrics.inc_accounts_labeled();
+                claims::set_label(redis_conn, &job.post_did, &check.label, None).await?;
+                info!("Labeled account: {}", job.post_did);
+            } else {
+                metrics.inc_accounts_already_labeled();
+                info!("Account already labeled, skipping: {}", job.post_did);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// Manual Clone implementation
+impl Clone for WorkerPool {
+    fn clone(&self) -> Self {
+        Self {
+            config: self.config.clone(),
+            client: self.client.clone(),
+            agent: self.agent.clone(),
+            blob_checks: self.blob_checks.clone(),
+            metrics: self.metrics.clone(),
+            rate_limiter: self.rate_limiter.clone(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    // Note: Worker tests require integration testing with Redis
+}

src/types/README.md

···
+# Types Module
+
+## Purpose
+Shared data structures used across the entire application for jobs, rules, matches, and blob references.
+
+## Key Types
+
+### `BlobCheck`
+Rule definition for matching and taking action on bad images.
+
+**Fields:**
+- `phashes: Vec<String>` - List of known bad phashes (16-char hex)
+- `label: String` - Label to apply (e.g., "spam", "csam", "troll")
+- `comment: String` - Human-readable description of violation
+- `report_acct: bool` - Report the account to moderators
+- `label_acct: bool` - Apply label to account
+- `report_post: bool` - Report the post to moderators
+- `to_label: bool` - Apply label to post
+- `takedown_post: bool` - Takedown/remove the post
+- `takedown_acct: bool` - Takedown/suspend the account
+- `hamming_threshold: Option<u32>` - Max distance for match (overrides global)
+- `description: Option<String>` - Optional human description
+- `ignore_did: Option<Vec<String>>` - DIDs to skip checking
+
+**JSON format (rules/blobs.json):**
+```json
+{
+  "phashes": ["e0e0e0e0e0fcfefe"],
+  "label": "spam",
+  "comment": "Known spam image detected",
+  "reportAcct": false,
+  "labelAcct": true,
+  "reportPost": true,
+  "toLabel": true,
+  "takedownPost": false,
+  "takedownAcct": false,
+  "hammingThreshold": 3,
+  "description": "Spam campaign from Oct 2024",
+  "ignoreDID": ["did:plc:exempted-account"]
+}
+```
+
+**Usage:**
+- Loaded at startup from JSON file
+- Cloned into each worker
+- Used by `match_phash()` to determine matches
+- Defines what actions to take on match
+
+### `BlobReference`
+Reference to an image blob in a post.
+
+**Fields:**
+- `cid: String` - Content identifier (blob hash)
+- `mime_type: Option<String>` - MIME type (e.g., "image/jpeg")
+
+**Source:** Extracted from Jetstream post records
+**Usage:** Part of `ImageJob`, tells worker which blobs to check
+
+### `ImageJob`
+A job representing a post with images to check.
+
+**Fields:**
+- `post_uri: String` - AT-URI of the post (e.g., "at://did:plc:xyz/app.bsky.feed.post/abc")
+- `post_cid: String` - Post commit CID
+- `post_did: String` - DID of post author
+- `blobs: Vec<BlobReference>` - Images to check
+- `timestamp: i64` - Unix timestamp when job created
+- `attempts: u32` - Retry counter (0 = first attempt)
+
+**Lifecycle:**
+1. Created by Jetstream client from post event
+2. Pushed to Redis queue (JSON serialized)
+3. Popped by worker
+4. Processed (download, compute, match)
+5. If retry needed: `attempts++`, push back to queue
+6. If max retries: move to dead letter queue
+
+### `MatchResult`
+Result of a successful phash match.
+
+**Fields:**
+- `phash: String` - Computed phash from image
+- `matched_check: BlobCheck` - Which rule matched
+- `matched_phash: String` - Specific phash from rule that matched
+- `hamming_distance: u32` - How close the match was (0 = exact)
+
+**Usage:**
+- Returned by `match_phash()` on successful match
+- Contains all info needed for moderation actions
+- Passed to `take_moderation_action()`
+- Used to build detailed moderation comments
+
+**Example:**
+```rust
+MatchResult {
+    phash: "e0e0e0e0e0fcfefe",
+    matched_check: BlobCheck { label: "spam", ... },
+    matched_phash: "e0e0e0e0fcfef0",
+    hamming_distance: 2,  // 2 bits different
+}
+```
+
+## Serde Configuration
+
+All types use `#[serde(rename_all = "camelCase")]`:
+- Rust: `report_acct`
+- JSON: `reportAcct`
+
+**Why?** JSON format matches AT Protocol conventions (camelCase).
+
+## Type Flow
+
+```
+Jetstream Event
+    ↓ extract blobs
+BlobReference (cid, mime_type)
+    ↓ create job
+ImageJob (post_uri, post_cid, post_did, blobs, ...)
+    ↓ serialize to JSON
+Redis Queue
+    ↓ deserialize from JSON
+Worker
+    ↓ download & compute
+    ↓ match against
+BlobCheck (phashes, label, actions, ...)
+    ↓ if match
+MatchResult (phash, matched_check, distance)
+    ↓ execute actions
+Moderation API
+```
+
+## Design Decisions
+
+**Why separate BlobReference from ImageJob?**
+- Post can have multiple images
+- Each image needs separate processing
+- But all share same post metadata
+
+**Why include post_uri in ImageJob?**
+- Needed for moderation actions
+- Included in moderation comments
+- Used for deduplication in claims
+
+**Why store attempts in ImageJob?**
+- Retry logic needs to track failure count
+- Prevents infinite retry loops
+- Used to determine dead letter queue
+
+**Why include matched_check in MatchResult?**
+- Need to know which actions to take
+- Need comment for moderation API
+- Avoids re-looking up the rule
+
+## Dependencies
+
+- `serde` - Serialization/deserialization
+- All types derive: `Debug`, `Clone`, `Serialize`, `Deserialize`
+
+## Related Modules
+
+- Used by: All modules - these are the core data types
+- Loaded by: `processor::matcher` - BlobCheck from JSON
+- Created by: `jetstream` - ImageJob and BlobReference
+- Returned by: `processor::matcher` - MatchResult

src/types/mod.rs

···
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlobCheck {
+    pub phashes: Vec<String>,
+    pub label: String,
+    pub comment: String,
+    pub report_acct: bool,
+    pub label_acct: bool,
+    pub report_post: bool,
+    pub to_label: bool,
+    #[serde(default)]
+    pub takedown_post: bool,
+    #[serde(default)]
+    pub takedown_acct: bool,
+    #[serde(default)]
+    pub hamming_threshold: Option<u32>,
+    #[serde(default)]
+    pub description: Option<String>,
+    #[serde(default, alias = "ignoreDID")]
+    pub ignore_did: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlobReference {
+    pub cid: String,
+    #[serde(default)]
+    pub mime_type: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ImageJob {
+    pub post_uri: String,
+    pub post_cid: String,
+    pub post_did: String,
+    pub blobs: Vec<BlobReference>,
+    pub timestamp: i64,
+    pub attempts: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MatchResult {
+    pub phash: String,
+    pub matched_check: BlobCheck,
+    pub matched_phash: String,
+    pub hamming_distance: u32,
+}