wasmtime 24.0.0 → 25.0.0

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/io/error.wit

@@ -1,34 +0,0 @@
-package wasi:io@0.2.0;
-
-
-interface error {
-    /// A resource which represents some error information.
-    ///
-    /// The only method provided by this resource is `to-debug-string`,
-    /// which provides some human-readable information about the error.
-    ///
-    /// In the `wasi:io` package, this resource is returned through the
-    /// `wasi:io/streams/stream-error` type.
-    ///
-    /// To provide more specific error information, other interfaces may
-    /// provide functions to further "downcast" this error into more specific
-    /// error information. For example, `error`s returned in streams derived
-    /// from filesystem types to be described using the filesystem's own
-    /// error-code type, using the function
-    /// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
-    /// `borrow<error>` and returns
-    /// `option<wasi:filesystem/types/error-code>`.
-    ///
-    /// The set of functions which can "downcast" an `error` into a more
-    /// concrete type is open.
-    resource error {
-        /// Returns a string that is suitable to assist humans in debugging
-        /// this error.
-        ///
-        /// WARNING: The returned string should not be consumed mechanically!
-        /// It may change across platforms, hosts, or other implementation
-        /// details. Parsing this string is a major platform-compatibility
-        /// hazard.
-        to-debug-string: func() -> string;
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/io/poll.wit

@@ -1,41 +0,0 @@
-package wasi:io@0.2.0;
-
-/// A poll API intended to let users wait for I/O events on multiple handles
-/// at once.
-interface poll {
-    /// `pollable` represents a single I/O event which may be ready, or not.
-    resource pollable {
-
-      /// Return the readiness of a pollable. This function never blocks.
-      ///
-      /// Returns `true` when the pollable is ready, and `false` otherwise.
-      ready: func() -> bool;
-
-      /// `block` returns immediately if the pollable is ready, and otherwise
-      /// blocks until ready.
-      ///
-      /// This function is equivalent to calling `poll.poll` on a list
-      /// containing only this pollable.
-      block: func();
-    }
-
-    /// Poll for completion on a set of pollables.
-    ///
-    /// This function takes a list of pollables, which identify I/O sources of
-    /// interest, and waits until one or more of the events is ready for I/O.
-    ///
-    /// The result `list<u32>` contains one or more indices of handles in the
-    /// argument list that is ready for I/O.
-    ///
-    /// If the list contains more elements than can be indexed with a `u32`
-    /// value, this function traps.
-    ///
-    /// A timeout can be implemented by adding a pollable from the
-    /// wasi-clocks API to the list.
-    ///
-    /// This function does not return a `result`; polling in itself does not
-    /// do any I/O so it doesn't fail. If any of the I/O sources identified by
-    /// the pollables has an error, it is indicated by marking the source as
-    /// being reaedy for I/O.
-    poll: func(in: list<borrow<pollable>>) -> list<u32>;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/io/streams.wit

@@ -1,262 +0,0 @@
-package wasi:io@0.2.0;
-
-/// WASI I/O is an I/O abstraction API which is currently focused on providing
-/// stream types.
-///
-/// In the future, the component model is expected to add built-in stream types;
-/// when it does, they are expected to subsume this API.
-interface streams {
-    use error.{error};
-    use poll.{pollable};
-
-    /// An error for input-stream and output-stream operations.
-    variant stream-error {
-        /// The last operation (a write or flush) failed before completion.
-        ///
-        /// More information is available in the `error` payload.
-        last-operation-failed(error),
-        /// The stream is closed: no more input will be accepted by the
-        /// stream. A closed output-stream will return this error on all
-        /// future operations.
-        closed
-    }
-
-    /// An input bytestream.
-    ///
-    /// `input-stream`s are *non-blocking* to the extent practical on underlying
-    /// platforms. I/O operations always return promptly; if fewer bytes are
-    /// promptly available than requested, they return the number of bytes promptly
-    /// available, which could even be zero. To wait for data to be available,
-    /// use the `subscribe` function to obtain a `pollable` which can be polled
-    /// for using `wasi:io/poll`.
-    resource input-stream {
-        /// Perform a non-blocking read from the stream.
-        ///
-        /// When the source of a `read` is binary data, the bytes from the source
-        /// are returned verbatim. When the source of a `read` is known to the
-        /// implementation to be text, bytes containing the UTF-8 encoding of the
-        /// text are returned.
-        ///
-        /// This function returns a list of bytes containing the read data,
-        /// when successful. The returned list will contain up to `len` bytes;
-        /// it may return fewer than requested, but not more. The list is
-        /// empty when no bytes are available for reading at this time. The
-        /// pollable given by `subscribe` will be ready when more bytes are
-        /// available.
-        ///
-        /// This function fails with a `stream-error` when the operation
-        /// encounters an error, giving `last-operation-failed`, or when the
-        /// stream is closed, giving `closed`.
-        ///
-        /// When the caller gives a `len` of 0, it represents a request to
-        /// read 0 bytes. If the stream is still open, this call should
-        /// succeed and return an empty list, or otherwise fail with `closed`.
-        ///
-        /// The `len` parameter is a `u64`, which could represent a list of u8 which
-        /// is not possible to allocate in wasm32, or not desirable to allocate as
-        /// as a return value by the callee. The callee may return a list of bytes
-        /// less than `len` in size while more bytes are available for reading.
-        read: func(
-            /// The maximum number of bytes to read
-            len: u64
-        ) -> result<list<u8>, stream-error>;
-
-        /// Read bytes from a stream, after blocking until at least one byte can
-        /// be read. Except for blocking, behavior is identical to `read`.
-        blocking-read: func(
-            /// The maximum number of bytes to read
-            len: u64
-        ) -> result<list<u8>, stream-error>;
-
-        /// Skip bytes from a stream. Returns number of bytes skipped.
-        ///
-        /// Behaves identical to `read`, except instead of returning a list
-        /// of bytes, returns the number of bytes consumed from the stream.
-        skip: func(
-            /// The maximum number of bytes to skip.
-            len: u64,
-        ) -> result<u64, stream-error>;
-
-        /// Skip bytes from a stream, after blocking until at least one byte
-        /// can be skipped. Except for blocking behavior, identical to `skip`.
-        blocking-skip: func(
-            /// The maximum number of bytes to skip.
-            len: u64,
-        ) -> result<u64, stream-error>;
-
-        /// Create a `pollable` which will resolve once either the specified stream
-        /// has bytes available to read or the other end of the stream has been
-        /// closed.
-        /// The created `pollable` is a child resource of the `input-stream`.
-        /// Implementations may trap if the `input-stream` is dropped before
-        /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable;
-    }
-
-
-    /// An output bytestream.
-    ///
-    /// `output-stream`s are *non-blocking* to the extent practical on
-    /// underlying platforms. Except where specified otherwise, I/O operations also
-    /// always return promptly, after the number of bytes that can be written
-    /// promptly, which could even be zero. To wait for the stream to be ready to
-    /// accept data, the `subscribe` function to obtain a `pollable` which can be
-    /// polled for using `wasi:io/poll`.
-    resource output-stream {
-        /// Check readiness for writing. This function never blocks.
-        ///
-        /// Returns the number of bytes permitted for the next call to `write`,
-        /// or an error. Calling `write` with more bytes than this function has
-        /// permitted will trap.
-        ///
-        /// When this function returns 0 bytes, the `subscribe` pollable will
-        /// become ready when this function will report at least 1 byte, or an
-        /// error.
-        check-write: func() -> result<u64, stream-error>;
-
-        /// Perform a write. This function never blocks.
-        ///
-        /// When the destination of a `write` is binary data, the bytes from
-        /// `contents` are written verbatim. When the destination of a `write` is
-        /// known to the implementation to be text, the bytes of `contents` are
-        /// transcoded from UTF-8 into the encoding of the destination and then
-        /// written.
-        ///
-        /// Precondition: check-write gave permit of Ok(n) and contents has a
-        /// length of less than or equal to n. Otherwise, this function will trap.
-        ///
-        /// returns Err(closed) without writing if the stream has closed since
-        /// the last call to check-write provided a permit.
-        write: func(
-            contents: list<u8>
-        ) -> result<_, stream-error>;
-
-        /// 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
-        /// ```
-        blocking-write-and-flush: func(
-            contents: list<u8>
-        ) -> result<_, stream-error>;
-
-        /// Request to flush buffered output. This function never blocks.
-        ///
-        /// This tells the output-stream that the caller intends any buffered
-        /// output to be flushed. the output which is expected to be flushed
-        /// is all that has been passed to `write` prior to this call.
-        ///
-        /// Upon calling this function, the `output-stream` will not accept any
-        /// writes (`check-write` will return `ok(0)`) until the flush has
-        /// completed. The `subscribe` pollable will become ready when the
-        /// flush has completed and the stream can accept more writes.
-        flush: func() -> result<_, stream-error>;
-
-        /// Request to flush buffered output, and block until flush completes
-        /// and stream is ready for writing again.
-        blocking-flush: func() -> result<_, stream-error>;
-
-        /// Create a `pollable` which will resolve once the output-stream
-        /// is ready for more writing, or an error has occured. When this
-        /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
-        /// error.
-        ///
-        /// If the stream is closed, this pollable is always ready immediately.
-        ///
-        /// The created `pollable` is a child resource of the `output-stream`.
-        /// Implementations may trap if the `output-stream` is dropped before
-        /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable;
-
-        /// Write zeroes to a stream.
-        ///
-        /// This should be used precisely like `write` with the exact same
-        /// preconditions (must use check-write first), but instead of
-        /// passing a list of bytes, you simply pass the number of zero-bytes
-        /// that should be written.
-        write-zeroes: func(
-            /// The number of zero-bytes to write
-            len: u64
-        ) -> result<_, stream-error>;
-
-        /// 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
-        /// ```
-        blocking-write-zeroes-and-flush: func(
-            /// The number of zero-bytes to write
-            len: u64
-        ) -> result<_, stream-error>;
-
-        /// Read from one stream and write to another.
-        ///
-        /// The behavior of splice is equivelant to:
-        /// 1. calling `check-write` on the `output-stream`
-        /// 2. calling `read` on the `input-stream` with the smaller of the
-        /// `check-write` permitted length and the `len` provided to `splice`
-        /// 3. calling `write` on the `output-stream` with that read data.
-        ///
-        /// Any error reported by the call to `check-write`, `read`, or
-        /// `write` ends the splice and reports that error.
-        ///
-        /// This function returns the number of bytes transferred; it may be less
-        /// than `len`.
-        splice: func(
-            /// The stream to read from
-            src: borrow<input-stream>,
-            /// The number of bytes to splice
-            len: u64,
-        ) -> result<u64, stream-error>;
-
-        /// Read from one stream and write to another, with blocking.
-        ///
-        /// This is similar to `splice`, except that it blocks until the
-        /// `output-stream` is ready for writing, and the `input-stream`
-        /// is ready for reading, before performing the `splice`.
-        blocking-splice: func(
-            /// The stream to read from
-            src: borrow<input-stream>,
-            /// The number of bytes to splice
-            len: u64,
-        ) -> result<u64, stream-error>;
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/io/world.wit

@@ -1,6 +0,0 @@
-package wasi:io@0.2.0;
-
-world imports {
-    import streams;
-    import poll;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/random/insecure-seed.wit

@@ -1,25 +0,0 @@
-package wasi:random@0.2.0;
-/// The insecure-seed interface for seeding hash-map DoS resistance.
-///
-/// It is intended to be portable at least between Unix-family platforms and
-/// Windows.
-interface insecure-seed {
-    /// Return a 128-bit value that may contain a pseudo-random value.
-    ///
-    /// The returned value is not required to be computed from a CSPRNG, and may
-    /// even be entirely deterministic. Host implementations are encouraged to
-    /// provide pseudo-random values to any program exposed to
-    /// attacker-controlled content, to enable DoS protection built into many
-    /// languages' hash-map implementations.
-    ///
-    /// This function is intended to only be called once, by a source language
-    /// to initialize Denial Of Service (DoS) protection in its hash-map
-    /// implementation.
-    ///
-    /// # Expected future evolution
-    ///
-    /// This will likely be changed to a value import, to prevent it from being
-    /// called multiple times and potentially used for purposes other than DoS
-    /// protection.
-    insecure-seed: func() -> tuple<u64, u64>;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/random/insecure.wit

@@ -1,22 +0,0 @@
-package wasi:random@0.2.0;
-/// The insecure interface for insecure pseudo-random numbers.
-///
-/// It is intended to be portable at least between Unix-family platforms and
-/// Windows.
-interface insecure {
-    /// Return `len` insecure pseudo-random bytes.
-    ///
-    /// This function is not cryptographically secure. Do not use it for
-    /// anything related to security.
-    ///
-    /// There are no requirements on the values of the returned bytes, however
-    /// implementations are encouraged to return evenly distributed values with
-    /// a long period.
-    get-insecure-random-bytes: func(len: u64) -> list<u8>;
-
-    /// Return an insecure pseudo-random `u64` value.
-    ///
-    /// This function returns the same type of pseudo-random data as
-    /// `get-insecure-random-bytes`, represented as a `u64`.
-    get-insecure-random-u64: func() -> u64;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/random/random.wit

@@ -1,26 +0,0 @@
-package wasi:random@0.2.0;
-/// WASI Random is a random data API.
-///
-/// It is intended to be portable at least between Unix-family platforms and
-/// Windows.
-interface random {
-    /// Return `len` cryptographically-secure random or pseudo-random bytes.
-    ///
-    /// This function must produce data at least as cryptographically secure and
-    /// fast as an adequately seeded cryptographically-secure pseudo-random
-    /// number generator (CSPRNG). It must not block, from the perspective of
-    /// the calling program, under any circumstances, including on the first
-    /// request and on requests for numbers of bytes. The returned data must
-    /// always be unpredictable.
-    ///
-    /// This function must always return fresh data. Deterministic environments
-    /// must omit this function, rather than implementing it with deterministic
-    /// data.
-    get-random-bytes: func(len: u64) -> list<u8>;
-
-    /// Return a cryptographically-secure random or pseudo-random `u64` value.
-    ///
-    /// This function returns the same type of data as `get-random-bytes`,
-    /// represented as a `u64`.
-    get-random-u64: func() -> u64;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/random/world.wit

@@ -1,7 +0,0 @@
-package wasi:random@0.2.0;
-
-world imports {
-    import random;
-    import insecure;
-    import insecure-seed;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/sockets/instance-network.wit

@@ -1,9 +0,0 @@
-
-/// This interface provides a value-export of the default network handle..
-interface instance-network {
-    use network.{network};
-
-    /// Get a handle to the default network.
-    instance-network: func() -> network;
-
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/sockets/ip-name-lookup.wit

@@ -1,51 +0,0 @@
-
-interface ip-name-lookup {
-    use wasi:io/poll@0.2.0.{pollable};
-    use network.{network, error-code, ip-address};
-
-
-    /// Resolve an internet host name to a list of IP addresses.
-    ///
-    /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
-    /// If the input is an IP address string, the address is parsed and returned
-    /// as-is without making any external requests.
-    ///
-    /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
-    ///
-    /// This function never blocks. It either immediately fails or immediately
-    /// returns successfully with a `resolve-address-stream` that can be used
-    /// to (asynchronously) fetch the results.
-    ///
-    /// # Typical errors
-    /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
-    ///
-    /// # References:
-    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
-    /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
-    /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
-    /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
-    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
-
-    resource resolve-address-stream {
-        /// Returns the next address from the resolver.
-        ///
-        /// This function should be called multiple times. On each call, it will
-        /// return the next address in connection order preference. If all
-        /// addresses have been exhausted, this function returns `none`.
-        ///
-        /// This function never returns IPv4-mapped IPv6 addresses.
-        ///
-        /// # Typical errors
-        /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
-        /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
-        /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
-        /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
-        resolve-next-address: func() -> result<option<ip-address>, error-code>;
-
-        /// Create a `pollable` which will resolve once the stream is ready for I/O.
-        ///
-        /// Note: this function is here for WASI Preview2 only.
-        /// It's planned to be removed when `future` is natively supported in Preview3.
-        subscribe: func() -> pollable;
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/sockets/network.wit

@@ -1,145 +0,0 @@
-
-interface network {
-    /// An opaque resource that represents access to (a subset of) the network.
-    /// This enables context-based security for networking.
-    /// There is no need for this to map 1:1 to a physical network interface.
-    resource network;
-
-    /// Error codes.
-    ///
-    /// In theory, every API can return any error code.
-    /// In practice, API's typically only return the errors documented per API
-    /// combined with a couple of errors that are always possible:
-    /// - `unknown`
-    /// - `access-denied`
-    /// - `not-supported`
-    /// - `out-of-memory`
-    /// - `concurrency-conflict`
-    ///
-    /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
-    enum error-code {
-        /// Unknown error
-        unknown,
-
-        /// Access denied.
-        ///
-        /// POSIX equivalent: EACCES, EPERM
-        access-denied,
-
-        /// The operation is not supported.
-        ///
-        /// POSIX equivalent: EOPNOTSUPP
-        not-supported,
-
-        /// One of the arguments is invalid.
-        ///
-        /// POSIX equivalent: EINVAL
-        invalid-argument,
-
-        /// Not enough memory to complete the operation.
-        ///
-        /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
-        out-of-memory,
-
-        /// The operation timed out before it could finish completely.
-        timeout,
-
-        /// This operation is incompatible with another asynchronous operation that is already in progress.
-        ///
-        /// POSIX equivalent: EALREADY
-        concurrency-conflict,
-
-        /// Trying to finish an asynchronous operation that:
-        /// - has not been started yet, or:
-        /// - was already finished by a previous `finish-*` call.
-        ///
-        /// Note: this is scheduled to be removed when `future`s are natively supported.
-        not-in-progress,
-
-        /// The operation has been aborted because it could not be completed immediately.
-        ///
-        /// Note: this is scheduled to be removed when `future`s are natively supported.
-        would-block,
-
-
-        /// The operation is not valid in the socket's current state.
-        invalid-state,
-
-        /// A new socket resource could not be created because of a system limit.
-        new-socket-limit,
-
-        /// A bind operation failed because the provided address is not an address that the `network` can bind to.
-        address-not-bindable,
-
-        /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
-        address-in-use,
-
-        /// The remote address is not reachable
-        remote-unreachable,
-
-
-        /// The TCP connection was forcefully rejected
-        connection-refused,
-
-        /// The TCP connection was reset.
-        connection-reset,
-
-        /// A TCP connection was aborted.
-        connection-aborted,
-
-
-        /// The size of a datagram sent to a UDP socket exceeded the maximum
-        /// supported size.
-        datagram-too-large,
-
-
-        /// Name does not exist or has no suitable associated IP addresses.
-        name-unresolvable,
-
-        /// A temporary failure in name resolution occurred.
-        temporary-resolver-failure,
-
-        /// A permanent failure in name resolution occurred.
-        permanent-resolver-failure,
-    }
-
-    enum ip-address-family {
-        /// Similar to `AF_INET` in POSIX.
-        ipv4,
-
-        /// Similar to `AF_INET6` in POSIX.
-        ipv6,
-    }
-
-    type ipv4-address = tuple<u8, u8, u8, u8>;
-    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
-
-    variant ip-address {
-        ipv4(ipv4-address),
-        ipv6(ipv6-address),
-    }
-
-    record ipv4-socket-address {
-        /// sin_port
-        port: u16,
-        /// sin_addr
-        address: ipv4-address,
-    }
-
-    record ipv6-socket-address {
-        /// sin6_port
-        port: u16,
-        /// sin6_flowinfo
-        flow-info: u32,
-        /// sin6_addr
-        address: ipv6-address,
-        /// sin6_scope_id
-        scope-id: u32,
-    }
-
-    variant ip-socket-address {
-        ipv4(ipv4-socket-address),
-        ipv6(ipv6-socket-address),
-    }
-
-}