fixed the wasm websocket compile

crates/jacquard-common/src/stream.rs

···
 
 use std::error::Error;
 use std::fmt;
+use std::pin::Pin;
 
 /// Boxed error type for streaming operations
 pub type BoxError = Box<dyn Error + Send + Sync + 'static>;
···
 
 /// Platform-agnostic byte sink abstraction
 pub struct ByteSink {
-    inner: Box<dyn n0_future::Sink<Bytes, Error = StreamError>>,
+    inner: Pin<Box<dyn n0_future::Sink<Bytes, Error = StreamError>>>,
 }
 
 impl ByteSink {
···
         S: n0_future::Sink<Bytes, Error = StreamError> + 'static,
     {
         Self {
-            inner: Box::new(sink),
+            inner: Box::pin(sink),
         }
     }
 
     /// Convert into the inner boxed sink
-    pub fn into_inner(self) -> Box<dyn n0_future::Sink<Bytes, Error = StreamError>> {
+    pub fn into_inner(self) -> Pin<Box<dyn n0_future::Sink<Bytes, Error = StreamError>>> {
         self.inner
     }
 }

crates/jacquard-common/src/websocket.rs

···
 use crate::stream::StreamError;
 use bytes::Bytes;
 use n0_future::Stream;
-use n0_future::stream::Boxed;
 use std::borrow::Borrow;
 use std::fmt::{self, Display};
 use std::future::Future;
 use std::ops::Deref;
+use std::pin::Pin;
 use url::Url;
 
 /// UTF-8 validated bytes for WebSocket text messages
···
 }
 
 /// WebSocket message stream
-pub struct WsStream(Boxed<Result<WsMessage, StreamError>>);
+#[cfg(not(target_arch = "wasm32"))]
+pub struct WsStream(Pin<Box<dyn Stream<Item = Result<WsMessage, StreamError>> + Send>>);
+
+/// WebSocket message stream
+#[cfg(target_arch = "wasm32")]
+pub struct WsStream(Pin<Box<dyn Stream<Item = Result<WsMessage, StreamError>>>>);
 
 impl WsStream {
     /// Create a new message stream
···
     }
 
     /// Convert into the inner pinned boxed stream
-    pub fn into_inner(self) -> Boxed<Result<WsMessage, StreamError>> {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn into_inner(self) -> Pin<Box<dyn Stream<Item = Result<WsMessage, StreamError>> + Send>> {
+        self.0
+    }
+
+    /// Convert into the inner pinned boxed stream
+    #[cfg(target_arch = "wasm32")]
+    pub fn into_inner(self) -> Pin<Box<dyn Stream<Item = Result<WsMessage, StreamError>>>> {
         self.0
     }
 
···
 }
 
 /// WebSocket message sink
-pub struct WsSink(Box<dyn n0_future::Sink<WsMessage, Error = StreamError>>);
+#[cfg(not(target_arch = "wasm32"))]
+pub struct WsSink(Pin<Box<dyn n0_future::Sink<WsMessage, Error = StreamError> + Send>>);
+
+/// WebSocket message sink
+#[cfg(target_arch = "wasm32")]
+pub struct WsSink(Pin<Box<dyn n0_future::Sink<WsMessage, Error = StreamError>>>);
 
 impl WsSink {
     /// Create a new message sink
+    #[cfg(not(target_arch = "wasm32"))]
     pub fn new<S>(sink: S) -> Self
     where
         S: n0_future::Sink<WsMessage, Error = StreamError> + Send + 'static,
     {
-        Self(Box::new(sink))
+        Self(Box::pin(sink))
+    }
+
+    /// Create a new message sink
+    #[cfg(target_arch = "wasm32")]
+    pub fn new<S>(sink: S) -> Self
+    where
+        S: n0_future::Sink<WsMessage, Error = StreamError> + 'static,
+    {
+        Self(Box::pin(sink))
+    }
+
+    /// Convert into the inner boxed sink
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn into_inner(
+        self,
+    ) -> Pin<Box<dyn n0_future::Sink<WsMessage, Error = StreamError> + Send>> {
+        self.0
     }
 
     /// Convert into the inner boxed sink
-    pub fn into_inner(self) -> Box<dyn n0_future::Sink<WsMessage, Error = StreamError>> {
+    #[cfg(target_arch = "wasm32")]
+    pub fn into_inner(self) -> Pin<Box<dyn n0_future::Sink<WsMessage, Error = StreamError>>> {
         self.0
     }
 }

crates/jacquard-common/src/xrpc/subscription.rs

···
 //! This module defines traits and types for typed WebSocket subscriptions,
 //! mirroring the request/response pattern used for HTTP XRPC endpoints.
 
+#[cfg(not(target_arch = "wasm32"))]
 use n0_future::stream::Boxed;
+#[cfg(target_arch = "wasm32")]
+use n0_future::stream::BoxedLocal as Boxed;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
 use std::future::Future;
···
 
         let (tx, rx) = self.connection.split();
 
+        #[cfg(not(target_arch = "wasm32"))]
         let stream = match S::ENCODING {
             MessageEncoding::Json => rx
                 .into_inner()
···
                 .boxed(),
         };
 
+        #[cfg(target_arch = "wasm32")]
+        let stream = match S::ENCODING {
+            MessageEncoding::Json => rx
+                .into_inner()
+                .filter_map(|msg| decode_json_msg::<S>(msg))
+                .boxed_local(),
+            MessageEncoding::DagCbor => rx
+                .into_inner()
+                .filter_map(|msg| decode_cbor_msg::<S>(msg))
+                .boxed_local(),
+        };
+
         (tx, stream)
     }
 
···
             serde_ipld_dagcbor::from_slice(bytes)
         }
 
+        #[cfg(not(target_arch = "wasm32"))]
         let stream = match S::ENCODING {
             MessageEncoding::Json => rx
                 .into_inner()
···
                 .boxed(),
         };
 
+        #[cfg(target_arch = "wasm32")]
+        let stream = match S::ENCODING {
+            MessageEncoding::Json => rx
+                .into_inner()
+                .filter_map(|msg_result| match msg_result {
+                    Ok(WsMessage::Text(text)) => Some(
+                        parse_msg(text.as_ref())
+                            .map(|v| v.into_static())
+                            .map_err(StreamError::decode),
+                    ),
+                    Ok(WsMessage::Binary(bytes)) => {
+                        #[cfg(feature = "zstd")]
+                        {
+                            match decompress_zstd(&bytes) {
+                                Ok(decompressed) => Some(
+                                    parse_msg(&decompressed)
+                                        .map(|v| v.into_static())
+                                        .map_err(StreamError::decode),
+                                ),
+                                Err(_) => Some(
+                                    parse_msg(&bytes)
+                                        .map(|v| v.into_static())
+                                        .map_err(StreamError::decode),
+                                ),
+                            }
+                        }
+                        #[cfg(not(feature = "zstd"))]
+                        {
+                            Some(
+                                parse_msg(&bytes)
+                                    .map(|v| v.into_static())
+                                    .map_err(StreamError::decode),
+                            )
+                        }
+                    }
+                    Ok(WsMessage::Close(_)) => Some(Err(StreamError::closed())),
+                    Err(e) => Some(Err(e)),
+                })
+                .boxed_local(),
+            MessageEncoding::DagCbor => rx
+                .into_inner()
+                .filter_map(|msg_result| match msg_result {
+                    Ok(WsMessage::Binary(bytes)) => Some(
+                        parse_cbor(&bytes)
+                            .map(|v| v.into_static())
+                            .map_err(|e| StreamError::decode(crate::error::DecodeError::from(e))),
+                    ),
+                    Ok(WsMessage::Text(_)) => Some(Err(StreamError::wrong_message_format(
+                        "expected binary frame for CBOR, got text",
+                    ))),
+                    Ok(WsMessage::Close(_)) => Some(Err(StreamError::closed())),
+                    Err(e) => Some(Err(e)),
+                })
+                .boxed_local(),
+        };
+
         (tx, stream)
     }
 
···
             serde_ipld_dagcbor::from_slice(bytes)
         }
 
+        #[cfg(not(target_arch = "wasm32"))]
         let stream = match S::ENCODING {
             MessageEncoding::Json => rx
                 .into_inner()
···
                 .boxed(),
         };
 
+        #[cfg(target_arch = "wasm32")]
+        let stream = match S::ENCODING {
+            MessageEncoding::Json => rx
+                .into_inner()
+                .filter_map(|msg_result| match msg_result {
+                    Ok(WsMessage::Text(text)) => Some(
+                        parse_msg(text.as_ref())
+                            .map(|v| v.into_static())
+                            .map_err(StreamError::decode),
+                    ),
+                    Ok(WsMessage::Binary(bytes)) => {
+                        #[cfg(feature = "zstd")]
+                        {
+                            match decompress_zstd(&bytes) {
+                                Ok(decompressed) => Some(
+                                    parse_msg(&decompressed)
+                                        .map(|v| v.into_static())
+                                        .map_err(StreamError::decode),
+                                ),
+                                Err(_) => Some(
+                                    parse_msg(&bytes)
+                                        .map(|v| v.into_static())
+                                        .map_err(StreamError::decode),
+                                ),
+                            }
+                        }
+                        #[cfg(not(feature = "zstd"))]
+                        {
+                            Some(
+                                parse_msg(&bytes)
+                                    .map(|v| v.into_static())
+                                    .map_err(StreamError::decode),
+                            )
+                        }
+                    }
+                    Ok(WsMessage::Close(_)) => Some(Err(StreamError::closed())),
+                    Err(e) => Some(Err(e)),
+                })
+                .boxed_local(),
+            MessageEncoding::DagCbor => rx
+                .into_inner()
+                .filter_map(|msg_result| match msg_result {
+                    Ok(WsMessage::Binary(bytes)) => Some(
+                        parse_cbor(&bytes)
+                            .map(|v| v.into_static())
+                            .map_err(|e| StreamError::decode(crate::error::DecodeError::from(e))),
+                    ),
+                    Ok(WsMessage::Text(_)) => Some(Err(StreamError::wrong_message_format(
+                        "expected binary frame for CBOR, got text",
+                    ))),
+                    Ok(WsMessage::Close(_)) => Some(Err(StreamError::closed())),
+                    Err(e) => Some(Err(e)),
+                })
+                .boxed_local(),
+        };
+
         (tx, stream)
     }
 
···
         // Put the raw stream back
         *rx = raw_rx;
 
-        match S::ENCODING {
+        #[cfg(not(target_arch = "wasm32"))]
+        let stream = match S::ENCODING {
             MessageEncoding::Json => typed_rx_source
                 .into_inner()
                 .filter_map(|msg| decode_json_msg::<S>(msg))
···
                 .into_inner()
                 .filter_map(|msg| decode_cbor_msg::<S>(msg))
                 .boxed(),
-        }
+        };
+
+        #[cfg(target_arch = "wasm32")]
+        let stream = match S::ENCODING {
+            MessageEncoding::Json => typed_rx_source
+                .into_inner()
+                .filter_map(|msg| decode_json_msg::<S>(msg))
+                .boxed_local(),
+            MessageEncoding::DagCbor => typed_rx_source
+                .into_inner()
+                .filter_map(|msg| decode_cbor_msg::<S>(msg))
+                .boxed_local(),
+        };
+        stream
     }
 }
 

crates/jacquard/Cargo.toml

···
     "jacquard-api/streaming",
 ]
 websocket = ["jacquard-common/websocket"]
+zstd = ["jacquard-common/zstd"]
 
 [[example]]
 name = "oauth_timeline"

examples/subscribe_jetstream.rs

···
     let client = TungsteniteSubscriptionClient::from_base_uri(base_url);
 
     // Subscribe with no filters (firehose mode)
-    let mut params_builder = JetstreamParams::new();
-
     // Enable compression if zstd feature is available
     #[cfg(feature = "zstd")]
-    {
-        params_builder = params_builder.compress(true);
-    }
+    let params = { JetstreamParams::new().compress(true).build() };
 
-    let params = params_builder.build();
+    #[cfg(not(feature = "zstd"))]
+    let params = { JetstreamParams::new().build() };
+
     let stream = client.subscribe(&params).await.into_diagnostic()?;
 
     println!("Connected! Streaming messages (Ctrl-C to stop)...\n");

justfile

···
 
 # Check that jacquard-common compiles for wasm32
 check-wasm:
-    cargo build --target wasm32-unknown-unknown -p jacquard-common --no-default-features
+    cargo build --target wasm32-unknown-unknown -p jacquard-common --no-default-features --features websocket
 
 # Run 'cargo run' on the project
 run *ARGS: