refactor: update rate limiting constants and query mode

src/bundle_format.rs

···
     }
 
     #[test]
-    fn test_parallel_compression_matches_sequential() {
-        use crate::operations::Operation;
-        use sonic_rs::{Value, from_str};
-
-        // Create test operations
-        let mut operations = Vec::new();
-        for i in 0..250 {
-            // Multiple frames (250 ops = 3 frames with FRAME_SIZE=100)
-            let operation_json = format!(r#"{{"type":"create","data":"test data {}"}}"#, i);
-            let operation_value: Value = from_str(&operation_json).unwrap();
-            let extra_value: Value = from_str("{}").unwrap_or_else(|_| Value::new());
-            operations.push(Operation {
-                did: format!("did:plc:test{}", i),
-                operation: operation_value,
-                cid: Some(format!("cid{}", i)),
-                created_at: "2024-01-01T00:00:00Z".to_string(),
-                nullified: false,
-                extra: extra_value,
-                raw_json: None,
-            });
-        }
-
-        // Compress using both methods
-        let result_sequential = compress_operations_to_frames(&operations).unwrap();
-        let result_parallel = compress_operations_to_frames_parallel(&operations).unwrap();
-
-        // Verify results match
-        assert_eq!(
-            result_sequential.compressed_frames.len(),
-            result_parallel.compressed_frames.len()
-        );
-        assert_eq!(
-            result_sequential.frame_offsets,
-            result_parallel.frame_offsets
-        );
-        assert_eq!(
-            result_sequential.uncompressed_size,
-            result_parallel.uncompressed_size
-        );
-        assert_eq!(
-            result_sequential.compressed_size,
-            result_parallel.compressed_size
-        );
-
-        // Verify compressed frames are identical
-        for (seq_frame, par_frame) in result_sequential
-            .compressed_frames
-            .iter()
-            .zip(result_parallel.compressed_frames.iter())
-        {
-            assert_eq!(seq_frame, par_frame, "Compressed frames must be identical");
-        }
-
-        println!("✓ Parallel compression produces identical output to sequential");
-        println!("  Frames: {}", result_parallel.compressed_frames.len());
-        println!(
-            "  Compressed size: {} bytes",
-            result_parallel.compressed_size
-        );
-    }
-
-    #[test]
     fn test_skippable_frame_roundtrip() {
         let data = b"test data";
         let mut buffer = Vec::new();

src/constants.rs

···
 // Rate Limiting Constants
 // ============================================================================
 
-/// Default rate limit for PLC API requests (requests per minute)
-/// Set to 80% of quota (72 req/min) to provide safety margin and prevent rate limiting
-pub const DEFAULT_RATE_LIMIT: usize = 72;
+/// PLC directory quota: maximum requests allowed per period
+pub const PLC_RATE_LIMIT_REQUEST: usize = 500;
+
+/// Rate limiting window length in seconds (measurement and enforcement are equal)
+pub const PLC_RATE_LIMIT_PERIOD: u64 = 300;
+
+/// Safety margin applied to quota to avoid hitting limits (e.g., 0.8 = 80%)
+pub const PLC_RATE_LIMIT_SAFETY_FACTOR: f64 = 0.8;
 
 // ============================================================================
 // Timeout Constants (in seconds)
···
     fn test_constants_values() {
         assert_eq!(BUNDLE_SIZE, 10_000);
         assert_eq!(FRAME_SIZE, 100);
-        assert_eq!(DEFAULT_RATE_LIMIT, 72);
+        assert_eq!(PLC_RATE_LIMIT_REQUEST, 500);
+        assert_eq!(PLC_RATE_LIMIT_PERIOD, 300);
+        assert!((PLC_RATE_LIMIT_SAFETY_FACTOR - 0.8).abs() < f64::EPSILON);
         assert_eq!(HTTP_TIMEOUT_SECS, 60);
         assert_eq!(HTTP_INDEX_TIMEOUT_SECS, 30);
         assert_eq!(HTTP_BUNDLE_TIMEOUT_SECS, 60);

src/lib.rs

···
 //! assert!(resolved.locations_found >= 0);
 //!
 //! // Query a bundle range
-//! let spec = QuerySpec { bundles: BundleRange::Range(1, 10), filter: None, query: String::new(), mode: QueryMode::All };
+//! let spec = QuerySpec { bundles: BundleRange::Range(1, 10), filter: None, query: String::new(), mode: QueryMode::Simple };
 //! for item in mgr.query(spec) { let _ = item?; }
 //! # Ok::<(), anyhow::Error>(())
 //! ```

src/manager.rs

···
 /// println!("Resolved to shard {}", resolved.shard_num);
 ///
 /// // Query a range and export
-/// let spec = QuerySpec { bundles: BundleRange::Range(40, 45), filter: None, query: String::new(), mode: QueryMode::All };
+/// let spec = QuerySpec { bundles: BundleRange::Range(40, 45), filter: None, query: String::new(), mode: QueryMode::Simple };
 /// let mut count = 0u64;
 /// for item in mgr.query(spec) { count += 1; }
 /// assert!(count > 0);

src/plc_client.rs

···
 
 impl PLCClient {
     pub fn new(base_url: impl Into<String>) -> Result<Self> {
-        let rate_limit_period = Duration::from_secs(constants::HTTP_TIMEOUT_SECS);
+        let period = Duration::from_secs(constants::PLC_RATE_LIMIT_PERIOD);
+        let requests_per_period = (constants::PLC_RATE_LIMIT_REQUEST as f64
+            * constants::PLC_RATE_LIMIT_SAFETY_FACTOR)
+            .floor() as usize;
         Ok(Self {
             client: reqwest::Client::builder()
                 .timeout(Duration::from_secs(constants::HTTP_TIMEOUT_SECS))
                 .build()?,
             base_url: base_url.into(),
-            rate_limiter: RateLimiter::new(constants::DEFAULT_RATE_LIMIT, rate_limit_period),
+            rate_limiter: RateLimiter::new(requests_per_period, period),
             last_retry_after: std::sync::Arc::new(tokio::sync::Mutex::new(None)),
             request_timestamps: Arc::new(std::sync::Mutex::new(VecDeque::new())),
-            rate_limit_period,
+            rate_limit_period: period,
         })
     }
 
···
                     let retry_after = self.last_retry_after.lock().await.take();
                     if let Some(retry_after) = retry_after {
                         let requests_in_period = self.count_requests_in_period();
-                        let rate_limit = constants::DEFAULT_RATE_LIMIT;
+                        let rate_limit = (constants::PLC_RATE_LIMIT_REQUEST as f64
+                            * constants::PLC_RATE_LIMIT_SAFETY_FACTOR)
+                            .floor() as usize;
                         eprintln!(
                             "[Sync] Rate limited by PLC directory ({} requests in last {:?}, limit: {}), waiting {:?} before retry {}/{}",
                             requests_in_period,

src/server/handle_random.rs

···
     if count > 1000 {
         return bad_request("count must be <= 1000").into_response();
     }
-    let effective_seed = params
-        .seed
-        .unwrap_or_else(|| {
-            SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_nanos() as u64
-        });
+    let effective_seed = params.seed.unwrap_or_else(|| {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as u64
+    });
     if count == 0 {
         return (
             StatusCode::OK,
···
         Err(e) => return task_join_error(e).into_response(),
     };
 
-    (StatusCode::OK, axum::Json(json!({
-        "dids": dids,
-        "count": count,
-        "seed": effective_seed
-    })))
+    (
+        StatusCode::OK,
+        axum::Json(json!({
+            "dids": dids,
+            "count": count,
+            "seed": effective_seed
+        })),
+    )
         .into_response()
-}
+}

tests/common/mod.rs

···
 use tempfile::TempDir;
 
 use plcbundle::BundleManager;
+use plcbundle::Operation;
 use plcbundle::index::{BundleMetadata, Index};
-use plcbundle::operations::Operation;
 
 pub fn setup_manager(dir: &PathBuf) -> Result<BundleManager> {
-    plcbundle::Index::init(dir, "http://localhost:1234".to_string(), true)?;
+    Index::init(dir, "http://localhost:1234".to_string(), true)?;
     let manager = BundleManager::new(dir.clone(), ())?;
     Ok(manager)
 }

tests/manager.rs

···
         bundles: plcbundle::BundleRange::Single(1),
         format: plcbundle::ExportFormat::JsonLines,
         filter: None,
-        compression: None,
         count: Some(5),
         after_timestamp: None,
     };