html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/tokio/tests/uds_stream.rs

@@ -0,0 +1,446 @@
+#![cfg(feature = "full")]
+#![warn(rust_2018_idioms)]
+#![cfg(unix)]
+#![cfg(not(miri))] // No socket in miri.
+
+use std::io;
+#[cfg(target_os = "android")]
+use std::os::android::net::SocketAddrExt;
+#[cfg(target_os = "linux")]
+use std::os::linux::net::SocketAddrExt;
+use std::task::Poll;
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt, Interest};
+use tokio::net::{UnixListener, UnixStream};
+use tokio_test::{assert_ok, assert_pending, assert_ready_ok, task};
+
+use futures::future::{poll_fn, try_join};
+
+#[tokio::test]
+async fn accept_read_write() -> std::io::Result<()> {
+    let dir = tempfile::Builder::new()
+        .prefix("tokio-uds-tests")
+        .tempdir()
+        .unwrap();
+    let sock_path = dir.path().join("connect.sock");
+
+    let listener = UnixListener::bind(&sock_path)?;
+
+    let accept = listener.accept();
+    let connect = UnixStream::connect(&sock_path);
+    let ((mut server, _), mut client) = try_join(accept, connect).await?;
+
+    // Write to the client.
+    client.write_all(b"hello").await?;
+    drop(client);
+
+    // Read from the server.
+    let mut buf = vec![];
+    server.read_to_end(&mut buf).await?;
+    assert_eq!(&buf, b"hello");
+    let len = server.read(&mut buf).await?;
+    assert_eq!(len, 0);
+    Ok(())
+}
+
+#[tokio::test]
+async fn shutdown() -> std::io::Result<()> {
+    let dir = tempfile::Builder::new()
+        .prefix("tokio-uds-tests")
+        .tempdir()
+        .unwrap();
+    let sock_path = dir.path().join("connect.sock");
+
+    let listener = UnixListener::bind(&sock_path)?;
+
+    let accept = listener.accept();
+    let connect = UnixStream::connect(&sock_path);
+    let ((mut server, _), mut client) = try_join(accept, connect).await?;
+
+    // Shut down the client
+    AsyncWriteExt::shutdown(&mut client).await?;
+    // Read from the server should return 0 to indicate the channel has been closed.
+    let mut buf = [0u8; 1];
+    let n = server.read(&mut buf).await?;
+    assert_eq!(n, 0);
+    Ok(())
+}
+
+#[tokio::test]
+async fn try_read_write() -> std::io::Result<()> {
+    let msg = b"hello world";
+
+    let dir = tempfile::tempdir()?;
+    let bind_path = dir.path().join("bind.sock");
+
+    // Create listener
+    let listener = UnixListener::bind(&bind_path)?;
+
+    // Create socket pair
+    let client = UnixStream::connect(&bind_path).await?;
+
+    let (server, _) = listener.accept().await?;
+    let mut written = msg.to_vec();
+
+    // Track the server receiving data
+    let mut readable = task::spawn(server.readable());
+    assert_pending!(readable.poll());
+
+    // Write data.
+    client.writable().await?;
+    assert_eq!(msg.len(), client.try_write(msg)?);
+
+    // The task should be notified
+    while !readable.is_woken() {
+        tokio::task::yield_now().await;
+    }
+
+    // Fill the write buffer using non-vectored I/O
+    loop {
+        // Still ready
+        let mut writable = task::spawn(client.writable());
+        assert_ready_ok!(writable.poll());
+
+        match client.try_write(msg) {
+            Ok(n) => written.extend(&msg[..n]),
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                break;
+            }
+            Err(e) => panic!("error = {e:?}"),
+        }
+    }
+
+    {
+        // Write buffer full
+        let mut writable = task::spawn(client.writable());
+        assert_pending!(writable.poll());
+
+        // Drain the socket from the server end using non-vectored I/O
+        let mut read = vec![0; written.len()];
+        let mut i = 0;
+
+        while i < read.len() {
+            server.readable().await?;
+
+            match server.try_read(&mut read[i..]) {
+                Ok(n) => i += n,
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                Err(e) => panic!("error = {e:?}"),
+            }
+        }
+
+        assert_eq!(read, written);
+    }
+
+    written.clear();
+    client.writable().await.unwrap();
+
+    // Fill the write buffer using vectored I/O
+    let msg_bufs: Vec<_> = msg.chunks(3).map(io::IoSlice::new).collect();
+    loop {
+        // Still ready
+        let mut writable = task::spawn(client.writable());
+        assert_ready_ok!(writable.poll());
+
+        match client.try_write_vectored(&msg_bufs) {
+            Ok(n) => written.extend(&msg[..n]),
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                break;
+            }
+            Err(e) => panic!("error = {e:?}"),
+        }
+    }
+
+    {
+        // Write buffer full
+        let mut writable = task::spawn(client.writable());
+        assert_pending!(writable.poll());
+
+        // Drain the socket from the server end using vectored I/O
+        let mut read = vec![0; written.len()];
+        let mut i = 0;
+
+        while i < read.len() {
+            server.readable().await?;
+
+            let mut bufs: Vec<_> = read[i..]
+                .chunks_mut(0x10000)
+                .map(io::IoSliceMut::new)
+                .collect();
+            match server.try_read_vectored(&mut bufs) {
+                Ok(n) => i += n,
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                Err(e) => panic!("error = {e:?}"),
+            }
+        }
+
+        assert_eq!(read, written);
+    }
+
+    // Now, we listen for shutdown
+    drop(client);
+
+    loop {
+        let ready = server.ready(Interest::READABLE).await?;
+
+        if ready.is_read_closed() {
+            break;
+        } else {
+            tokio::task::yield_now().await;
+        }
+    }
+
+    Ok(())
+}
+
+async fn create_pair() -> (UnixStream, UnixStream) {
+    let dir = assert_ok!(tempfile::tempdir());
+    let bind_path = dir.path().join("bind.sock");
+
+    let listener = assert_ok!(UnixListener::bind(&bind_path));
+
+    let accept = listener.accept();
+    let connect = UnixStream::connect(&bind_path);
+    let ((server, _), client) = assert_ok!(try_join(accept, connect).await);
+
+    (client, server)
+}
+
+macro_rules! assert_readable_by_polling {
+    ($stream:expr) => {
+        assert_ok!(poll_fn(|cx| $stream.poll_read_ready(cx)).await);
+    };
+}
+
+macro_rules! assert_not_readable_by_polling {
+    ($stream:expr) => {
+        poll_fn(|cx| {
+            assert_pending!($stream.poll_read_ready(cx));
+            Poll::Ready(())
+        })
+        .await;
+    };
+}
+
+macro_rules! assert_writable_by_polling {
+    ($stream:expr) => {
+        assert_ok!(poll_fn(|cx| $stream.poll_write_ready(cx)).await);
+    };
+}
+
+macro_rules! assert_not_writable_by_polling {
+    ($stream:expr) => {
+        poll_fn(|cx| {
+            assert_pending!($stream.poll_write_ready(cx));
+            Poll::Ready(())
+        })
+        .await;
+    };
+}
+
+#[tokio::test]
+async fn poll_read_ready() {
+    let (mut client, mut server) = create_pair().await;
+
+    // Initial state - not readable.
+    assert_not_readable_by_polling!(server);
+
+    // There is data in the buffer - readable.
+    assert_ok!(client.write_all(b"ping").await);
+    assert_readable_by_polling!(server);
+
+    // Readable until calls to `poll_read` return `Poll::Pending`.
+    let mut buf = [0u8; 4];
+    assert_ok!(server.read_exact(&mut buf).await);
+    assert_readable_by_polling!(server);
+    read_until_pending(&mut server);
+    assert_not_readable_by_polling!(server);
+
+    // Detect the client disconnect.
+    drop(client);
+    assert_readable_by_polling!(server);
+}
+
+#[tokio::test]
+async fn poll_write_ready() {
+    let (mut client, server) = create_pair().await;
+
+    // Initial state - writable.
+    assert_writable_by_polling!(client);
+
+    // No space to write - not writable.
+    write_until_pending(&mut client);
+    assert_not_writable_by_polling!(client);
+
+    // Detect the server disconnect.
+    drop(server);
+    assert_writable_by_polling!(client);
+}
+
+fn read_until_pending(stream: &mut UnixStream) {
+    let mut buf = vec![0u8; 1024 * 1024];
+    loop {
+        match stream.try_read(&mut buf) {
+            Ok(_) => (),
+            Err(err) => {
+                assert_eq!(err.kind(), io::ErrorKind::WouldBlock);
+                break;
+            }
+        }
+    }
+}
+
+fn write_until_pending(stream: &mut UnixStream) {
+    let buf = vec![0u8; 1024 * 1024];
+    loop {
+        match stream.try_write(&buf) {
+            Ok(_) => (),
+            Err(err) => {
+                assert_eq!(err.kind(), io::ErrorKind::WouldBlock);
+                break;
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn try_read_buf() -> std::io::Result<()> {
+    let msg = b"hello world";
+
+    let dir = tempfile::tempdir()?;
+    let bind_path = dir.path().join("bind.sock");
+
+    // Create listener
+    let listener = UnixListener::bind(&bind_path)?;
+
+    // Create socket pair
+    let client = UnixStream::connect(&bind_path).await?;
+
+    let (server, _) = listener.accept().await?;
+    let mut written = msg.to_vec();
+
+    // Track the server receiving data
+    let mut readable = task::spawn(server.readable());
+    assert_pending!(readable.poll());
+
+    // Write data.
+    client.writable().await?;
+    assert_eq!(msg.len(), client.try_write(msg)?);
+
+    // The task should be notified
+    while !readable.is_woken() {
+        tokio::task::yield_now().await;
+    }
+
+    // Fill the write buffer
+    loop {
+        // Still ready
+        let mut writable = task::spawn(client.writable());
+        assert_ready_ok!(writable.poll());
+
+        match client.try_write(msg) {
+            Ok(n) => written.extend(&msg[..n]),
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                break;
+            }
+            Err(e) => panic!("error = {e:?}"),
+        }
+    }
+
+    {
+        // Write buffer full
+        let mut writable = task::spawn(client.writable());
+        assert_pending!(writable.poll());
+
+        // Drain the socket from the server end
+        let mut read = Vec::with_capacity(written.len());
+        let mut i = 0;
+
+        while i < read.capacity() {
+            server.readable().await?;
+
+            match server.try_read_buf(&mut read) {
+                Ok(n) => i += n,
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => continue,
+                Err(e) => panic!("error = {e:?}"),
+            }
+        }
+
+        assert_eq!(read, written);
+    }
+
+    // Now, we listen for shutdown
+    drop(client);
+
+    loop {
+        let ready = server.ready(Interest::READABLE).await?;
+
+        if ready.is_read_closed() {
+            break;
+        } else {
+            tokio::task::yield_now().await;
+        }
+    }
+
+    Ok(())
+}
+
+// https://github.com/tokio-rs/tokio/issues/3879
+#[tokio::test]
+#[cfg(not(target_os = "macos"))]
+async fn epollhup() -> io::Result<()> {
+    let dir = tempfile::Builder::new()
+        .prefix("tokio-uds-tests")
+        .tempdir()
+        .unwrap();
+    let sock_path = dir.path().join("connect.sock");
+
+    let listener = UnixListener::bind(&sock_path)?;
+    let connect = UnixStream::connect(&sock_path);
+    tokio::pin!(connect);
+
+    // Poll `connect` once.
+    poll_fn(|cx| {
+        use std::future::Future;
+
+        assert_pending!(connect.as_mut().poll(cx));
+        Poll::Ready(())
+    })
+    .await;
+
+    drop(listener);
+
+    let err = connect.await.unwrap_err();
+    let errno = err.kind();
+    assert!(
+        // As far as I can tell, whether we see ECONNREFUSED or ECONNRESET here
+        // seems relatively inconsistent, at least on non-Linux operating
+        // systems. The difference in meaning between these errnos is not
+        // particularly well-defined, so let's just accept either.
+        matches!(
+            errno,
+            io::ErrorKind::ConnectionRefused | io::ErrorKind::ConnectionReset
+        ),
+        "unexpected error kind: {errno:?} (expected ConnectionRefused or ConnectionReset)"
+    );
+    Ok(())
+}
+
+// test for https://github.com/tokio-rs/tokio/issues/6767
+#[tokio::test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+async fn abstract_socket_name() {
+    let socket_path = "\0aaa";
+    let listener = UnixListener::bind(socket_path).unwrap();
+
+    let accept = listener.accept();
+    let connect = UnixStream::connect(&socket_path);
+
+    let ((stream, _), _) = try_join(accept, connect).await.unwrap();
+
+    let local_addr = stream.into_std().unwrap().local_addr().unwrap();
+    let abstract_path_name = local_addr.as_abstract_name().unwrap();
+
+    // `as_abstract_name` removes leading zero bytes
+    assert_eq!(abstract_path_name, b"aaa");
+}

data/rust-vendor/tokio/tests/unwindsafe.rs

@@ -0,0 +1,42 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+
+use std::panic::{RefUnwindSafe, UnwindSafe};
+
+#[test]
+fn notify_is_unwind_safe() {
+    is_unwind_safe::<tokio::sync::Notify>();
+}
+
+#[test]
+fn join_handle_is_unwind_safe() {
+    is_unwind_safe::<tokio::task::JoinHandle<()>>();
+}
+
+#[test]
+fn net_types_are_unwind_safe() {
+    is_unwind_safe::<tokio::net::TcpListener>();
+    is_unwind_safe::<tokio::net::TcpSocket>();
+    is_unwind_safe::<tokio::net::TcpStream>();
+    is_unwind_safe::<tokio::net::UdpSocket>();
+}
+
+#[test]
+#[cfg(unix)]
+fn unix_net_types_are_unwind_safe() {
+    is_unwind_safe::<tokio::net::UnixDatagram>();
+    is_unwind_safe::<tokio::net::UnixListener>();
+    is_unwind_safe::<tokio::net::UnixStream>();
+}
+
+#[test]
+#[cfg(windows)]
+fn windows_net_types_are_unwind_safe() {
+    use tokio::net::windows::named_pipe::NamedPipeClient;
+    use tokio::net::windows::named_pipe::NamedPipeServer;
+
+    is_unwind_safe::<NamedPipeClient>();
+    is_unwind_safe::<NamedPipeServer>();
+}
+
+fn is_unwind_safe<T: UnwindSafe + RefUnwindSafe>() {}

data/rust-vendor/wasip2/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{".cargo_vcs_info.json":"009488b807b23328fe46f6eef637e16f791a3bb01e494bcbfc27767fa4558e59","Cargo.lock":"f71a2db991e963e3d670e63af583f67808a5c8110dbc143ca43f9ea5561f3189","Cargo.toml":"e44ba1682361d605e5e5549b0ffc3bac73694c9d0b137f67209c657b30e29806","Cargo.toml.orig":"064c751923c59463e2587ee85890cac5eca5059714087d62a95151df23e2bdf6","README.md":"b768b011583d6c3f7d47c57de28f7dd9ade631b286753435ae1ae9acab6ce557","examples/cli-command-no_std.rs":"56f3f5d08affa4f2211cbdcdf4ec865981502aaa5cdccbffb0b2084736330430","examples/cli-command.rs":"1e84ceae7a33d9c9e9340651b086f155d138eeb9d375c6a1678e3d282f3b668a","examples/hello-world-no_std.rs":"a0b3581ea43e8a1588de8619dee70ddb48a2360e84ef7c9c21b9d6cfbe350dda","examples/hello-world.rs":"634b4999d89675ffad329eea3eb006fad935806895507e0c3e7d770681a9089d","examples/http-proxy-no_std.rs":"9969f8c9747739be697329c563e32c352961655c600eedafb2fac11589216443","examples/http-proxy.rs":"a31e4c31203860ab96da3ca176ca99db7b88ea513ca7a20cc8955a57794367bc","src/command.rs":"3a74ae964950195610dc1b3bd1d669bcd903c23888f7356d476f1dadb796ea9f","src/ext/mod.rs":"4bc79c71442ac6c55dc4f8a0632b6d6805c0c9c74b22b56791a483ae447dac0c","src/ext/std.rs":"c35fd8bdafd24a6adef4f5a27e8e4bb421b0e50cebfe350868ded43980b1a06e","src/imports.rs":"b29d63727fd01b43e723b6ad5c41f8902f66927ceae366181f4a267949490f6a","src/lib.rs":"2db558cb84747a1178155997ff55c4cf87972a9fd0fdb7f0ed1c04f1c97d9f47","src/proxy.rs":"639a98c734bf2f2ee363b9cdf16c5534fda7fc7c9373652ef681f24c472fdd43","wit/deps/cli/command.wit":"f729a20e99a4601f90677e31a16e63f24ee32eef062b9305e94419428c8ff70b","wit/deps/cli/environment.wit":"5e58cd47b162e9f004bc9224a29c2ec3cf9e1a3d4c910154ce53742f828af91f","wit/deps/cli/exit.wit":"a0fae6014751dc95f45b1dbe530b7f4db99d5bd607ed8bbf879b22a906f4514c","wit/deps/cli/imports.wit":"a576c17e15ece40fe29eaeb73f416d6f46ac639f512d51ad20bb915b4686a4dd","wit/deps/cli/run.wit":"a7df5376da8230e0509fffbb8355641af0765cc5cff8064bbe58fef1cbbe63c1","wit/deps/cli/stdio.wit":"bc6e5e55963d9c49b91d9880d8e50e44a718c5a7b7211bb8cb5d4fcd552b13a8","wit/deps/cli/terminal.wit":"fc87cd0bc3f76ff7181d3666617a38ee10239f8e0344db2a52cb79f46c6b2d31","wit/deps/clocks/monotonic-clock.wit":"ab12521f4522c7bae48fb272fc90f7bf21f83bc3e6b86e400075826628fdcf23","wit/deps/clocks/timezone.wit":"aaabf8145758aa75222a5e18de29a912d5ebb5babc348884fd81b1fa90225adc","wit/deps/clocks/wall-clock.wit":"b7b63d7bbb6631bcc8ce7d25910d47308e6345104dc146513b76ff1d82e1d7a0","wit/deps/clocks/world.wit":"5f066526b320973195e083bc946874b36fc488f8ae5004119c9b5dcd83430660","wit/deps/filesystem/preopens.wit":"1c53bbc639e87efc67440332e186bcc617f1ab0f2a9789c339a69ed0da424358","wit/deps/filesystem/types.wit":"24413900954e7ca1438f3c9b326a6f799b748beab51a297ab687003578f66765","wit/deps/filesystem/world.wit":"70f31a63ada7aeb6be29380aae712406baf91dad72e73de39025e38f41a32cae","wit/deps/http/handler.wit":"1f66174b4058b102367e69ce8aa657b3e9dbc767f6ade960108faaa1731f0945","wit/deps/http/proxy.wit":"c8756768c033db884734f98858b0d448a3a2cb98d9e4584c705f1fc0418422f1","wit/deps/http/types.wit":"82ac209d799643a39309c40d108a9594bebb79312f383ffcf284f23011041e7e","wit/deps/io/error.wit":"ea8a48ed6aa970947f65e378a2e72b878b421d0594b5425349d1c033a138533f","wit/deps/io/poll.wit":"d6eafcf78f220dfc07c4f055019732cc30c526d6d0d0b24150325c5eeef5d041","wit/deps/io/streams.wit":"d4b8980637de85e47459a0144dc1a9b999bfcbfb6ab344f0eceadc5face6135b","wit/deps/io/world.wit":"5572ef45d90cd766282c171a6cc403b3b9567b73e63a413c4eba1b4ad05caf25","wit/deps/random/insecure-seed.wit":"466da73f3aa1065083dd15ffd1d55c8e69b6ec4dfc6c9c149e651a126f60f33c","wit/deps/random/insecure.wit":"0a132cde99268a502973ca112db9da45c0c32870c67d6b92bd3110636c1cd871","wit/deps/random/random.wit":"cebb42f292bada460ab424bb56caf392ad14d4d7dfae1b85dfbc55253c1b751f","wit/deps/random/world.wit":"7d825a7a1624f4a165f6c7abc9aaa77e25618a9fed0c56461df8826965920dc2","wit/deps/sockets/instance-network.wit":"1e4a5d97df44421503a169e1d514eca2cf160f545c44d320ce8a82f726a40cf8","wit/deps/sockets/ip-name-lookup.wit":"c87cc003ff2b92a0d74294418e0d62d12f42f913b94617f73cc09738a46e8fac","wit/deps/sockets/network.wit":"077f76c2f266b3211b0e3fbddf4fbfd9060be050954d44aad9b331419fbe3caf","wit/deps/sockets/tcp-create-socket.wit":"96a6a1a93b859127ee60273f0a77cda8d60930f7952174fb22469293b5da6a3a","wit/deps/sockets/tcp.wit":"ad16e21cae8b67e09f6541fafaf57c88242722871aced8e53aaf018ee63be086","wit/deps/sockets/udp-create-socket.wit":"c52b9bf91ef4e30e7ec08ad1fc9e77ef005a0a87648c5d2e416dd6e35369f08c","wit/deps/sockets/udp.wit":"b8cd7720349cf11278dd30c77799b0255bfc8cbfb2dc2a8dd333f658a88d147e","wit/deps/sockets/world.wit":"84e8071d91f63484a326b5a745728e1964edc55cc90796df7ba042b508325103","wit/wasi-crate.wit":"561b9308e635f442fcfbe3c4e783d0b4f2110f4c7bdadc8775170e2e119f7453"},"package":"0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"}
+{"files":{".cargo_vcs_info.json":"6db47a044aaea8461ba63346a96ac4ee93eb065b05d902e91eae7fd7b07549e8","Cargo.lock":"a0bae1d749228589ae9a9a1a22ee6e19abf47c8025ae0e5584773211999811a7","Cargo.toml":"df5f20155009f7a858d67af7755ba85c925b0174559abc8723ec3c97ca6629df","Cargo.toml.orig":"22b4d1984cd3f2df71911afab64e1d20cc4af088a8c7ea88829cf20a4e82418c","README.md":"b768b011583d6c3f7d47c57de28f7dd9ade631b286753435ae1ae9acab6ce557","examples/cli-command-no_std.rs":"56f3f5d08affa4f2211cbdcdf4ec865981502aaa5cdccbffb0b2084736330430","examples/cli-command.rs":"1e84ceae7a33d9c9e9340651b086f155d138eeb9d375c6a1678e3d282f3b668a","examples/hello-world-no_std.rs":"a0b3581ea43e8a1588de8619dee70ddb48a2360e84ef7c9c21b9d6cfbe350dda","examples/hello-world.rs":"634b4999d89675ffad329eea3eb006fad935806895507e0c3e7d770681a9089d","examples/http-proxy-no_std.rs":"9969f8c9747739be697329c563e32c352961655c600eedafb2fac11589216443","examples/http-proxy.rs":"a31e4c31203860ab96da3ca176ca99db7b88ea513ca7a20cc8955a57794367bc","src/command.rs":"35e114d1e65923d46d2fd22eb6b64cb0c37964094450b0e4789413ef1aad240e","src/ext/mod.rs":"4bc79c71442ac6c55dc4f8a0632b6d6805c0c9c74b22b56791a483ae447dac0c","src/ext/std.rs":"c35fd8bdafd24a6adef4f5a27e8e4bb421b0e50cebfe350868ded43980b1a06e","src/imports.rs":"40aa666ccca0b8e7469d2a9193588b00425a8efd4252f7b9a8e6b5144401c5f9","src/lib.rs":"2db558cb84747a1178155997ff55c4cf87972a9fd0fdb7f0ed1c04f1c97d9f47","src/proxy.rs":"6261baf8ac38d8e5dac067156c78448a81eede6963e9370dbf59940fac71ada2","wit/deps/cli.wit":"91aebf406712e618d037fa153b270476541d48d890b4ad6b111ec97b40d73194","wit/deps/clocks.wit":"654a3b5e8b065202334de477828444dca099e576660b6a069c6aaf64685bf68f","wit/deps/filesystem.wit":"4065ba3e5d45ac9cdcfb4bbc31774424d24c453abccf1c9421414ff45f8459b9","wit/deps/http.wit":"873455584340b0e0aa801b842a72d86a67206825bf2d8fc6bca870da6e6ff8f6","wit/deps/io.wit":"80957ac766c6b7eb743ce237a8f92700e1a0b007a1856794ef1972b61ddfce50","wit/deps/random.wit":"4b3229e0ec18cc3fe71f824f855d9cf04809ec8a8d383f088671ca654f7fb885","wit/deps/sockets.wit":"d19af1d835606a576aace12d24a3699aa6f150e22084bb8d880e285c6257786c","wit/wasi-crate.wit":"561b9308e635f442fcfbe3c4e783d0b4f2110f4c7bdadc8775170e2e119f7453"},"package":"9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"}

data/rust-vendor/wasip2/.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "3da562c06214feafc14d37bf290671636caa6718"
+    "sha1": "06ce201370fcde0d1b0d47cac8ecb1b0b312c9f9"
   },
   "path_in_vcs": "crates/wasip2"
 }

data/rust-vendor/wasip2/Cargo.lock

@@ -4,25 +4,25 @@ version = 4
 
 [[package]]
 name = "bitflags"
-version = "2.9.3"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34efbcccd345379ca2868b2b2c9d3782e9cc58ba87bc7d79d5b53d9c9ae6f25d"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "rustc-std-workspace-alloc"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff66d57013a5686e1917ed6a025d54dd591fcda71a41fe07edf4d16726aefa86"
+checksum = "f9d441c3b2ebf55cebf796bfdc265d67fa09db17b7bb6bd4be75c509e1e8fec3"
 
 [[package]]
 name = "rustc-std-workspace-core"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c"
+checksum = "aa9c45b374136f52f2d6311062c7146bff20fec063c3f5d46a410bd937746955"
 
 [[package]]
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.2+wasi-0.2.9"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
@@ -31,9 +31,9 @@ dependencies = [
 
 [[package]]
 name = "wit-bindgen"
-version = "0.46.0"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
  "bitflags",
  "rustc-std-workspace-alloc",

data/rust-vendor/wasip2/Cargo.toml

@@ -11,9 +11,9 @@
 
 [package]
 edition = "2021"
-rust-version = "1.82.0"
+rust-version = "1.87.0"
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.2+wasi-0.2.9"
 build = false
 autolib = false
 autobins = false
@@ -93,5 +93,5 @@ optional = true
 package = "rustc-std-workspace-core"
 
 [dependencies.wit-bindgen]
-version = "0.46.0"
+version = "0.51.0"
 default-features = false

data/rust-vendor/wasip2/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.2+wasi-0.2.9"
 description = "WASIp2 API bindings for Rust"
 categories = ["no-std", "wasm"]
 keywords = ["webassembly", "wasm"]