Provide a way to get blobs as a stream of bytes

[rklaehn]

This is currently already possible via export_bao, but it is a bit convoluted since you need to ignore some of the data.

This should be a stream of Result<Bytes, E> where E is Intoio::Error so it can be used with hyper etc. easily.

[vmx]

That would be really appreciated. I've put together some demo locally that can do a streaming download from iroh from a browser. The browser streams expect a channel to get the data from.

I post the code (not cleaned up) below, so that you can an idea in case it influences the API. Though I think a stream of Result<Bytes, E> should be good.

use wasm_streams::{readable::sys::ReadableStream as JsReadableStream, ReadableStream};
…
    pub async fn download(&self, ticket: String) -> Result<JsReadableStream, JsError> {
        let ticket: BlobTicket = ticket.parse().map_err(to_js_err)?;
        let connection = self.0.endpoint().connect(ticket.addr().id, iroh_blobs::ALPN).await?;
        let mut progress = iroh_blobs::get::request::get_blob(connection, ticket.hash());

        let (mut tx, rx) = mpsc::channel::<Result<JsValue, JsValue>>(1);

        loop {
            match progress.next().await {
                Some(GetBlobItem::Item(item)) => match item {
                    BaoContentItem::Leaf(leaf) => {
                        println!("vmx: data received: {:?}", &leaf.data);
                        tracing::info!("vmx: data received: {:?}", &leaf.data);
                        let js_value = Uint8Array::from(&leaf.data[..]).into();
                        tx.try_send(Ok(js_value)).unwrap();
                    }
                    BaoContentItem::Parent(parent) => {
                        tracing::info!("Parent: {parent:?}");
                    }
                },
                Some(GetBlobItem::Done(stats)) => {
                    println!("vmx: stats: {:?}", stats);
                    break
                }
                Some(GetBlobItem::Error(err)) => {
                    return Err(anyhow!("Error while streaming blob: {err}")).map_err(to_js_err);
                }
                None => {
                    return Err(anyhow!("Stream ended unexpectedly.")).map_err(to_js_err);
                }
            }
        }

        let output_stream = ReadableStream::from_stream(rx).into_raw();
        Ok(output_stream)
    }