Stream: git-wasmtime

Topic: wasmtime / PR #14872 [DO NOT REVIEW] Fill gaps in the emb...

Wasmtime GitHub notifications bot (Oct 19 2026 at 22:27):

jrandolf edited PR #14872.

Wasmtime GitHub notifications bot (Oct 20 2026 at 01:09):

github-actions[bot] added the label wasmtime:api on PR #14872.

Wasmtime GitHub notifications bot (Oct 20 2026 at 01:09):

github-actions[bot] added the label wasmtime:c-api on PR #14872.

Wasmtime GitHub notifications bot (Oct 20 2026 at 20:39):

jrandolf updated PR #14872.

Wasmtime GitHub notifications bot (Oct 20 2026 at 22:19):

jrandolf updated PR #14872.

Wasmtime GitHub notifications bot (Oct 21 2026 at 18:23):

jrandolf updated PR #14872.

Wasmtime GitHub notifications bot (Oct 21 2026 at 18:50):

jrandolf edited PR #14872:

This fills the gaps from #14862 in how implements and external-id are exposed to embedders:

• Component::get_export_extern and Instance::get_export_extern return an export's attributes along with its type and index, with C and C++ versions.
• Type imports at the root of a component now show up in component_type().imports(), like root type exports do.
• ComponentExtern no longer borrows the Engine, so the named_imports code from bindgen! drops its workaround for that.
• ComponentExtern is now #[non_exhaustive], so fields can be added later.

Closes #14862

<details>
<summary>LLM summary of the changes</summary>

1. Looking up an export together with its attributes

The problem: Component::get_export and Instance::get_export return a ComponentItem, which is only the type. The implements and external-id of an export were only reachable by walking component_type().exports(). Wasmtime already stored them next to each export name, in NameMap<_, (ExportIndex, ComponentExternData)>, but nothing read them.

The change:

• Component::get_export_extern(instance, name) returns Option<(types::ComponentExtern, ComponentExportIndex)>: the type plus implements and external_id, and the index to pass to get_func and the other lookups.
• Instance::get_export_extern(store, instance, name) does the same for an instance. It builds the type from the instance's real resource types, so the result borrows from the store.
• How it works: a new lookup_export_extern returns the export index and the stored attribute data. The existing ExportLookup for str now shares the name-map lookup with it (lookup_export_by_name). A small constructor, ComponentExtern::from_parts, joins the type and the attributes.
• It takes a &str, not impl ExportLookup. Attributes belong to the name an item is exported under, so a lookup that starts from a ComponentExportIndex has no name to read them from.
• C API: wasmtime_component_get_export_extern and wasmtime_component_instance_get_export_extern return the export index and write a wasmtime_component_extern_t to an out-parameter. A name that isn't valid UTF-8 returns NULL.
• C++: Component::export_extern and Instance::get_export_extern return std::optional<std::pair<ComponentExtern, ExportIndex>>.
• Docs: get_export now points to the new methods.

2. Type imports at the root now show up in component_type().imports()

The problem: a root import like (import "t" (external-id "x") (type (eq $u))) was missing from the component's reported type, while root type exports and nested component types were listed. In inline.rs, type imports continue before reaching import_types, which is the list the Linker has to satisfy, and ComponentTypesBuilder::finish built the reported imports from that list.

The change:

• inline.rs now records every root import, types included, with a new types.push_root_import(..) called before that continue.
• finish builds the reported imports from that full list, in declaration order.
• import_types itself is unchanged. Type imports still don't need to be defined in a Linker, and define_unknown_imports_as_* still walks import_types, so it isn't affected.

3. ComponentExtern no longer borrows the Engine

The problem: ComponentExtern<'a> from types::Component and types::ComponentInstance was tied to the &'a Engine borrow, even though its strings only borrow from the type. So ty.get_import(&engine.clone(), "p") didn't compile.

The change:

• get_import and get_export take a plain &Engine.
• imports() and exports() clone the engine (a cheap Arc clone) into the iterator and declare + use<'a>, so the iterator only borrows the type.
• The C API getters drop the 'a on their engine parameter, and the C++ docs now say the result borrows from the type only.

Knock-on change in wit-bindgen/src/lib.rs: the add_to_linker that bindgen! generates for named_imports worked around the old borrow. It cloned the engine and collected matching imports first, then defined them in a second loop. It now does both in one loop: iterate component_ty.imports(linker.engine()), skip imports where is_implements is false, then call lookup(name)? and linker.instance(name)?.

Side effect: if lookup fails partway through, the imports that matched before it are already defined in the linker. Before, nothing was defined unless every lookup succeeded.

4. ComponentExtern is #[non_exhaustive]

This leaves room to add fields later, such as a version suffix for canonical names. It breaks code that builds the struct with a literal or destructures it exhaustively. Nothing in the repo does, and only Wasmtime produces it.

Tests

• tests/all/component_model/aot.rs: external_id_shows_up adds a root type import and checks that it shows up as a record type with its external-id. A new export_extern_lookup checks get_export_extern on both the component and the instance, at the top level and nested.
• crates/c-api/tests/component/lookup_func.cc: a new lookup_export_extern test covers the C++ wrappers in the same way.

</details>

Last updated: Oct 31 2026 at 23:03 UTC