fix: failing tests

consumer/src/db/operations/feed/like.rs

···
     // - Without post actor_id: scans all segments, ~50-500ms
     // - With post actor_id: selective decompression, ~0.5ms
     //
-    // The like's rkey tells us the earliest possible chunk (posts can only have likes created
-    // after the post itself), so we filter rkey >= like_rkey to avoid scanning old chunks.
+    // The like's rkey tells us the latest possible chunk (posts can only have likes created
+    // after the post itself), so we filter rkey <= like_rkey to avoid scanning newer chunks.
 
-    // Step 1: Find which post has this like (rkey >= $1 for chunk exclusion)
+    // Step 1: Find which post has this like (rkey <= $1 for chunk exclusion)
     let post_key = conn
         .query_opt(
             "SELECT actor_id, rkey
              FROM posts
              WHERE $2 = ANY(like_actor_ids)
                AND $1 = ANY(like_rkeys)
-               AND rkey >= $1
+               AND rkey <= $1
              LIMIT 1",
             &[&rkey, &actor_id],
         )

parakeet-db/src/tid_util.rs

···
     table
 };
 
-/// Minimum valid TID timestamp (2022-01-01 00:00:00 UTC in microseconds) (2023 is probably more accurate but we'll be slightly permissive)
-const MIN_VALID_TIMESTAMP_MICROS: i64 = 1_640_995_200_000_000; // 2022-01-01
+/// Minimum valid TID timestamp (2023-01-01 00:00:00 UTC in microseconds)
+const MIN_VALID_TIMESTAMP_MICROS: i64 = 1_672_531_200_000_000; // 2023-01-01
 
-/// Maximum valid TID timestamp (2028-01-01 00:00:00 UTC in microseconds)
-const MAX_VALID_TIMESTAMP_MICROS: i64 = 1_830_297_600_000_000; // 2028-01-01 (exclusive)
+/// Maximum valid TID timestamp (2027-01-01 00:00:00 UTC in microseconds, exclusive)
+const MAX_VALID_TIMESTAMP_MICROS: i64 = 1_798_761_600_000_000; // 2027-01-01 (exclusive)
 
 /// Error type for TID operations
 #[derive(Debug, Clone, PartialEq, Eq)]
···
             TidError::TimestampOutOfRange { timestamp_micros } => {
                 write!(
                     f,
-                    "TID timestamp {} is outside valid range (2022-01-01 to 2027-12-31)",
+                    "TID timestamp {} is outside valid range (2023-01-01 to 2026-12-31)",
                     timestamp_micros
                 )
             }
···
         return false;
     }
 
-    // Decode TID to check timestamp range (2022-2028 inclusive)
+    // Decode TID to check timestamp range (2023-2026 inclusive)
     // This is a fast decode-in-place without error handling since we already validated format
     let mut result: i64 = 0;
     for &byte in bytes {
···
     // Extract timestamp (upper 53 bits, shift right by 10 to remove clock ID)
     let timestamp_micros = result >> 10;
 
-    // Check if timestamp is within valid range (2022-01-01 to 2027-12-31)
+    // Check if timestamp is within valid range (2023-01-01 to 2026-12-31)
     (MIN_VALID_TIMESTAMP_MICROS..MAX_VALID_TIMESTAMP_MICROS).contains(&timestamp_micros)
 }
 
···
     // Extract timestamp (upper 53 bits, shift right by 10 to remove clock ID)
     let timestamp_micros = result >> 10;
 
-    // Check if timestamp is within valid range (2022-01-01 to 2027-12-31)
+    // Check if timestamp is within valid range (2023-01-01 to 2026-12-31)
     if !(MIN_VALID_TIMESTAMP_MICROS..MAX_VALID_TIMESTAMP_MICROS).contains(&timestamp_micros) {
         return Err(TidError::TimestampOutOfRange { timestamp_micros });
     }

parakeet/tests/sql/batch_loading_test.rs

···
 
     // Use the ACTUAL query builder from the source code
     let query = parakeet::loaders::build_lists_batch_query();
-    let uris = vec!["at://did:plc:test/app.bsky.graph.list/123"];
+
+    // The query expects owner_actor_ids and rkeys as separate arrays
+    // For testing, we just need to ensure the query is valid
+    let actor_ids = vec![1i32];  // Sample actor IDs
+    let rkeys = vec!["123".to_string()];  // Sample rkeys
 
     diesel_async::RunQueryDsl::execute(
         diesel::sql_query(query)
-            .bind::<Array<diesel::sql_types::Text>, _>(&uris),
+            .bind::<Array<diesel::sql_types::Integer>, _>(&actor_ids)
+            .bind::<Array<diesel::sql_types::Text>, _>(&rkeys),
         &mut conn,
     )
     .await
···
 
     // Use the ACTUAL query builder from the source code
     let query = parakeet::loaders::build_feedgens_batch_query();
-    let uris = vec!["at://did:plc:test/app.bsky.feed.generator/123"];
+
+    // The query expects owner_actor_ids and rkeys as separate arrays
+    // For testing, we just need to ensure the query is valid
+    let actor_ids = vec![1i32];  // Sample actor IDs
+    let rkeys = vec!["123".to_string()];  // Sample rkeys
 
     diesel_async::RunQueryDsl::execute(
         diesel::sql_query(query)
-            .bind::<Array<diesel::sql_types::Text>, _>(&uris),
+            .bind::<Array<diesel::sql_types::Integer>, _>(&actor_ids)
+            .bind::<Array<diesel::sql_types::Text>, _>(&rkeys),
         &mut conn,
     )
     .await
···
 
     // Use the ACTUAL query builder from the source code
     let query = parakeet::loaders::build_starterpacks_batch_query();
-    let uris = vec!["at://did:plc:test/app.bsky.graph.starterpack/123"];
+
+    // The query expects owner_actor_ids and rkeys as separate arrays
+    // For testing, we just need to ensure the query is valid
+    let actor_ids = vec![1i32];  // Sample actor IDs
+    let rkeys = vec![123i64];  // Sample rkeys (bigint for starterpacks)
 
     diesel_async::RunQueryDsl::execute(
         diesel::sql_query(query)
-            .bind::<Array<diesel::sql_types::Text>, _>(&uris),
+            .bind::<Array<diesel::sql_types::Integer>, _>(&actor_ids)
+            .bind::<Array<diesel::sql_types::BigInt>, _>(&rkeys),
         &mut conn,
     )
     .await
···
     let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
 
     // Use the ACTUAL query builder from the source code
-    // This tests that feedgens query properly constructs URIs
-    // Query expects URIs (not natural keys), so construct AT-URI format
+    // The query expects owner_actor_ids and rkeys as separate arrays
     let query = parakeet::loaders::build_feedgens_batch_query();
-    let uris = vec!["at://did:plc:test/app.bsky.feed.generator/test".to_string()];
+    let actor_ids = vec![1i32];  // Sample actor IDs
+    let rkeys = vec!["test".to_string()];  // Sample rkeys
 
     diesel_async::RunQueryDsl::execute(
         diesel::sql_query(query)
-            .bind::<Array<diesel::sql_types::Text>, _>(&uris),
+            .bind::<Array<diesel::sql_types::Integer>, _>(&actor_ids)
+            .bind::<Array<diesel::sql_types::Text>, _>(&rkeys),
         &mut conn,
     )
     .await