wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/wasmtime-23.0.2/src/runtime/vm.rs

@@ -0,0 +1,403 @@
+//! Runtime library support for Wasmtime.
+
+#![deny(missing_docs)]
+#![warn(clippy::cast_sign_loss)]
+
+use crate::prelude::*;
+use alloc::sync::Arc;
+use core::fmt;
+use core::mem;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use wasmtime_environ::{
+    DefinedFuncIndex, DefinedMemoryIndex, HostPtr, ModuleInternedTypeIndex, VMOffsets,
+    VMSharedTypeIndex,
+};
+
+mod arch;
+mod async_yield;
+#[cfg(feature = "component-model")]
+pub mod component;
+mod const_expr;
+mod export;
+mod gc;
+mod imports;
+mod instance;
+mod memory;
+mod mmap;
+mod mmap_vec;
+mod send_sync_ptr;
+mod store_box;
+mod sys;
+mod table;
+mod traphandlers;
+mod vmcontext;
+
+mod threads;
+pub use self::threads::*;
+
+#[cfg(feature = "debug-builtins")]
+pub mod debug_builtins;
+pub mod libcalls;
+pub mod mpk;
+
+#[cfg(feature = "debug-builtins")]
+pub use wasmtime_jit_debug::gdb_jit_int::GdbJitImageRegistration;
+
+pub use crate::runtime::vm::arch::{get_stack_pointer, V128Abi};
+pub use crate::runtime::vm::async_yield::*;
+pub use crate::runtime::vm::export::*;
+pub use crate::runtime::vm::gc::*;
+pub use crate::runtime::vm::imports::Imports;
+pub use crate::runtime::vm::instance::{
+    GcHeapAllocationIndex, Instance, InstanceAllocationRequest, InstanceAllocator,
+    InstanceAllocatorImpl, InstanceHandle, MemoryAllocationIndex, OnDemandInstanceAllocator,
+    StorePtr, TableAllocationIndex,
+};
+#[cfg(feature = "pooling-allocator")]
+pub use crate::runtime::vm::instance::{
+    InstanceLimits, PoolConcurrencyLimitError, PoolingInstanceAllocator,
+    PoolingInstanceAllocatorConfig,
+};
+pub use crate::runtime::vm::memory::{Memory, RuntimeLinearMemory, RuntimeMemoryCreator};
+pub use crate::runtime::vm::mmap::Mmap;
+pub use crate::runtime::vm::mmap_vec::MmapVec;
+pub use crate::runtime::vm::mpk::MpkEnabled;
+pub use crate::runtime::vm::store_box::*;
+pub use crate::runtime::vm::sys::unwind::UnwindRegistration;
+pub use crate::runtime::vm::table::{Table, TableElement};
+pub use crate::runtime::vm::traphandlers::*;
+pub use crate::runtime::vm::vmcontext::{
+    VMArrayCallFunction, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMFunctionBody,
+    VMFunctionImport, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition, VMMemoryImport,
+    VMOpaqueContext, VMRuntimeLimits, VMTableImport, VMWasmCallFunction, ValRaw,
+};
+pub use send_sync_ptr::SendSyncPtr;
+
+mod module_id;
+pub use module_id::CompiledModuleId;
+
+mod cow;
+pub use crate::runtime::vm::cow::{MemoryImage, MemoryImageSlot, ModuleMemoryImages};
+
+/// Dynamic runtime functionality needed by this crate throughout the execution
+/// of a wasm instance.
+///
+/// This trait is used to store a raw pointer trait object within each
+/// `VMContext`. This raw pointer trait object points back to the
+/// `wasmtime::Store` internally but is type-erased so this `wasmtime-runtime`
+/// crate doesn't need the entire `wasmtime` crate to build.
+///
+/// Note that this is an extra-unsafe trait because no heed is paid to the
+/// lifetime of this store or the Send/Sync-ness of this store. All of that must
+/// be respected by embedders (e.g. the `wasmtime::Store` structure). The theory
+/// is that `wasmtime::Store` handles all this correctly.
+pub unsafe trait Store {
+    /// Returns the raw pointer in memory where this store's shared
+    /// `VMRuntimeLimits` structure is located.
+    ///
+    /// Used to configure `VMContext` initialization and store the right pointer
+    /// in the `VMContext`.
+    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits;
+
+    /// Returns a pointer to the global epoch counter.
+    ///
+    /// Used to configure the `VMContext` on initialization.
+    fn epoch_ptr(&self) -> *const AtomicU64;
+
+    /// Get this store's GC heap.
+    fn gc_store(&mut self) -> &mut GcStore {
+        self.maybe_gc_store()
+            .expect("attempt to access the GC store before it has been allocated")
+    }
+
+    /// Get this store's GC heap, if it has been allocated.
+    fn maybe_gc_store(&mut self) -> Option<&mut GcStore>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// memory grow operation.
+    fn memory_growing(
+        &mut self,
+        current: usize,
+        desired: usize,
+        maximum: Option<usize>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a memory
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `memory_growing` returns an error.
+    fn memory_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// table grow operation.
+    fn table_growing(
+        &mut self,
+        current: u32,
+        desired: u32,
+        maximum: Option<u32>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a table
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `table_growing` returns an error.
+    fn table_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked whenever fuel runs out by a wasm instance. If an error
+    /// is returned that's raised as a trap. Otherwise wasm execution will
+    /// continue as normal.
+    fn out_of_gas(&mut self) -> Result<(), Error>;
+
+    /// Callback invoked whenever an instance observes a new epoch
+    /// number. Cannot fail; cooperative epoch-based yielding is
+    /// completely semantically transparent. Returns the new deadline.
+    fn new_epoch(&mut self) -> Result<u64, Error>;
+
+    /// Callback invoked whenever an instance needs to trigger a GC.
+    ///
+    /// Optionally given a GC reference that is rooted for the collection, and
+    /// then whose updated GC reference is returned.
+    ///
+    /// Cooperative, async-yielding (if configured) is completely transparent.
+    ///
+    /// If the async GC was cancelled, returns an error. This should be raised
+    /// as a trap to clean up Wasm execution.
+    fn gc(&mut self, root: Option<VMGcRef>) -> Result<Option<VMGcRef>>;
+
+    /// Metadata required for resources for the component model.
+    #[cfg(feature = "component-model")]
+    fn component_calls(&mut self) -> &mut component::CallContexts;
+}
+
+/// Functionality required by this crate for a particular module. This
+/// is chiefly needed for lazy initialization of various bits of
+/// instance state.
+///
+/// When an instance is created, it holds an `Arc<dyn ModuleRuntimeInfo>`
+/// so that it can get to signatures, metadata on functions, memory and
+/// funcref-table images, etc. All of these things are ordinarily known
+/// by the higher-level layers of Wasmtime. Specifically, the main
+/// implementation of this trait is provided by
+/// `wasmtime::module::ModuleInner`.  Since the runtime crate sits at
+/// the bottom of the dependence DAG though, we don't know or care about
+/// that; we just need some implementor of this trait for each
+/// allocation request.
+#[derive(Clone)]
+pub enum ModuleRuntimeInfo {
+    Module(crate::Module),
+    Bare(Box<BareModuleInfo>),
+}
+
+/// A barebones implementation of ModuleRuntimeInfo that is useful for
+/// cases where a purpose-built environ::Module is used and a full
+/// CompiledModule does not exist (for example, for tests or for the
+/// default-callee instance).
+#[derive(Clone)]
+pub struct BareModuleInfo {
+    module: Arc<wasmtime_environ::Module>,
+    one_signature: Option<VMSharedTypeIndex>,
+    offsets: VMOffsets<HostPtr>,
+}
+
+impl ModuleRuntimeInfo {
+    pub(crate) fn bare(module: Arc<wasmtime_environ::Module>) -> Self {
+        ModuleRuntimeInfo::bare_maybe_imported_func(module, None)
+    }
+
+    pub(crate) fn bare_maybe_imported_func(
+        module: Arc<wasmtime_environ::Module>,
+        one_signature: Option<VMSharedTypeIndex>,
+    ) -> Self {
+        ModuleRuntimeInfo::Bare(Box::new(BareModuleInfo {
+            offsets: VMOffsets::new(HostPtr, &module),
+            module,
+            one_signature,
+        }))
+    }
+
+    /// The underlying Module.
+    pub(crate) fn module(&self) -> &Arc<wasmtime_environ::Module> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.env_module(),
+            ModuleRuntimeInfo::Bare(b) => &b.module,
+        }
+    }
+
+    /// Translate a module-level interned type index into an engine-level
+    /// interned type index.
+    fn engine_type_index(&self, module_index: ModuleInternedTypeIndex) -> VMSharedTypeIndex {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m
+                .code_object()
+                .signatures()
+                .shared_type(module_index)
+                .expect("bad module-level interned type index"),
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        }
+    }
+
+    /// Returns the address, in memory, that the function `index` resides at.
+    fn function(&self, index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction> {
+        let module = match self {
+            ModuleRuntimeInfo::Module(m) => m,
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        };
+        let ptr = module
+            .compiled_module()
+            .finished_function(index)
+            .as_ptr()
+            .cast::<VMWasmCallFunction>()
+            .cast_mut();
+        NonNull::new(ptr).unwrap()
+    }
+
+    /// Returns the address, in memory, of the trampoline that allows the given
+    /// defined Wasm function to be called by the array calling convention.
+    ///
+    /// Returns `None` for Wasm functions which do not escape, and therefore are
+    /// not callable from outside the Wasm module itself.
+    fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<VMArrayCallFunction> {
+        let m = match self {
+            ModuleRuntimeInfo::Module(m) => m,
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        };
+        let ptr = m
+            .compiled_module()
+            .array_to_wasm_trampoline(index)?
+            .as_ptr();
+        Some(unsafe { mem::transmute::<*const u8, VMArrayCallFunction>(ptr) })
+    }
+
+    /// Returns the `MemoryImage` structure used for copy-on-write
+    /// initialization of the memory, if it's applicable.
+    fn memory_image(
+        &self,
+        memory: DefinedMemoryIndex,
+    ) -> anyhow::Result<Option<&Arc<MemoryImage>>> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => {
+                let images = m.memory_images()?;
+                Ok(images.and_then(|images| images.get_memory_image(memory)))
+            }
+            ModuleRuntimeInfo::Bare(_) => Ok(None),
+        }
+    }
+
+    /// A unique ID for this particular module. This can be used to
+    /// allow for fastpaths to optimize a "re-instantiate the same
+    /// module again" case.
+    fn unique_id(&self) -> Option<CompiledModuleId> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => Some(m.id()),
+            ModuleRuntimeInfo::Bare(_) => None,
+        }
+    }
+
+    /// A slice pointing to all data that is referenced by this instance.
+    fn wasm_data(&self) -> &[u8] {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.compiled_module().code_memory().wasm_data(),
+            ModuleRuntimeInfo::Bare(_) => &[],
+        }
+    }
+
+    /// Returns an array, indexed by `ModuleInternedTypeIndex` of all
+    /// `VMSharedSignatureIndex` entries corresponding to the `SignatureIndex`.
+    fn type_ids(&self) -> &[VMSharedTypeIndex] {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m
+                .code_object()
+                .signatures()
+                .as_module_map()
+                .values()
+                .as_slice(),
+            ModuleRuntimeInfo::Bare(b) => match &b.one_signature {
+                Some(s) => core::slice::from_ref(s),
+                None => &[],
+            },
+        }
+    }
+
+    /// Offset information for the current host.
+    pub(crate) fn offsets(&self) -> &VMOffsets<HostPtr> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.offsets(),
+            ModuleRuntimeInfo::Bare(b) => &b.offsets,
+        }
+    }
+}
+
+/// Returns the host OS page size, in bytes.
+pub fn host_page_size() -> usize {
+    static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
+
+    return match PAGE_SIZE.load(Ordering::Relaxed) {
+        0 => {
+            let size = sys::vm::get_page_size();
+            assert!(size != 0);
+            PAGE_SIZE.store(size, Ordering::Relaxed);
+            size
+        }
+        n => n,
+    };
+}
+
+/// Is `bytes` a multiple of the host page size?
+pub fn usize_is_multiple_of_host_page_size(bytes: usize) -> bool {
+    bytes % host_page_size() == 0
+}
+
+/// Round the given byte size up to a multiple of the host OS page size.
+///
+/// Returns an error if rounding up overflows.
+pub fn round_u64_up_to_host_pages(bytes: u64) -> Result<u64> {
+    let page_size = u64::try_from(crate::runtime::vm::host_page_size()).err2anyhow()?;
+    debug_assert!(page_size.is_power_of_two());
+    bytes
+        .checked_add(page_size - 1)
+        .ok_or_else(|| anyhow!(
+            "{bytes} is too large to be rounded up to a multiple of the host page size of {page_size}"
+        ))
+        .map(|val| val & !(page_size - 1))
+}
+
+/// Same as `round_u64_up_to_host_pages` but for `usize`s.
+pub fn round_usize_up_to_host_pages(bytes: usize) -> Result<usize> {
+    let bytes = u64::try_from(bytes).err2anyhow()?;
+    let rounded = round_u64_up_to_host_pages(bytes)?;
+    Ok(usize::try_from(rounded).err2anyhow()?)
+}
+
+/// Result of `Memory::atomic_wait32` and `Memory::atomic_wait64`
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum WaitResult {
+    /// Indicates that a `wait` completed by being awoken by a different thread.
+    /// This means the thread went to sleep and didn't time out.
+    Ok = 0,
+    /// Indicates that `wait` did not complete and instead returned due to the
+    /// value in memory not matching the expected value.
+    Mismatch = 1,
+    /// Indicates that `wait` completed with a timeout, meaning that the
+    /// original value matched as expected but nothing ever called `notify`.
+    TimedOut = 2,
+}
+
+/// Description about a fault that occurred in WebAssembly.
+#[derive(Debug)]
+pub struct WasmFault {
+    /// The size of memory, in bytes, at the time of the fault.
+    pub memory_size: usize,
+    /// The WebAssembly address at which the fault occurred.
+    pub wasm_address: u64,
+}
+
+impl fmt::Display for WasmFault {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "memory fault at wasm address 0x{:x} in linear memory of size 0x{:x}",
+            self.wasm_address, self.memory_size,
+        )
+    }
+}

data/ext/cargo-vendor/wasmtime-23.0.2/src/runtime.rs

@@ -0,0 +1,113 @@
+#[macro_use]
+pub(crate) mod func;
+
+pub(crate) mod code;
+pub(crate) mod code_memory;
+pub(crate) mod debug;
+pub(crate) mod externals;
+pub(crate) mod gc;
+pub(crate) mod instance;
+pub(crate) mod instantiate;
+pub(crate) mod limits;
+pub(crate) mod linker;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod resources;
+pub(crate) mod store;
+pub(crate) mod trampoline;
+pub(crate) mod trap;
+pub(crate) mod type_registry;
+pub(crate) mod types;
+pub(crate) mod uninhabited;
+pub(crate) mod v128;
+pub(crate) mod values;
+pub(crate) mod vm;
+
+#[cfg(feature = "component-model")]
+pub mod component;
+
+cfg_if::cfg_if! {
+    if #[cfg(miri)] {
+        // no extensions on miri
+    } else if #[cfg(unix)] {
+        pub mod unix;
+    } else if #[cfg(windows)] {
+        pub mod windows;
+    } else {
+        // ... unknown os!
+    }
+}
+
+pub use code_memory::CodeMemory;
+pub use externals::*;
+pub use func::*;
+pub use gc::*;
+pub use instance::{Instance, InstancePre};
+pub use instantiate::CompiledModule;
+pub use limits::*;
+pub use linker::*;
+pub use memory::*;
+pub use module::{Module, ModuleExport};
+pub use resources::*;
+#[cfg(all(feature = "async", feature = "call-hook"))]
+pub use store::CallHookHandler;
+pub use store::{
+    AsContext, AsContextMut, CallHook, Store, StoreContext, StoreContextMut, UpdateDeadline,
+};
+pub use trap::*;
+pub use types::*;
+pub use v128::V128;
+pub use values::*;
+
+pub(crate) use uninhabited::*;
+
+#[cfg(feature = "pooling-allocator")]
+pub use vm::PoolConcurrencyLimitError;
+
+#[cfg(feature = "profiling")]
+mod profiling;
+#[cfg(feature = "profiling")]
+pub use profiling::GuestProfiler;
+
+#[cfg(feature = "async")]
+pub(crate) mod stack;
+#[cfg(feature = "async")]
+pub use stack::*;
+
+#[cfg(feature = "coredump")]
+mod coredump;
+#[cfg(feature = "coredump")]
+pub use coredump::*;
+
+fn _assertions_runtime() {
+    use crate::_assert_send_and_sync;
+
+    #[cfg(feature = "async")]
+    fn _assert_send<T: Send>(_t: T) {}
+
+    _assert_send_and_sync::<Caller<'_, ()>>();
+    _assert_send_and_sync::<ExternRef>();
+    _assert_send_and_sync::<(Func, TypedFunc<(), ()>, Global, Table, Memory)>();
+    _assert_send_and_sync::<Instance>();
+    _assert_send_and_sync::<InstancePre<()>>();
+    _assert_send_and_sync::<InstancePre<*mut u8>>();
+    _assert_send_and_sync::<Linker<()>>();
+    _assert_send_and_sync::<Linker<*mut u8>>();
+    _assert_send_and_sync::<Module>();
+    _assert_send_and_sync::<Store<()>>();
+    _assert_send_and_sync::<StoreContext<'_, ()>>();
+    _assert_send_and_sync::<StoreContextMut<'_, ()>>();
+
+    #[cfg(feature = "async")]
+    fn _call_async(s: &mut Store<()>, f: Func) {
+        _assert_send(f.call_async(&mut *s, &[], &mut []))
+    }
+    #[cfg(feature = "async")]
+    fn _typed_call_async(s: &mut Store<()>, f: TypedFunc<(), ()>) {
+        _assert_send(f.call_async(&mut *s, ()))
+    }
+    #[cfg(feature = "async")]
+    fn _instantiate_async(s: &mut Store<()>, m: &Module) {
+        _assert_send(Instance::new_async(s, m, &[]))
+    }
+}

data/ext/cargo-vendor/wasmtime-asm-macros-23.0.2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"f55508b4ab4da98eef12ec5c76c89c672a6f13e9d670e6061f2ed07145f87ca7","src/lib.rs":"52cfa6e1ce00e0fd54d9c6a3e9e5e6c067953710871db971755db9586e796396"},"package":"e5a9c42562d879c749288d9a26acc0d95d2ca069e30c2ec2efce84461c4d62b3"}

data/ext/cargo-vendor/wasmtime-asm-macros-23.0.2/Cargo.toml

@@ -0,0 +1,32 @@
+# 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 = "wasmtime-asm-macros"
+version = "23.0.2"
+authors = ["The Wasmtime Project Developers"]
+build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Macros for defining asm functions in Wasmtime"
+readme = false
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+name = "wasmtime_asm_macros"
+path = "src/lib.rs"
+
+[dependencies.cfg-if]
+version = "1.0"

data/ext/cargo-vendor/wasmtime-cache-23.0.2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"ec55025e933dfa7fd26b70e5014708955375579d13717fc538202c1ecdc2e3fa","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"84808c8cd0549042bcc42222cbff424467b5ff259ff6063209877c3cf0b7f4dc","src/config/tests.rs":"32a819e3d9ec8b3926c3636215df4d6df4c2dd9c42851084dcb1c9f35db48bbf","src/lib.rs":"23d2bf2b7ed6663c60d3271ef472b63ecdc5350923b502fd556bc58f7239d990","src/tests.rs":"fe729fc056ea66355be4abd0d955949d6e0c10d260dcba43ff0a13b197d3b208","src/worker.rs":"bfd3ed702b27a2c1618afd991a0cbdfd55e8d9bb30a8ffe1bc6d8154c651f23d","src/worker/tests.rs":"888cc64f923304393c88e60e2c1c8cf559282937f7ad1b9036c65bf6577138be","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"38d5d5aac98c8ae87cf5244495da7722e3fa022aa6f3f4fcd5e3d6e5699ce422"}

data/ext/cargo-vendor/wasmtime-cache-23.0.2/Cargo.toml

@@ -0,0 +1,103 @@
+# 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 = "wasmtime-cache"
+version = "23.0.2"
+authors = ["The Wasmtime Project Developers"]
+build = "build.rs"
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Support for automatic module caching with Wasmtime"
+documentation = "https://docs.rs/wasmtime-cache/"
+readme = false
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+name = "wasmtime_cache"
+path = "src/lib.rs"
+
+[[test]]
+name = "cache_write_default_config"
+path = "tests/cache_write_default_config.rs"
+
+[dependencies.anyhow]
+version = "1.0.22"
+features = ["std"]
+default-features = false
+
+[dependencies.base64]
+version = "0.21.0"
+
+[dependencies.directories-next]
+version = "2.0"
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.postcard]
+version = "1.0.8"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde]
+version = "1.0.188"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde_derive]
+version = "1.0.188"
+
+[dependencies.sha2]
+version = "0.10.2"
+
+[dependencies.toml]
+version = "0.8.10"
+
+[dependencies.zstd]
+version = "0.13.0"
+default-features = false
+
+[dev-dependencies.filetime]
+version = "0.2.7"
+
+[dev-dependencies.once_cell]
+version = "1.12.0"
+default-features = false
+
+[dev-dependencies.pretty_env_logger]
+version = "0.5.0"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[target.'cfg(not(target_os = "windows"))'.dependencies.rustix]
+version = "0.38.31"
+features = ["process"]
+
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.52.0"
+features = ["Win32_System_Threading"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasmtime-component-macro-23.0.2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7205af5de0ee2ff2b931f3f3b8e7e53d53ba088b5f45895965f9602abfe5daf2","build.rs":"0067e626dfcf105d55adda251ed37b72dd4797c764dc8bf08511d847fc7a4a7a","src/bindgen.rs":"7a8518438434e15909f352c14cbf2f82eaac0ebd5203857ad48f6a10e1162e6c","src/component.rs":"04a3b4f8c35ecc787600089514813f9e8dfc9edeef5562d09d4c32788daa0080","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"0e221e3621847ee1b97103bfad0a79b6aced72f070273447fe5dc13dd9570d78","tests/codegen/char.wit":"3a731ee7325e54e8494fa15b96ec8df50b7ad07f34e741b5b55a798cc6858d38","tests/codegen/conventions.wit":"b78144acdea1168381756ab1a3b7bdb2b23be5de4f3db78139c04893b85d373e","tests/codegen/dead-code.wit":"b294e7f6126308796f5ebad94f283dee2c28acb7ecbf1d83f462cdebad487243","tests/codegen/direct-import.wit":"a6c312877b15c2fcdd34db9f52f77d198eb8a6b99f31ba4ec36f5b2ec66effdd","tests/codegen/empty.wit":"7874837ba306e8bffafc5b404f8ae3b0edff93f8ec89a16a251606d055fc1ef8","tests/codegen/flags.wit":"43f9af51c6e444e18e0da556fb7116e70de7710d1880e2f06af704ba32bab92d","tests/codegen/floats.wit":"dc6916ee5ef27f6d00bdeef32a363f85eb078cd4518973175f037948987d128d","tests/codegen/function-new.wit":"7d3d4383afc395321c4a0d780a293c1940cfcf58098568eecaf42364c9c83b3e","tests/codegen/integers.wit":"2a75648502290cc9e0264f71a0c0175cd1ba0756b1cd6e840080ad7327469eeb","tests/codegen/lists.wit":"900a0d3eb8176c4703690c9d42a99e55893815541825333e8e606d9fde33e712","tests/codegen/many-arguments.wit":"800948d14043ecccef1677a9e48b86fedcf9e368c851ee539ea93e575e9a72e3","tests/codegen/multi-return.wit":"9bff3e4bc93d8169a951443f02692cf0c3d2583737ac1156f7bb41840973ba5e","tests/codegen/multiversion/deps/v1/root.wit":"3f9b6ac5dfbd1f8ac8ec0d1e8ffb1f6bd34d42f546d55293868ac3f54ee870dd","tests/codegen/multiversion/deps/v2/root.wit":"e0c635ca0dd8f73eec3301332157c1a067b1533b214b3c076316e19eaec38cae","tests/codegen/multiversion/root.wit":"748f057ace46d2fc035d040993a2d0aeb0cd202f399e30c9b17b253e5672d1ec","tests/codegen/records.wit":"e8aaac38df43c81b1663ae3cd52cbe7ee74c24d18d60ea0daafaed5fd15749c2","tests/codegen/rename.wit":"d063db707f0914d8570cde2e5d4e075da366e4edb314d7971643ffd4787ee739","tests/codegen/resources-export.wit":"dddd289af8dfeb0c409caeacfc8b48f16d3ba9abf8ac6b7de6454b45d2aaeaa3","tests/codegen/resources-import.wit":"5c030b21fd9a02b81aed35d2a3ee5b14bd64c0f47866e2584c8058f5ce16833d","tests/codegen/share-types.wit":"97f8265c88aa002a8245f8cc86cee9fa5feae3742dae909ceae226f9d06ef77a","tests/codegen/simple-functions.wit":"7416e4676e0806f3967683671ace67078c53b2baab2ab9e132a823494ea8d38e","tests/codegen/simple-lists.wit":"32e5f8c12868009cc4d46695b3cbd1bef79ade90c30210d4327bcac17aba7818","tests/codegen/simple-wasi.wit":"176801368e001b1e2dca83f2be82804f316546c800ff988644a67b1b4fd47f04","tests/codegen/small-anonymous.wit":"9ee8953f815595f653a39fe32af7d71e51bb3ad54615a333799d38ffa6a0a8ef","tests/codegen/smoke-default.wit":"f361239858b59b07d6a1cff5a5fd618360d6a603111bb2f5fffe80e4a2767cb2","tests/codegen/smoke-export.wit":"09531839d5e90c8827d94cef4f646d1232377b4086aba7200ac387af7224d87f","tests/codegen/smoke.wit":"a52173e9490a73c75132186e0657284ed1d2f6c33dd14b330e851ec880869341","tests/codegen/strings.wit":"7e1465b7730a56bc7ba8f6a3fead29e4558d3ad58f38da94da246cb8fbe07996","tests/codegen/unversioned-foo.wit":"185a83194bddd6234319016eff65046445809e1ef45af50e19001fe4c640bdb3","tests/codegen/use-paths.wit":"523723be1767525497422afe1f9a4da4f0a3fb07cfc83e7196b8c109d0e4f153","tests/codegen/variants.wit":"cc3071a696624bdb5713c2fb6dc9bc60073abbb191874595e656f2cc774ae7e1","tests/codegen/wat.wit":"dc094243945e979572c60bc3689cc9916c1022d2a3fbba3a083095fa3017fdab","tests/codegen/worlds-with-types.wit":"2eea2fadc327ee6a77b424373f48fe3ac937af6ee21cc3b1f6ff41e81b23200f","tests/codegen_no_std.rs":"aa99fe0097352f49d7f27b63ef124d927e37f13ae5d73b4808644bd9ed008dca","tests/expanded.rs":"894577c83789ef763b8ca0fcedd6705bd1b5abdc3abfa4c217bab03cdcb7b7a5","tests/expanded/char.rs":"c5b9ca68c0ecd7712367ada3d773c80b64b2634475ab91a06ed941eb89f597e6","tests/expanded/char_async.rs":"effeba647371329598d933868c5db5c360cb0dcbbc399376ac9968e7fd186dd3","tests/expanded/conventions.rs":"7ff14d946d425f1f45fbc4f34a6c2538189675d8c44ff01a87079acdcd22ad43","tests/expanded/conventions_async.rs":"f84e004246a4567af91103678faba69dca46db8575d4bfd4aebbd17745de0e68","tests/expanded/dead-code.rs":"f7430542c94d978c5288b6c01e08452bfc79fade528785ff2cc1c9551796ef35","tests/expanded/dead-code_async.rs":"af8bff0ba6ce49d3225193639991e671270cb353776d1ea1b6a37e3f414ab538","tests/expanded/direct-import.rs":"83a4bfc515dc627b8b32b7ce87e937f2edd63a6891ecdb0fcf5ad9106dd53de8","tests/expanded/direct-import_async.rs":"1dcf26c400e16c18efe0757f9c700c6e9a2b0782137df69697c1687ddb8d1c47","tests/expanded/empty.rs":"54f8ce572d0d6597e0a67b0d913dc80459f246fad837fec8dc711c0aff151e19","tests/expanded/empty_async.rs":"d7f076df815953039232acfde9a90975f083e2db4ec87131000c050482bec417","tests/expanded/flags.rs":"280b0fe70a5a03bd5971ce8d4fdcb742eb03abc4b395a7a8e5dadbef23cf5532","tests/expanded/flags_async.rs":"ddd6ec0496a616d15f10e7861fe12f7f48aa705114174345022e72f28b5f7b85","tests/expanded/floats.rs":"053e6fe3bca98e745f49c6ed084b7c85884a2c4cf4427be05147625924c4bd93","tests/expanded/floats_async.rs":"30396055f4b788ae108dabc90ef4e5fbde7351afadb5d3120ff385b5f7a9e17a","tests/expanded/function-new.rs":"dbbcfe28f927708cc9e3a38b506ebd5d992acab3da328d372f4910a7f2333ba3","tests/expanded/function-new_async.rs":"dd5783a45bfadb1192117635fc8f4130e93209f216455d35feae57b26d1bd9e1","tests/expanded/integers.rs":"c6d3256a7c1f4fbce823d2589008af8266fe513a44bfade6e9a6ba3544a84d89","tests/expanded/integers_async.rs":"0d5ba28ef7a3c5edbcb1da124dca600c07393c54fb3d340dbd4d23d7c9db72d0","tests/expanded/lists.rs":"329d8223b70679c9b173e6bd5f304a864120cb5ae2f16b62af845cee2eb1c42d","tests/expanded/lists_async.rs":"bfa9554d1d8973430a7927972d4e053c9995f297d67d6c33317d86ef63692e9b","tests/expanded/many-arguments.rs":"c63d551933987e346e83ba337d58ce09d71ec043ff1a8a5e630ad583c23e8be8","tests/expanded/many-arguments_async.rs":"687bd77602a740c1d155bb4250dd21579d85b3afcc9e3ad4b5d80645421b5e3c","tests/expanded/multi-return.rs":"1d2ffd99dae5e09ff5dd7908b57b69ca5a87b65a10cfd3929a42ccb3cf10c2c5","tests/expanded/multi-return_async.rs":"303a84b066c73f23baaea270e276b4f9a13e3d15e55fe24cf5f15ed23cb740d9","tests/expanded/multiversion.rs":"76d4bb07abf8fcab8ab1526834e59671a3dbfc7ce01cf8dd6d6fbd219d4f721b","tests/expanded/multiversion_async.rs":"a023e6e207fe73721798eaae3fba4a6099fff7b59b3062de74e23a92e2985bc5","tests/expanded/records.rs":"704f42c2e9087db594d402676ac750b8be11eea89926d485296438b6736269a1","tests/expanded/records_async.rs":"46e0b70bb48d7039a0d0623a5e54bd734dc7146b9b7dfcd0e3e94586dfe4ea90","tests/expanded/rename.rs":"2505618f61c3c6e957fbfa14f4dbea6387a560cb4feba4242a2a8e48c40fe37f","tests/expanded/rename_async.rs":"78de0f6b04d6c2127e5168d9ad061f58dfeaf47a3beb36542fc6277a640c2574","tests/expanded/resources-export.rs":"e5c9cefcfc0b786b5bd243678da7f2f4bf7edfc1696dd00ad4a52ed139362bf1","tests/expanded/resources-export_async.rs":"389d1739422dd9cde4b44fbe0ebb4722eb56ffe7d9859a298776ebd031e2f99b","tests/expanded/resources-import.rs":"3729b6e269c30aa4f1da5266f83d09bfe7fe74444ac07026bb05a358fd101a42","tests/expanded/resources-import_async.rs":"d0daf22974daba8961776914a80e6ba5893a98a3361dd77ec80b380b5c69076d","tests/expanded/share-types.rs":"ca324cbfadaac9cc972fc63dcf1ac1049feb37e271ce8ffc5815dc80f649ff95","tests/expanded/share-types_async.rs":"2011dc1ac6067f8ecd8dcffb04d68663f77ab294aefe1702d128ff459d902b39","tests/expanded/simple-functions.rs":"d47f96d3f607a69a65ffb93a42498f5654979df6e4fcad7713a3bbe59bb830b7","tests/expanded/simple-functions_async.rs":"dfaa2d6aa8f40d38e37f837f85b24485b6836999609b530657b127c3cd6e2c1c","tests/expanded/simple-lists.rs":"3e7d05a74818fa4189b3dc4c896f4b9aa0922da57fbe28df1a97ca2303048283","tests/expanded/simple-lists_async.rs":"c0ae45e9b21dccf30011dfacda05630d2c7a6078c677919589eba58f96a9e75a","tests/expanded/simple-wasi.rs":"cc9d3687ad9d4c9bcdceef2972f96629fe988c177688c40448e6dd6f750326a7","tests/expanded/simple-wasi_async.rs":"8a7110cf5565bb01e1ecc6b0b27dd9cf60d1399e7c37de866b8654359c0dad1b","tests/expanded/small-anonymous.rs":"9348a037d34a3f4e940bae2dc016a17968753a532412b84835c7a487e8c446a9","tests/expanded/small-anonymous_async.rs":"a52d3b4d7989dc0597da1fe64db4980bf90dbd0e054b742b7538fa3bbf48f48a","tests/expanded/smoke-default.rs":"03cd41582ee7da6f514440bb4d252303b26d05f36ea94556e27e2c25e63ed140","tests/expanded/smoke-default_async.rs":"5cadd983be4c3505ca14667225a1f46662169acae633a919239724bc3fa9f0af","tests/expanded/smoke-export.rs":"329993f0f274dace4e6d07f6bdac9d8bd8b0805cb45dce34f24d3a003c1ffa45","tests/expanded/smoke-export_async.rs":"59dfd2d92f84264b1a5ec3da1806a82e57fec27d5b9c20ef718e25456fb68754","tests/expanded/smoke.rs":"3c0bf506955e19fcef4be69b3c0828b475d4ff72cda8d9b7b6dd68a230a21da2","tests/expanded/smoke_async.rs":"5195d64f7c844fcbb4a83b7ad6a58fb3feabe98f6284e24baaed19cedb537c26","tests/expanded/strings.rs":"062ec15defed2e8cd65da935540137ac6947bf9c8291b5027c48856e994387bd","tests/expanded/strings_async.rs":"8a9e359ceee807ea52da43f7aaeebd2f595003169d36513626d7002429313506","tests/expanded/unversioned-foo.rs":"99723c114adaa18ada12e4624a91f525d90dd3b7816bc804fc20dd56cf63aee3","tests/expanded/unversioned-foo_async.rs":"eb45f6aec17fb0e68784370abb914d9413c8d21c64b4ff1655b989357a97928f","tests/expanded/use-paths.rs":"3965ef3de176c517620aa8df8640b8f57263542ce1140f656191850d955a4475","tests/expanded/use-paths_async.rs":"6af423c9e23117d465a48d8861edd8209f3f552dd16e5794c19a872ec952a36c","tests/expanded/variants.rs":"8a27e12fb9f63e6b1d0805579e580d476bf12c0563f3a7c276e359e0337f6e25","tests/expanded/variants_async.rs":"d8bba2179dcfba92625d2df79dec1d837350e2934d4a22cb08d0518071fc240f","tests/expanded/wat.rs":"53a52d764f596686597171b4ca3ed14034aaeb1662f1792d4f6bb6decdad394b","tests/expanded/wat_async.rs":"6b249e9150b11e09e4120307fd591426b2694aba54fb45ba002d371a141b284d","tests/expanded/worlds-with-types.rs":"b171de4d8033da99282e6e19c6ca717ac26cc3ce85cec46b025cdfe5485e493a","tests/expanded/worlds-with-types_async.rs":"8f69f975b345969ea2e5554dc59311737ed2b149e3b6b2d04462e49342a54a56"},"package":"c0c3f57c4bc96f9b4a6ff4d6cb6e837913eff32e98d09e2b6d79b5c4647b415b"}