refactor: adding minimal streaming parser for tap event id fields.

Cargo.toml

···
 secrecy = { version = "0.10", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_ipld_dagcbor = "0.6"
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["unbounded_depth"] }
 sha2 = "0.10"
 thiserror = "2.0"
 tokio = { version = "1.41", features = ["macros", "rt", "rt-multi-thread"] }

crates/atproto-tap/src/events.rs

···
 //! - `serde_json::Value` for record payloads (allows lazy access)
 
 use compact_str::CompactString;
+use serde::de::{self, Deserializer, IgnoredAny, MapAccess, Visitor};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use std::fmt;
 
 /// A TAP event received from the stream.
 ///
···
             TapEvent::Record { id, .. } => *id,
             TapEvent::Identity { id, .. } => *id,
         }
+    }
+}
+
+/// Extract only the event ID from a JSON string without fully parsing it.
+///
+/// This is a fallback parser used when full `TapEvent` parsing fails (e.g., due to
+/// deeply nested records hitting serde_json's recursion limit). It uses `IgnoredAny`
+/// to efficiently skip over nested content without building data structures, allowing
+/// us to extract the ID for acknowledgment even when full parsing fails.
+///
+/// # Example
+///
+/// ```
+/// use atproto_tap::extract_event_id;
+///
+/// let json = r#"{"type":"record","id":12345,"record":{"deeply":"nested"}}"#;
+/// assert_eq!(extract_event_id(json), Some(12345));
+/// ```
+pub fn extract_event_id(json: &str) -> Option<u64> {
+    let mut deserializer = serde_json::Deserializer::from_str(json);
+    deserializer.disable_recursion_limit();
+    EventIdOnly::deserialize(&mut deserializer).ok().map(|e| e.id)
+}
+
+/// Internal struct for extracting only the "id" field from a TAP event.
+#[derive(Debug)]
+struct EventIdOnly {
+    id: u64,
+}
+
+impl<'de> Deserialize<'de> for EventIdOnly {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(EventIdOnlyVisitor)
+    }
+}
+
+struct EventIdOnlyVisitor;
+
+impl<'de> Visitor<'de> for EventIdOnlyVisitor {
+    type Value = EventIdOnly;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a map with an 'id' field")
+    }
+
+    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
+    {
+        let mut id: Option<u64> = None;
+
+        while let Some(key) = map.next_key::<&str>()? {
+            if key == "id" {
+                id = Some(map.next_value()?);
+                // Found what we need - skip the rest efficiently using IgnoredAny
+                // which handles deeply nested structures without recursion issues
+                while map.next_entry::<IgnoredAny, IgnoredAny>()?.is_some() {}
+                break;
+            } else {
+                // Skip this value without fully parsing it
+                map.next_value::<IgnoredAny>()?;
+            }
+        }
+
+        id.map(|id| EventIdOnly { id })
+            .ok_or_else(|| de::Error::missing_field("id"))
     }
 }
 
···
             },
         };
         assert_eq!(identity_event.id(), 200);
+    }
+
+    #[test]
+    fn test_extract_event_id_simple() {
+        let json = r#"{"type":"record","id":12345,"record":{"deeply":"nested"}}"#;
+        assert_eq!(extract_event_id(json), Some(12345));
+    }
+
+    #[test]
+    fn test_extract_event_id_at_end() {
+        let json = r#"{"type":"record","record":{"deeply":"nested"},"id":99999}"#;
+        assert_eq!(extract_event_id(json), Some(99999));
+    }
+
+    #[test]
+    fn test_extract_event_id_missing() {
+        let json = r#"{"type":"record","record":{"deeply":"nested"}}"#;
+        assert_eq!(extract_event_id(json), None);
+    }
+
+    #[test]
+    fn test_extract_event_id_invalid_json() {
+        let json = r#"{"type":"record","id":123"#; // Truncated JSON
+        assert_eq!(extract_event_id(json), None);
+    }
+
+    #[test]
+    fn test_extract_event_id_deeply_nested() {
+        // Create a deeply nested JSON that would exceed serde_json's default recursion limit
+        let mut json = String::from(r#"{"id":42,"record":{"nested":"#);
+        for _ in 0..200 {
+            json.push_str("[");
+        }
+        json.push_str("1");
+        for _ in 0..200 {
+            json.push_str("]");
+        }
+        json.push_str("}}");
+
+        // extract_event_id should still work because it uses IgnoredAny with disabled recursion limit
+        assert_eq!(extract_event_id(&json), Some(42));
     }
 }

crates/atproto-tap/src/lib.rs

···
 pub use client::RepoStatus;
 pub use config::{TapConfig, TapConfigBuilder};
 pub use errors::TapError;
-pub use events::{IdentityEvent, IdentityStatus, RecordAction, RecordEvent, TapEvent};
+pub use events::{IdentityEvent, IdentityStatus, RecordAction, RecordEvent, TapEvent, extract_event_id};
 pub use stream::{TapStream, connect, connect_to};

crates/atproto-tap/src/stream.rs

···
 use crate::config::TapConfig;
 use crate::connection::TapConnection;
 use crate::errors::TapError;
-use crate::events::TapEvent;
+use crate::events::{TapEvent, extract_event_id};
 use futures::Stream;
 use std::pin::Pin;
 use std::sync::Arc;
···
                                         Err(err) => {
                                             // Parse errors don't affect connection
                                             tracing::warn!(error = %err, "Failed to parse TAP message");
+
+                                            // Try to extract just the ID using fallback parser
+                                            // so we can still ack the message even if full parsing fails
+                                            if config.send_acks {
+                                                if let Some(event_id) = extract_event_id(&msg) {
+                                                    tracing::debug!(event_id, "Extracted event ID via fallback parser");
+                                                    if let Err(ack_err) = conn.send_ack(event_id).await {
+                                                        tracing::warn!(error = %ack_err, "Failed to send ack for unparseable message");
+                                                    }
+                                                } else {
+                                                    tracing::warn!("Could not extract event ID from unparseable message");
+                                                }
+                                            }
+
                                             if event_tx.send(Err(TapError::ParseError(err.to_string()))).await.is_err() {
                                                 tracing::debug!("Event receiver dropped, closing connection");
                                                 let _ = conn.close().await;