use sonic_rs for JSON handling

src/cli/cmd_compare.rs

···
 use anyhow::{Context, Result, bail};
 use clap::{Args, ValueHint};
 use plcbundle::{BundleManager, constants, remote};
+use sonic_rs::JsonValueTrait;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use tokio::runtime::Runtime;

src/cli/cmd_did.rs

···
 use anyhow::{Context, Result};
 use clap::{Args, Subcommand, ValueHint};
 use plcbundle::{BundleManager, DIDLookupStats, DIDLookupTimings};
+use sonic_rs::{JsonContainerTrait, JsonValueTrait};
 use std::path::PathBuf;
 
 #[derive(Args)]
···
         println!("{}", values.join(separator));
         
         if verbose && !owl.nullified {
-            if let Some(op_data) = owl.operation.operation.as_object() {
-                if let Some(op_type) = op_data.get("type").and_then(|v| v.as_str()) {
-                    eprintln!("      type: {}", op_type);
-                }
-                if let Some(handle) = op_data.get("handle").and_then(|v| v.as_str()) {
-                    eprintln!("      handle: {}", handle);
-                } else if let Some(aka) = op_data.get("alsoKnownAs").and_then(|v| v.as_array()) {
+            let op_val = &owl.operation.operation;
+            if let Some(op_type) = op_val.get("type").and_then(|v| v.as_str()) {
+                eprintln!("      type: {}", op_type);
+            }
+            if let Some(handle) = op_val.get("handle").and_then(|v| v.as_str()) {
+                eprintln!("      handle: {}", handle);
+            } else {
+                if let Some(aka) = op_val.get("alsoKnownAs").and_then(|v| v.as_array()) {
                     if let Some(aka_str) = aka.first().and_then(|v| v.as_str()) {
                         let handle = aka_str.strip_prefix("at://").unwrap_or(aka_str);
                         eprintln!("      handle: {}", handle);

src/cli/cmd_inspect.rs

···
 use anyhow::Result;
 use chrono::DateTime;
 use clap::{Args, ValueHint};
-use plcbundle::constants;
 use plcbundle::format::{format_bytes, format_duration_verbose, format_number};
 use plcbundle::{BundleManager, LoadOptions, Operation};
 use serde::Serialize;
-use serde_json::Value;
+use sonic_rs::{JsonContainerTrait, JsonValueTrait};
 use std::collections::HashMap;
 use std::path::PathBuf;
 
···
     let manager = super::utils::create_manager(dir.clone(), false, false)?;
 
     // Resolve target to bundle number or file path
-    let (bundle_num, file_path) = resolve_target(&cmd.target, &dir)?;
+    let (bundle_num, file_path) = super::utils::resolve_bundle_target(&manager, &cmd.target, &dir)?;
 
-    // Get file size - use bundle metadata if available, otherwise read from filesystem
+    // Get file size - always use bundle metadata if available, otherwise read from filesystem
     let file_size = if let Some(num) = bundle_num {
         // Use bundle metadata from index (avoids direct file access per RULES.md)
         manager
             .get_bundle_metadata(num)?
             .map(|meta| meta.compressed_size)
-            .unwrap_or_else(|| {
-                // Fallback to filesystem if metadata not available
-                std::fs::metadata(&file_path).map(|m| m.len()).unwrap_or(0)
-            })
+            .unwrap_or(0)
     } else {
-        // For arbitrary file paths, we still need filesystem access
-        // TODO: Add method to load from arbitrary path
-        anyhow::bail!("Loading from arbitrary paths not yet implemented");
+        // For arbitrary file paths, we still need filesystem access - this should be refactored
+        // to use a manager method for loading from arbitrary paths in the future if supported.
+        // For now, it will return an error as per `resolve_bundle_target`.
+        anyhow::bail!("Loading from arbitrary paths not yet implemented. Please specify a bundle number.");
     };
 
     if !cmd.json {
···
         max_op_size = max_op_size.max(op_size);
 
         // Parse operation for detailed analysis
-        if let Value::Object(ref map) = op.operation {
-            // Operation type
-            if let Some(Value::String(op_type)) = map.get("type") {
-                *operation_types.entry(op_type.clone()).or_insert(0) += 1;
-            }
+        let op_val = &op.operation;
+        // Operation type
+        if let Some(op_type) = op_val.get("type").and_then(|v| v.as_str()) {
+            *operation_types.entry(op_type.to_string()).or_insert(0) += 1;
+        }
 
-            // Pattern analysis (if not skipped)
-            if !cmd.skip_patterns {
-                // Handle analysis
-                if let Some(Value::Array(aka)) = map.get("alsoKnownAs") {
-                    for item in aka {
-                        if let Value::String(aka_str) = item {
-                            if aka_str.starts_with("at://") {
-                                total_handles += 1;
+        // Pattern analysis (if not skipped)
+        if !cmd.skip_patterns {
+            // Handle analysis
+            if let Some(aka) = op_val.get("alsoKnownAs").and_then(|v| v.as_array()) {
+                for item in aka.iter() {
+                    if let Some(aka_str) = item.as_str() {
+                        if aka_str.starts_with("at://") {
+                            total_handles += 1;
 
-                                // Extract domain
-                                let handle = aka_str.strip_prefix("at://").unwrap_or("");
-                                let handle = handle.split('/').next().unwrap_or("");
+                            // Extract domain
+                            let handle = aka_str.strip_prefix("at://").unwrap_or("");
+                            let handle = handle.split('/').next().unwrap_or("");
 
-                                // Count domain (TLD)
-                                let parts: Vec<&str> = handle.split('.').collect();
-                                if parts.len() >= 2 {
-                                    let domain = format!(
-                                        "{}.{}",
-                                        parts[parts.len() - 2],
-                                        parts[parts.len() - 1]
-                                    );
-                                    *domain_counts.entry(domain).or_insert(0) += 1;
-                                }
+                            // Count domain (TLD)
+                            let parts: Vec<&str> = handle.split('.').collect();
+                            if parts.len() >= 2 {
+                                let domain = format!(
+                                    "{}.{}",
+                                    parts[parts.len() - 2],
+                                    parts[parts.len() - 1]
+                                );
+                                *domain_counts.entry(domain).or_insert(0) += 1;
+                            }
 
-                                // Check for invalid patterns
-                                if handle.contains('_') {
-                                    invalid_handles += 1;
-                                }
+                            // Check for invalid patterns
+                            if handle.contains('_') {
+                                invalid_handles += 1;
                             }
                         }
                     }
                 }
+            }
 
-                // Service analysis
-                if let Some(Value::Object(services)) = map.get("services") {
-                    total_services += services.len();
+            // Service analysis
+            if let Some(services) = op_val.get("services").and_then(|v| v.as_object()) {
+                total_services += services.len();
 
-                    // Extract PDS endpoints
-                    if let Some(Value::Object(pds)) = services.get("atproto_pds") {
-                        if let Some(Value::String(endpoint)) = pds.get("endpoint") {
+                // Extract PDS endpoints
+                if let Some(pds_val) = op_val.get("services").and_then(|v| v.get("atproto_pds")) {
+                    if let Some(pds) = pds_val.as_object() {
+                        if let Some(endpoint) = pds_val.get("endpoint").and_then(|v| v.as_str()) {
                             // Normalize endpoint
                             let endpoint = endpoint
                                 .strip_prefix("https://")
···
 
     Ok(())
 }
-
-fn resolve_target(target: &str, dir: &PathBuf) -> Result<(Option<u32>, PathBuf)> {
-    // Try to parse as bundle number
-    if let Ok(num) = target.parse::<u32>() {
-        let path = constants::bundle_path(dir, num);
-        if path.exists() {
-            return Ok((Some(num), path));
-        } else {
-            anyhow::bail!("Bundle {} not found in repository", num);
-        }
-    }
-
-    // Otherwise treat as file path
-    let path = PathBuf::from(target);
-    if path.exists() {
-        Ok((None, path))
-    } else {
-        anyhow::bail!("File not found: {}", target)
-    }
-}

src/cli/cmd_op.rs

···
 use anyhow::Result;
 use clap::{Args, Subcommand};
 use plcbundle::{LoadOptions, constants};
+use sonic_rs::{JsonContainerTrait, JsonValueTrait};
 use std::path::PathBuf;
 use std::time::Instant;
 
···
     let pds = op
         .operation
         .get("services")
-        .and_then(|v| v.as_object())
-        .and_then(|services| services.get("atproto_pds"))
-        .and_then(|v| v.as_object())
-        .and_then(|pds| pds.get("endpoint"))
+        .and_then(|services_val| services_val.get("atproto_pds"))
+        .and_then(|pds_val| pds_val.get("endpoint"))
         .and_then(|v| v.as_str());
 
     // Display formatted output

src/cli/cmd_stats.rs

···
 use anyhow::Result;
 use clap::{Args, ValueEnum};
 use plcbundle::BundleManager;
-use serde_json::Value;
+use sonic_rs::JsonValueTrait;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
···
                 nullified_operations += 1;
             }
 
-            if let Value::Object(ref map) = op.operation {
-                if let Some(Value::String(op_type)) = map.get("type") {
-                    *operation_types.entry(op_type.clone()).or_insert(0) += 1;
-                } else {
-                    *operation_types.entry("unknown".to_string()).or_insert(0) += 1;
-                }
+            if let Some(op_type) = op.operation.get("type").and_then(|v| v.as_str()) {
+                *operation_types.entry(op_type.to_string()).or_insert(0) += 1;
             } else {
                 *operation_types.entry("unknown".to_string()).or_insert(0) += 1;
             }

src/cli/utils.rs

···
     create_manager(dir, cmd.verbose(), cmd.quiet())
 }
 
+/// Resolve a target string (bundle number or path) into a bundle number and canonical path.
+/// This utility ensures that file existence checks for bundles are done through the BundleManager.
+pub fn resolve_bundle_target(
+    manager: &BundleManager,
+    target: &str,
+    repo_dir: &PathBuf,
+) -> Result<(Option<u32>, PathBuf)> {
+    // Try to parse as bundle number
+    if let Ok(num) = target.parse::<u32>() {
+        let path = plcbundle::constants::bundle_path(repo_dir, num);
+        // Check if bundle exists via BundleManager's index
+        if manager.get_bundle_metadata(num)?.is_some() {
+            Ok((Some(num), path))
+        } else {
+            anyhow::bail!("Bundle {} not found in repository index", num);
+        }
+    } else {
+        // Otherwise treat as file path. For now, this is an error as direct file access is disallowed.
+        anyhow::bail!("Loading from arbitrary paths not yet implemented. Please specify a bundle number.");
+    }
+}
+
 /// Get all bundle metadata from the repository
 /// This is more efficient than iterating through bundle numbers
 pub fn get_all_bundle_metadata(manager: &BundleManager) -> Vec<plcbundle::index::BundleMetadata> {

src/ffi.rs

···
 use crate::constants;
 use crate::manager::*;
 use crate::operations::*;
+use sonic_rs::JsonValueTrait;
 use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
 use std::path::PathBuf;

src/manager.rs

···
 use crate::operations::{Operation, OperationFilter, OperationRequest, OperationWithLocation};
 use crate::options::QueryMode;
 use crate::{cache, did_index, handle_resolver, mempool, verification};
-use anyhow::Result;
+use anyhow::{Context, Result};
 use chrono::{DateTime, Utc};
 use std::collections::{HashMap, HashSet};
 use std::io::Write;
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex, RwLock};
+use std::fs::File;
 
 /// Result of a sync_next_bundle operation
 #[derive(Debug, Clone)]
···
         let failed_count = failed.load(Ordering::SeqCst);
 
         Ok((downloaded_count, failed_count))
+    }
+
+    /// Deletes a bundle file from the repository.
+    ///
+    /// This method removes a bundle file from the repository directory.
+    ///
+    /// # Arguments
+    /// * `bundle_num` - The number of the bundle to delete.
+    ///
+    /// # Returns
+    /// A `Result` indicating whether the operation was successful.
+    pub fn delete_bundle_file(&self, bundle_num: u32) -> Result<()> {
+        let bundle_path = constants::bundle_path(&self.directory, bundle_num);
+        if bundle_path.exists() {
+            std::fs::remove_file(bundle_path)?;
+        }
+        self.cache.remove(bundle_num);
+        Ok(())
     }
 }
 

src/operations.rs

···
 // src/operations.rs
 use serde::{Deserialize, Serialize};
+use sonic_rs::{self, Value};
 
 /// PLC Operation
 ///
···
 pub struct Operation {
     pub did: String,
     #[serde(alias = "operation")]
-    pub operation: serde_json::Value,
+    pub operation: Value,
     #[serde(default)]
     pub cid: Option<String>,
     #[serde(default)]
···
     #[serde(rename = "createdAt", alias = "created_at")]
     pub created_at: String,
     #[serde(flatten)]
-    pub extra: serde_json::Value,
+    pub extra: Value,
 
     /// CRITICAL: Raw JSON bytes as received from source
     ///

src/resolver.rs

···
 use crate::operations::Operation;
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
+use sonic_rs::{JsonContainerTrait, JsonValueTrait, Value};
 use std::collections::HashMap;
 
 // ============================================================================
···
 }
 
 /// Apply a single operation to the state
-fn apply_operation_to_state(state: &mut DIDState, op_data: &serde_json::Value) {
+fn apply_operation_to_state(state: &mut DIDState, op_data: &Value) {
     // Update rotation keys
     if let Some(rot_keys) = op_data.get("rotationKeys").and_then(|v| v.as_array()) {
         state.rotation_keys = rot_keys
···
     {
         state.verification_methods = vm
             .iter()
-            .filter_map(|(k, v)| v.as_str().map(|s| (k.clone(), s.to_string())))
+            .filter_map(|(k, v)| v.as_str().map(|s| (k.to_string(), s.to_string())))
             .collect();
     }
 
···
                 let service_type = v.get("type")?.as_str()?.to_string();
                 let endpoint = v.get("endpoint")?.as_str()?.to_string();
                 Some((
-                    k.clone(),
+                    k.to_string(),
                     ServiceDefinition {
                         service_type,
                         endpoint: normalize_service_endpoint(&endpoint),
···
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AuditLogEntry {
     pub did: String,
-    pub operation: serde_json::Value,
+    #[serde(skip)]
+    pub operation: Value,
     pub cid: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub nullified: Option<bool>,

src/sync.rs

···
 use crate::plc_client::PLCClient;
 use anyhow::Result;
 use serde::Deserialize;
+use sonic_rs::{JsonValueTrait, Value};
 use std::any::Any;
 use std::collections::HashSet;
 use std::sync::{Arc, Mutex};
···
 #[derive(Debug, Deserialize)]
 pub struct PLCOperation {
     did: String,
-    operation: serde_json::Value,
+    operation: Value,
     cid: String,
     #[serde(default)]
-    nullified: Option<serde_json::Value>,
+    nullified: Option<Value>,
     #[serde(rename = "createdAt")]
     created_at: String,
     #[serde(skip)]
···
             cid: Some(plc.cid),
             nullified: is_nullified,
             created_at: plc.created_at,
-            extra: serde_json::Value::Null,
+            extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
             raw_json: plc.raw_json,
         }
     }
···
         let ops = vec![
             Operation {
                 did: "did:plc:1".into(),
-                operation: serde_json::Value::Null,
+                operation: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 cid: Some("cid1".into()),
                 nullified: false,
                 created_at: "2024-01-01T00:00:00Z".into(),
-                extra: serde_json::Value::Null,
+                extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 raw_json: None,
             },
             Operation {
                 did: "did:plc:2".into(),
-                operation: serde_json::Value::Null,
+                operation: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 cid: Some("cid2".into()),
                 nullified: false,
                 created_at: "2024-01-01T00:00:01Z".into(),
-                extra: serde_json::Value::Null,
+                extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 raw_json: None,
             },
             Operation {
                 did: "did:plc:3".into(),
-                operation: serde_json::Value::Null,
+                operation: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 cid: Some("cid3".into()),
                 nullified: false,
                 created_at: "2024-01-01T00:00:01Z".into(), // Same time as cid2
-                extra: serde_json::Value::Null,
+                extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 raw_json: None,
             },
         ];
···
         let ops = vec![
             Operation {
                 did: "did:plc:1".into(),
-                operation: serde_json::Value::Null,
+                operation: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 cid: Some("cid1".into()), // Duplicate
                 nullified: false,
                 created_at: "2024-01-01T00:00:00Z".into(),
-                extra: serde_json::Value::Null,
+                extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 raw_json: None,
             },
             Operation {
                 did: "did:plc:2".into(),
-                operation: serde_json::Value::Null,
+                operation: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 cid: Some("cid2".into()), // New
                 nullified: false,
                 created_at: "2024-01-01T00:00:01Z".into(),
-                extra: serde_json::Value::Null,
+                extra: sonic_rs::from_str("null").unwrap_or_else(|_| Value::new()),
                 raw_json: None,
             },
         ];