@lovrozagar/honey 0.6.8 → 0.7.1

package/src/client-rust/realtime.rs

@@ -1,12 +1,14 @@
 /* Code generated by honey. DO NOT EDIT. */
 
 use crate::errors::Error;
+use crate::sse::SseParser;
 use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::marker::PhantomData;
 use std::pin::Pin;
+use std::time::Duration;
 
 /// TransportKind tags which transport a connection was opened with.
 /// The behaviour-bearing abstraction is the [`Transport`] trait.
@@ -51,6 +53,12 @@ impl std::fmt::Display for RealtimeError {
 impl std::error::Error for RealtimeError {}
 
 /// ResumableConnectionOpts configures reconnect behaviour and auth.
+///
+/// `max_reconnect_attempts` caps consecutive failed reconnects (default 5; 0
+/// means unlimited). Reconnects back off exponentially from
+/// `reconnect_delay_ms` (default 1000) up to 30 s, with jitter. `headers` go
+/// on every transport request; the generated SDK fills in config headers and
+/// auth. `http_client` lets SSE / long-poll share the SDK's client.
 #[derive(Debug, Clone, Default)]
 pub struct ResumableConnectionOpts {
     pub reconnect_token: Option<String>,
@@ -59,6 +67,7 @@ pub struct ResumableConnectionOpts {
     pub reconnect_delay_ms: Option<u64>,
     pub last_event_id: Option<String>,
     pub headers: HashMap<String, String>,
+    pub http_client: Option<reqwest::Client>,
 }
 
 /// TransportOpts is handed to each `Transport::connect`.
@@ -74,37 +83,35 @@ pub struct TransportOpts {
     pub reconnect_delay_ms: Option<u64>,
 }
 
+const MAX_RECONNECT_DELAY: Duration = Duration::from_secs(30);
+const OPEN_TIMEOUT: Duration = Duration::from_secs(30);
+const POLL_TIMEOUT: Duration = Duration::from_secs(60);
+
 type WsStream = tokio_tungstenite::WebSocketStream<
     tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
 >;
 
 type ByteStream = Pin<Box<dyn futures_util::Stream<Item = Result<Bytes, reqwest::Error>> + Send>>;
 
-/// SseState holds mutable state for an active SSE resumable connection.
+/// SseState holds mutable state for an active SSE connection.
 pub struct SseState {
     pub byte_stream: ByteStream,
-    pub buf: Vec<u8>,
     pub last_event_id: Option<String>,
     pub retry_hint_ms: u64,
-    /* internal fields for reconnect and send */
+    parser: SseParser,
+    pending: VecDeque<crate::sse::SseEvent>,
     http_client: reqwest::Client,
     url: String,
     extra_headers: HashMap<String, String>,
-    max_reconnect_attempts: u32,
-    reconnect_delay_ms: u64,
-    reconnect_attempts: u32,
 }
 
-/// LongpollState holds mutable state for a long-poll resumable connection.
+/// LongpollState holds mutable state for a long-poll connection.
 pub struct LongpollState {
     pub client: reqwest::Client,
     pub url: String,
     pub cursor: Option<String>,
     pub pending_events: VecDeque<serde_json::Value>,
     pub headers: HashMap<String, String>,
-    max_reconnect_attempts: u32,
-    reconnect_delay_ms: u64,
-    reconnect_attempts: u32,
 }
 
 /// TransportConn is the live per-transport connection.
@@ -132,6 +139,15 @@ pub trait Transport: Send + Sync + 'static {
     ) -> Result<Box<dyn TransportConn>, RealtimeError>;
 }
 
+/// Payloads that are not JSON arrive as a JSON string instead of tearing the connection down.
+fn decode_payload(text: &str) -> serde_json::Value {
+    serde_json::from_str(text).unwrap_or_else(|_| serde_json::Value::String(text.to_string()))
+}
+
+fn connect_err(e: impl std::fmt::Display) -> RealtimeError {
+    RealtimeError::Connect(Error::Other(e.to_string()))
+}
+
 /* ------------------------------------------------------------------ */
 /*  WS adapter                                                         */
 /* ------------------------------------------------------------------ */
@@ -160,19 +176,13 @@ impl Transport for WsTransport {
         opts: &TransportOpts,
     ) -> Result<Box<dyn TransportConn>, RealtimeError> {
         use tokio_tungstenite::tungstenite::client::IntoClientRequest;
-        let ws_url = url.replacen("https://", "wss://", 1).replacen("http://", "ws://", 1);
-        let mut req = ws_url
-            .as_str()
-            .into_client_request()
-            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        let ws_url = crate::runtime::to_ws_url(url);
+        let mut req = ws_url.as_str().into_client_request().map_err(connect_err)?;
         if let Some(ref protos) = opts.protocols {
             if !protos.is_empty() {
                 req.headers_mut().insert(
                     "Sec-WebSocket-Protocol",
-                    protos
-                        .join(", ")
-                        .parse()
-                        .map_err(|_| RealtimeError::Connect(Error::Other("invalid protocol header".into())))?,
+                    protos.join(", ").parse().map_err(|_| connect_err("invalid protocol header"))?,
                 );
             }
         }
@@ -184,9 +194,7 @@ impl Transport for WsTransport {
                 req.headers_mut().insert(name, val);
             }
         }
-        let (stream, _) = tokio_tungstenite::connect_async(req)
-            .await
-            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        let (stream, _) = tokio_tungstenite::connect_async(req).await.map_err(connect_err)?;
         Ok(Box::new(WsConn { stream: Box::new(stream) }))
     }
 }
@@ -199,10 +207,9 @@ impl TransportConn for WsConn {
     async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
         use futures_util::SinkExt;
         use tokio_tungstenite::tungstenite::Message;
-        let encoded = serde_json::to_vec(&value)
-            .map_err(|e| RealtimeError::Send(Error::Json(e)))?;
+        let encoded = serde_json::to_string(&value).map_err(|e| RealtimeError::Send(Error::Json(e)))?;
         self.stream
-            .send(Message::Text(String::from_utf8_lossy(&encoded).into_owned()))
+            .send(Message::Text(encoded))
             .await
             .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))
     }
@@ -213,15 +220,10 @@ impl TransportConn for WsConn {
             match self.stream.next().await {
                 None => return Err(RealtimeError::Closed),
                 Some(Err(e)) => return Err(RealtimeError::Recv(Error::Other(e.to_string()))),
-                Some(Ok(Message::Text(t))) => {
-                    return serde_json::from_slice(t.as_bytes())
-                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
-                }
-                Some(Ok(Message::Binary(b))) => {
-                    return serde_json::from_slice(&b)
-                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
-                }
-                Some(Ok(_)) => continue, /* ping/pong/close — skip */
+                Some(Ok(Message::Text(t))) => return Ok(decode_payload(&t)),
+                Some(Ok(Message::Binary(b))) => return Ok(decode_payload(&String::from_utf8_lossy(&b))),
+                Some(Ok(Message::Close(_))) => return Err(RealtimeError::Closed),
+                Some(Ok(_)) => continue, /* ping/pong — skip */
             }
         }
     }
@@ -249,10 +251,17 @@ pub struct SseTransport {
 }
 
 /// SseConn is the live SSE connection returned by [`SseTransport::connect`].
+/// A dropped or ended stream is reported as an error; ResumableConnection reconnects.
 pub struct SseConn {
     state: SseState,
 }
 
+fn pick_client(own: &Option<reqwest::Client>, opts: &TransportOpts) -> reqwest::Client {
+    own.clone()
+        .or_else(|| opts.http_client.clone())
+        .unwrap_or_else(crate::runtime::default_http_client)
+}
+
 #[async_trait::async_trait]
 impl Transport for SseTransport {
     fn name(&self) -> &'static str {
@@ -266,14 +275,8 @@ impl Transport for SseTransport {
         url: &str,
         opts: &TransportOpts,
     ) -> Result<Box<dyn TransportConn>, RealtimeError> {
-        let client = self
-            .http_client
-            .clone()
-            .or_else(|| opts.http_client.clone())
-            .unwrap_or_else(reqwest::Client::new);
-        let state = build_sse_state(url.to_string(), client, opts)
-            .await
-            .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
+        let client = pick_client(&self.http_client, opts);
+        let state = build_sse_state(url.to_string(), client, opts).await?;
         Ok(Box::new(SseConn { state }))
     }
 }
@@ -284,75 +287,36 @@ impl TransportConn for SseConn {
         TransportKind::Sse
     }
     async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
-        /* SSE is server → client; send POSTs back to the endpoint. */
-        self.state
-            .http_client
-            .post(self.state.url.as_str())
-            .json(&value)
-            .send()
-            .await
-            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        /* SSE is server → client; send POSTs back to the endpoint with the same headers. */
+        let mut req = self.state.http_client.post(self.state.url.as_str()).json(&value);
+        for (k, v) in &self.state.extra_headers {
+            req = req.header(k.as_str(), v.as_str());
+        }
+        let resp = req.send().await.map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        if !resp.status().is_success() {
+            return Err(RealtimeError::Send(Error::Other(format!("status {}", resp.status()))));
+        }
         Ok(())
     }
     async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
-        use crate::sse::{find_double_newline, parse_sse_block};
         use futures_util::StreamExt;
         loop {
-            if let Some((start, end)) = find_double_newline(&self.state.buf) {
-                let block = self.state.buf[..start].to_vec();
-                self.state.buf.drain(..end);
-                let block_str = String::from_utf8_lossy(&block);
-                let trimmed = block_str.trim();
-                if !trimmed.is_empty() {
-                    if let Some(ev) = parse_sse_block(trimmed) {
-                        if !ev.id.is_empty() {
-                            self.state.last_event_id = Some(ev.id.clone());
-                        }
-                        if ev.retry > 0 {
-                            self.state.retry_hint_ms = ev.retry as u64;
-                        }
-                        return serde_json::from_str(&ev.data)
-                            .map_err(|e| RealtimeError::Recv(Error::Json(e)));
-                    }
+            if let Some(ev) = self.state.pending.pop_front() {
+                if !ev.id.is_empty() {
+                    self.state.last_event_id = Some(ev.id.clone());
                 }
-                continue;
+                if ev.retry > 0 {
+                    self.state.retry_hint_ms = (ev.retry as u64).min(MAX_RECONNECT_DELAY.as_millis() as u64);
+                }
+                return Ok(decode_payload(&ev.data));
             }
             match self.state.byte_stream.next().await {
                 Some(Ok(bytes)) => {
-                    self.state.buf.extend_from_slice(&bytes);
-                }
-                Some(Err(e)) => {
-                    return Err(RealtimeError::Recv(Error::Other(e.to_string())));
-                }
-                None => {
-                    /* stream ended — attempt transport-level reconnect */
-                    self.state.reconnect_attempts += 1;
-                    if self.state.reconnect_attempts >= self.state.max_reconnect_attempts {
-                        return Err(RealtimeError::Closed);
-                    }
-                    let delay_ms = if self.state.retry_hint_ms > 0 {
-                        self.state.retry_hint_ms
-                    } else {
-                        self.state.reconnect_delay_ms
-                    };
-                    tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await;
-                    let reopen_opts = TransportOpts {
-                        last_event_id: self.state.last_event_id.clone(),
-                        headers: self.state.extra_headers.clone(),
-                        max_reconnect_attempts: Some(self.state.max_reconnect_attempts),
-                        reconnect_delay_ms: Some(self.state.reconnect_delay_ms),
-                        ..Default::default()
-                    };
-                    let new_state = build_sse_state(
-                        self.state.url.clone(),
-                        self.state.http_client.clone(),
-                        &reopen_opts,
-                    )
-                    .await
-                    .map_err(|e| RealtimeError::Connect(Error::Other(e.to_string())))?;
-                    self.state.byte_stream = new_state.byte_stream;
-                    self.state.buf.clear();
+                    let events = self.state.parser.feed(&bytes).map_err(RealtimeError::Recv)?;
+                    self.state.pending.extend(events);
                 }
+                Some(Err(e)) => return Err(RealtimeError::Recv(Error::Other(e.to_string()))),
+                None => return Err(RealtimeError::Closed),
             }
         }
     }
@@ -390,84 +354,83 @@ impl Transport for LongpollTransport {
         url: &str,
         opts: &TransportOpts,
     ) -> Result<Box<dyn TransportConn>, RealtimeError> {
-        let client = self
-            .http_client
-            .clone()
-            .or_else(|| opts.http_client.clone())
-            .unwrap_or_else(reqwest::Client::new);
         let state = LongpollState {
-            client,
+            client: pick_client(&self.http_client, opts),
             url: url.to_string(),
             cursor: None,
             pending_events: VecDeque::new(),
             headers: opts.headers.clone(),
-            max_reconnect_attempts: opts.max_reconnect_attempts.unwrap_or(5),
-            reconnect_delay_ms: opts.reconnect_delay_ms.unwrap_or(1000),
-            reconnect_attempts: 0,
         };
         Ok(Box::new(LongpollConn { state }))
     }
 }
 
+fn with_query(url: &str, key: &str, value: &str) -> String {
+    let sep = if url.contains('?') { '&' } else { '?' };
+    format!(
+        "{}{}{}={}",
+        url,
+        sep,
+        crate::runtime::escape_query(key),
+        crate::runtime::escape_query(value)
+    )
+}
+
 #[async_trait::async_trait]
 impl TransportConn for LongpollConn {
     fn kind(&self) -> TransportKind {
         TransportKind::Longpoll
     }
     async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
-        self.state
-            .client
-            .post(self.state.url.as_str())
-            .json(&value)
-            .send()
-            .await
-            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        let mut req = self.state.client.post(self.state.url.as_str()).json(&value);
+        for (k, v) in &self.state.headers {
+            req = req.header(k.as_str(), v.as_str());
+        }
+        let resp = req.send().await.map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))?;
+        if !resp.status().is_success() {
+            return Err(RealtimeError::Send(Error::Other(format!("status {}", resp.status()))));
+        }
         Ok(())
     }
+    /// recv_json returns the next queued event, polling when the queue is empty.
+    /// A failed or non-2xx poll is returned as an error (ResumableConnection backs off).
     async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
         loop {
             if let Some(ev) = self.state.pending_events.pop_front() {
                 return Ok(ev);
             }
             let request_url = match &self.state.cursor {
-                Some(c) => format!("{}?cursor={}", self.state.url, c),
+                Some(c) => with_query(&self.state.url, "cursor", c),
                 None => self.state.url.clone(),
             };
-            let mut req = self.state.client.get(request_url.as_str());
+            let mut req = self.state.client.get(request_url.as_str()).timeout(POLL_TIMEOUT);
             for (k, v) in &self.state.headers {
                 req = req.header(k.as_str(), v.as_str());
             }
-            match req.send().await {
-                Err(e) => {
-                    self.state.reconnect_attempts += 1;
-                    if self.state.reconnect_attempts >= self.state.max_reconnect_attempts {
-                        return Err(RealtimeError::Recv(Error::Other(e.to_string())));
-                    }
-                    tokio::time::sleep(tokio::time::Duration::from_millis(
-                        self.state.reconnect_delay_ms,
-                    ))
-                    .await;
-                }
-                Ok(resp) => {
-                    let bytes = resp
-                        .bytes()
-                        .await
-                        .map_err(|e| RealtimeError::Recv(Error::Other(e.to_string())))?;
-
-                    #[derive(serde::Deserialize)]
-                    struct PollResponse {
-                        #[serde(default)]
-                        events: Vec<serde_json::Value>,
-                        cursor: Option<String>,
+            let resp = req.send().await.map_err(|e| RealtimeError::Recv(Error::Other(e.to_string())))?;
+            if !resp.status().is_success() {
+                return Err(RealtimeError::Recv(Error::Other(format!(
+                    "longpoll status {}",
+                    resp.status()
+                ))));
+            }
+            let bytes = resp.bytes().await.map_err(|e| RealtimeError::Recv(Error::Other(e.to_string())))?;
+            if bytes.is_empty() {
+                continue;
+            }
+            match serde_json::from_slice::<serde_json::Value>(&bytes)
+                .map_err(|e| RealtimeError::Recv(Error::Json(e)))?
+            {
+                serde_json::Value::Array(events) => self.state.pending_events.extend(events),
+                serde_json::Value::Object(mut obj) => {
+                    if let Some(c) = obj.get("cursor").and_then(|c| c.as_str()) {
+                        self.state.cursor = Some(c.to_string());
                     }
-
-                    let parsed: PollResponse = serde_json::from_slice(&bytes)
-                        .map_err(|e| RealtimeError::Recv(Error::Json(e)))?;
-                    self.state.cursor = parsed.cursor;
-                    for ev in parsed.events {
-                        self.state.pending_events.push_back(ev);
+                    if let Some(serde_json::Value::Array(events)) = obj.remove("events") {
+                        self.state.pending_events.extend(events);
                     }
                 }
+                other => self.state.pending_events.push_back(other),
             }
         }
     }
@@ -483,6 +446,10 @@ impl TransportConn for LongpollConn {
 
 /// ResumableConnection is a typed, self-reconnecting realtime channel.
 /// Send/Recv type parameters encode the message types flowing in each direction.
+///
+/// `recv` is cancel-safe with respect to the connection: if a `recv` future is
+/// dropped mid-reconnect (`select!`, `timeout`), the next `recv` or `send`
+/// reopens the chain instead of reporting the connection closed.
 pub struct ResumableConnection<Send, Recv> {
     state: ConnectionState,
     url: String,
@@ -492,6 +459,7 @@ pub struct ResumableConnection<Send, Recv> {
     conn: Option<Box<dyn TransportConn>>,
     proven_index: Option<usize>,
     reconnect_attempts: u32,
+    closed: bool,
     _send: PhantomData<Send>,
     _recv: PhantomData<Recv>,
 }
@@ -509,16 +477,14 @@ where
         transports: Vec<Box<dyn Transport>>,
     ) -> Result<Self, RealtimeError> {
         if transports.is_empty() {
-            return Err(RealtimeError::Connect(Error::Other(
-                "no transports configured".into(),
-            )));
+            return Err(RealtimeError::Connect(Error::Other("no transports configured".into())));
         }
         let transport_opts = TransportOpts {
             reconnect_token: opts.reconnect_token.clone(),
             protocols: opts.protocols.clone(),
             last_event_id: opts.last_event_id.clone(),
             headers: opts.headers.clone(),
-            http_client: None,
+            http_client: opts.http_client.clone(),
             max_reconnect_attempts: opts.max_reconnect_attempts,
             reconnect_delay_ms: opts.reconnect_delay_ms,
         };
@@ -531,6 +497,7 @@ where
             conn: None,
             proven_index: None,
             reconnect_attempts: 0,
+            closed: false,
             _send: PhantomData,
             _recv: PhantomData,
         };
@@ -560,9 +527,7 @@ where
 
     /// proven_transport returns the kind of the last successfully-opened transport.
     pub fn proven_transport(&self) -> Option<TransportKind> {
-        self.proven_index
-            .and_then(|i| self.transports.get(i))
-            .map(|t| t.kind())
+        self.proven_index.and_then(|i| self.transports.get(i)).map(|t| t.kind())
     }
 
     /// current_transport returns the kind of the currently-active transport.
@@ -570,58 +535,52 @@ where
         self.conn.as_ref().map(|c| c.kind())
     }
 
-    /// send serialises a message and writes it to the active transport.
+    /// send serialises a message and writes it to the active transport,
+    /// reopening the chain first if a previous reconnect was interrupted.
     pub async fn send(&mut self, data: &SendMsg) -> Result<(), RealtimeError> {
-        let conn = self.conn.as_mut().ok_or(RealtimeError::Closed)?;
+        self.ensure_open().await?;
         let v = serde_json::to_value(data).map_err(|e| RealtimeError::Send(Error::Json(e)))?;
+        let conn = self.conn.as_mut().ok_or(RealtimeError::Closed)?;
         conn.send_json(v).await
     }
 
-    /// recv reads the next message from the transport and deserialises it.
-    /// On transport failure: invalidates `proven_index`, sleeps `reconnect_delay_ms`,
-    /// re-runs `open_chain()` (full fallback sequence). Mirrors Python `_iter`
-    /// and TS `createResumableConnection`'s recv loop. Gives up after
-    /// `max_reconnect_attempts` attempts and returns the last error.
+    /// recv reads the next message, reconnecting with exponential backoff and
+    /// jitter on transport failure. Gives up after `max_reconnect_attempts`
+    /// consecutive failures and returns the last error.
     pub async fn recv(&mut self) -> Result<RecvMsg, RealtimeError> {
-        let max_attempts = self.opts.max_reconnect_attempts.unwrap_or(5);
-        let delay_ms = self.opts.reconnect_delay_ms.unwrap_or(1000);
         loop {
-            let result = {
-                let conn = self.conn.as_mut().ok_or(RealtimeError::Closed)?;
-                conn.recv_json().await
+            self.ensure_open().await?;
+            let result = match self.conn.as_mut() {
+                Some(conn) => conn.recv_json().await,
+                None => continue,
             };
             match result {
                 Ok(v) => {
                     self.reconnect_attempts = 0;
-                    return serde_json::from_value(v)
-                        .map_err(|e| RealtimeError::Recv(Error::Json(e)));
+                    return serde_json::from_value(v).map_err(|e| RealtimeError::Recv(Error::Json(e)));
                 }
                 Err(err) => {
-                    self.reconnect_attempts += 1;
-                    if max_attempts > 0 && self.reconnect_attempts > max_attempts {
-                        self.state = ConnectionState::Disconnected;
-                        return Err(err);
+                    if self.closed {
+                        return Err(RealtimeError::Closed);
                     }
                     self.state = ConnectionState::Reconnecting;
-                    /* drop the dead conn + invalidate proven so chain retries from the top */
+                    /* drop the dead conn + invalidate proven so the chain retries from the top */
                     if let Some(mut c) = self.conn.take() {
                         let _ = c.close().await;
                     }
                     self.proven_index = None;
-                    if delay_ms > 0 {
-                        tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await;
-                    }
-                    if let Err(open_err) = self.open_chain().await {
+                    if let Err(e) = self.reconnect(err).await {
                         self.state = ConnectionState::Disconnected;
-                        return Err(open_err);
+                        return Err(e);
                     }
                 }
             }
         }
     }
 
-    /// close gracefully shuts down the connection.
+    /// close gracefully shuts down the connection; later calls return Closed.
     pub async fn close(&mut self) -> Result<(), RealtimeError> {
+        self.closed = true;
         if let Some(mut c) = self.conn.take() {
             let _ = c.close().await;
         }
@@ -629,74 +588,115 @@ where
         Ok(())
     }
 
+    async fn ensure_open(&mut self) -> Result<(), RealtimeError> {
+        if self.closed {
+            return Err(RealtimeError::Closed);
+        }
+        if self.conn.is_some() {
+            return Ok(());
+        }
+        /* a reconnect future was dropped mid-way: pick up where it left off */
+        self.state = ConnectionState::Reconnecting;
+        self.reconnect(RealtimeError::Closed).await
+    }
+
+    async fn reconnect(&mut self, mut last: RealtimeError) -> Result<(), RealtimeError> {
+        let max_attempts = self.opts.max_reconnect_attempts.unwrap_or(5);
+        loop {
+            self.reconnect_attempts += 1;
+            if max_attempts > 0 && self.reconnect_attempts > max_attempts {
+                return Err(last);
+            }
+            tokio::time::sleep(self.backoff(self.reconnect_attempts)).await;
+            match self.open_chain().await {
+                Ok(()) => return Ok(()),
+                Err(e) => last = e,
+            }
+        }
+    }
+
+    fn backoff(&self, attempt: u32) -> Duration {
+        let base = Duration::from_millis(self.opts.reconnect_delay_ms.unwrap_or(1000));
+        let mut d = base;
+        for _ in 1..attempt {
+            if d >= MAX_RECONNECT_DELAY {
+                break;
+            }
+            d *= 2;
+        }
+        let d = d.min(MAX_RECONNECT_DELAY);
+        /* jitter in [d/2, d] without a rand dependency */
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|t| t.subsec_nanos() as u64)
+            .unwrap_or(0);
+        let half = d.as_millis() as u64 / 2;
+        Duration::from_millis(half + if half == 0 { 0 } else { nanos % (half + 1) })
+    }
+
     async fn open_chain(&mut self) -> Result<(), RealtimeError> {
-        /* Try proven first if set */
+        let mut order: Vec<usize> = Vec::with_capacity(self.transports.len());
         if let Some(i) = self.proven_index {
-            if let Some(t) = self.transports.get(i) {
-                if let Ok(c) = t.connect(&self.url, &self.transport_opts).await {
-                    self.conn = Some(c);
-                    self.state = ConnectionState::Connected;
-                    return Ok(());
-                }
-            }
+            order.push(i);
         }
-        /* Full chain */
+        order.extend((0..self.transports.len()).filter(|i| Some(*i) != self.proven_index));
         let mut last_err: Option<RealtimeError> = None;
-        for (i, t) in self.transports.iter().enumerate() {
-            match t.connect(&self.url, &self.transport_opts).await {
-                Ok(c) => {
+        for i in order {
+            let Some(t) = self.transports.get(i) else { continue };
+            match tokio::time::timeout(OPEN_TIMEOUT, t.connect(&self.url, &self.transport_opts)).await {
+                Ok(Ok(c)) => {
                     self.conn = Some(c);
                     self.proven_index = Some(i);
                     self.state = ConnectionState::Connected;
                     return Ok(());
                 }
-                Err(e) => last_err = Some(e),
+                Ok(Err(e)) => last_err = Some(e),
+                Err(_) => last_err = Some(connect_err("transport open timed out")),
             }
         }
-        Err(last_err.unwrap_or(RealtimeError::Connect(Error::Other(
-            "all transports failed".into(),
-        ))))
+        Err(last_err.unwrap_or(RealtimeError::Connect(Error::Other("all transports failed".into()))))
     }
-
 }
 
+/// build_sse_state opens the stream; a non-2xx status or a non-event-stream
+/// content type is a connect error, so the chain moves on.
 async fn build_sse_state(
     url: String,
     http_client: reqwest::Client,
     opts: &TransportOpts,
-) -> Result<SseState, reqwest::Error> {
-    let mut req_builder = http_client
-        .get(url.as_str())
-        .header("Accept", "text/event-stream");
+) -> Result<SseState, RealtimeError> {
+    let mut req_builder = http_client.get(url.as_str()).header("Accept", "text/event-stream");
     if let Some(ref last_event_id) = opts.last_event_id {
         req_builder = req_builder.header("Last-Event-ID", last_event_id.as_str());
     }
     for (k, v) in &opts.headers {
         req_builder = req_builder.header(k.as_str(), v.as_str());
     }
-    if !opts
-        .headers
-        .keys()
-        .any(|k| k.eq_ignore_ascii_case("x-request-id"))
-    {
+    if !opts.headers.keys().any(|k| k.eq_ignore_ascii_case("x-request-id")) {
         req_builder = req_builder.header("x-request-id", uuid::Uuid::new_v4().to_string());
     }
-    let resp = req_builder.send().await?;
-    let reconnect_delay_ms = opts.reconnect_delay_ms.unwrap_or(1000);
-    let max_reconnect_attempts = opts.max_reconnect_attempts.unwrap_or(5);
-    let last_event_id = opts.last_event_id.clone();
-    let extra_headers = opts.headers.clone();
+    let resp = req_builder.send().await.map_err(connect_err)?;
+    if !resp.status().is_success() {
+        return Err(connect_err(format!("sse status {}", resp.status())));
+    }
+    let is_event_stream = resp
+        .headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|v| v.to_str().ok())
+        .map(|v| v.to_ascii_lowercase().starts_with("text/event-stream"))
+        .unwrap_or(false);
+    if !is_event_stream {
+        return Err(connect_err("sse response is not text/event-stream"));
+    }
     let byte_stream: ByteStream = Box::pin(resp.bytes_stream());
     Ok(SseState {
         byte_stream,
-        buf: Vec::new(),
-        last_event_id,
-        retry_hint_ms: reconnect_delay_ms,
+        last_event_id: opts.last_event_id.clone(),
+        retry_hint_ms: opts.reconnect_delay_ms.unwrap_or(1000),
+        parser: SseParser::new(),
+        pending: VecDeque::new(),
         http_client,
         url,
-        extra_headers,
-        max_reconnect_attempts,
-        reconnect_delay_ms,
-        reconnect_attempts: 0,
+        extra_headers: opts.headers.clone(),
     })
 }