wasmtime 36.0.0 → 36.0.1

data/ext/cargo-vendor/wasmtime-wasi-io-36.0.0/Cargo.toml

@@ -1,104 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2024"
-rust-version = "1.86.0"
-name = "wasmtime-wasi-io"
-version = "36.0.0"
-authors = ["The Wasmtime Project Developers"]
-build = false
-autolib = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = "wasi-io common traits to be shared among other wasi implementations"
-readme = false
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-resolver = "2"
-
-[features]
-default = ["std"]
-std = [
-    "bytes/std",
-    "anyhow/std",
-    "wasmtime/std",
-]
-
-[lib]
-name = "wasmtime_wasi_io"
-path = "src/lib.rs"
-
-[dependencies.anyhow]
-version = "1.0.93"
-default-features = false
-
-[dependencies.async-trait]
-version = "0.1.71"
-
-[dependencies.bytes]
-version = "1.4"
-default-features = false
-
-[dependencies.futures]
-version = "0.3.27"
-default-features = false
-
-[dependencies.wasmtime]
-version = "36.0.0"
-features = [
-    "component-model",
-    "async",
-    "runtime",
-]
-default-features = false
-
-[lints.clippy]
-allow_attributes_without_reason = "warn"
-clone_on_copy = "warn"
-from_over_into = "warn"
-manual_strip = "warn"
-map_clone = "warn"
-redundant_field_names = "warn"
-uninlined_format_args = "warn"
-unnecessary_cast = "warn"
-unnecessary_fallible_conversions = "warn"
-unnecessary_mut_passed = "warn"
-unnecessary_to_owned = "warn"
-useless_conversion = "warn"
-
-[lints.clippy.all]
-level = "allow"
-priority = -1
-
-[lints.rust]
-trivial_numeric_casts = "warn"
-unstable_features = "warn"
-unused-lifetimes = "warn"
-unused-macro-rules = "warn"
-unused_extern_crates = "warn"
-unused_import_braces = "warn"
-
-[lints.rust.unexpected_cfgs]
-level = "warn"
-priority = 0
-check-cfg = [
-    "cfg(pulley_tail_calls)",
-    "cfg(pulley_assume_llvm_makes_tail_calls)",
-    "cfg(pulley_disable_interp_simd)",
-]

data/ext/cargo-vendor/wasmtime-wasi-io-36.0.0/src/impls.rs

@@ -1,290 +0,0 @@
-use crate::bindings::wasi::io::{error, poll, streams};
-use crate::poll::{DynFuture, DynPollable, MakeFuture, subscribe};
-use crate::streams::{DynInputStream, DynOutputStream, StreamError, StreamResult};
-use alloc::collections::BTreeMap;
-use alloc::string::String;
-use alloc::vec::Vec;
-use anyhow::{Result, anyhow};
-use core::future::Future;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use wasmtime::component::{Resource, ResourceTable};
-
-impl poll::Host for ResourceTable {
-    async fn poll(&mut self, pollables: Vec<Resource<DynPollable>>) -> Result<Vec<u32>> {
-        type ReadylistIndex = u32;
-
-        if pollables.is_empty() {
-            return Err(anyhow!("empty poll list"));
-        }
-
-        let mut table_futures: BTreeMap<u32, (MakeFuture, Vec<ReadylistIndex>)> = BTreeMap::new();
-
-        for (ix, p) in pollables.iter().enumerate() {
-            let ix: u32 = ix.try_into()?;
-
-            let pollable = self.get(p)?;
-            let (_, list) = table_futures
-                .entry(pollable.index)
-                .or_insert((pollable.make_future, Vec::new()));
-            list.push(ix);
-        }
-
-        let mut futures: Vec<(DynFuture<'_>, Vec<ReadylistIndex>)> = Vec::new();
-        for (entry, (make_future, readylist_indices)) in self.iter_entries(table_futures) {
-            let entry = entry?;
-            futures.push((make_future(entry), readylist_indices));
-        }
-
-        struct PollList<'a> {
-            futures: Vec<(DynFuture<'a>, Vec<ReadylistIndex>)>,
-        }
-        impl<'a> Future for PollList<'a> {
-            type Output = Vec<u32>;
-
-            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-                let mut any_ready = false;
-                let mut results = Vec::new();
-                for (fut, readylist_indicies) in self.futures.iter_mut() {
-                    match fut.as_mut().poll(cx) {
-                        Poll::Ready(()) => {
-                            results.extend_from_slice(readylist_indicies);
-                            any_ready = true;
-                        }
-                        Poll::Pending => {}
-                    }
-                }
-                if any_ready {
-                    Poll::Ready(results)
-                } else {
-                    Poll::Pending
-                }
-            }
-        }
-
-        Ok(PollList { futures }.await)
-    }
-}
-
-impl crate::bindings::wasi::io::poll::HostPollable for ResourceTable {
-    async fn block(&mut self, pollable: Resource<DynPollable>) -> Result<()> {
-        let pollable = self.get(&pollable)?;
-        let ready = (pollable.make_future)(self.get_any_mut(pollable.index)?);
-        ready.await;
-        Ok(())
-    }
-    async fn ready(&mut self, pollable: Resource<DynPollable>) -> Result<bool> {
-        let pollable = self.get(&pollable)?;
-        let ready = (pollable.make_future)(self.get_any_mut(pollable.index)?);
-        futures::pin_mut!(ready);
-        Ok(matches!(
-            futures::future::poll_immediate(ready).await,
-            Some(())
-        ))
-    }
-    fn drop(&mut self, pollable: Resource<DynPollable>) -> Result<()> {
-        let pollable = self.delete(pollable)?;
-        if let Some(delete) = pollable.remove_index_on_delete {
-            delete(self, pollable.index)?;
-        }
-        Ok(())
-    }
-}
-
-impl error::Host for ResourceTable {}
-
-impl streams::Host for ResourceTable {
-    fn convert_stream_error(&mut self, err: StreamError) -> Result<streams::StreamError> {
-        match err {
-            StreamError::Closed => Ok(streams::StreamError::Closed),
-            StreamError::LastOperationFailed(e) => {
-                Ok(streams::StreamError::LastOperationFailed(self.push(e)?))
-            }
-            StreamError::Trap(e) => Err(e),
-        }
-    }
-}
-
-impl error::HostError for ResourceTable {
-    fn drop(&mut self, err: Resource<streams::Error>) -> Result<()> {
-        self.delete(err)?;
-        Ok(())
-    }
-
-    fn to_debug_string(&mut self, err: Resource<streams::Error>) -> Result<String> {
-        Ok(alloc::format!("{:?}", self.get(&err)?))
-    }
-}
-
-impl streams::HostOutputStream for ResourceTable {
-    async fn drop(&mut self, stream: Resource<DynOutputStream>) -> Result<()> {
-        self.delete(stream)?.cancel().await;
-        Ok(())
-    }
-
-    fn check_write(&mut self, stream: Resource<DynOutputStream>) -> StreamResult<u64> {
-        let bytes = self.get_mut(&stream)?.check_write()?;
-        Ok(bytes as u64)
-    }
-
-    fn write(&mut self, stream: Resource<DynOutputStream>, bytes: Vec<u8>) -> StreamResult<()> {
-        self.get_mut(&stream)?.write(bytes.into())?;
-        Ok(())
-    }
-
-    fn subscribe(&mut self, stream: Resource<DynOutputStream>) -> Result<Resource<DynPollable>> {
-        subscribe(self, stream)
-    }
-
-    async fn blocking_write_and_flush(
-        &mut self,
-        stream: Resource<DynOutputStream>,
-        bytes: Vec<u8>,
-    ) -> StreamResult<()> {
-        if bytes.len() > 4096 {
-            return Err(StreamError::trap(
-                "Buffer too large for blocking-write-and-flush (expected at most 4096)",
-            ));
-        }
-
-        self.get_mut(&stream)?
-            .blocking_write_and_flush(bytes.into())
-            .await
-    }
-
-    async fn blocking_write_zeroes_and_flush(
-        &mut self,
-        stream: Resource<DynOutputStream>,
-        len: u64,
-    ) -> StreamResult<()> {
-        if len > 4096 {
-            return Err(StreamError::trap(
-                "Buffer too large for blocking-write-zeroes-and-flush (expected at most 4096)",
-            ));
-        }
-
-        self.get_mut(&stream)?
-            .blocking_write_zeroes_and_flush(len as usize)
-            .await
-    }
-
-    fn write_zeroes(&mut self, stream: Resource<DynOutputStream>, len: u64) -> StreamResult<()> {
-        self.get_mut(&stream)?.write_zeroes(len as usize)?;
-        Ok(())
-    }
-
-    fn flush(&mut self, stream: Resource<DynOutputStream>) -> StreamResult<()> {
-        self.get_mut(&stream)?.flush()?;
-        Ok(())
-    }
-
-    async fn blocking_flush(&mut self, stream: Resource<DynOutputStream>) -> StreamResult<()> {
-        let s = self.get_mut(&stream)?;
-        s.flush()?;
-        s.write_ready().await?;
-        Ok(())
-    }
-
-    fn splice(
-        &mut self,
-        dest: Resource<DynOutputStream>,
-        src: Resource<DynInputStream>,
-        len: u64,
-    ) -> StreamResult<u64> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-
-        let permit = {
-            let output = self.get_mut(&dest)?;
-            output.check_write()?
-        };
-        let len = len.min(permit);
-        if len == 0 {
-            return Ok(0);
-        }
-
-        let contents = self.get_mut(&src)?.read(len)?;
-
-        let len = contents.len();
-        if len == 0 {
-            return Ok(0);
-        }
-
-        let output = self.get_mut(&dest)?;
-        output.write(contents)?;
-        Ok(len.try_into().expect("usize can fit in u64"))
-    }
-
-    async fn blocking_splice(
-        &mut self,
-        dest: Resource<DynOutputStream>,
-        src: Resource<DynInputStream>,
-        len: u64,
-    ) -> StreamResult<u64> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-
-        let permit = {
-            let output = self.get_mut(&dest)?;
-            output.write_ready().await?
-        };
-        let len = len.min(permit);
-        if len == 0 {
-            return Ok(0);
-        }
-
-        let contents = self.get_mut(&src)?.blocking_read(len).await?;
-
-        let len = contents.len();
-        if len == 0 {
-            return Ok(0);
-        }
-
-        let output = self.get_mut(&dest)?;
-        output.blocking_write_and_flush(contents).await?;
-        Ok(len.try_into().expect("usize can fit in u64"))
-    }
-}
-
-impl streams::HostInputStream for ResourceTable {
-    async fn drop(&mut self, stream: Resource<DynInputStream>) -> Result<()> {
-        self.delete(stream)?.cancel().await;
-        Ok(())
-    }
-
-    fn read(&mut self, stream: Resource<DynInputStream>, len: u64) -> StreamResult<Vec<u8>> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-        let bytes = self.get_mut(&stream)?.read(len)?;
-        debug_assert!(bytes.len() <= len);
-        Ok(bytes.into())
-    }
-
-    async fn blocking_read(
-        &mut self,
-        stream: Resource<DynInputStream>,
-        len: u64,
-    ) -> StreamResult<Vec<u8>> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-        let bytes = self.get_mut(&stream)?.blocking_read(len).await?;
-        debug_assert!(bytes.len() <= len);
-        Ok(bytes.into())
-    }
-
-    fn skip(&mut self, stream: Resource<DynInputStream>, len: u64) -> StreamResult<u64> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-        let written = self.get_mut(&stream)?.skip(len)?;
-        Ok(written.try_into().expect("usize always fits in u64"))
-    }
-
-    async fn blocking_skip(
-        &mut self,
-        stream: Resource<DynInputStream>,
-        len: u64,
-    ) -> StreamResult<u64> {
-        let len = len.try_into().unwrap_or(usize::MAX);
-        let written = self.get_mut(&stream)?.blocking_skip(len).await?;
-        Ok(written.try_into().expect("usize always fits in u64"))
-    }
-
-    fn subscribe(&mut self, stream: Resource<DynInputStream>) -> Result<Resource<DynPollable>> {
-        crate::poll::subscribe(self, stream)
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-io-36.0.0/src/streams.rs

@@ -1,312 +0,0 @@
-use crate::poll::Pollable;
-use alloc::boxed::Box;
-use anyhow::Result;
-use bytes::Bytes;
-
-/// `Pollable::ready()` for `InputStream` and `OutputStream` may return
-/// prematurely due to `io::ErrorKind::WouldBlock`.
-///
-/// To ensure that `blocking_` functions return a valid non-empty result,
-/// we use a loop with a maximum iteration limit.
-///
-/// This constant defines the maximum number of loop attempts allowed.
-const MAX_BLOCKING_ATTEMPTS: u8 = 10;
-
-/// Host trait for implementing the `wasi:io/streams.input-stream` resource: A
-/// bytestream which can be read from.
-#[async_trait::async_trait]
-pub trait InputStream: Pollable {
-    /// Reads up to `size` bytes, returning a buffer holding these bytes on
-    /// success.
-    ///
-    /// This function does not block the current thread and is the equivalent of
-    /// a non-blocking read. On success all bytes read are returned through
-    /// `Bytes`, which is no larger than the `size` provided. If the returned
-    /// list of `Bytes` is empty then no data is ready to be read at this time.
-    ///
-    /// # Errors
-    ///
-    /// The [`StreamError`] return value communicates when this stream is
-    /// closed, when a read fails, or when a trap should be generated.
-    fn read(&mut self, size: usize) -> StreamResult<Bytes>;
-
-    /// Similar to `read`, except that it blocks until at least one byte can be
-    /// read.
-    async fn blocking_read(&mut self, size: usize) -> StreamResult<Bytes> {
-        if size == 0 {
-            self.ready().await;
-            return self.read(size);
-        }
-
-        let mut i = 0;
-        loop {
-            // This `ready` call may return prematurely due to `io::ErrorKind::WouldBlock`.
-            self.ready().await;
-            let data = self.read(size)?;
-            if !data.is_empty() {
-                return Ok(data);
-            }
-            if i >= MAX_BLOCKING_ATTEMPTS {
-                return Err(StreamError::trap("max blocking attempts exceeded"));
-            }
-            i += 1;
-        }
-    }
-
-    /// Same as the `read` method except that bytes are skipped.
-    ///
-    /// Note that this method is non-blocking like `read` and returns the same
-    /// errors.
-    fn skip(&mut self, nelem: usize) -> StreamResult<usize> {
-        let bs = self.read(nelem)?;
-        Ok(bs.len())
-    }
-
-    /// Similar to `skip`, except that it blocks until at least one byte can be
-    /// skipped.
-    async fn blocking_skip(&mut self, nelem: usize) -> StreamResult<usize> {
-        let bs = self.blocking_read(nelem).await?;
-        Ok(bs.len())
-    }
-
-    /// Cancel any asynchronous work and wait for it to wrap up.
-    async fn cancel(&mut self) {}
-}
-
-/// Representation of the `error` resource type in the `wasi:io/error`
-/// interface.
-///
-/// This is currently `anyhow::Error` to retain full type information for
-/// errors.
-pub type Error = anyhow::Error;
-
-pub type StreamResult<T> = Result<T, StreamError>;
-
-#[derive(Debug)]
-pub enum StreamError {
-    Closed,
-    LastOperationFailed(anyhow::Error),
-    Trap(anyhow::Error),
-}
-
-impl StreamError {
-    pub fn trap(msg: &str) -> StreamError {
-        StreamError::Trap(anyhow::anyhow!("{msg}"))
-    }
-}
-
-impl alloc::fmt::Display for StreamError {
-    fn fmt(&self, f: &mut alloc::fmt::Formatter<'_>) -> alloc::fmt::Result {
-        match self {
-            StreamError::Closed => write!(f, "closed"),
-            StreamError::LastOperationFailed(e) => write!(f, "last operation failed: {e}"),
-            StreamError::Trap(e) => write!(f, "trap: {e}"),
-        }
-    }
-}
-
-impl core::error::Error for StreamError {
-    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
-        match self {
-            StreamError::Closed => None,
-            StreamError::LastOperationFailed(e) | StreamError::Trap(e) => e.source(),
-        }
-    }
-}
-
-impl From<wasmtime::component::ResourceTableError> for StreamError {
-    fn from(error: wasmtime::component::ResourceTableError) -> Self {
-        Self::Trap(error.into())
-    }
-}
-
-/// Host trait for implementing the `wasi:io/streams.output-stream` resource:
-/// A bytestream which can be written to.
-#[async_trait::async_trait]
-pub trait OutputStream: Pollable {
-    /// Write bytes after obtaining a permit to write those bytes
-    ///
-    /// Prior to calling [`write`](Self::write) the caller must call
-    /// [`check_write`](Self::check_write), which resolves to a non-zero permit
-    ///
-    /// This method must never block.  The [`check_write`](Self::check_write)
-    /// permit indicates the maximum amount of bytes that are permitted to be
-    /// written in a single [`write`](Self::write) following the
-    /// [`check_write`](Self::check_write) resolution.
-    ///
-    /// # Errors
-    ///
-    /// Returns a [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
-    fn write(&mut self, bytes: Bytes) -> StreamResult<()>;
-
-    /// Trigger a flush of any bytes buffered in this stream implementation.
-    ///
-    /// This method may be called at any time and must never block.
-    ///
-    /// After this method is called, [`check_write`](Self::check_write) must
-    /// pend until flush is complete.
-    ///
-    /// When [`check_write`](Self::check_write) becomes ready after a flush,
-    /// that guarantees that all prior writes have been flushed from the
-    /// implementation successfully, or that any error associated with those
-    /// writes is reported in the return value of [`flush`](Self::flush) or
-    /// [`check_write`](Self::check_write)
-    ///
-    /// # Errors
-    ///
-    /// Returns a [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
-    fn flush(&mut self) -> StreamResult<()>;
-
-    /// Returns the number of bytes that are ready to be written to this stream.
-    ///
-    /// Zero bytes indicates that this stream is not currently ready for writing
-    /// and `ready()` must be awaited first.
-    ///
-    /// Note that this method does not block.
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    fn check_write(&mut self) -> StreamResult<usize>;
-
-    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
-    /// until all of these operations are complete, or an error occurs.
-    ///
-    /// This is a convenience wrapper around the use of `check-write`,
-    /// `subscribe`, `write`, and `flush`, and is implemented with the
-    /// following pseudo-code:
-    ///
-    /// ```text
-    /// let pollable = this.subscribe();
-    /// while !contents.is_empty() {
-    ///     // Wait for the stream to become writable
-    ///     pollable.block();
-    ///     let Ok(n) = this.check-write(); // eliding error handling
-    ///     let len = min(n, contents.len());
-    ///     let (chunk, rest) = contents.split_at(len);
-    ///     this.write(chunk  );            // eliding error handling
-    ///     contents = rest;
-    /// }
-    /// this.flush();
-    /// // Wait for completion of `flush`
-    /// pollable.block();
-    /// // Check for any errors that arose during `flush`
-    /// let _ = this.check-write();         // eliding error handling
-    /// ```
-    async fn blocking_write_and_flush(&mut self, mut bytes: Bytes) -> StreamResult<()> {
-        loop {
-            let permit = self.write_ready().await?;
-            let len = bytes.len().min(permit);
-            let chunk = bytes.split_to(len);
-            self.write(chunk)?;
-            if bytes.is_empty() {
-                break;
-            }
-        }
-
-        // If the stream encounters an error, return it, but if the stream
-        // has become closed, do not.
-        match self.flush() {
-            Ok(_) => {}
-            Err(StreamError::Closed) => {}
-            Err(e) => Err(e)?,
-        };
-        match self.write_ready().await {
-            Ok(_) => {}
-            Err(StreamError::Closed) => {}
-            Err(e) => Err(e)?,
-        };
-
-        Ok(())
-    }
-
-    /// Repeatedly write a byte to a stream.
-    /// Important: this write must be non-blocking!
-    /// Returning an Err which downcasts to a [`StreamError`] will be
-    /// reported to Wasm as the empty error result. Otherwise, errors will trap.
-    fn write_zeroes(&mut self, nelem: usize) -> StreamResult<()> {
-        // TODO: We could optimize this to not allocate one big zeroed buffer, and instead write
-        // repeatedly from a 'static buffer of zeros.
-        let bs = Bytes::from_iter(core::iter::repeat(0).take(nelem));
-        self.write(bs)?;
-        Ok(())
-    }
-
-    /// Perform a write of up to 4096 zeroes, and then flush the stream.
-    /// Block until all of these operations are complete, or an error
-    /// occurs.
-    ///
-    /// This is a convenience wrapper around the use of `check-write`,
-    /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
-    /// the following pseudo-code:
-    ///
-    /// ```text
-    /// let pollable = this.subscribe();
-    /// while num_zeroes != 0 {
-    ///     // Wait for the stream to become writable
-    ///     pollable.block();
-    ///     let Ok(n) = this.check-write(); // eliding error handling
-    ///     let len = min(n, num_zeroes);
-    ///     this.write-zeroes(len);         // eliding error handling
-    ///     num_zeroes -= len;
-    /// }
-    /// this.flush();
-    /// // Wait for completion of `flush`
-    /// pollable.block();
-    /// // Check for any errors that arose during `flush`
-    /// let _ = this.check-write();         // eliding error handling
-    /// ```
-    async fn blocking_write_zeroes_and_flush(&mut self, nelem: usize) -> StreamResult<()> {
-        // TODO: We could optimize this to not allocate one big zeroed buffer, and instead write
-        // repeatedly from a 'static buffer of zeros.
-        let bs = Bytes::from_iter(core::iter::repeat(0).take(nelem));
-        self.blocking_write_and_flush(bs).await
-    }
-
-    /// Simultaneously waits for this stream to be writable and then returns how
-    /// much may be written or the last error that happened.
-    async fn write_ready(&mut self) -> StreamResult<usize> {
-        let mut i = 0;
-        loop {
-            // This `ready` call may return prematurely due to `io::ErrorKind::WouldBlock`.
-            self.ready().await;
-            let n = self.check_write()?;
-            if n > 0 {
-                return Ok(n);
-            }
-            if i >= MAX_BLOCKING_ATTEMPTS {
-                return Err(StreamError::trap("max blocking attempts exceeded"));
-            }
-            i += 1;
-        }
-    }
-
-    /// Cancel any asynchronous work and wait for it to wrap up.
-    async fn cancel(&mut self) {}
-}
-
-#[async_trait::async_trait]
-impl Pollable for Box<dyn OutputStream> {
-    async fn ready(&mut self) {
-        (**self).ready().await
-    }
-}
-
-#[async_trait::async_trait]
-impl Pollable for Box<dyn InputStream> {
-    async fn ready(&mut self) {
-        (**self).ready().await
-    }
-}
-
-pub type DynInputStream = Box<dyn InputStream>;
-
-pub type DynOutputStream = Box<dyn OutputStream>;