Changes in lib.rs

1b59b579 - Add support for map type (#12216)

Mon, 09 Mar 2026 23:34:21 +0000

Add support for map type (#12216)* Add support for map typeSigned-off-by: Yordis Prieto * Add Map and MapEntry classes to support key/value pairs in component modelThis commit introduces the Map and MapEntry classes, enabling the representation of map values in the component model. The Map class allows for the creation and iteration of key/value pairs, enhancing the functionality of the wasmtime component API. Additionally, the .gitignore file is updated to exclude build artifacts from the crates/c-api directory.* Add wasm_component_model_map configuration support* Format code* Format C code* Enhance component model to support HashMap typeThis commit introduces support for HashMap in the component model, allowing maps to be represented as list> in the canonical ABI. It includes implementations for the ComponentType, Lower, and Lift traits for HashMap, enabling type checking, lowering to flat representations, and lifting from memory. Additionally, the maximum depth for type generation in the fuzzing utility is updated to accommodate the new map type.* Refactor component configuration to introduce map supportThis commit removes the previous wasm features configuration and adds new functions for creating a map-configured engine. The `map_config` and `map_engine` functions are introduced to facilitate the use of the component model with maps in tests, ensuring that the engine is properly configured for map types in the component model.* Add new WAST test for map types and remove map type definitions from existing testsThis commit introduces a new WAST test file specifically for testing various map types in the component model. Additionally, it removes the redundant map type definitions from the existing types.wast file to streamline the test suite.* Update component fuzzing and dynamic tests to replace call_and_post_return with call* Format code* Refactor HashMap usage in typed.rs to use wasmtime_environ collections* Fix HashMap initialization and insertion to handle potential errors in typed.rs* Refactor HashMap handling in typed.rs to use lower_map_iter for improved iteration and memory management. Introduce new implementations for ComponentType, Lower, and Lift traits for std::collections::HashMap, enhancing support for map types in the component model.* Fix map adapter trampoline compilation and alignment bugsThe translate_map function had two categories of bugs preventing mapadapter trampolines from working:1. Wasm stack discipline: local_set_new_tmp emits LocalSet which pops from the stack, but was called when the stack was empty (to "pre-allocate" locals). Fixed by computing values first, then calling local_set_new_tmp to consume them—matching translate_list's pattern. Also removed an erroneous LocalTee that left an orphan value on the stack. Affected: src_byte_len, dst_byte_len, cur_src_ptr, cur_dst_ptr.2. Pointer advancement: after value translation, the pointer still points at the value start. The code only advanced by trailing padding instead of value_size + trailing_padding, causing every loop iteration to re-read the same memory.Also fixes entry layout to use proper record alignment rules (entryalign = max(key_align, value_align), value at aligned offset).* Refactor map entry layout calculations to use canonical ABI* Remove unnecessary clone of map pairs during loweringVal::Map already holds Vec<(Val, Val)> which derefs to &[(Val, Val)],matching lower_map's signature directly. The intermediate Vec allocationand deep clone of every key/value pair was redundant.* Deduplicate map lift logic between HashMap implementations* Deduplicate list and map sequence translation scaffolding* Fix cargo fmt formatting issues* Deduplicate map typecheck logic* Deduplicate map lowering with linear_lower_map_to_flat and linear_lower_map_to_memory helpers* Clean up lift_try_map: use drop, move TryHashMap import to module scope* Fix CI: arbtest overflow and no-std HashMap lift_map- component_fuzz: use saturating_sub in generate_hashable_key to prevent underflow when fuel is 0 and Enum variant is chosen- typed: remove incorrect ? operators in lift_map for hashbrown::HashMap (with_capacity and insert don't return Result)* Store map tuple layout in TypeMapCompute map entry ABI and value offsets once during type building, and reuse that metadata in runtime map lift/lower paths instead of recalculating tuple layout at each call site.* Refactor map ABI argument passingBundle map lift/lower layout and type metadata into a small MapAbi32 helper so map helper calls stay concise without changing behavior.* Fix CI: enable component_model_map in fuzzing and handle map in arbitrary_valThe fuzzer's component_api oracle was generating map types but the enginedidn't have the map feature enabled, and arbitrary_val had no arm forType::Map. Enable component_model_map in the store helper (matching howcomponent_model_async is forced on) and implement arbitrary value generationfor map types.---------Signed-off-by: Yordis Prieto List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

4a168844 - Fix some minor `bindgen!` issues with `anyhow: true` (#12657)

Tue, 24 Feb 2026 23:36:26 +0000

Fix some minor `bindgen!` issues with `anyhow: true` (#12657)* Fix some minor `bindgen!` issues with `anyhow: true`Found when updating Spin to Wasmtime 42.0.0 where some cases weren'thandled:* Trappable functions with no result.* Resource destructors.* Functions with custom trappable errors.* Shuffle some features List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

1e0b0b46 - Remove subtask reparenting (#12570)

Mon, 23 Feb 2026 21:00:21 +0000

Remove subtask reparenting (#12570)This commit updates the implementation of component-model-asyncprimitives to remove the manual subtask reparenting process. This isrequired to fix #12544 at a semantic level because a subtask isn't everactually reparented, even if its parent exits. The first part of thischange is to remove the `GuestTask::subtasks` field and all relevantmanipulations of it.This field, however, powered the `TaskExit` abstraction returned from`call_concurrent`. This commit then subsequently deletes `TaskExit` andall related infrastructure as it's no longer directly applicable as-is.The rest of this change is then updating tests/bindings/etc to accountfor these two changes.The main semantic changes related to tests are:* `wasmtime run`, with and without `--invoke`, no longer waits for all subtasks. This instead only waits for the main task returning before exiting. Whether or not this is the correct behavior is under discussion in WebAssembly/component-model#608* `wasmtime serve` has been updated to keep the store alive at least until the response body has been fully transmitted. This is also part of WebAssembly/component-model#608.* Some `component-async-tests`-related tests were updated to either avoid blocking the store as it wasn't needed or yield enough times to ensure that the test passes.Closes #12544prtest:full List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

d2fbd2de - Update to wasm-tools 245 (#12571)

Thu, 12 Feb 2026 15:38:22 +0000

Update to wasm-tools 245 (#12571)* Intrinsics updates* Remove ds_store* Update to wasm-tools 245* Add vets* Fixup tests* Add missing feature for `indexmap`---------Co-authored-by: Sy Brand List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

c09aa380 - deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)

Tue, 03 Feb 2026 19:13:45 +0000

deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)* deprecate `[Typed]Func::post_return[_async]` and make them no-opsWith the advent of the Component Model concurrency ABI and it's `task.return`intrinsic, post-return functions have been informally deprecated and areexpected to be removed for WASI 1.0 and the corresponding stable edition of theComponent Model. Consequently, it does not make sense anymore to requireembedders to explicitly call the post-return function after using`[Typed]Func::call[_async]`.As of this commit, `[Typed]Func::post_return[_async]` are no-ops. Instead, thepost-return function is called automatically as part of`[Typed]Func::call[_async]` if present, which is how`[Typed]Func::call_concurrent` has worked all along. In addition, this commitfixes and tests a couple of cases where the task and/or thread was beingdisposed of before the post-return function was called.* address review feedback* test post-return function in more scenariosSpecifically, I've split the `invoke_post_return` test into multiple tests:- using `TypedFunc::call`- using `TypedFunc::call_async` with concurrency support enabled- using `TypedFunc::call_async` with concurrency support disabled- using `Func::call_async` with concurrency support disabled- using `TypedFunc::call_concurrent`* remove GCC/clang-specific deprecation attributeThis broke the MSVC build.* bless bindgen output* remove obsolete post-return functions and fieldsNow that post-return calls are handled internally without requiring explicitaction by the embedder, we can avoid unnecessary bookkeeping. List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

bc4582c3 - Forbid rustdoc warnings in CI (#12420)

Tue, 27 Jan 2026 03:47:35 +0000

Forbid rustdoc warnings in CI (#12420)* Forbid rustdoc warnings in CIThis commit corrects our handling of rustdoc flags in CI to ensure thatwarnings indeed fire. Additionally this changes our flags to pass`-Dwarnings` to ensure that we have warning-free doc builds when allfeatures are enabled at least.There were quite a lot of preexisting issues to fix, so thisadditionally goes through and fixes all the warnings that cropped up.* Update nightly toolchain againprtest:full* Update another nightly* Fix a warning in generated code List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

b856261d - refactor recursive reentrance checks (#12349)

Wed, 14 Jan 2026 22:27:49 +0000

refactor recursive reentrance checks (#12349)* refactor recursive reentrance checksThis commit makes a few changes related to recursive reentrance checks, instancepoisoning, etc.:- Implements the more restrictive lift/lower rules described in https://github.com/WebAssembly/component-model/pull/589 such that a component instance may not lower a function lifted by one of its ancestors, nor vice-versa. Any such lower will result in a fused adapter which traps unconditionally, preventing guest-to-guest recursive reentrance without requiring data flow analysis. - Note that this required updating several WAST tests which were violating the new rule, including some in the `tests/component-model` Git submodule, which I've updated. - This is handled entirely in the `fact` module now; I've removed the `AlwaysTrap` case previously handled by `wasmtime-cranelift`.- Removes `FLAG_MAY_ENTER` from `InstanceFlags`. It is no longer needed for guest-to-guest calls due to the above, and for guest-to-host-to-guest calls we can rely on either `FLAG_NEEDS_POST_RETURN` for sync-lifted functions or the `GuestTask` call stack for async-lifted functions.- Adds a `StoreOpaque::trapped` field which is set when _any_ instance belonging to that store traps, at which point the entire store is considered poisoned, meaning no instance belonging to it may be entered. This prevents indeterminant concurrent task state left over from the trapping instance from leaking into other instances.Note that this does _not_ include code to push and pop `GuestTask` instances forguest-to-guest sync-to-sync calls, nor for host-to-guest calls using e.g. thesynchronous `Func::call` API, so certain intrinsics which expect a `GuestTask`to be present such as `backpressure.inc` will still fail in such cases. I'lladdress that in a later PR.Also note that I made a small change to `wasmtime-wit-bindgen`, adding a `Send`bound on the `T` type parameter for `store | async` functions. This allowed meto recursively call `{Typed}Func::call_concurrent` from inside a host function,and it doesn't have any downsides AFAICT.Fixes #12128* bless bindgen expansions* bless disas tests* address review feedback* sync `trap.h` with `trap_encoding.rs`...and add const assertions to `trap.rs` to help avoid future divergence. List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

9a874100 - Fix generated code for `anyhow: true` in wit-bindgen (#12334)

Tue, 13 Jan 2026 22:00:07 +0000

Fix generated code for `anyhow: true` in wit-bindgen (#12334)* Fix generated code for `anyhow: true` in wit-bindgenThe trait was still declared as using `wasmtime::Result`. It now uses`wasmtime::anyhow::Result` and we re-export `anyhow` through `wasmtime::anyhow`-- with `doc(hidden)` since it is only for macro-generated code -- when the`anyhow` cargo feature is enabled.* Fix macro expansion test expectations List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

fb1827ee - `wit-bindgen`: Add an option to use `anyhow::Result` instead of `wasmtime::Result` (#12331)

Tue, 13 Jan 2026 18:46:48 +0000

`wit-bindgen`: Add an option to use `anyhow::Result` instead of `wasmtime::Result` (#12331)* wit-bindgen: Add an option to use `anyhow::Result` instead of `wasmtime::Result`* Add option to reference docs* Rename `anyhow` dev dependency to `anyhow-for-testing` List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

e63dd69f - Update wasm-tools dependencies (#12254)

Wed, 07 Jan 2026 18:44:38 +0000

Update wasm-tools dependencies (#12254)* Update wasm-tools dependenciesBrings in binary-parsing support for the WIT `map` type as well as thewasm compact-imports proposal. Neither of these are enabled by defaultand will continue to be rejected, but it'll now be possible to supportthem without needing to update dependencies.* Add vets* Update test expectations, add testsCloses #12166 List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

96e19700 - Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)

Wed, 07 Jan 2026 17:08:11 +0000

Migrate the `wasmtime` crate to `wasmtime_environ::error::*` (#12231)* Migrate the `wasmtime` crate to `wasmtime_environ::error::*`Instead of `anyhow::Error`.This commit re-exports the `wasmtime_environ::error` as the `wasmtime::error`module, updates the prelude to include these new error-handling types, redirectsour top-level `wasmtime::{Error, Result}` re-exports to re-export`wasmtime::error::{Error, Result}`, and updates various use sites that weredirectly using `anyhow` to use the new `wasmtime` versions.This process also required updating the component macro and wit-bindgen macro touse the new error types instead of `anyhow`.Part of https://github.com/bytecodealliance/wasmtime/issues/12069* Replace wasmtime::error::Thing with wasmtime::Thing where it makes sense* cargo fmt* Move `crate::error::Thing` to `crate::Thing` where it makes sense List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

fee9be21 - Add a new fuzzer focused on component-model-async events (#12119)

Tue, 09 Dec 2025 19:32:20 +0000

Add a new fuzzer focused on component-model-async events (#12119)* Add a new fuzzer focused on component-model-async eventsThis commit adds a new fuzzer mode to the `misc` fuzzer of Wasmtimewhich is focused on async events and interleavings of components usingthe component-model-async proposal. This fuzzer works by having aprecompiled guest program which serves as the component to run. Thisprecompiled component has a custom `fuzz.wit` which is used to interfacewith the fuzzer itself. The fuzzer is then a fuzz-generated sequence ofcommands to send to the component which verifies that everythingexecutes correctly, has no panics, etc.This fuzzer intends to stress async communication and taskinfrastructure with component-model-async. Notably this does not stresslifting/lowering or arbitrary type signatures. This does, however,permute all of the following:* Guest/host interactions (also guest/guest, host/host, etc).* Async functions, both ready and pending.* Future operations: reads, writes, cancellation, transfers, etc.* Stream operations: reads, writes, cancellation, transfers, etc.This is all throwing into a large "soup" and then asserted to workcorrectly. There's a few gotchas here and there for how this fuzzer isdesigned, such as some events requiring "yield N times to await thisevent happening". This is required because Wasmtime is allowed tonon-deterministically select between a number of "ready events" and whatto dispatch.This is not intended to be a one-size-fits-all fuzzer forcomponent-model-async. The recent enhancements to the `component_api`fuzzer are intended to complement this fuzzer in terms of what'sstressed where internally.* Review comments List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

e2f9ca6b - Relax required host capabilities in wasip3 tcp/udp bindings (#12085)

Mon, 24 Nov 2025 22:31:07 +0000

Relax required host capabilities in wasip3 tcp/udp bindings (#12085)Don't require `async | store` when it's not necessary as this'll soonhave ramifications on the type of the function being bound in thecomponent model. List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

8c03849b - Use `.` instead of `/` for interface members. (#11947)

Mon, 27 Oct 2025 21:23:36 +0000

Use `.` instead of `/` for interface members. (#11947)* Use `.` instead of `/` for interface members.In the `wasmtime::component::generate` macro, change the syntax forreferencing functions and types inside interfaces to use `.` insteadof `/`.For example, this changes strings like `wasi:http/types/outgoing-body`to `wasi:http/types.outgoing-body`.This makes the syntax more consistent with the syntax of[WIT `use` statements], which use `.` for this purpose.And, it avoids an incompatibility with the future nested namespaces syntax([��]), where the `/d` in `a:b/c/d` is for traversing a component exportrather than an interface member.[WIT `use` statements]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/WIT.md#wit-packages-and-use[��]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#gated-features* Use the new syntax in more places.* Revert changes to vendored WIT files.* Revert more changes to vendored files.* Update syntax in more places. List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

4dd4b890 - Fix(wit_bindgen): use declared defaults to decide on `Send` Bounds in `Wastime::world_add_to_linker` (#11761)

Wed, 01 Oct 2025 14:15:35 +0000

Fix(wit_bindgen): use declared defaults to decide on `Send` Bounds in `Wastime::world_add_to_linker` (#11761)* feat: make FonctionConfig.default pub(crate)Signed-off-by: Antoine Lavandier * fix: use declared imports/exports defaults when deciding on Send boundsSigned-off-by: Antoine Lavandier * fix: add Send bound on relevant test outputSigned-off-by: Antoine Lavandier * fix(tests): add test using imports to define send boundsSigned-off-by: Antoine Lavandier * fix(fmt): make rustfmt happySigned-off-by: Antoine Lavandier * fix(fmt): actually make rustfmt happy this timeSigned-off-by: Antoine Lavandier ---------Signed-off-by: Antoine Lavandier List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

080faa1a - add `task_exit` option to `wasmtime-wit-bindgen` (#11665)

Wed, 10 Sep 2025 20:27:13 +0000

add `task_exit` option to `wasmtime-wit-bindgen` (#11665)This builds on #11662 by optionally exposing the `TaskExit` return value from`[Typed]Func::call_concurrent` in the bindings generated for exported functions.Note that the first two commits are shared with #11662.Fixes #11600Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

f75ae788 - return `TaskExit` future from `[Typed]Func::call_concurrent` (#11662)

Wed, 10 Sep 2025 16:37:25 +0000

return `TaskExit` future from `[Typed]Func::call_concurrent` (#11662)* return `TaskExit` future from `[Typed]Func::call_concurrent`In addition to returning the value produced by the callee, these functions nowalso return a `TaskExit` future which resolves once the subtask (and anytransitively-created subtasks) have exited. This partially addresses #11600;the next step will be to add a `wasmtime-wit-bindgen` option to expose the`TaskExit` value in generated bindings.Signed-off-by: Joel Dice * address review feedback`TaskExit` now has an `async fn block` instead of closing over an `implAsAccessor` and implementing `Future`.Signed-off-by: Joel Dice ---------Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

9f47be2e - Support store-access in `bindgen!` generated imports (#11628)

Fri, 05 Sep 2025 21:28:49 +0000

Support store-access in `bindgen!` generated imports (#11628)* Support store-access in `bindgen!` generated importsThis commit adds support to accessing the store in `bindgen!`-generatedimport functions in traits. Since the inception of `bindgen!` this hasnever been possible and access to the store requires manually workingwith `Linker`, for example. This is not easy to do because it requiressurgically editing code or working around what bindings generation partsyou do want.The implementation here is a small step away from whatcomponent-model-async has already implemented for async functions.Effectively it's a small extension of the `*WithStore` traits to alsohave synchronous functions with `Access` parameters instead of `async`functions with an `Accessor` parameter.This is something we're going to want for the WASIp3 implementationwhere I've noticed some resource destructors are going to want access tothe store to close out streams and such and this'll provide the bindingsnecessary for that.Closes #11590* Update test expectations List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

5764da5f - Revamp component model stream/future host API (again) (#11515)

Thu, 04 Sep 2025 21:12:18 +0000

Revamp component model stream/future host API (again) (#11515)* Revamp component model stream/future host API (again)This changes the host APIs for dealing with futures and streams from a"rendezvous"-style API to a callback-oriented one.Previously you would create e.g. a `StreamReader`/`StreamWriter` pair and calltheir `read` and `write` methods, respectively, and those methods would return`Future`s that resolved when the operation was matched with a corresponding`write` or `read` operation on the other end.With the new API, you instead provide a `StreamProducer` trait implementationwhe creating the stream, whose `produce` method will be called as soon as a readhappens, giving the implementation a chance to respond immediately withoutmaking the reader wait for a rendezvous. Likewise, you can match the read endof a stream to a `StreamConsumer` to respond immediately to writes. This modelshould reduce scheduling overhead and make it easier to e.g. pipe items to/from`AsyncWrite`/`AsyncRead` or `Sink`/`Stream` implementations without needing toexplicitly spawn background tasks. In addition, the new API provides directaccess to guest read and write buffers for `stream` operations, enablingzero-copy operations.Other changes:- I've removed the `HostTaskOutput`; we were using it to run extra code with access to the store after a host task completes, but we can do that more elegantly inside the future using `tls::get`. This also allowed me to simplify `Instance::poll_until` a bit.- I've removed the `watch_{reader,writer}` functionality; it's not needed now given that the runtime will automatically dispose of the producer or consumer when the other end of the stream or future is closed -- no need for embedder code to manage that.- In order to make `UntypedWriteBuffer` `Send`, I had to wrap its raw pointer `buf` field in a `SendSyncPtr`.- I've removed `{Future,Stream}Writer` entirely and moved `Instance::{future,stream}` to `{Future,Stream}Reader::new`, respectively.- I've added a bounds check to the beginnings of `Instance::guest_read` and `Instance::guest_write` so that we need not do it later in `Guest{Source,Destination}::remaining`, meaning those functions can be infallible.Note that I haven't updated `wasmtime-wasi` yet to match; that will happen inone or more follow-up commits.Signed-off-by: Joel Dice * Add `Accessor::getter`, rename `with_data` to `with_getter`* fixup bindgen invocationSigned-off-by: Roman Volosatovs * add support for zero-length writes/reads to/from hostI've added a test to cover this; it also tests direct buffer access for`stream`, which I realized I forgot to cover earlier. And of course therewas a bug :facepalm:.Signed-off-by: Joel Dice * add `{Destination,Source}::remaining` methodsThis can help `Stream{Producer,Consumer}` implementations determine how manyitems to write or read, respectively.Signed-off-by: Joel Dice * wasi: migrate sockets to new APISigned-off-by: Roman Volosatovs * tests: read the socket stream until EOFSigned-off-by: Roman Volosatovs * p3-sockets: account for cancellationSigned-off-by: Roman Volosatovs * p3-sockets: mostly ensure byte buffer cancellation-safetySigned-off-by: Roman Volosatovs * p3-filesystem: switch to new APISigned-off-by: Roman Volosatovs * fixup! p3-sockets: mostly ensure byte buffer cancellation-safety* p3-cli: switch to new APISigned-off-by: Roman Volosatovs * p3: limit maximum buffer sizeSigned-off-by: Roman Volosatovs * p3-sockets: remove reuseaddr test loop workaroundSigned-off-by: Roman Volosatovs * p3: drive I/O in `when_ready`Signed-off-by: Roman Volosatovs * fixup! p3: drive I/O in `when_ready`* Refine `Stream{Producer,Consumer}` APIsPer conversations last week with Roman, Alex, and Lann, I've updated thesetraits to present a lower-level API based on `poll_{consume,produce}` functionsand have documented the implementation requirements for various scenarios whichhave come up in `wasmtime-wasi`, particularly around graceful cancellation. Seethe doc comments for those functions for details.Signed-off-by: Joel Dice * being integration of new APISigned-off-by: Roman Volosatovs * update wasi/src/p3/filesystem to use new stream APIThis is totally untested so far; I'll run the tests once we have everything elsecompiling.Signed-off-by: Joel Dice * update wasi/src/p3/cli to use new stream APIThis is totally untested and doesn't even compile yet due to a lifetime issue Idon't have time to address yet. I'll follow up later with a fix.Signed-off-by: Joel Dice * fix: remove `'a` bound on `&self`Signed-off-by: Roman Volosatovs * finish `wasi:sockets` adaptationSigned-off-by: Roman Volosatovs * finish `wasi:cli` adaptationNote, that this removes the read optimization - let's get theimplementation complete first and optimize laterSigned-off-by: Roman Volosatovs * remove redundant loop in socketsSigned-off-by: Roman Volosatovs * wasi: buffer on 0-length readsSigned-off-by: Roman Volosatovs * finish `wasi:filesystem` adaptationSigned-off-by: Roman Volosatovs * remove `MAX_BUFFER_CAPACITY`Signed-off-by: Roman Volosatovs * refactor `Cursor` usageSigned-off-by: Roman Volosatovs * impl Default for VecBufferSigned-off-by: Roman Volosatovs * refactor: use consistent import stylingSigned-off-by: Roman Volosatovs * feature-gate fs Arc accessorsSigned-off-by: Roman Volosatovs * Update test expectations---------Signed-off-by: Joel Dice Signed-off-by: Roman Volosatovs Co-authored-by: Alex Crichton Co-authored-by: Roman Volosatovs List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs

7ccd258c - Use `trappable_error_type` in WASIp3 sockets (#11373)

Fri, 01 Aug 2025 23:40:24 +0000

Use `trappable_error_type` in WASIp3 sockets (#11373)This commit updates to using the `trappable_error_type` in bindingsgenerated for WASIp3 to mirror what happens in WASIp2, removing an extra`Result>` layer to only have one layer of results. List of files: /wasmtime-44.0.1/crates/wit-bindgen/src/lib.rs