@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/client-rust/realtime.rs

@@ -1,702 +0,0 @@
-/* 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.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TransportKind {
-    Ws,
-    Sse,
-    Longpoll,
-}
-
-/// ConnectionState mirrors the TS client's connection lifecycle.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ConnectionState {
-    Connecting,
-    Connected,
-    Reconnecting,
-    Disconnected,
-}
-
-/// RealtimeError wraps realtime-specific error variants.
-#[derive(Debug)]
-pub enum RealtimeError {
-    Connect(Error),
-    Send(Error),
-    Recv(Error),
-    Closed,
-    NotImplemented(String),
-}
-
-impl std::fmt::Display for RealtimeError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            RealtimeError::Connect(e) => write!(f, "connect error: {e}"),
-            RealtimeError::Send(e) => write!(f, "send error: {e}"),
-            RealtimeError::Recv(e) => write!(f, "recv error: {e}"),
-            RealtimeError::Closed => write!(f, "connection closed"),
-            RealtimeError::NotImplemented(s) => write!(f, "not implemented: {s}"),
-        }
-    }
-}
-
-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>,
-    pub protocols: Option<Vec<String>>,
-    pub max_reconnect_attempts: Option<u32>,
-    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`.
-/// Mirrors TS `TransportOpts`; `http_client` lets SSE / longpoll adapters share a pool.
-#[derive(Debug, Clone, Default)]
-pub struct TransportOpts {
-    pub reconnect_token: Option<String>,
-    pub protocols: Option<Vec<String>>,
-    pub last_event_id: Option<String>,
-    pub headers: HashMap<String, String>,
-    pub http_client: Option<reqwest::Client>,
-    pub max_reconnect_attempts: Option<u32>,
-    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 connection.
-pub struct SseState {
-    pub byte_stream: ByteStream,
-    pub last_event_id: Option<String>,
-    pub retry_hint_ms: u64,
-    parser: SseParser,
-    pending: VecDeque<crate::sse::SseEvent>,
-    http_client: reqwest::Client,
-    url: String,
-    extra_headers: HashMap<String, String>,
-}
-
-/// 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>,
-}
-
-/// TransportConn is the live per-transport connection.
-/// Each built-in adapter returns its own impl (`WsConn`, `SseConn`, `LongpollConn`).
-/// Send-only (not Sync): SSE's byte stream is a `Pin<Box<dyn Stream + Send>>`,
-/// exclusive owned access via `&mut self` is sufficient — no cross-thread sharing needed.
-#[async_trait::async_trait]
-pub trait TransportConn: Send {
-    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError>;
-    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError>;
-    async fn close(&mut self) -> Result<(), RealtimeError>;
-    fn kind(&self) -> TransportKind;
-}
-
-/// Transport is the pluggable adapter trait. Consumers can swap in their own
-/// WS / SSE / longpoll impls by implementing this.
-#[async_trait::async_trait]
-pub trait Transport: Send + Sync + 'static {
-    fn name(&self) -> &'static str;
-    fn kind(&self) -> TransportKind;
-    async fn connect(
-        &self,
-        url: &str,
-        opts: &TransportOpts,
-    ) -> 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                                                         */
-/* ------------------------------------------------------------------ */
-
-/// WsTransport dials a WebSocket via tokio-tungstenite.
-#[derive(Debug, Default)]
-pub struct WsTransport;
-
-/// WsConn is the live WS connection returned by [`WsTransport::connect`].
-pub struct WsConn {
-    /* WsStream is ~1384 bytes; box to flatten */
-    stream: Box<WsStream>,
-}
-
-#[async_trait::async_trait]
-impl Transport for WsTransport {
-    fn name(&self) -> &'static str {
-        "ws"
-    }
-    fn kind(&self) -> TransportKind {
-        TransportKind::Ws
-    }
-    async fn connect(
-        &self,
-        url: &str,
-        opts: &TransportOpts,
-    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
-        use tokio_tungstenite::tungstenite::client::IntoClientRequest;
-        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(|_| connect_err("invalid protocol header"))?,
-                );
-            }
-        }
-        for (k, v) in &opts.headers {
-            if let (Ok(name), Ok(val)) = (
-                tokio_tungstenite::tungstenite::http::HeaderName::from_bytes(k.as_bytes()),
-                v.parse::<tokio_tungstenite::tungstenite::http::HeaderValue>(),
-            ) {
-                req.headers_mut().insert(name, val);
-            }
-        }
-        let (stream, _) = tokio_tungstenite::connect_async(req).await.map_err(connect_err)?;
-        Ok(Box::new(WsConn { stream: Box::new(stream) }))
-    }
-}
-
-#[async_trait::async_trait]
-impl TransportConn for WsConn {
-    fn kind(&self) -> TransportKind {
-        TransportKind::Ws
-    }
-    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_string(&value).map_err(|e| RealtimeError::Send(Error::Json(e)))?;
-        self.stream
-            .send(Message::Text(encoded))
-            .await
-            .map_err(|e| RealtimeError::Send(Error::Other(e.to_string())))
-    }
-    async fn recv_json(&mut self) -> Result<serde_json::Value, RealtimeError> {
-        use futures_util::StreamExt;
-        use tokio_tungstenite::tungstenite::Message;
-        loop {
-            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 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 */
-            }
-        }
-    }
-    async fn close(&mut self) -> Result<(), RealtimeError> {
-        use futures_util::SinkExt;
-        use tokio_tungstenite::tungstenite::protocol::CloseFrame;
-        use tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode;
-        let frame = CloseFrame { code: CloseCode::Normal, reason: "client close".into() };
-        self.stream
-            .send(tokio_tungstenite::tungstenite::Message::Close(Some(frame)))
-            .await
-            .ok();
-        Ok(())
-    }
-}
-
-/* ------------------------------------------------------------------ */
-/*  SSE adapter                                                        */
-/* ------------------------------------------------------------------ */
-
-/// SseTransport opens a GET / text-event-stream using reqwest.
-#[derive(Debug, Default)]
-pub struct SseTransport {
-    pub http_client: Option<reqwest::Client>,
-}
-
-/// 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 {
-        "sse"
-    }
-    fn kind(&self) -> TransportKind {
-        TransportKind::Sse
-    }
-    async fn connect(
-        &self,
-        url: &str,
-        opts: &TransportOpts,
-    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
-        let client = pick_client(&self.http_client, opts);
-        let state = build_sse_state(url.to_string(), client, opts).await?;
-        Ok(Box::new(SseConn { state }))
-    }
-}
-
-#[async_trait::async_trait]
-impl TransportConn for SseConn {
-    fn kind(&self) -> TransportKind {
-        TransportKind::Sse
-    }
-    async fn send_json(&mut self, value: serde_json::Value) -> Result<(), RealtimeError> {
-        /* 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 futures_util::StreamExt;
-        loop {
-            if let Some(ev) = self.state.pending.pop_front() {
-                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).min(MAX_RECONNECT_DELAY.as_millis() as u64);
-                }
-                return Ok(decode_payload(&ev.data));
-            }
-            match self.state.byte_stream.next().await {
-                Some(Ok(bytes)) => {
-                    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),
-            }
-        }
-    }
-    async fn close(&mut self) -> Result<(), RealtimeError> {
-        /* reqwest stream is dropped with self; nothing to do explicitly. */
-        Ok(())
-    }
-}
-
-/* ------------------------------------------------------------------ */
-/*  Longpoll adapter                                                   */
-/* ------------------------------------------------------------------ */
-
-/// LongpollTransport opens a long-poll GET loop using reqwest.
-#[derive(Debug, Default)]
-pub struct LongpollTransport {
-    pub http_client: Option<reqwest::Client>,
-}
-
-/// LongpollConn is the live longpoll connection returned by [`LongpollTransport::connect`].
-pub struct LongpollConn {
-    state: LongpollState,
-}
-
-#[async_trait::async_trait]
-impl Transport for LongpollTransport {
-    fn name(&self) -> &'static str {
-        "longpoll"
-    }
-    fn kind(&self) -> TransportKind {
-        TransportKind::Longpoll
-    }
-    async fn connect(
-        &self,
-        url: &str,
-        opts: &TransportOpts,
-    ) -> Result<Box<dyn TransportConn>, RealtimeError> {
-        let state = LongpollState {
-            client: pick_client(&self.http_client, opts),
-            url: url.to_string(),
-            cursor: None,
-            pending_events: VecDeque::new(),
-            headers: opts.headers.clone(),
-        };
-        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> {
-        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) => with_query(&self.state.url, "cursor", c),
-                None => self.state.url.clone(),
-            };
-            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());
-            }
-            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());
-                    }
-                    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),
-            }
-        }
-    }
-    async fn close(&mut self) -> Result<(), RealtimeError> {
-        /* no persistent connection to tear down */
-        Ok(())
-    }
-}
-
-/* ------------------------------------------------------------------ */
-/*  ResumableConnection                                                */
-/* ------------------------------------------------------------------ */
-
-/// 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,
-    opts: ResumableConnectionOpts,
-    transport_opts: TransportOpts,
-    transports: Vec<Box<dyn Transport>>,
-    conn: Option<Box<dyn TransportConn>>,
-    proven_index: Option<usize>,
-    reconnect_attempts: u32,
-    closed: bool,
-    _send: PhantomData<Send>,
-    _recv: PhantomData<Recv>,
-}
-
-impl<SendMsg, RecvMsg> ResumableConnection<SendMsg, RecvMsg>
-where
-    SendMsg: Serialize,
-    RecvMsg: DeserializeOwned,
-{
-    /// connect tries each transport in order, memoizes the first that succeeds,
-    /// and returns the active ResumableConnection.
-    pub async fn connect(
-        url: String,
-        opts: ResumableConnectionOpts,
-        transports: Vec<Box<dyn Transport>>,
-    ) -> Result<Self, RealtimeError> {
-        if transports.is_empty() {
-            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: opts.http_client.clone(),
-            max_reconnect_attempts: opts.max_reconnect_attempts,
-            reconnect_delay_ms: opts.reconnect_delay_ms,
-        };
-        let mut rc = ResumableConnection {
-            state: ConnectionState::Connecting,
-            url,
-            opts,
-            transport_opts,
-            transports,
-            conn: None,
-            proven_index: None,
-            reconnect_attempts: 0,
-            closed: false,
-            _send: PhantomData,
-            _recv: PhantomData,
-        };
-        rc.open_chain().await?;
-        Ok(rc)
-    }
-
-    /// connect_with_defaults builds the canonical transport chain
-    /// `[WsTransport, SseTransport, LongpollTransport]` and calls [`Self::connect`].
-    /// Convenience entry point for consumers that don't need a custom chain.
-    pub async fn connect_with_defaults(
-        url: String,
-        opts: ResumableConnectionOpts,
-    ) -> Result<Self, RealtimeError> {
-        let transports: Vec<Box<dyn Transport>> = vec![
-            Box::new(WsTransport),
-            Box::new(SseTransport::default()),
-            Box::new(LongpollTransport::default()),
-        ];
-        Self::connect(url, opts, transports).await
-    }
-
-    /// state returns the current connection lifecycle state.
-    pub fn state(&self) -> &ConnectionState {
-        &self.state
-    }
-
-    /// 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())
-    }
-
-    /// current_transport returns the kind of the currently-active transport.
-    pub fn current_transport(&self) -> Option<TransportKind> {
-        self.conn.as_ref().map(|c| c.kind())
-    }
-
-    /// 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> {
-        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, 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> {
-        loop {
-            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)));
-                }
-                Err(err) => {
-                    if self.closed {
-                        return Err(RealtimeError::Closed);
-                    }
-                    self.state = ConnectionState::Reconnecting;
-                    /* 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 let Err(e) = self.reconnect(err).await {
-                        self.state = ConnectionState::Disconnected;
-                        return Err(e);
-                    }
-                }
-            }
-        }
-    }
-
-    /// 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;
-        }
-        self.state = ConnectionState::Disconnected;
-        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> {
-        let mut order: Vec<usize> = Vec::with_capacity(self.transports.len());
-        if let Some(i) = self.proven_index {
-            order.push(i);
-        }
-        order.extend((0..self.transports.len()).filter(|i| Some(*i) != self.proven_index));
-        let mut last_err: Option<RealtimeError> = None;
-        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(());
-                }
-                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()))))
-    }
-}
-
-/// 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, 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")) {
-        req_builder = req_builder.header("x-request-id", uuid::Uuid::new_v4().to_string());
-    }
-    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,
-        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: opts.headers.clone(),
-    })
-}