wasmtime 17.0.1 → 18.0.3

data/ext/cargo-vendor/tokio-1.36.0/tests/uds_socket.rs

@@ -0,0 +1,118 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+
+use futures::future::try_join;
+use std::io;
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::UnixSocket,
+};
+
+#[tokio::test]
+async fn datagram_echo_server() -> io::Result<()> {
+    let dir = tempfile::tempdir().unwrap();
+    let server_path = dir.path().join("server.sock");
+    let client_path = dir.path().join("client.sock");
+
+    let server_socket = {
+        let socket = UnixSocket::new_datagram()?;
+        socket.bind(&server_path)?;
+        socket.datagram()?
+    };
+
+    tokio::spawn(async move {
+        let mut recv_buf = vec![0u8; 1024];
+        loop {
+            let (len, peer_addr) = server_socket.recv_from(&mut recv_buf[..]).await?;
+            if let Some(path) = peer_addr.as_pathname() {
+                server_socket.send_to(&recv_buf[..len], path).await?;
+            }
+        }
+
+        #[allow(unreachable_code)]
+        Ok::<(), io::Error>(())
+    });
+
+    {
+        let socket = UnixSocket::new_datagram()?;
+        socket.bind(&client_path).unwrap();
+        let socket = socket.datagram()?;
+
+        socket.connect(server_path)?;
+        socket.send(b"ECHO").await?;
+
+        let mut recv_buf = [0u8; 16];
+        let len = socket.recv(&mut recv_buf[..]).await?;
+        assert_eq!(&recv_buf[..len], b"ECHO");
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn listen_and_stream() -> std::io::Result<()> {
+    let dir = tempfile::Builder::new().tempdir().unwrap();
+    let sock_path = dir.path().join("connect.sock");
+    let peer_path = dir.path().join("peer.sock");
+
+    let listener = {
+        let sock = UnixSocket::new_stream()?;
+        sock.bind(&sock_path)?;
+        sock.listen(1024)?
+    };
+
+    let accept = listener.accept();
+    let connect = {
+        let sock = UnixSocket::new_stream()?;
+        sock.bind(&peer_path)?;
+        sock.connect(&sock_path)
+    };
+
+    let ((mut server, _), mut client) = try_join(accept, connect).await?;
+
+    assert_eq!(
+        server.peer_addr().unwrap().as_pathname().unwrap(),
+        &peer_path
+    );
+
+    // 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 assert_usage() -> std::io::Result<()> {
+    let datagram_socket = UnixSocket::new_datagram()?;
+    let result = datagram_socket
+        .connect(std::path::PathBuf::new().join("invalid.sock"))
+        .await;
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "connect cannot be called on a datagram socket"
+    );
+
+    let datagram_socket = UnixSocket::new_datagram()?;
+    let result = datagram_socket.listen(1024);
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "listen cannot be called on a datagram socket"
+    );
+
+    let stream_socket = UnixSocket::new_stream()?;
+    let result = stream_socket.datagram();
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "datagram cannot be called on a stream socket"
+    );
+
+    Ok(())
+}

data/ext/cargo-vendor/wasi-common-18.0.3/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"a8acfe74473cdec8cc01dc6e0d546ce8a1d738aaec64014eedc378271d6f60ae","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"033504feca189aceb1127385592096a7b9f44c396df9a5740bac670c80b44f4c","WASI/README.md":"5ad232d948b1cb086e3a132e53c2f79aa95b908837fd064c2d3d72a508951fc4","WASI/docs/README.md":"7627fbae3c521a267a8b5d591aa8f5b2201df59531da02f973ca9b7713208690","WASI/phases/README.md":"37838db43096e0fc8bddd57f783cf1712b22709ba32cb9590fc4287c6ac7ee76","WASI/phases/ephemeral/docs.md":"f95ddd731918aa5a56d3c2f89af68dbe7ed4aa2eb36ca9bc463336b7cd4f56fe","WASI/phases/ephemeral/witx/typenames.witx":"d014a34f75e664e014073675b835ec776153b7e726a279c1ef967b55f3c80857","WASI/phases/ephemeral/witx/wasi_ephemeral_args.witx":"c1b1d92ca9067ba5128d33f2545682a29a35e23e462a246bf9ce9ed66bf4c026","WASI/phases/ephemeral/witx/wasi_ephemeral_clock.witx":"4c9f81b865e6599066dd437a24fd1e777d4eed4f3b37ab517b3fd7595cb76618","WASI/phases/ephemeral/witx/wasi_ephemeral_environ.witx":"346cf09850551d4eeed117142876db4a4ece4a9da994b5e2f0cd0e0e9eb6b2b0","WASI/phases/ephemeral/witx/wasi_ephemeral_fd.witx":"4dcd68997a811f2ef6a7037b2239eff582dddf3c0060e8d0118ed52748b598e7","WASI/phases/ephemeral/witx/wasi_ephemeral_path.witx":"f6654aac05e2dd310d247f08ad834c2830c0bc595dca077c13c18cba0470716d","WASI/phases/ephemeral/witx/wasi_ephemeral_poll.witx":"74e7912b73a11449100a64f27cc27e0f77a360601cbbdc48131d5d06678b6c56","WASI/phases/ephemeral/witx/wasi_ephemeral_proc.witx":"3ec2cd41a7d8ecb2e2f185a6f9bf52e9ff45d008f4745d57d941935baae48658","WASI/phases/ephemeral/witx/wasi_ephemeral_random.witx":"f03c15c1b242cb6f7e14e001c4847400ef9c397b0258570082c48c80242f0dc4","WASI/phases/ephemeral/witx/wasi_ephemeral_sched.witx":"2d74c211c4c8534663ca0dc00f9e8bffd59a32df3ed6548735f5509c05c5cef5","WASI/phases/ephemeral/witx/wasi_ephemeral_sock.witx":"f0c6017e4a218b5337b1004fcd25eb8403f4a9ce3b0ec95e7c48e1c7eae6dab7","WASI/phases/old/snapshot_0/docs.md":"8631f27d8035b273b37235aaa35d9cc8747489204d5af66c62f068a5d3eb5d87","WASI/phases/old/snapshot_0/witx/typenames.witx":"b45680d63d3cd0b4214e37997e43b184f812c897755053c774e7bec54d39c1aa","WASI/phases/old/snapshot_0/witx/wasi_unstable.witx":"8998761927fdf36c77ddc282a689a56154541ea634c22822a7cce013205b3735","WASI/phases/snapshot/docs.html":"a1dc863106219f2d33e387cd6fa070bdbd8e369524937aed01d44e55555d88c0","WASI/phases/snapshot/docs.md":"fa04c2632f62e660d11f8507871ec6f79a043b1326870ea2e670fd5513227800","WASI/phases/snapshot/witx/typenames.witx":"65b41b94060e923ef543621080c2bdcb258bc550494a819ade2688eb1fcccfa6","WASI/phases/snapshot/witx/wasi_snapshot_preview1.witx":"56135b1fdfe9eb4e2fbaabf93178070cd5b0cc5fe451ae74d218ebfc7dda7e88","WASI/proposal-template/README.md":"c4cad0646f2e38d7eec3003c2386d0003462825b01fd03718f01aa7a03c14c46","WASI/proposals/README.md":"eff1b52eff2627607562f6f38b4f94bd5b1ac3e6abfad1d65a839bccf6ed5cb9","WASI/snapshots/README.md":"ecd689060c2d4756ef2bd827d75c655f335228f80c3a1eabdb720bc5eeeeacce","WASI/standard/README.md":"7a86870703ae6329f80a6763b7da664c3acac75aa660ac620f98217c16a05203","build.rs":"47d105388b68d1f6d6526d0f87ce58a9218d6649bcf879a46fa6e4d341bb6b45","src/clocks.rs":"3d6f01b3129bd4cb60eca5f17137e589365092a03f1bbec812c655d6c023476e","src/ctx.rs":"8cd70eee8a19d6f5573e39a344a6531a5e30004bdcee8d4efeec1a468fd5c140","src/dir.rs":"fd8df63ddf4247a3ea5b63200d798a9537ead1dedba4748718085598e9679705","src/error.rs":"81fff5a99f40cc3892e0e6d7f5bbb4420a0d87d5cf75521370b306eee17ac3ce","src/file.rs":"156da21bba7e23f7830af521cbf4a8f5980bd23b732a7b0a5784dea20d5e1079","src/lib.rs":"8426c73b421c0a596cffebbe596186a6e74e5e44f735420dc4137910d90c2be4","src/pipe.rs":"a872805cbbbec11e11970b8f8be0bb5d3a28a0f144039fd492b32a2e967704ad","src/random.rs":"a7d4bb5649223a868f4d2d3072c0d36cf6f8d3ec25420267505488374dc8a775","src/sched.rs":"d0629edb4f36414671be086038eaefc7984b69d740337772a872e69e1e8ab96c","src/sched/subscription.rs":"5e588932bf8b1068d2f1d89401617ba111d05c85c26d13f35bc3f968161b07cc","src/snapshots/mod.rs":"8a0ebeaed2f7234d4bb92286da3048e8c61e2ae8e6115bff8f5aa7115e8b1d35","src/snapshots/preview_0.rs":"745746167b7dafe55cedebb66eb1fbb4973bbe733490fc2505b01f08369cc943","src/snapshots/preview_1.rs":"006661552dd5b7446159bf52b830e93b0f42fd9aa9247c77718d41b38d71d36b","src/snapshots/preview_1/error.rs":"8a4222a297b7310494524a517e7a936180e2fbab14fb1601bf7fcfb082509676","src/string_array.rs":"fd5eccecaca4f431b03402617a120b1f822e3159a17ff95b82c918f51f26b1e8","src/sync/clocks.rs":"fb2eede865a3e20b9f16af9b23f64dff4f28197161bcd4c5b388624907eab8d5","src/sync/dir.rs":"4675ac744622487c010c8a82cb692fc62693b232224494e9d93af01f809a9e57","src/sync/file.rs":"921e282ba3f038b9a83dbcbcb05baa0e7227c6f1a74e986887b656ccf6358ede","src/sync/mod.rs":"0e6df94bfc0db221e863f7d3c01eb943a3950d658cc7a530c0eeba84cf71b2d8","src/sync/net.rs":"9a35201a3e070b22f6dfe163eb3f84e4a46fa958dc9fbc08126021bf20db8b87","src/sync/sched.rs":"3d57d08385df1b1751c96b0d38e6d07f0f4e938cf03ea3776694afc403124954","src/sync/sched/unix.rs":"d209047b18c67186e50f0b8c4581c5fe4179a3dec72b20197bcc002557b6bfa6","src/sync/sched/windows.rs":"ce351a8839d9eb24fa5477374882ffc4f979cb496e6a1d4f889472c71b22e0c1","src/sync/stdio.rs":"d9940871d284f67183bd154aef4c8668afbde5b5553470522b0ca739d3e24b11","src/table.rs":"0f546fbdf092a425de70c19e5e7632a5d1d266b57e2c856843046669da783294","src/tokio/dir.rs":"3a092fcf005b49a26b7981b61722d8393daee83b17e19db8bdad265fe186cb9b","src/tokio/file.rs":"857b80dd6b6bfae2a5dee0e6eb109160b4d909ddf7d6da93ed4b2e8904e6ed1c","src/tokio/mod.rs":"c79e06f0fd43d89ad656c0d5a926a028a910c3dd891028e34574cf15603dec21","src/tokio/net.rs":"790626f827f65e91fad2e98dc2b4179eda3daff1786704d56ab2eded1a46f13c","src/tokio/sched.rs":"50a1fe0c52130894e4bfcf908c8a8712bf12b6c2d8befedd728b30f9ce1f8c92","src/tokio/sched/unix.rs":"f26618b267dff768a1429f9262ac992b34bf5fe38ef4de2d6abdea22a9be7141","src/tokio/sched/windows.rs":"2646717b9f20c3a00775ec0dbc709b56b24159c30a7df90061037c4311c9dd73","src/tokio/stdio.rs":"d5ed3529f55d3bf6142d1650a7476489e24297f706f7acd122ac96a7b7fd68df","tests/all/async_.rs":"ec997d8eb85eb2a95fe02fff22fb7119f75d50c56f127d3d022699f505c64aa6","tests/all/main.rs":"c0e7d48273a1f78693621672076277f47e0af09ccf80f674b6033855e94bf8cb","tests/all/sync.rs":"4ff7424445740a494549e87d37a137eb897170a6b6283f8f0872b12ed97d0da6"},"package":"95e022c29ad56af4cc0a8a8f0e0191abf9e0a0c4a68d25dfe088c39c9a8e3d2c"}

data/ext/cargo-vendor/wasi-common-18.0.3/Cargo.toml

@@ -0,0 +1,223 @@
+# 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 = "2021"
+name = "wasi-common"
+version = "18.0.3"
+authors = ["The Wasmtime Project Developers"]
+build = "build.rs"
+links = "wasi-common-19"
+include = [
+    "src/**/*",
+    "tests/**/*",
+    "WASI/phases/**/*",
+    "README.md",
+    "LICENSE",
+    "build.rs",
+]
+description = "WASI implementation in Rust"
+readme = "README.md"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[[test]]
+name = "all"
+required-features = [
+    "wasmtime",
+    "sync",
+    "tokio",
+]
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.bitflags]
+version = "2.0"
+
+[dependencies.cap-fs-ext]
+version = "2.0.0"
+optional = true
+
+[dependencies.cap-rand]
+version = "2.0.0"
+features = ["small_rng"]
+
+[dependencies.cap-std]
+version = "2.0.0"
+
+[dependencies.cap-time-ext]
+version = "2.0.0"
+optional = true
+
+[dependencies.fs-set-times]
+version = "0.20.0"
+optional = true
+
+[dependencies.io-lifetimes]
+version = "2.0.2"
+optional = true
+default-features = false
+
+[dependencies.libc]
+version = "0.2.60"
+optional = true
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.system-interface]
+version = "0.26.0"
+features = [
+    "cap_std_impls",
+    "cap_std_impls",
+]
+optional = true
+
+[dependencies.thiserror]
+version = "1.0.43"
+
+[dependencies.tokio]
+version = "1.26.0"
+features = [
+    "rt",
+    "time",
+    "rt",
+    "fs",
+    "time",
+    "io-util",
+    "net",
+    "io-std",
+    "rt-multi-thread",
+]
+optional = true
+
+[dependencies.tracing]
+version = "0.1.26"
+
+[dependencies.wasmtime]
+version = "18.0.3"
+features = ["runtime"]
+optional = true
+default-features = false
+
+[dependencies.wiggle]
+version = "=18.0.3"
+default-features = false
+
+[dev-dependencies.tempfile]
+version = "3.1.0"
+
+[dev-dependencies.test-log]
+version = "0.2"
+features = ["trace"]
+default-features = false
+
+[dev-dependencies.tokio]
+version = "1.26.0"
+features = [
+    "rt",
+    "time",
+    "macros",
+    "rt-multi-thread",
+]
+
+[dev-dependencies.tracing-subscriber]
+version = "0.3.1"
+features = [
+    "fmt",
+    "env-filter",
+    "ansi",
+    "tracing-log",
+]
+default-features = false
+
+[dev-dependencies.wasmtime]
+version = "18.0.3"
+features = [
+    "cranelift",
+    "async",
+    "runtime",
+]
+default-features = false
+
+[features]
+default = [
+    "trace_log",
+    "wasmtime",
+    "sync",
+]
+exit = [
+    "wasmtime",
+    "dep:libc",
+]
+sync = [
+    "wasmtime",
+    "dep:cap-fs-ext",
+    "dep:cap-time-ext",
+    "dep:fs-set-times",
+    "dep:system-interface",
+    "dep:io-lifetimes",
+]
+tokio = [
+    "sync",
+    "wasmtime/async",
+    "wiggle/wasmtime_async",
+    "dep:tokio",
+]
+trace_log = [
+    "wiggle/tracing_log",
+    "tracing/log",
+]
+wasmtime = [
+    "dep:wasmtime",
+    "wiggle/wasmtime",
+]
+wiggle_metadata = ["wiggle/wiggle_metadata"]
+
+[target."cfg(unix)".dependencies.rustix]
+version = "0.38.21"
+features = [
+    "fs",
+    "event",
+]
+
+[target."cfg(windows)".dependencies.io-extras]
+version = "0.18.0"
+
+[target."cfg(windows)".dependencies.once_cell]
+version = "1.12.0"
+
+[target."cfg(windows)".dependencies.rustix]
+version = "0.38.21"
+features = ["net"]
+
+[target."cfg(windows)".dependencies.windows-sys]
+version = "0.52.0"
+features = [
+    "Win32_Foundation",
+    "Win32_Networking_WinSock",
+]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasi-common-18.0.3/src/lib.rs

@@ -0,0 +1,193 @@
+//! # wasi-common
+//!
+//! This is Wasmtime's legacy implementation of WASI 0.1 (Preview 1). The
+//! Wasmtime maintainers suggest all users upgrade to the implementation
+//! of WASI 0.1 and 0.2 provided by the `wasmtime-wasi` crate. This
+//! implementation remains in the wasmtime tree because it is required to use
+//! the `wasmtime-wasi-threads` crate, an implementation of the `wasi-threads`
+//! proposal which is not compatible with WASI 0.2.
+//!
+//! In addition to integration with Wasmtime, this implementation may be used
+//! by other runtimes by disabling the `wasmtime` feature on this crate.
+//!
+//! ## The `WasiFile` and `WasiDir` traits
+//!
+//! The WASI specification only defines one `handle` type, `fd`, on which all
+//! operations on both files and directories (aka dirfds) are defined. We
+//! believe this is a design mistake, and are architecting wasi-common to make
+//! this straightforward to correct in future snapshots of WASI.  Wasi-common
+//! internally treats files and directories as two distinct resource types in
+//! the table - `Box<dyn WasiFile>` and `Box<dyn WasiDir>`. The snapshot 0 and
+//! 1 interfaces via `fd` will attempt to downcast a table element to one or
+//! both of these interfaces depending on what is appropriate - e.g.
+//! `fd_close` operates on both files and directories, `fd_read` only operates
+//! on files, and `fd_readdir` only operates on directories.
+
+//! The `WasiFile` and `WasiDir` traits are defined by `wasi-common` in terms
+//! of types defined directly in the crate's source code (I decided it should
+//! NOT those generated by the `wiggle` proc macros, see snapshot architecture
+//! below), as well as the `cap_std::time` family of types.  And, importantly,
+//! `wasi-common` itself provides no implementation of `WasiDir`, and only two
+//! trivial implementations of `WasiFile` on the `crate::pipe::{ReadPipe,
+//! WritePipe}` types, which in turn just delegate to `std::io::{Read,
+//! Write}`. In order for `wasi-common` to access the local filesystem at all,
+//! you need to provide `WasiFile` and `WasiDir` impls through either the new
+//! `wasi-cap-std-sync` crate found at `crates/wasi-common/cap-std-sync` - see
+//! the section on that crate below - or by providing your own implementation
+//! from elsewhere.
+//!
+//! This design makes it possible for `wasi-common` embedders to statically
+//! reason about access to the local filesystem by examining what impls are
+//! linked into an application. We found that this separation of concerns also
+//! makes it pretty enjoyable to write alternative implementations, e.g. a
+//! virtual filesystem.
+//!
+//! Implementations of the `WasiFile` and `WasiDir` traits are provided
+//! for synchronous embeddings (i.e. Config::async_support(false)) in
+//! `wasi_common::sync` and for Tokio embeddings in `wasi_common::tokio`.
+//!
+//! ## Traits for the rest of WASI's features
+//!
+//! Other aspects of a WASI implementation are not yet considered resources
+//! and accessed by `handle`. We plan to correct this design deficiency in
+//! WASI in the future, but for now we have designed the following traits to
+//! provide embedders with the same sort of implementation flexibility they
+//! get with WasiFile/WasiDir:
+//!
+//! * Timekeeping: `WasiSystemClock` and `WasiMonotonicClock` provide the two
+//! interfaces for a clock. `WasiSystemClock` represents time as a
+//! `cap_std::time::SystemTime`, and `WasiMonotonicClock` represents time as
+//! `cap_std::time::Instant`.  * Randomness: we re-use the `cap_rand::RngCore`
+//! trait to represent a randomness source. A trivial `Deterministic` impl is
+//! provided.  * Scheduling: The `WasiSched` trait abstracts over the
+//! `sched_yield` and `poll_oneoff` functions.
+//!
+//! Users can provide implementations of each of these interfaces to the
+//! `WasiCtx::builder(...)` function. The
+//! `wasi_cap_std_sync::WasiCtxBuilder::new()` function uses this public
+//! interface to plug in its own implementations of each of these resources.
+
+#![warn(clippy::cast_sign_loss)]
+
+pub mod clocks;
+mod ctx;
+pub mod dir;
+mod error;
+pub mod file;
+pub mod pipe;
+pub mod random;
+pub mod sched;
+pub mod snapshots;
+mod string_array;
+#[cfg(feature = "sync")]
+pub mod sync;
+pub mod table;
+#[cfg(feature = "tokio")]
+pub mod tokio;
+
+pub use cap_rand::RngCore;
+pub use clocks::{SystemTimeSpec, WasiClocks, WasiMonotonicClock, WasiSystemClock};
+pub use ctx::WasiCtx;
+pub use dir::WasiDir;
+pub use error::{Error, ErrorExt, I32Exit};
+pub use file::WasiFile;
+pub use sched::{Poll, WasiSched};
+pub use string_array::{StringArray, StringArrayError};
+pub use table::Table;
+
+// The only difference between these definitions for sync vs async is whether
+// the wasmtime::Funcs generated are async (& therefore need an async Store and an executor to run)
+// or whether they have an internal "dummy executor" that expects the implementation of all
+// the async funcs to poll to Ready immediately.
+#[cfg(feature = "wasmtime")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! define_wasi {
+    ($async_mode:tt $($bounds:tt)*) => {
+
+    use wasmtime::Linker;
+
+    pub fn add_to_linker<T, U>(
+        linker: &mut Linker<T>,
+        get_cx: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> anyhow::Result<()>
+        where U: Send
+                + crate::snapshots::preview_0::wasi_unstable::WasiUnstable
+                + crate::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1,
+            $($bounds)*
+    {
+        snapshots::preview_1::add_wasi_snapshot_preview1_to_linker(linker, get_cx)?;
+        snapshots::preview_0::add_wasi_unstable_to_linker(linker, get_cx)?;
+        Ok(())
+    }
+
+    pub mod snapshots {
+        pub mod preview_1 {
+            wiggle::wasmtime_integration!({
+                // The wiggle code to integrate with lives here:
+                target: crate::snapshots::preview_1,
+                // This must be the same witx document as used above. This should be ensured by
+                // the `WASI_ROOT` env variable, which is set in wasi-common's `build.rs`.
+                witx: ["$WASI_ROOT/phases/snapshot/witx/wasi_snapshot_preview1.witx"],
+                errors: { errno => trappable Error },
+                $async_mode: *
+            });
+        }
+        pub mod preview_0 {
+            wiggle::wasmtime_integration!({
+                // The wiggle code to integrate with lives here:
+                target: crate::snapshots::preview_0,
+                // This must be the same witx document as used above. This should be ensured by
+                // the `WASI_ROOT` env variable, which is set in wasi-common's `build.rs`.
+                witx: ["$WASI_ROOT/phases/old/snapshot_0/witx/wasi_unstable.witx"],
+                errors: { errno => trappable Error },
+                $async_mode: *
+            });
+        }
+    }
+}}
+
+/// Exit the process with a conventional OS error code as long as Wasmtime
+/// understands the error. If the error is not an `I32Exit` or `Trap`, return
+/// the error back to the caller for it to decide what to do.
+///
+/// Note: this function is designed for usage where it is acceptable for
+/// Wasmtime failures to terminate the parent process, such as in the Wasmtime
+/// CLI; this would not be suitable for use in multi-tenant embeddings.
+#[cfg(feature = "exit")]
+pub fn maybe_exit_on_error(e: anyhow::Error) -> anyhow::Error {
+    use std::process;
+    use wasmtime::Trap;
+
+    // If a specific WASI error code was requested then that's
+    // forwarded through to the process here without printing any
+    // extra error information.
+    let code = e.downcast_ref::<crate::I32Exit>().map(|e| e.0);
+    if let Some(exit) = code {
+        // Print the error message in the usual way.
+        // On Windows, exit status 3 indicates an abort (see below),
+        // so return 1 indicating a non-zero status to avoid ambiguity.
+        if cfg!(windows) && exit >= 3 {
+            process::exit(1);
+        }
+        process::exit(exit);
+    }
+
+    // If the program exited because of a trap, return an error code
+    // to the outside environment indicating a more severe problem
+    // than a simple failure.
+    if e.is::<Trap>() {
+        eprintln!("Error: {:?}", e);
+
+        if cfg!(unix) {
+            // On Unix, return the error code of an abort.
+            process::exit(128 + libc::SIGABRT);
+        } else if cfg!(windows) {
+            // On Windows, return 3.
+            // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/abort?view=vs-2019
+            process::exit(3);
+        }
+    }
+
+    e
+}

data/ext/cargo-vendor/wasi-common-18.0.3/src/sync/clocks.rs

@@ -0,0 +1,41 @@
+use crate::clocks::{WasiClocks, WasiMonotonicClock, WasiSystemClock};
+use cap_std::time::{Duration, Instant, SystemTime};
+use cap_std::{ambient_authority, AmbientAuthority};
+use cap_time_ext::{MonotonicClockExt, SystemClockExt};
+
+pub struct SystemClock(cap_std::time::SystemClock);
+
+impl SystemClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        SystemClock(cap_std::time::SystemClock::new(ambient_authority))
+    }
+}
+impl WasiSystemClock for SystemClock {
+    fn resolution(&self) -> Duration {
+        self.0.resolution()
+    }
+    fn now(&self, precision: Duration) -> SystemTime {
+        self.0.now_with(precision)
+    }
+}
+
+pub struct MonotonicClock(cap_std::time::MonotonicClock);
+impl MonotonicClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        MonotonicClock(cap_std::time::MonotonicClock::new(ambient_authority))
+    }
+}
+impl WasiMonotonicClock for MonotonicClock {
+    fn resolution(&self) -> Duration {
+        self.0.resolution()
+    }
+    fn now(&self, precision: Duration) -> Instant {
+        self.0.now_with(precision)
+    }
+}
+
+pub fn clocks_ctx() -> WasiClocks {
+    WasiClocks::new()
+        .with_system(SystemClock::new(ambient_authority()))
+        .with_monotonic(MonotonicClock::new(ambient_authority()))
+}