diff --git a/configure.py b/configure.py
index 9b56a041c4b0..fc85ae303c29 100755
--- a/configure.py
+++ b/configure.py
@@ -1052,6 +1052,7 @@ def find_headers(repodir, excluded_dirs):
                 'service/raft/raft_group0.cc',
                 'direct_failure_detector/failure_detector.cc',
                 'service/raft/raft_group0_client.cc',
+                'rust/wasmtime_bindings/src/lib.rs',
                 ] + [Antlr3Grammar('cql3/Cql.g')] + [Thrift('interface/cassandra.thrift', 'Cassandra')] \
                   + scylla_raft_core
                )
@@ -1418,18 +1419,6 @@ def clang_inline_threshold():
     for mode in modes:
         modes[mode]['cxxflags'] += f' -Wstack-usage={modes[mode]["stack-usage-threshold"]} -Wno-error=stack-usage='
 
-has_wasmtime = False
-
-if has_wasmtime:
-    if platform.machine() == 'aarch64':
-        print("wasmtime is temporarily not supported on aarch64. Ref: issue #9387")
-        has_wasmtime = False
-    else:
-        for mode in modes:
-            modes[mode]['cxxflags'] += ' -DSCYLLA_ENABLE_WASMTIME'
-else:
-    print("wasmtime not found - WASM support will not be enabled in this build")
-
 linker_flags = linker_flags(compiler=args.cxx)
 
 dbgflag = '-g -gz' if args.debuginfo else ''
@@ -1747,8 +1736,6 @@ def configure_abseil(build_dir, mode, mode_config):
                  maybe_static(args.staticboost, '-lboost_date_time -lboost_regex -licuuc -licui18n'),
                  '-lxxhash',
                 ])
-if has_wasmtime:
-    print("Found wasmtime dependency, linking with libwasmtime")
 
 if not args.staticboost:
     args.user_cflags += ' -DBOOST_TEST_DYN_LINK'
@@ -1934,8 +1921,6 @@ def configure_abseil(build_dir, mode, mode_config):
                     for src in srcs
                     if src.endswith('.cc')]
             objs.append('$builddir/../utils/arch/powerpc/crc32-vpmsum/crc32.S')
-            if has_wasmtime:
-                objs.append('/usr/lib64/libwasmtime.a')
             has_thrift = False
             has_rust = False
             for dep in deps[binary]:
diff --git a/lang/wasm.cc b/lang/wasm.cc
index 933b593ea80f..9373e43826c7 100644
--- a/lang/wasm.cc
+++ b/lang/wasm.cc
@@ -6,8 +6,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-#ifdef SCYLLA_ENABLE_WASMTIME
-
 #include "wasm.hh"
 #include "wasm_instance_cache.hh"
 #include "concrete_types.hh"
@@ -19,140 +17,54 @@
 #include <seastar/core/coroutine.hh>
 #include <seastar/util/defer.hh>
 #include "seastarx.hh"
+#include "rust/cxx.h"
+#include "rust/wasmtime_bindings.hh"
+#include <seastar/coroutine/maybe_yield.hh>
 
 static logging::logger wasm_logger("wasm");
 
 namespace wasm {
 
-context::context(wasm::engine* engine_ptr, std::string name, instance_cache* cache) : engine_ptr(engine_ptr), function_name(name), cache(cache) {
+context::context(rust::Box<wasmtime::Engine>* engine_ptr, std::string name, instance_cache* cache) : engine_ptr(engine_ptr), function_name(name), cache(cache) {
 }
 
 static constexpr size_t WASM_PAGE_SIZE = 64 * 1024;
 
-static uint32_t get_abi(wasmtime::Instance& instance, wasmtime::Store& store, uint8_t* data) {
-    auto abi_export = instance.get(store, "_scylla_abi");
-    if (!abi_export) {
-        throw wasm::exception(format("ABI version export not found - please export `_scylla_abi` in the wasm module"));
-    }
-    wasmtime::Global* abi_global = std::get_if<wasmtime::Global>(&*abi_export);
-    if (!abi_global) {
-        throw wasm::exception(format("Exported object {} is not a global", "_scylla_abi"));
-    }
-    wasmtime::Val abi_val = abi_global->get(store);
-    return seastar::read_le<uint32_t>((char*)data + abi_val.i32());
-}
-
-static wasmtime::Func import_func(wasmtime::Instance& instance, wasmtime::Store& store, std::string_view name) {
-    auto func_export = instance.get(store, name);
-    if (func_export) {
-        wasmtime::Func* func = std::get_if<wasmtime::Func>(&*func_export);
-        if (!func) {
-            throw wasm::exception(format("Exported object {} is not a function", name));
-        }
-        return std::move(*func);
-    } else {
-        throw wasm::exception(format("Function {} was not found in given wasm source code", name));
-    }
-}
-
-static wasmtime::Val call_func(wasmtime::Store& store, wasmtime::Func func, std::vector<wasmtime::Val> argv) {
-    auto result = func.call(store, argv);
-    if (!result) {
-        throw wasm::exception("Calling wasm function failed: " + result.err().message());
-    }
-    std::vector<wasmtime::Val> result_vec = std::move(result).unwrap();
-    if (result_vec.size() != 1) {
-        throw wasm::exception(format("Unexpected number of returned values: {} (expected: 1)", result_vec.size()));
-    }
-    return std::move(result_vec[0]);
-}
-
-static void call_void_func(wasmtime::Store& store, wasmtime::Func func, std::vector<wasmtime::Val> argv) {
-    auto result = func.call(store, argv);
-    if (!result) {
-        throw wasm::exception("Calling wasm function failed: " + result.err().message());
-    }
-    std::vector<wasmtime::Val> result_vec = std::move(result).unwrap();
-    if (result_vec.size() != 0) {
-        throw wasm::exception(format("Unexpected number of returned values: {} (expected: 0)", result_vec.size()));
-    }
-}
-
-static std::pair<wasmtime::Instance, wasmtime::Func> create_instance_and_func(context& ctx, wasmtime::Store& store) {
-    auto linker = wasmtime::Linker(ctx.engine_ptr->get());
-    auto wasi_def = linker.define_wasi();
-    if (!wasi_def) {
-        throw wasm::exception(format("Setting up wasi failed: {}", wasi_def.err().message()));
-    }
-    auto cfg = wasmtime::WasiConfig();
-    auto set_cfg = store.context().set_wasi(std::move(cfg));
-    if (!set_cfg) {
-        throw wasm::exception(format("Setting up wasi failed: {}", set_cfg.err().message()));
-    }
-    auto instance_res = linker.instantiate(store, *ctx.module);
-    if (!instance_res) {
-        throw wasm::exception(format("Creating a wasm runtime instance failed: {}", instance_res.err().message()));
-    }
-    auto instance = instance_res.unwrap();
-    auto function_obj = instance.get(store, ctx.function_name);
-    if (!function_obj) {
-        throw wasm::exception(format("Function {} was not found in given wasm source code", ctx.function_name));
-    }
-    wasmtime::Func* func = std::get_if<wasmtime::Func>(&*function_obj);
-    if (!func) {
-        throw wasm::exception(format("Exported object {} is not a function", ctx.function_name));
-    }
-    return std::make_pair(std::move(instance), std::move(*func));
-}
-
-void compile(context& ctx, const std::vector<sstring>& arg_names, std::string script) {
-    wasm_logger.debug("Compiling script {}", script);
-    auto module = wasmtime::Module::compile(ctx.engine_ptr->get(), script);
-    if (!module) {
-        throw wasm::exception(format("Compilation failed: {}", module.err().message()));
-    }
-    ctx.module = module.unwrap();
-    // Create the instance and extract function definition for validation purposes only
-    wasmtime::Store store(ctx.engine_ptr->get());
-    create_instance_and_func(ctx, store);
-}
-
-static void init_abstract_arg(const abstract_type& t, const bytes_opt& param, std::vector<wasmtime::Val>& argv, wasmtime::Store& store, wasmtime::Instance& instance) {
+static void init_abstract_arg(const abstract_type& t, const bytes_opt& param, wasmtime::ValVec& argv, wasmtime::Store& store, wasmtime::Instance& instance) {
         // set up exported memory's underlying buffer,
         // `memory` is required to be exported in the WebAssembly module
-        auto memory_export = instance.get(store, "memory");
-        if (!memory_export) {
-            throw wasm::exception("memory export not found - please export `memory` in the wasm module");
-        }
-        auto memory = std::get<wasmtime::Memory>(*memory_export);
-        uint8_t* data = memory.data(store).data();
-        size_t mem_size = memory.size(store) * WASM_PAGE_SIZE;
-        int32_t serialized_size = param ? param->size() : 0;
-        if (serialized_size > std::numeric_limits<int32_t>::max()) {
+        auto memory = wasmtime::get_memory(instance, store);
+        size_t mem_size = memory->size(store) * WASM_PAGE_SIZE;
+        if (param && param->size() > std::numeric_limits<int32_t>::max()) {
             throw wasm::exception(format("Serialized parameter is too large: {} > {}", param->size(), std::numeric_limits<int32_t>::max()));
         }
-        switch (uint32_t abi_ver = get_abi(instance, store, data)) {
-            case 1: {
-                auto grown = memory.grow(store, 1 + (sizeof(int32_t) + serialized_size - 1) / WASM_PAGE_SIZE); // for fitting serialized size + the buffer itself
-                if (!grown) {
-                    throw wasm::exception(format("Failed to grow wasm memory to {}: {}", serialized_size, grown.err().message()));
+        int32_t serialized_size = param ? param->size() : 0;
+        if (param) {
+            switch (uint32_t abi_ver = wasmtime::get_abi(instance, store, *memory)) {
+                case 1: {
+                    auto pre_grow = memory->grow(store, 1 + (serialized_size - 1) / WASM_PAGE_SIZE);
+                    mem_size = pre_grow * WASM_PAGE_SIZE;
+                    break;
                 }
-                mem_size = std::move(grown).unwrap() * WASM_PAGE_SIZE;
-                break;
-            }
-            case 2: {
-                auto malloc_func = import_func(instance, store, "_scylla_malloc");
-                import_func(instance, store, "_scylla_free");
-                auto size = call_func(store, malloc_func, {int32_t(sizeof(int32_t) + serialized_size)});
-                mem_size = size.i32();
-                break;
+                case 2: {
+                    auto malloc_func = wasmtime::create_func(instance, store, "_scylla_malloc");
+                    wasmtime::create_func(instance, store, "_scylla_free");
+                    auto argv = wasmtime::get_val_vec();
+                    argv->push_i32(serialized_size);
+                    auto rets = wasmtime::get_val_vec();
+                    rets->push_i32(0);
+
+                    auto fut = wasmtime::get_func_future(store, *malloc_func, *argv, *rets);
+                    while(!fut->resume());
+                    auto val = rets->pop_val();
+                    mem_size = val->i32();
+                    break;
+                }
+                default:
+                    throw wasm::exception(format("ABI version {} not recognized", abi_ver));
             }
-            default:
-                throw wasm::exception(format("ABI version {} not recognized", abi_ver));
-        }
-        if (param) {
             // put the argument in wasm module's memory
-            std::memcpy(data + mem_size, param->data(), serialized_size);
+            std::memcpy(memory->data(store) + mem_size, param->data(), serialized_size);
         } else {
             // size of -1 means that the value is null
             serialized_size = -1;
@@ -160,49 +72,42 @@ static void init_abstract_arg(const abstract_type& t, const bytes_opt& param, st
 
         // the size of the struct in top 32 bits and the place inside wasm memory where the struct is placed in the bottom 32 bits
         int64_t arg_combined = ((int64_t)serialized_size << 32) | mem_size;
-        argv.push_back(arg_combined);
+        argv.push_i64(arg_combined);
 }
 
 struct init_arg_visitor {
     const bytes_opt& param;
-    std::vector<wasmtime::Val>& argv;
+    wasmtime::ValVec& argv;
     wasmtime::Store& store;
     wasmtime::Instance& instance;
 
     void operator()(const boolean_type_impl&) {
         auto dv = boolean_type->deserialize(*param);
-        auto val = wasmtime::Val(int32_t(value_cast<bool>(dv)));
-        argv.push_back(std::move(val));
+        argv.push_i32(int32_t(value_cast<bool>(dv)));
     }
     void operator()(const byte_type_impl&) {
         auto dv = byte_type->deserialize(*param);
-        auto val = wasmtime::Val(int32_t(value_cast<int8_t>(dv)));
-        argv.push_back(std::move(val));
+        argv.push_i32(int32_t(value_cast<int8_t>(dv)));
     }
     void operator()(const short_type_impl&) {
         auto dv = short_type->deserialize(*param);
-        auto val = wasmtime::Val(int32_t(value_cast<int16_t>(dv)));
-        argv.push_back(std::move(val));
+        argv.push_i32(int32_t(value_cast<int16_t>(dv)));
     }
     void operator()(const double_type_impl&) {
         auto dv = double_type->deserialize(*param);
-        auto val = wasmtime::Val(value_cast<double>(dv));
-        argv.push_back(std::move(val));
+        argv.push_f64(value_cast<double>(dv));
     }
     void operator()(const float_type_impl&) {
         auto dv = float_type->deserialize(*param);
-        auto val = wasmtime::Val(value_cast<float>(dv));
-        argv.push_back(std::move(val));
+        argv.push_f32(value_cast<float>(dv));
     }
     void operator()(const int32_type_impl&) {
         auto dv = int32_type->deserialize(*param);
-        auto val = wasmtime::Val(value_cast<int32_t>(dv));
-        argv.push_back(std::move(val));
+        argv.push_i32(value_cast<int32_t>(dv));
     }
     void operator()(const long_type_impl&) {
         auto dv = long_type->deserialize(*param);
-        auto val = wasmtime::Val(value_cast<int64_t>(dv));
-        argv.push_back(std::move(val));
+        argv.push_i64(value_cast<int64_t>(dv));
     }
 
     void operator()(const abstract_type& t) {
@@ -215,7 +120,7 @@ struct init_arg_visitor {
 
 struct init_nullable_arg_visitor {
     const bytes_opt& param;
-    std::vector<wasmtime::Val>& argv;
+    wasmtime::ValVec& argv;
     wasmtime::Store& store;
     wasmtime::Instance& instance;
 
@@ -261,12 +166,8 @@ struct from_val_visitor {
 
     bytes_opt operator()(const abstract_type& t) {
         expect_kind(wasmtime::ValKind::I64);
-        auto memory_export = instance.get(store, "memory");
-        if (!memory_export) {
-            throw wasm::exception("memory export not found - please export `memory` in the wasm module");
-        }
-        auto memory = std::get<wasmtime::Memory>(*memory_export);
-        uint8_t* mem_base = memory.data(store).data();
+        auto memory = wasmtime::get_memory(instance, store);
+        uint8_t* mem_base = memory->data(store);
         uint8_t* data = mem_base + (val.i64() & 0xffffffff);
         int32_t ret_size = val.i64() >> 32;
         if (ret_size == -1) {
@@ -274,9 +175,13 @@ struct from_val_visitor {
         }
         bytes_opt ret = t.decompose(t.deserialize(bytes_view(reinterpret_cast<int8_t*>(data), ret_size)));
 
-        if (get_abi(instance, store, mem_base) == 2) {
-            auto free_func = import_func(instance, store, "_scylla_free");
-            call_void_func(store, free_func, {wasmtime::Val((int32_t)val.i64())});
+        if (wasmtime::get_abi(instance, store, *memory) == 2) {
+            auto free_func = wasmtime::create_func(instance, store, "_scylla_free");
+            auto argv = wasmtime::get_val_vec();
+            argv->push_i32((int32_t)val.i64());
+            auto rets = wasmtime::get_val_vec();
+            auto free_fut = wasmtime::get_func_future(store, *free_func, *argv, *rets);
+            while(!free_fut->resume());
         }
 
         return ret;
@@ -290,8 +195,8 @@ struct from_val_visitor {
             "f32",
             "f64",
             "v128",
-            "externref",
             "funcref",
+            "externref",
         };
         if (val.kind() != expected) {
             throw wasm::exception(format("Incorrect wasm value kind returned. Expected {}, got {}", kind_str[size_t(expected)], kind_str[size_t(val.kind())]));
@@ -299,42 +204,51 @@ struct from_val_visitor {
     }
 };
 
+void compile(context& ctx, const std::vector<sstring>& arg_names, std::string script) {
+    try {
+        ctx.module = wasmtime::create_module(**ctx.engine_ptr, rust::Str(script.data(), script.size()));
+        auto store = wasmtime::create_store(**ctx.engine_ptr);
+        auto inst = create_instance(**ctx.engine_ptr, **ctx.module, *store);
+        create_func(*inst, *store, ctx.function_name);
+    } catch (const rust::Error& e) {
+        throw wasm::exception(e.what());
+    }
+}
 seastar::future<bytes_opt> run_script(context& ctx, wasmtime::Store& store, wasmtime::Instance& instance, wasmtime::Func& func, const std::vector<data_type>& arg_types, const std::vector<bytes_opt>& params, data_type return_type, bool allow_null_input) {
     wasm_logger.debug("Running function {}", ctx.function_name);
 
-    // Replenish the store with initial amount of fuel
-    auto added = store.context().add_fuel(ctx.engine_ptr->initial_fuel_amount());
-    if (!added) {
-        co_await coroutine::return_exception(wasm::exception(added.err().message()));
-    }
-    std::vector<wasmtime::Val> argv;
+    rust::Box<wasmtime::ValVec> argv = wasmtime::get_val_vec();
     for (size_t i = 0; i < arg_types.size(); ++i) {
         const abstract_type& type = *arg_types[i];
         const bytes_opt& param = params[i];
         // If nulls are allowed, each type will be passed indirectly
         // as a struct {bool is_null; int32_t serialized_size, char[] serialized_buf}
         if (allow_null_input) {
-            visit(type, init_nullable_arg_visitor{param, argv, store, instance});
+            visit(type, init_nullable_arg_visitor{param, *argv, store, instance});
         } else if (param) {
-            visit(type, init_arg_visitor{param, argv, store, instance});
+            visit(type, init_arg_visitor{param, *argv, store, instance});
         } else {
             co_await coroutine::return_exception(wasm::exception(format("Function {} cannot be called on null values", ctx.function_name)));
         }
     }
-    uint64_t fuel_before = *store.context().fuel_consumed();
-
-    auto result = func.call(store, argv);
-
-    uint64_t consumed = *store.context().fuel_consumed() - fuel_before;
-    wasm_logger.debug("Consumed {} fuel units", consumed);
-
-    if (!result) {
-        co_await coroutine::return_exception(wasm::instance_corrupting_exception("Calling wasm function failed: " + result.err().message()));
-    }
-    std::vector<wasmtime::Val> result_vec = std::move(result).unwrap();
-    if (result_vec.size() != 1) {
-      co_await coroutine::return_exception(wasm::exception(format("Unexpected number of returned values: {} (expected: 1)", result_vec.size())));
+    auto rets = wasmtime::get_val_vec();
+    rets->push_i32(0);
+
+    auto fut = wasmtime::get_func_future(store, func, *argv, *rets);
+    bool stop = false;
+    while (!stop) {
+        std::exception_ptr eptr;
+        try {
+            stop = fut->resume();
+        } catch (const rust::Error& e) {
+            eptr = std::make_exception_ptr(wasm::instance_corrupting_exception(format("Calling wasm function failed: {}", e.what())));
+        }
+        if (eptr) {
+            co_await coroutine::return_exception_ptr(eptr);
+        }
+        co_await coroutine::maybe_yield();
     }
+    auto result = rets->pop_val();
 
     // TODO: ABI for return values is experimental and subject to change in the future.
     // Currently, if a function is marked with `CALLED ON NULL INPUT` it is also capable
@@ -352,16 +266,21 @@ seastar::future<bytes_opt> run_script(context& ctx, wasmtime::Store& store, wasm
     if (allow_null_input) {
         // Force calling the default method for abstract_type, which checks for nulls
         // and expects a serialized input
-        co_return from_val_visitor{result_vec[0], store, instance}(static_cast<const abstract_type&>(*return_type));
+        co_return from_val_visitor{*result, store, instance}(static_cast<const abstract_type&>(*return_type));
     } else {
-        co_return visit(*return_type, from_val_visitor{result_vec[0], store, instance});
+        co_return visit(*return_type, from_val_visitor{*result, store, instance});
     }
 }
 
 seastar::future<bytes_opt> run_script(context& ctx, const std::vector<data_type>& arg_types, const std::vector<bytes_opt>& params, data_type return_type, bool allow_null_input) {
-    auto store = wasmtime::Store(ctx.engine_ptr->get());
-    auto [instance, func] = create_instance_and_func(ctx, store);
-    return run_script(ctx, store, instance, func, arg_types, params, return_type, allow_null_input);
+    try {
+        auto store = wasmtime::create_store(**ctx.engine_ptr);
+        auto instance = wasmtime::create_instance(**ctx.engine_ptr, **ctx.module, *store);
+        auto func = wasmtime::create_func(*instance, *store, ctx.function_name);
+        return run_script(ctx, *store, *instance, *func, arg_types, params, return_type, allow_null_input);
+    } catch (const rust::Error& e) {
+        return make_exception_future<bytes_opt>(wasm::exception(e.what()));
+    }
 }
 
 seastar::future<bytes_opt> run_script(const db::functions::function_name& name, context& ctx, const std::vector<data_type>& arg_types, const std::vector<bytes_opt>& params, data_type return_type, bool allow_null_input) {
@@ -370,7 +289,7 @@ seastar::future<bytes_opt> run_script(const db::functions::function_name& name,
     bytes_opt ret;
     try {
         func_inst = ctx.cache->get(name, arg_types, ctx).get0();
-        ret = wasm::run_script(ctx, func_inst->instance->store, func_inst->instance->instance, func_inst->instance->func, arg_types, params, return_type, allow_null_input).get0();
+        ret = wasm::run_script(ctx, *func_inst->instance->store, *func_inst->instance->instance, *func_inst->instance->func, arg_types, params, return_type, allow_null_input).get0();
     } catch (const wasm::instance_corrupting_exception& e) {
         func_inst->instance = std::nullopt;
         ex = std::current_exception();
@@ -384,5 +303,3 @@ seastar::future<bytes_opt> run_script(const db::functions::function_name& name,
     return make_ready_future<bytes_opt>(ret);
 }
 }
-
-#endif
diff --git a/lang/wasm.hh b/lang/wasm.hh
index cb54b80df0a0..ccab937b1d94 100644
--- a/lang/wasm.hh
+++ b/lang/wasm.hh
@@ -10,8 +10,8 @@
 
 #include "types.hh"
 #include <seastar/core/future.hh>
-#include "lang/wasm_engine.hh"
 #include "db/functions/function_name.hh"
+#include "rust/wasmtime_bindings.hh"
 
 namespace wasm {
 
@@ -30,15 +30,13 @@ struct instance_corrupting_exception : public exception {
     explicit instance_corrupting_exception(std::string_view msg) : exception(msg) {}
 };
 
-#ifdef SCYLLA_ENABLE_WASMTIME
-
 struct context {
-    wasm::engine* engine_ptr;
-    std::optional<wasmtime::Module> module;
+    rust::Box<wasmtime::Engine>* engine_ptr;
+    std::optional<rust::Box<wasmtime::Module>> module;
     std::string function_name;
     instance_cache* cache;
 
-    context(wasm::engine* engine_ptr, std::string name, instance_cache* cache);
+    context(rust::Box<wasmtime::Engine>* engine_ptr, std::string name, instance_cache* cache);
 };
 
 void compile(context& ctx, const std::vector<sstring>& arg_names, std::string script);
@@ -47,25 +45,4 @@ seastar::future<bytes_opt> run_script(context& ctx, const std::vector<data_type>
 
 seastar::future<bytes_opt> run_script(const db::functions::function_name& name, context& ctx, const std::vector<data_type>& arg_types, const std::vector<bytes_opt>& params, data_type return_type, bool allow_null_input);
 
-#else
-
-struct context {
-    context(wasm::engine*, std::string, instance_cache*) {
-        throw wasm::exception("WASM support was not enabled during compilation!");
-    }
-};
-
-inline void compile(context&, const std::vector<sstring>&, std::string) {
-    throw wasm::exception("WASM support was not enabled during compilation!");
-}
-
-inline seastar::future<bytes_opt> run_script(context&, const std::vector<data_type>&, const std::vector<bytes_opt>&, data_type, bool) {
-    throw wasm::exception("WASM support was not enabled during compilation!");
-}
-
-inline seastar::future<bytes_opt> run_script(const db::functions::function_name& name, context& ctx, const std::vector<data_type>& arg_types, const std::vector<bytes_opt>& params, data_type return_type, bool allow_null_input) {
-    throw wasm::exception("WASM support was not enabled during compilation!");
-}
-#endif
-
 }
diff --git a/lang/wasm_engine.hh b/lang/wasm_engine.hh
deleted file mode 100644
index 480149002c91..000000000000
--- a/lang/wasm_engine.hh
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2021-present ScyllaDB
- */
-
-/*
- * SPDX-License-Identifier: AGPL-3.0-or-later
- */
-
-#pragma once
-
-#include <seastar/core/future.hh>
-#include <seastar/core/sharded.hh>
-
-#ifdef SCYLLA_ENABLE_WASMTIME
-
-#include "wasmtime.hh"
-
-namespace wasm {
-
-// Fuel defines more or less how many bytecode instructions
-// can be performed at once. Empirically, 20k units
-// allow for considerably less than 0.5ms of preemption-free execution time.
-// TODO: investigate other configuration variables.
-// We're particularly interested in limiting resource usage
-// and yielding in the middle of execution - which is possible
-// in the original wasmtime implementation for Rust and tightly
-// bound with its native async support, but not yet possible
-// in wasmtime.hh binding at the time of this writing.
-// It's highly probable that a more generic support for yielding
-// can be contributed to wasmtime.  
-constexpr uint64_t default_initial_fuel_amount = 20*1024;
-
-class engine {
-    wasmtime::Engine _engine;
-    uint64_t _initial_fuel_amount;
-public:
-    engine(uint64_t initial_fuel_amount = default_initial_fuel_amount)
-            : _engine(make_config())
-            , _initial_fuel_amount(initial_fuel_amount)
-        {}
-    wasmtime::Engine& get() { return _engine; }
-    uint64_t initial_fuel_amount() { return _initial_fuel_amount; };
-private:
-    wasmtime::Config make_config() {
-        wasmtime::Config cfg;
-        cfg.consume_fuel(true);
-        return cfg;
-    }
-};
-
-}
-
-#else
-
-namespace wasm {
-class engine {};
-}
-
-#endif
diff --git a/lang/wasm_instance_cache.cc b/lang/wasm_instance_cache.cc
index 28ff3d8d3f21..f6b1446a4115 100644
--- a/lang/wasm_instance_cache.cc
+++ b/lang/wasm_instance_cache.cc
@@ -6,8 +6,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-#ifdef SCYLLA_ENABLE_WASMTIME
-
 #include "lang/wasm_instance_cache.hh"
 #include "seastar/core/metrics.hh"
 #include "seastar/core/scheduling.hh"
@@ -49,37 +47,11 @@ instance_cache::instance_cache(size_t size, seastar::lowres_clock::duration time
 }
 
 wasm_instance instance_cache::load(wasm::context& ctx) {
-    auto store = wasmtime::Store(ctx.engine_ptr->get());
-    auto linker = wasmtime::Linker(ctx.engine_ptr->get());
-    auto wasi_def = linker.define_wasi();
-    if (!wasi_def) {
-        throw wasm::exception(format("Setting up wasi failed: {}", wasi_def.err().message()));
-    }
-    auto cfg = wasmtime::WasiConfig();
-    auto set_cfg = store.context().set_wasi(std::move(cfg));
-    if (!set_cfg) {
-        throw wasm::exception(format("Setting up wasi failed: {}", set_cfg.err().message()));
-    }
-    auto instance_res = linker.instantiate(store, *ctx.module);
-    if (!instance_res) {
-        throw wasm::exception(format("Creating a wasm runtime instance failed: {}", instance_res.err().message()));
-    }
-    auto instance = instance_res.unwrap();
-    auto function_obj = instance.get(store, ctx.function_name);
-    if (!function_obj) {
-        throw wasm::exception(format("Function {} was not found in given wasm source code", ctx.function_name));
-    }
-    wasmtime::Func* func = std::get_if<wasmtime::Func>(&*function_obj);
-    if (!func) {
-        throw wasm::exception(format("Exported object {} is not a function", ctx.function_name));
-    }
-    auto memory_export = instance.get(store, "memory");
-    if (!memory_export) {
-        throw wasm::exception("memory export not found - please export `memory` in the wasm module");
-    }
-    auto memory = std::get<wasmtime::Memory>(*memory_export);
-
-    return wasm::wasm_instance{.store=std::move(store), .instance=std::move(instance), .func=std::move(*func), .memory=std::move(memory)};
+    auto store = wasmtime::create_store(**ctx.engine_ptr);
+    auto instance = wasmtime::create_instance(**ctx.engine_ptr, **ctx.module, *store);
+    auto func = wasmtime::create_func(*instance, *store, ctx.function_name);
+    auto memory = wasmtime::get_memory(*instance, *store);
+    return wasm_instance{.store=std::move(store), .instance=std::move(instance), .func=std::move(func), .memory=std::move(memory)};
 }
 
 // lru must not be empty, and its elements must refer to entries in _cache
@@ -100,7 +72,7 @@ void instance_cache::on_timer() noexcept {
 
 static uint32_t get_instance_size(wasm_instance& instance) {
     // reserve 1 wasm page for instance data other than the wasm memory
-    return WASM_PAGE_SIZE * (1 + instance.memory.size(instance.store));
+    return WASM_PAGE_SIZE * (1 + instance.memory->size(*instance.store));
 }
 
 seastar::future<instance_cache::value_type> instance_cache::get(const db::functions::function_name& name, const std::vector<data_type>& arg_types, wasm::context& ctx) {
@@ -222,5 +194,3 @@ struct equal_to<seastar::scheduling_group> {
 };
 
 }
-
-#endif
diff --git a/lang/wasm_instance_cache.hh b/lang/wasm_instance_cache.hh
index 8c93bffd1474..8bab5fcc9b28 100644
--- a/lang/wasm_instance_cache.hh
+++ b/lang/wasm_instance_cache.hh
@@ -8,30 +8,6 @@
 
 #pragma once
 
-#ifndef SCYLLA_ENABLE_WASMTIME
-
-#include <cstddef>
-#include <seastar/core/lowres_clock.hh>
-#include "lang/wasm.hh"
-
-namespace wasm {
-
-struct instance_cache {
-    explicit instance_cache(size_t size, seastar::lowres_clock::duration timer_period) {}
-
-    void remove(const db::functions::function_name& name, const std::vector<data_type>& arg_types) {
-        throw wasm::exception("WASM support was not enabled during compilation!");
-    }
-
-    future<> stop() {
-        return seastar::make_ready_future<>();
-    }
-};
-
-}
-
-#else
-
 #include "db/functions/function_name.hh"
 #include <list>
 #include <seastar/core/metrics_registration.hh>
@@ -41,15 +17,16 @@ struct instance_cache {
 #include <seastar/core/timer.hh>
 #include <unordered_map>
 #include "lang/wasm.hh"
-#include "wasmtime.hh"
+#include "rust/cxx.h"
+#include "rust/wasmtime_bindings.hh"
 
 namespace wasm {
 
 struct wasm_instance {
-    wasmtime::Store store;
-    wasmtime::Instance instance;
-    wasmtime::Func func;
-    wasmtime::Memory memory;
+    rust::Box<wasmtime::Store> store;
+    rust::Box<wasmtime::Instance> instance;
+    rust::Box<wasmtime::Func> func;
+    rust::Box<wasmtime::Memory> memory;
 };
 
 // For each UDF full name and a scheduling group, we store a wasmtime instance
@@ -145,5 +122,3 @@ public:
 };
 
 }
-
-#endif
diff --git a/lang/wasmtime.hh b/lang/wasmtime.hh
deleted file mode 100644
index a909eeae9341..000000000000
--- a/lang/wasmtime.hh
+++ /dev/null
@@ -1,2665 +0,0 @@
-/**
- * Downloaded from https://github.com/bytecodealliance/wasmtime-cpp/blob/main/include/wasmtime.hh
- * License: Apache License 2.0
- */
-
-/**
- * \mainpage
- *
- * This project is a C++ API for
- * [Wasmtime](https://github.com/bytecodealliance/wasmtime). Support for the
- * C++ API is exclusively built on the [C API of
- * Wasmtime](https://docs.wasmtime.dev/c-api/), so the C++ support for this is
- * simply a single header file. To use this header file, though, it must be
- * combined with the header and binary of Wasmtime's C API. Note, though, that
- * while this header is built on top of the `wasmtime.h` header file you should
- * only need to use the contents of this header file to interact with Wasmtime.
- *
- * Examples can be [found
- * online](https://github.com/bytecodealliance/wasmtime-cpp/tree/main/examples)
- * and otherwise be sure to check out the
- * [README](https://github.com/bytecodealliance/wasmtime-cpp/blob/main/README.md)
- * for simple usage instructions. Otherwise you can dive right in to the
- * reference documentation of \ref wasmtime.hh
- *
- * \example hello.cc
- * \example gcd.cc
- * \example linking.cc
- * \example memory.cc
- * \example interrupt.cc
- * \example externref.cc
- */
-
-/**
- * \file wasmtime.hh
- */
-
-#ifndef WASMTIME_HH
-#define WASMTIME_HH
-
-#include <any>
-#include <initializer_list>
-#include <iostream>
-#include <limits>
-#include <memory>
-#include <optional>
-#include <variant>
-#include <vector>
-#ifdef __cpp_lib_span
-#include <span>
-#endif
-
-#include "wasmtime.h"
-
-namespace wasmtime {
-
-#ifdef __cpp_lib_span
-
-/// \brief Alias to C++20 std::span when it is available
-template <typename T, std::size_t Extent = std::dynamic_extent>
-using Span = std::span<T, Extent>;
-
-#else
-
-/// \brief Means number of elements determined at runtime
-inline constexpr size_t dynamic_extent =
-    std::numeric_limits<std::size_t>::max();
-
-/**
- * \brief Span class used when c++20 is not available
- * @tparam T Type of data
- * @tparam Extent Static size of data refered by Span class
- */
-template <typename T, std::size_t Extent = dynamic_extent> class Span {
-public:
-  /// \brief Type used to iterate over this span (a raw pointer)
-  using iterator = T *;
-
-  /// \brief Constructor of Span class
-  Span(T *t, std::size_t n) : ptr_{t}, size_{n} {}
-
-  /// \brief Constructor of Span class for containers
-  template <template <typename, typename> class Container>
-  Span(Container<T, std::allocator<T>> &range)
-      : ptr_{range.data()}, size_{range.size()} {}
-
-  /// \brief Returns item by index
-  T &operator[](ptrdiff_t idx) const {
-    return ptr_[idx]; // NOLINT
-  }
-
-  /// \brief Returns pointer to data
-  T *data() const { return ptr_; }
-
-  /// \brief Returns number of data that referred by Span class
-  std::size_t size() const { return size_; }
-
-  /// \brief Returns begin iterator
-  iterator begin() const { return ptr_; }
-
-  /// \brief Returns end iterator
-  iterator end() const {
-    return ptr_ + size_; // NOLINT
-  }
-
-  /// \brief Returns size in bytes
-  std::size_t size_bytes() const { return sizeof(T) * size_; }
-
-private:
-  T *ptr_;
-  std::size_t size_;
-};
-
-#endif
-
-/**
- * \brief Errors coming from Wasmtime
- *
- * This class represents an error that came from Wasmtime and contains a textual
- * description of the error that occurred.
- */
-class Error {
-  std::string msg;
-
-public:
-  /// \brief Creates an error from the raw C API representation
-  ///
-  /// Takes ownership of the provided `error`.
-  Error(wasmtime_error_t *error) {
-    wasm_byte_vec_t msg_bytes;
-    wasmtime_error_message(error, &msg_bytes);
-    msg = std::string(msg_bytes.data, msg_bytes.size);
-    wasm_byte_vec_delete(&msg_bytes);
-    wasmtime_error_delete(error);
-  }
-
-  /// \brief Returns the error message associated with this error.
-  std::string_view message() const { return msg; }
-};
-
-/// \brief Used to print an error.
-inline std::ostream &operator<<(std::ostream &os, const Error &e) {
-  os << e.message();
-  return os;
-}
-
-/**
- * \brief Fallible result type used for Wasmtime.
- *
- * This type is used as the return value of many methods in the Wasmtime API.
- * This behaves similarly to Rust's `Result<T, E>` and will be replaced with a
- * C++ standard when it exists.
- */
-template <typename T, typename E = Error> class Result {
-  std::variant<T, E> data;
-
-public:
-  /// \brief Creates a `Result` from its successful value.
-  Result(T t) : data(std::move(t)) {}
-  /// \brief Creates a `Result` from an error value.
-  Result(E e) : data(std::move(e)) {}
-
-  /// \brief Returns `true` if this result is a success, `false` if it's an
-  /// error
-  explicit operator bool() { return data.index() == 0; }
-
-  /// \brief Returns the error, if present, aborts if this is not an error.
-  E &&err() { return std::get<E>(std::move(data)); }
-  /// \brief Returns the error, if present, aborts if this is not an error.
-  const E &&err() const { return std::get<E>(std::move(data)); }
-
-  /// \brief Returns the success, if present, aborts if this is an error.
-  T &&ok() { return std::get<T>(std::move(data)); }
-  /// \brief Returns the success, if present, aborts if this is an error.
-  const T &&ok() const { return std::get<T>(std::move(data)); }
-
-  /// \brief Returns the success, if present, aborts if this is an error.
-  T unwrap() {
-    if (*this) {
-      return this->ok();
-    }
-    std::cerr << "error: " << this->err().message() << "\n";
-    std::abort();
-  }
-};
-
-/// \brief Strategies passed to `Config::strategy`
-enum class Strategy {
-  /// Automatically selects the compilation strategy
-  Auto = WASMTIME_STRATEGY_AUTO,
-  /// Requires Cranelift to be used for compilation
-  Cranelift = WASMTIME_STRATEGY_CRANELIFT,
-  /// Uses lightbeam for compilation (not supported)
-  Lightbeam = WASMTIME_STRATEGY_LIGHTBEAM,
-};
-
-/// \brief Values passed to `Config::cranelift_opt_level`
-enum class OptLevel {
-  /// No extra optimizations performed
-  None = WASMTIME_OPT_LEVEL_NONE,
-  /// Optimize for speed
-  Speed = WASMTIME_OPT_LEVEL_SPEED,
-  /// Optimize for speed and generated code size
-  SpeedAndSize = WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
-};
-
-/// \brief Values passed to `Config::profiler`
-enum class ProfilingStrategy {
-  /// No profiling enabled
-  None = WASMTIME_PROFILING_STRATEGY_NONE,
-  /// Profiling hooks via perf's jitdump
-  Jitdump = WASMTIME_PROFILING_STRATEGY_JITDUMP,
-  /// Profiling hooks via VTune
-  Vtune = WASMTIME_PROFILING_STRATEGY_VTUNE,
-};
-
-/**
- * \brief Configuration for Wasmtime.
- *
- * This class is used to configure Wasmtime's compilation and various other
- * settings such as enabled WebAssembly proposals.
- *
- * For more information be sure to consult the [rust
- * documentation](https://docs.wasmtime.dev/api/wasmtime/struct.Config.html).
- */
-class Config {
-  friend class Engine;
-
-  struct deleter {
-    void operator()(wasm_config_t *p) const { wasm_config_delete(p); }
-  };
-
-  std::unique_ptr<wasm_config_t, deleter> ptr;
-
-public:
-  /// \brief Creates configuration with all the default settings.
-  Config() : ptr(wasm_config_new()) {}
-
-  /// \brief Configures whether dwarf debuginfo is emitted for assisting
-  /// in-process debugging.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.debug_info
-  void debug_info(bool enable) {
-    wasmtime_config_debug_info_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether WebAssembly code can be interrupted.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.interruptable
-  void interruptable(bool enable) {
-    wasmtime_config_interruptable_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether WebAssembly code will consume fuel and trap when
-  /// it runs out.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.consume_fuel
-  void consume_fuel(bool enable) {
-    wasmtime_config_consume_fuel_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures the maximum amount of native stack wasm can consume.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.max_wasm_stack
-  void max_wasm_stack(size_t stack) {
-    wasmtime_config_max_wasm_stack_set(ptr.get(), stack);
-  }
-
-  /// \brief Configures whether the WebAssembly threads proposal is enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_threads
-  void wasm_threads(bool enable) {
-    wasmtime_config_wasm_threads_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether the WebAssembly reference types proposal is
-  /// enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_reference_types
-  void wasm_reference_types(bool enable) {
-    wasmtime_config_wasm_reference_types_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether the WebAssembly simd proposal is enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_simd
-  void wasm_simd(bool enable) {
-    wasmtime_config_wasm_simd_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether the WebAssembly bulk memory proposal is enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_bulk_memory
-  void wasm_bulk_memory(bool enable) {
-    wasmtime_config_wasm_bulk_memory_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether the WebAssembly multi value proposal is enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_multi_value
-  void wasm_multi_value(bool enable) {
-    wasmtime_config_wasm_multi_value_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures whether the WebAssembly module linking proposal is
-  /// enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_module_linking
-  void wasm_module_linking(bool enable) {
-    wasmtime_config_wasm_module_linking_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures compilation strategy for wasm code.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.strategy
-  [[nodiscard]] Result<std::monostate> strategy(Strategy strategy) {
-    auto *error = wasmtime_config_strategy_set(
-        ptr.get(), static_cast<wasmtime_strategy_t>(strategy));
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// \brief Configures whether cranelift's debug verifier is enabled
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_debug_verifier
-  void cranelift_debug_verifier(bool enable) {
-    wasmtime_config_cranelift_debug_verifier_set(ptr.get(), enable);
-  }
-
-  /// \brief Configures cranelift's optimization level
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_opt_level
-  void cranelift_opt_level(OptLevel level) {
-    wasmtime_config_cranelift_opt_level_set(
-        ptr.get(), static_cast<wasmtime_opt_level_t>(level));
-  }
-
-  /// \brief Configures an active wasm profiler
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.profiler
-  [[nodiscard]] Result<std::monostate> profiler(ProfilingStrategy profiler) {
-    auto *error = wasmtime_config_profiler_set(
-        ptr.get(), static_cast<wasmtime_profiling_strategy_t>(profiler));
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// \brief Configures the maximum size of memory to use a "static memory"
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.static_memory_maximum_size
-  void static_memory_maximum_size(size_t size) {
-    wasmtime_config_static_memory_maximum_size_set(ptr.get(), size);
-  }
-
-  /// \brief Configures the size of static memory's guard region
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.static_memory_guard_size
-  void static_memory_guard_size(size_t size) {
-    wasmtime_config_static_memory_guard_size_set(ptr.get(), size);
-  }
-
-  /// \brief Configures the size of dynamic memory's guard region
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.dynamic_memory_guard_size
-  void dynamic_memory_guard_size(size_t size) {
-    wasmtime_config_dynamic_memory_guard_size_set(ptr.get(), size);
-  }
-
-  /// \brief Loads the default cache configuration present on the system.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cache_config_load_default
-  [[nodiscard]] Result<std::monostate> cache_load_default() {
-    auto *error = wasmtime_config_cache_config_load(ptr.get(), nullptr);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// \brief Loads cache configuration from the specified filename.
-  ///
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cache_config_load
-  [[nodiscard]] Result<std::monostate> cache_load(const std::string &path) {
-    auto *error = wasmtime_config_cache_config_load(ptr.get(), path.c_str());
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-};
-
-/**
- * \brief Global compilation state in Wasmtime.
- *
- * Created with either default configuration or with a specified instance of
- * configuration, an `Engine` is used as an umbrella "session" for all other
- * operations in Wasmtime.
- */
-class Engine {
-  friend class Store;
-  friend class Module;
-  friend class Linker;
-
-  struct deleter {
-    void operator()(wasm_engine_t *p) const { wasm_engine_delete(p); }
-  };
-
-  std::unique_ptr<wasm_engine_t, deleter> ptr;
-
-public:
-  /// \brief Creates an engine with default compilation settings.
-  Engine() : ptr(wasm_engine_new()) {}
-  /// \brief Creates an engine with the specified compilation settings.
-  explicit Engine(Config config)
-      : ptr(wasm_engine_new_with_config(config.ptr.release())) {}
-};
-
-/**
- * \brief Converts the WebAssembly text format into the WebAssembly binary
- * format.
- *
- * This will parse the text format and attempt to translate it to the binary
- * format. Note that the text parser assumes that all WebAssembly features are
- * enabled and will parse syntax of future proposals. The exact syntax here
- * parsed may be tweaked over time.
- *
- * Returns either an error if parsing failed or the wasm binary.
- */
-[[nodiscard]] inline Result<std::vector<uint8_t>>
-wat2wasm(std::string_view wat) {
-  wasm_byte_vec_t ret;
-  auto *error = wasmtime_wat2wasm(wat.data(), wat.size(), &ret);
-  if (error != nullptr) {
-    return Error(error);
-  }
-  std::vector<uint8_t> vec;
-  // NOLINTNEXTLINE TODO can this be done without triggering lints?
-  Span<uint8_t> raw(reinterpret_cast<uint8_t *>(ret.data), ret.size);
-  vec.assign(raw.begin(), raw.end());
-  wasm_byte_vec_delete(&ret);
-  return vec;
-}
-
-/**
- * \brief Min/max limits used for `MemoryType` and `TableType`
- */
-class Limits {
-  friend class MemoryType;
-  friend class TableType;
-
-  wasm_limits_t raw;
-
-public:
-  /// \brief Configures a minimum limit and no maximum limit.
-  explicit Limits(uint32_t min) : raw{} {
-    raw.min = min;
-    raw.max = wasm_limits_max_default;
-  }
-  /// \brief Configures both a minimum and a maximum limit.
-  Limits(uint32_t min, uint32_t max) : raw{} {
-    raw.min = min;
-    raw.max = max;
-  }
-  /// \brief Creates limits from the raw underlying C API.
-  Limits(const wasm_limits_t *limits) : raw(*limits) {}
-
-  /// \brief Returns the minimum size specified by these limits.
-  uint32_t min() const { return raw.min; }
-
-  /// \brief Returns optional maximum limit configured.
-  std::optional<uint32_t> max() const {
-    if (raw.max == wasm_limits_max_default) {
-      return std::nullopt;
-    }
-    return raw.max;
-  }
-};
-
-/// Different kinds of types accepted by Wasmtime.
-enum class ValKind {
-  /// WebAssembly's `i32` type
-  I32,
-  /// WebAssembly's `i64` type
-  I64,
-  /// WebAssembly's `f32` type
-  F32,
-  /// WebAssembly's `f64` type
-  F64,
-  /// WebAssembly's `v128` type from the simd proposal
-  V128,
-  /// WebAssembly's `externref` type from the reference types
-  ExternRef,
-  /// WebAssembly's `funcref` type from the reference types
-  FuncRef,
-};
-
-/**
- * \brief Type information about a WebAssembly value.
- *
- * Currently mostly just contains the `ValKind`.
- */
-class ValType {
-  friend class TableType;
-  friend class GlobalType;
-  friend class FuncType;
-
-  struct deleter {
-    void operator()(wasm_valtype_t *p) const { wasm_valtype_delete(p); }
-  };
-
-  std::unique_ptr<wasm_valtype_t, deleter> ptr;
-
-  static wasm_valkind_t kind_to_c(ValKind kind) {
-    switch (kind) {
-    case ValKind::I32:
-      return WASM_I32;
-    case ValKind::I64:
-      return WASM_I64;
-    case ValKind::F32:
-      return WASM_F32;
-    case ValKind::F64:
-      return WASM_F64;
-    case ValKind::ExternRef:
-      return WASM_ANYREF;
-    case ValKind::FuncRef:
-      return WASM_FUNCREF;
-    case ValKind::V128:
-      return WASMTIME_V128;
-    }
-  }
-
-public:
-  /// \brief Non-owning reference to a `ValType`, must not be used after the
-  /// original `ValType` is deleted.
-  class Ref {
-    friend class ValType;
-
-    const wasm_valtype_t *ptr;
-
-  public:
-    /// \brief Instantiates from the raw C API representation.
-    Ref(const wasm_valtype_t *ptr) : ptr(ptr) {}
-    /// Copy constructor
-    Ref(const ValType &ty) : Ref(ty.ptr.get()) {}
-
-    /// \brief Returns the corresponding "kind" for this type.
-    ValKind kind() const {
-      switch (wasm_valtype_kind(ptr)) {
-      case WASM_I32:
-        return ValKind::I32;
-      case WASM_I64:
-        return ValKind::I64;
-      case WASM_F32:
-        return ValKind::F32;
-      case WASM_F64:
-        return ValKind::F64;
-      case WASM_ANYREF:
-        return ValKind::ExternRef;
-      case WASM_FUNCREF:
-        return ValKind::FuncRef;
-      case WASMTIME_V128:
-        return ValKind::V128;
-      }
-      std::abort();
-    }
-  };
-
-  /// \brief Non-owning reference to a list of `ValType` instances. Must not be
-  /// used after the original owner is deleted.
-  class ListRef {
-    const wasm_valtype_vec_t *list;
-
-  public:
-    /// Creates a list from the raw underlying C API.
-    ListRef(const wasm_valtype_vec_t *list) : list(list) {}
-
-    /// This list iterates over a list of `ValType::Ref` instances.
-    typedef const Ref *iterator;
-
-    /// Pointer to the beginning of iteration
-    iterator begin() const {
-      return reinterpret_cast<Ref *>(&list->data[0]); // NOLINT
-    }
-
-    /// Pointer to the end of iteration
-    iterator end() const {
-      return reinterpret_cast<Ref *>(&list->data[list->size]); // NOLINT
-    }
-
-    /// Returns how many types are in this list.
-    size_t size() const { return list->size; }
-  };
-
-private:
-  Ref ref;
-  ValType(wasm_valtype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// Creates a new type from its kind.
-  ValType(ValKind kind) : ValType(wasm_valtype_new(kind_to_c(kind))) {}
-  /// Copies a `Ref` to a new owned value.
-  ValType(Ref other) : ValType(wasm_valtype_copy(other.ptr)) {}
-  /// Copies one type to a new one.
-  ValType(const ValType &other) : ValType(wasm_valtype_copy(other.ptr.get())) {}
-  /// Copies the contents of another type into this one.
-  ValType &operator=(const ValType &other) {
-    ptr.reset(wasm_valtype_copy(other.ptr.get()));
-    return *this;
-  }
-  ~ValType() = default;
-  /// Moves the memory owned by another value type into this one.
-  ValType(ValType &&other) = default;
-  /// Moves the memory owned by another value type into this one.
-  ValType &operator=(ValType &&other) = default;
-
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information about a WebAssembly linear memory
- */
-class MemoryType {
-  friend class Memory;
-
-  struct deleter {
-    void operator()(wasm_memorytype_t *p) const { wasm_memorytype_delete(p); }
-  };
-
-  std::unique_ptr<wasm_memorytype_t, deleter> ptr;
-
-public:
-  /// \brief Non-owning reference to a `MemoryType`, must not be used after the
-  /// original owner has been deleted.
-  class Ref {
-    friend class MemoryType;
-
-    const wasm_memorytype_t *ptr;
-
-  public:
-    /// Creates a refernece from the raw C API representation.
-    Ref(const wasm_memorytype_t *ptr) : ptr(ptr) {}
-    /// Creates a reference from an original `MemoryType`.
-    Ref(const MemoryType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns the underlying limits on this wasm memory type, specified in
-    /// units of wasm pages.
-    Limits limits() const { return Limits(wasm_memorytype_limits(ptr)); }
-  };
-
-private:
-  Ref ref;
-  MemoryType(wasm_memorytype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// Creates a new wasm memory from the specified limits.
-  explicit MemoryType(const Limits &limits)
-      : MemoryType(wasm_memorytype_new(&limits.raw)) {}
-  /// Creates a new wasm memory type from the specified ref, making a fresh
-  /// owned value.
-  MemoryType(Ref other) : MemoryType(wasm_memorytype_copy(other.ptr)) {}
-  /// Copies the provided type into a new type.
-  MemoryType(const MemoryType &other)
-      : MemoryType(wasm_memorytype_copy(other.ptr.get())) {}
-  /// Copies the provided type into a new type.
-  MemoryType &operator=(const MemoryType &other) {
-    ptr.reset(wasm_memorytype_copy(other.ptr.get()));
-    return *this;
-  }
-  ~MemoryType() = default;
-  /// Moves the type information from another type into this one.
-  MemoryType(MemoryType &&other) = default;
-  /// Moves the type information from another type into this one.
-  MemoryType &operator=(MemoryType &&other) = default;
-
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information about a WebAssembly table.
- */
-class TableType {
-  friend class Table;
-
-  struct deleter {
-    void operator()(wasm_tabletype_t *p) const { wasm_tabletype_delete(p); }
-  };
-
-  std::unique_ptr<wasm_tabletype_t, deleter> ptr;
-
-public:
-  /// Non-owning reference to a `TableType`, must not be used after the original
-  /// owner is deleted.
-  class Ref {
-    friend class TableType;
-
-    const wasm_tabletype_t *ptr;
-
-  public:
-    /// Creates a reference from the raw underlying C API representation.
-    Ref(const wasm_tabletype_t *ptr) : ptr(ptr) {}
-    /// Creates a reference to the provided `TableType`.
-    Ref(const TableType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns the limits, in units of elements, of this table.
-    Limits limits() const { return wasm_tabletype_limits(ptr); }
-
-    /// Returns the type of value that is stored in this table.
-    ValType::Ref element() const { return wasm_tabletype_element(ptr); }
-  };
-
-private:
-  Ref ref;
-  TableType(wasm_tabletype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// Creates a new table type from the specified value type and limits.
-  TableType(ValType ty, Limits limits)
-      : TableType(wasm_tabletype_new(ty.ptr.release(), &limits.raw)) {}
-  /// Clones the given reference into a new table type.
-  TableType(Ref other) : TableType(wasm_tabletype_copy(other.ptr)) {}
-  /// Copies another table type into this one.
-  TableType(const TableType &other)
-      : TableType(wasm_tabletype_copy(other.ptr.get())) {}
-  /// Copies another table type into this one.
-  TableType &operator=(const TableType &other) {
-    ptr.reset(wasm_tabletype_copy(other.ptr.get()));
-    return *this;
-  }
-  ~TableType() = default;
-  /// Moves the table type resources from another type to this one.
-  TableType(TableType &&other) = default;
-  /// Moves the table type resources from another type to this one.
-  TableType &operator=(TableType &&other) = default;
-
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information about a WebAssembly global
- */
-class GlobalType {
-  friend class Global;
-
-  struct deleter {
-    void operator()(wasm_globaltype_t *p) const { wasm_globaltype_delete(p); }
-  };
-
-  std::unique_ptr<wasm_globaltype_t, deleter> ptr;
-
-public:
-  /// Non-owning reference to a `Global`, must not be used after the original
-  /// owner is deleted.
-  class Ref {
-    friend class GlobalType;
-    const wasm_globaltype_t *ptr;
-
-  public:
-    /// Creates a new reference from the raw underlying C API representation.
-    Ref(const wasm_globaltype_t *ptr) : ptr(ptr) {}
-    /// Creates a new reference to the specified type.
-    Ref(const GlobalType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns whether or not this global type is mutable.
-    bool is_mutable() const {
-      return wasm_globaltype_mutability(ptr) == WASM_VAR;
-    }
-
-    /// Returns the type of value stored within this global type.
-    ValType::Ref content() const { return wasm_globaltype_content(ptr); }
-  };
-
-private:
-  Ref ref;
-  GlobalType(wasm_globaltype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// Creates a new global type from the specified value type and mutability.
-  GlobalType(ValType ty, bool mut)
-      : GlobalType(wasm_globaltype_new(
-            ty.ptr.release(),
-            (wasm_mutability_t)(mut ? WASM_VAR : WASM_CONST))) {}
-  /// Clones a reference into a uniquely owned global type.
-  GlobalType(Ref other) : GlobalType(wasm_globaltype_copy(other.ptr)) {}
-  /// Copies othe type information into this one.
-  GlobalType(const GlobalType &other)
-      : GlobalType(wasm_globaltype_copy(other.ptr.get())) {}
-  /// Copies othe type information into this one.
-  GlobalType &operator=(const GlobalType &other) {
-    ptr.reset(wasm_globaltype_copy(other.ptr.get()));
-    return *this;
-  }
-  ~GlobalType() = default;
-  /// Moves the underlying type information from another global into this one.
-  GlobalType(GlobalType &&other) = default;
-  /// Moves the underlying type information from another global into this one.
-  GlobalType &operator=(GlobalType &&other) = default;
-
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information for a WebAssembly function.
- */
-class FuncType {
-  friend class Func;
-
-  struct deleter {
-    void operator()(wasm_functype_t *p) const { wasm_functype_delete(p); }
-  };
-
-  std::unique_ptr<wasm_functype_t, deleter> ptr;
-
-public:
-  /// Non-owning reference to a `FuncType`, must not be used after the original
-  /// owner has been deleted.
-  class Ref {
-    friend class FuncType;
-    const wasm_functype_t *ptr;
-
-  public:
-    /// Creates a new reference from the underlying C API representation.
-    Ref(const wasm_functype_t *ptr) : ptr(ptr) {}
-    /// Creates a new reference to the given type.
-    Ref(const FuncType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns the list of types this function type takes as parameters.
-    ValType::ListRef params() const { return wasm_functype_params(ptr); }
-
-    /// Returns the list of types this function type returns.
-    ValType::ListRef results() const { return wasm_functype_results(ptr); }
-  };
-
-private:
-  Ref ref;
-  FuncType(wasm_functype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// Creates a new function type from the given list of parameters and results.
-  FuncType(std::initializer_list<ValType> params,
-           std::initializer_list<ValType> results)
-      : ref(nullptr) {
-    wasm_valtype_vec_t param_vec;
-    wasm_valtype_vec_t result_vec;
-    wasm_valtype_vec_new_uninitialized(&param_vec, params.size());
-    wasm_valtype_vec_new_uninitialized(&result_vec, results.size());
-    size_t i = 0;
-    for (auto val : params) {
-      param_vec.data[i++] = val.ptr.release(); // NOLINT
-    }
-    i = 0;
-    for (auto val : results) {
-      result_vec.data[i++] = val.ptr.release(); // NOLINT
-    }
-
-    ptr.reset(wasm_functype_new(&param_vec, &result_vec));
-    ref = ptr.get();
-  }
-
-  /// Copies a reference into a uniquely owned function type.
-  FuncType(Ref other) : FuncType(wasm_functype_copy(other.ptr)) {}
-  /// Copies another type's information into this one.
-  FuncType(const FuncType &other)
-      : FuncType(wasm_functype_copy(other.ptr.get())) {}
-  /// Copies another type's information into this one.
-  FuncType &operator=(const FuncType &other) {
-    ptr.reset(wasm_functype_copy(other.ptr.get()));
-    return *this;
-  }
-  ~FuncType() = default;
-  /// Moves type information from anothe type into this one.
-  FuncType(FuncType &&other) = default;
-  /// Moves type information from anothe type into this one.
-  FuncType &operator=(FuncType &&other) = default;
-
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information about a WebAssembly import.
- */
-class ImportType {
-public:
-  /// Non-owning reference to an `ImportType`, must not be used after the
-  /// original owner is deleted.
-  class Ref {
-    friend class TypeList;
-    friend class ExternType;
-
-    const wasm_importtype_t *ptr;
-
-    // TODO: can this circle be broken another way?
-    const wasm_externtype_t *raw_type() { return wasm_importtype_type(ptr); }
-
-  public:
-    /// Creates a new reference from the raw underlying C API representation.
-    Ref(const wasm_importtype_t *ptr) : ptr(ptr) {}
-
-    /// Returns the module name associated with this import.
-    std::string_view module() {
-      const auto *name = wasm_importtype_module(ptr);
-      return std::string_view(name->data, name->size);
-    }
-
-    /// Returns the field name associated with this import.
-    std::string_view name() {
-      const auto *name = wasm_importtype_name(ptr);
-      return std::string_view(name->data, name->size);
-    }
-  };
-
-  /// An owned list of `ImportType` instances.
-  class List {
-    friend class InstanceType;
-    friend class ModuleType;
-
-    wasm_importtype_vec_t list;
-
-  public:
-    /// Creates an empty list
-    List() : list{} {
-      list.size = 0;
-      list.data = nullptr;
-    }
-    List(const List &other) = delete;
-    /// Moves another list into this one.
-    List(List &&other) noexcept : list(other.list) { other.list.size = 0; }
-    ~List() {
-      if (list.size > 0) {
-        wasm_importtype_vec_delete(&list);
-      }
-    }
-
-    List &operator=(const List &other) = delete;
-    /// Moves another list into this one.
-    List &operator=(List &&other) noexcept {
-      std::swap(list, other.list);
-      return *this;
-    }
-
-    /// Iterator type, which is a list of non-owning `ImportType::Ref`
-    /// instances.
-    typedef const Ref *iterator;
-    /// Returns the start of iteration.
-    iterator begin() const {
-      return reinterpret_cast<iterator>(&list.data[0]); // NOLINT
-    }
-    /// Returns the end of iteration.
-    iterator end() const {
-      return reinterpret_cast<iterator>(&list.data[list.size]); // NOLINT
-    }
-    /// Returns the size of this list.
-    size_t size() const { return list.size; }
-  };
-};
-
-/**
- * \brief Type information about a WebAssembly export
- */
-class ExportType {
-
-public:
-  /// \brief Non-owning reference to an `ExportType`.
-  ///
-  /// Note to get type information you can use `ExternType::from_export`.
-  class Ref {
-    friend class ExternType;
-
-    const wasm_exporttype_t *ptr;
-
-    const wasm_externtype_t *raw_type() { return wasm_exporttype_type(ptr); }
-
-  public:
-    /// Creates a new reference from the raw underlying C API representation.
-    Ref(const wasm_exporttype_t *ptr) : ptr(ptr) {}
-
-    /// Returns the name of this export.
-    std::string_view name() {
-      const auto *name = wasm_exporttype_name(ptr);
-      return std::string_view(name->data, name->size);
-    }
-  };
-
-  /// An owned list of `ExportType` instances.
-  class List {
-    friend class InstanceType;
-    friend class ModuleType;
-
-    wasm_exporttype_vec_t list;
-
-  public:
-    /// Creates an empty list
-    List() : list{} {
-      list.size = 0;
-      list.data = nullptr;
-    }
-    List(const List &other) = delete;
-    /// Moves another list into this one.
-    List(List &&other) noexcept : list(other.list) { other.list.size = 0; }
-    ~List() {
-      if (list.size > 0) {
-        wasm_exporttype_vec_delete(&list);
-      }
-    }
-
-    List &operator=(const List &other) = delete;
-    /// Moves another list into this one.
-    List &operator=(List &&other) noexcept {
-      std::swap(list, other.list);
-      return *this;
-    }
-
-    /// Iterator type, which is a list of non-owning `ExportType::Ref`
-    /// instances.
-    typedef const Ref *iterator;
-    /// Returns the start of iteration.
-    iterator begin() const {
-      return reinterpret_cast<iterator>(&list.data[0]); // NOLINT
-    }
-    /// Returns the end of iteration.
-    iterator end() const {
-      return reinterpret_cast<iterator>(&list.data[list.size]); // NOLINT
-    }
-    /// Returns the size of this list.
-    size_t size() const { return list.size; }
-  };
-};
-
-/**
- * \brief Type information about a WebAssembly module.
- */
-class ModuleType {
-  friend class Module;
-
-  struct deleter {
-    void operator()(wasmtime_moduletype_t *p) const {
-      wasmtime_moduletype_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_moduletype_t, deleter> ptr;
-
-public:
-  /// Non-owning reference to a `ModuleType`, must not be used after the owner
-  /// has been deleted.
-  class Ref {
-    friend class ModuleType;
-
-    const wasmtime_moduletype_t *ptr;
-
-  public:
-    /// Creates a new reference from the raw underlying C API representation.
-    Ref(const wasmtime_moduletype_t *ptr) : ptr(ptr) {}
-    /// Creates a reference to the given type.
-    Ref(const ModuleType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns the list of types imported by this module.
-    ImportType::List imports() const {
-      ImportType::List list;
-      wasmtime_moduletype_imports(ptr, &list.list);
-      return list;
-    }
-
-    /// Returns the list of types exported by this module.
-    ExportType::List exports() const {
-      ExportType::List list;
-      wasmtime_moduletype_exports(ptr, &list.list);
-      return list;
-    }
-  };
-
-private:
-  Ref ref;
-  ModuleType(wasmtime_moduletype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Type information about a WebAssembly instance.
- */
-class InstanceType {
-  friend class Instance;
-
-  struct deleter {
-    void operator()(wasmtime_instancetype_t *p) const {
-      wasmtime_instancetype_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_instancetype_t, deleter> ptr;
-
-public:
-  /// Non-owning reference to an `InstanceType`, must not be used after the
-  /// original owner is deleted.
-  class Ref {
-    friend class InstanceType;
-
-    const wasmtime_instancetype_t *ptr;
-
-  public:
-    /// Creates a new reference from the raw underlying C API representation.
-    Ref(const wasmtime_instancetype_t *ptr) : ptr(ptr) {}
-    /// Creates a new reference to the provided type.
-    Ref(const InstanceType &ty) : Ref(ty.ptr.get()) {}
-
-    /// Returns the list of types exported by this instance.
-    ExportType::List exports() const {
-      ExportType::List list;
-      wasmtime_instancetype_exports(ptr, &list.list);
-      return list;
-    }
-  };
-
-private:
-  Ref ref;
-  InstanceType(wasmtime_instancetype_t *ptr) : ptr(ptr), ref(ptr) {}
-
-public:
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator->() { return &ref; }
-  /// \brief Returns the underlying `Ref`, a non-owning reference pointing to
-  /// this instance.
-  Ref *operator*() { return &ref; }
-};
-
-/**
- * \brief Generic type of a WebAssembly item.
- */
-class ExternType {
-  friend class ExportType;
-  friend class ImportType;
-
-public:
-  /// \typedef Ref
-  /// \brief Non-owning reference to an item's type
-  ///
-  /// This cannot be used after the original owner has been deleted, and
-  /// otherwise this is used to determine what the actual type of the outer item
-  /// is.
-  typedef std::variant<FuncType::Ref, GlobalType::Ref, TableType::Ref,
-                       MemoryType::Ref, ModuleType::Ref, InstanceType::Ref>
-      Ref;
-
-  /// Extract the type of the item imported by the provided type.
-  static Ref from_import(ImportType::Ref ty) {
-    // TODO: this would ideally be some sort of implicit constructor, unsure how
-    // to do that though...
-    return ref_from_c(ty.raw_type());
-  }
-
-  /// Extract the type of the item exported by the provided type.
-  static Ref from_export(ExportType::Ref ty) {
-    // TODO: this would ideally be some sort of implicit constructor, unsure how
-    // to do that though...
-    return ref_from_c(ty.raw_type());
-  }
-
-private:
-  static Ref ref_from_c(const wasm_externtype_t *ptr) {
-    switch (wasm_externtype_kind(ptr)) {
-    case WASM_EXTERN_FUNC:
-      return wasm_externtype_as_functype_const(ptr);
-    case WASM_EXTERN_GLOBAL:
-      return wasm_externtype_as_globaltype_const(ptr);
-    case WASM_EXTERN_TABLE:
-      return wasm_externtype_as_tabletype_const(ptr);
-    case WASM_EXTERN_MEMORY:
-      return wasm_externtype_as_memorytype_const(ptr);
-    case WASMTIME_EXTERN_MODULE:
-      // Should probably just add const versions of these functions to
-      // wasmtime's C API?
-      return wasmtime_externtype_as_moduletype(
-          const_cast<wasm_externtype_t *>(ptr)); // NOLINT
-    case WASMTIME_EXTERN_INSTANCE:
-      return wasmtime_externtype_as_instancetype(
-          const_cast<wasm_externtype_t *>(ptr)); // NOLINT
-    }
-    std::abort();
-  }
-};
-
-/**
- * \brief Non-owning reference to a WebAssembly function frame as part of a
- * `Trace`
- *
- * A `FrameRef` represents a WebAssembly function frame on the stack which was
- * collected as part of a trap.
- */
-class FrameRef {
-  wasm_frame_t *frame;
-
-public:
-  /// Returns the WebAssembly function index of this function, in the original
-  /// module.
-  uint32_t func_index() const { return wasm_frame_func_index(frame); }
-  /// Returns the offset, in bytes from the start of the function in the
-  /// original module, to this frame's program counter.
-  size_t func_offset() const { return wasm_frame_func_offset(frame); }
-  /// Returns the offset, in bytes from the start of the original module,
-  /// to this frame's program counter.
-  size_t module_offset() const { return wasm_frame_module_offset(frame); }
-
-  /// Returns the name, if present, associated with this function.
-  ///
-  /// Note that this requires that the `name` section is present in the original
-  /// WebAssembly binary.
-  std::optional<std::string_view> func_name() const {
-    const auto *name = wasmtime_frame_func_name(frame);
-    if (name != nullptr) {
-      return std::string_view(name->data, name->size);
-    }
-    return std::nullopt;
-  }
-
-  /// Returns the name, if present, associated with this function's module.
-  ///
-  /// Note that this requires that the `name` section is present in the original
-  /// WebAssembly binary.
-  std::optional<std::string_view> module_name() const {
-    const auto *name = wasmtime_frame_module_name(frame);
-    if (name != nullptr) {
-      return std::string_view(name->data, name->size);
-    }
-    return std::nullopt;
-  }
-};
-
-/**
- * \brief An owned vector of `FrameRef` instances representing the WebAssembly
- * call-stack on a trap.
- *
- * This can be used to iterate over the frames of a trap and determine what was
- * running when a trap happened.
- */
-class Trace {
-  friend class Trap;
-
-  wasm_frame_vec_t vec;
-
-  Trace(wasm_frame_vec_t vec) : vec(vec) {}
-
-public:
-  ~Trace() { wasm_frame_vec_delete(&vec); }
-
-  Trace(const Trace &other) = delete;
-  Trace(Trace &&other) = delete;
-  Trace &operator=(const Trace &other) = delete;
-  Trace &operator=(Trace &&other) = delete;
-
-  /// Iterator used to iterate over this trace.
-  typedef const FrameRef *iterator;
-
-  /// Returns the start of iteration
-  iterator begin() const {
-    return reinterpret_cast<FrameRef *>(&vec.data[0]); // NOLINT
-  }
-  /// Returns the end of iteration
-  iterator end() const {
-    return reinterpret_cast<FrameRef *>(&vec.data[vec.size]); // NOLINT
-  }
-  /// Returns the size of this trace, or how many frames it contains.
-  size_t size() const { return vec.size; }
-};
-
-/**
- * \brief Information about a WebAssembly trap.
- *
- * Traps can happen during normal wasm execution (such as the `unreachable`
- * instruction) but they can also happen in host-provided functions to a host
- * function can simulate raising a trap.
- *
- * Traps have a message associated with them as well as a trace of WebAssembly
- * frames on the stack.
- */
-class Trap {
-  friend class Linker;
-  friend class Instance;
-  friend class Func;
-
-  struct deleter {
-    void operator()(wasm_trap_t *p) const { wasm_trap_delete(p); }
-  };
-
-  std::unique_ptr<wasm_trap_t, deleter> ptr;
-
-  Trap(wasm_trap_t *ptr) : ptr(ptr) {}
-
-public:
-  /// Creates a new host-defined trap with the specified message.
-  explicit Trap(std::string_view msg)
-      : Trap(wasmtime_trap_new(msg.data(), msg.size())) {}
-
-  /// Returns the descriptive message associated with this trap
-  std::string message() const {
-    wasm_byte_vec_t msg;
-    wasm_trap_message(ptr.get(), &msg);
-    std::string ret(msg.data, msg.size - 1);
-    wasm_byte_vec_delete(&msg);
-    return ret;
-  }
-
-  /// If this trap represents a call to `exit` for WASI, this will return the
-  /// optional error code associated with the exit trap.
-  std::optional<int32_t> i32_exit() const {
-    int32_t status = 0;
-    if (wasmtime_trap_exit_status(ptr.get(), &status)) {
-      return status;
-    }
-    return std::nullopt;
-  }
-
-  /// Returns the trace of WebAssembly frames associated with this trap.
-  Trace trace() const {
-    wasm_frame_vec_t frames;
-    wasm_trap_trace(ptr.get(), &frames);
-    return Trace(frames);
-  }
-};
-
-/// Structure used to represent either a `Trap` or an `Error`.
-struct TrapError {
-  /// Storage for what this trap represents.
-  std::variant<Trap, Error> data;
-
-  /// Creates a new `TrapError` from a `Trap`
-  TrapError(Trap t) : data(std::move(t)) {}
-  /// Creates a new `TrapError` from an `Error`
-  TrapError(Error e) : data(std::move(e)) {}
-
-  /// Dispatches internally to return the message associated with this error.
-  std::string message() {
-    if (auto *trap = std::get_if<Trap>(&data)) {
-      return trap->message();
-    }
-    if (auto *error = std::get_if<Error>(&data)) {
-      return std::string(error->message());
-    }
-    std::abort();
-  }
-};
-
-/// Result used by functions which can fail because of invariants being violated
-/// (such as a type error) as well as because of a WebAssembly trap.
-template <typename T> using TrapResult = Result<T, TrapError>;
-
-/**
- * \brief Representation of a compiled WebAssembly module.
- *
- * This type contains JIT code of a compiled WebAssembly module. A `Module` is
- * connected to an `Engine` and can only be instantiated within that `Engine`.
- * You can inspect a `Module` for its type information. This is passed as an
- * argument to other APIs to instantiate it.
- */
-class Module {
-  friend class Store;
-  friend class Instance;
-  friend class Linker;
-
-  struct deleter {
-    void operator()(wasmtime_module_t *p) const { wasmtime_module_delete(p); }
-  };
-
-  std::unique_ptr<wasmtime_module_t, deleter> ptr;
-
-  Module(wasmtime_module_t *raw) : ptr(raw) {}
-
-public:
-  /// Copies another module into this one.
-  Module(const Module &other) : ptr(wasmtime_module_clone(other.ptr.get())) {}
-  /// Copies another module into this one.
-  Module &operator=(const Module &other) {
-    ptr.reset(wasmtime_module_clone(other.ptr.get()));
-    return *this;
-  }
-  ~Module() = default;
-  /// Moves resources from another module into this one.
-  Module(Module &&other) = default;
-  /// Moves resources from another module into this one.
-  Module &operator=(Module &&other) = default;
-
-  /**
-   * \brief Compiles a module from the WebAssembly text format.
-   *
-   * This function will automatically use `wat2wasm` on the input and then
-   * delegate to the #compile function.
-   */
-  [[nodiscard]] static Result<Module> compile(Engine &engine,
-                                              std::string_view wat) {
-    auto wasm = wat2wasm(wat);
-    if (!wasm) {
-      return wasm.err();
-    }
-    auto bytes = wasm.ok();
-    return compile(engine, bytes);
-  }
-
-  /**
-   * \brief Compiles a module from the WebAssembly binary format.
-   *
-   * This function compiles the provided WebAssembly binary specified by `wasm`
-   * within the compilation settings configured by `engine`. This method is
-   * synchronous and will not return until the module has finished compiling.
-   *
-   * This function can fail if the WebAssembly binary is invalid or doesn't
-   * validate (or similar).
-   */
-  [[nodiscard]] static Result<Module> compile(Engine &engine,
-                                              Span<uint8_t> wasm) {
-    wasmtime_module_t *ret = nullptr;
-    auto *error =
-        wasmtime_module_new(engine.ptr.get(), wasm.data(), wasm.size(), &ret);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Module(ret);
-  }
-
-  /**
-   * \brief Validates the provided WebAssembly binary without compiling it.
-   *
-   * This function will validate whether the provided binary is indeed valid
-   * within the compilation settings of the `engine` provided.
-   */
-  [[nodiscard]] static Result<std::monostate> validate(Engine &engine,
-                                                       Span<uint8_t> wasm) {
-    auto *error =
-        wasmtime_module_validate(engine.ptr.get(), wasm.data(), wasm.size());
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /**
-   * \brief Deserializes a previous list of bytes created with `serialize`.
-   *
-   * This function is intended to be much faster than `compile` where it uses
-   * the artifacts of a previous compilation to quickly create an in-memory
-   * module ready for instantiation.
-   *
-   * It is not safe to pass arbitrary input to this function, it is only safe to
-   * pass in output from previous calls to `serialize`. For more information see
-   * the Rust documentation -
-   * https://docs.wasmtime.dev/api/wasmtime/struct.Module.html#method.deserialize
-   */
-  [[nodiscard]] static Result<Module> deserialize(Engine &engine,
-                                                  Span<uint8_t> wasm) {
-    wasmtime_module_t *ret = nullptr;
-    auto *error = wasmtime_module_deserialize(engine.ptr.get(), wasm.data(),
-                                              wasm.size(), &ret);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Module(ret);
-  }
-
-  /// Returns the type of this module, which can be used to inspect the
-  /// imports/exports.
-  ModuleType type() { return wasmtime_module_type(ptr.get()); }
-
-  /**
-   * \brief Serializes this module to a list of bytes.
-   *
-   * The returned bytes can then be used to later pass to `deserialize` to
-   * quickly recreate this module in a different process perhaps.
-   */
-  [[nodiscard]] Result<std::vector<uint8_t>> serialize() const {
-    wasm_byte_vec_t bytes;
-    auto *error = wasmtime_module_serialize(ptr.get(), &bytes);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    std::vector<uint8_t> ret;
-    // NOLINTNEXTLINE TODO can this be done without triggering lints?
-    Span<uint8_t> raw(reinterpret_cast<uint8_t *>(bytes.data), bytes.size);
-    ret.assign(raw.begin(), raw.end());
-    wasm_byte_vec_delete(&bytes);
-    return ret;
-  }
-};
-
-/**
- * \brief Handle used to interrupt execution of WebAssembly from another thread.
- */
-class InterruptHandle {
-  friend class Store;
-
-  struct deleter {
-    void operator()(wasmtime_interrupt_handle_t *p) const {
-      wasmtime_interrupt_handle_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_interrupt_handle_t, deleter> ptr;
-
-  InterruptHandle(wasmtime_interrupt_handle_t *ptr) : ptr(ptr) {}
-
-public:
-  /// Indicates that the WebAssembly executing in the store this handle is
-  /// connected to should be interrupted as soon as possible.
-  void interrupt() const { wasmtime_interrupt_handle_interrupt(ptr.get()); }
-};
-
-/**
- * \brief Configuration for an instance of WASI.
- *
- * This is inserted into a store with `Store::Context::set_wasi`.
- */
-class WasiConfig {
-  friend class Store;
-
-  struct deleter {
-    void operator()(wasi_config_t *p) const { wasi_config_delete(p); }
-  };
-
-  std::unique_ptr<wasi_config_t, deleter> ptr;
-
-public:
-  /// Creates a new configuration object with default settings.
-  WasiConfig() : ptr(wasi_config_new()) {}
-
-  /// Configures the argv explicitly with the given string array.
-  void argv(const std::vector<std::string> &args) {
-    std::vector<const char *> ptrs;
-    ptrs.reserve(args.size());
-    for (const auto &arg : args) {
-      ptrs.push_back(arg.c_str());
-    }
-
-    wasi_config_set_argv(ptr.get(), (int)args.size(), ptrs.data());
-  }
-
-  /// Configures the argv for wasm to be inherited from this process itself.
-  void inherit_argv() { wasi_config_inherit_argv(ptr.get()); }
-
-  /// Configures the environment variables available to wasm, specified here as
-  /// a list of pairs where the first element of the pair is the key and the
-  /// second element is the value.
-  void env(const std::vector<std::pair<std::string, std::string>> &env) {
-    std::vector<const char *> names;
-    std::vector<const char *> values;
-    for (const auto &[name, value] : env) {
-      names.push_back(name.c_str());
-      values.push_back(value.c_str());
-    }
-    wasi_config_set_env(ptr.get(), (int)env.size(), names.data(),
-                        values.data());
-  }
-
-  /// Indicates that the entire environment of this process should be inherited
-  /// by the wasi configuration.
-  void inherit_env() { wasi_config_inherit_env(ptr.get()); }
-
-  /// Configures the provided file to be used for the stdin of this WASI
-  /// configuration.
-  [[nodiscard]] bool stdin_file(const std::string &path) {
-    return wasi_config_set_stdin_file(ptr.get(), path.c_str());
-  }
-
-  /// Configures this WASI configuration to inherit its stdin from the host
-  /// process.
-  void inherit_stdin() { return wasi_config_inherit_stdin(ptr.get()); }
-
-  /// Configures the provided file to be created and all stdout output will be
-  /// written there.
-  [[nodiscard]] bool stdout_file(const std::string &path) {
-    return wasi_config_set_stdout_file(ptr.get(), path.c_str());
-  }
-
-  /// Configures this WASI configuration to inherit its stdout from the host
-  /// process.
-  void inherit_stdout() { return wasi_config_inherit_stdout(ptr.get()); }
-
-  /// Configures the provided file to be created and all stderr output will be
-  /// written there.
-  [[nodiscard]] bool stderr_file(const std::string &path) {
-    return wasi_config_set_stderr_file(ptr.get(), path.c_str());
-  }
-
-  /// Configures this WASI configuration to inherit its stdout from the host
-  /// process.
-  void inherit_stderr() { return wasi_config_inherit_stderr(ptr.get()); }
-
-  /// Opens `path` to be opened as `guest_path` in the WASI pseudo-filesystem.
-  [[nodiscard]] bool preopen_dir(const std::string &path,
-                                 const std::string &guest_path) {
-    return wasi_config_preopen_dir(ptr.get(), path.c_str(), guest_path.c_str());
-  }
-};
-
-class Caller;
-
-/**
- * \brief Owner of all WebAssembly objects
- *
- * A `Store` owns all WebAssembly objects such as instances, globals, functions,
- * memories, etc. A `Store` is one of the main central points about working with
- * WebAssembly since it's an argument to almost all APIs. The `Store` serves as
- * a form of "context" to give meaning to the pointers of `Func` and friends.
- *
- * A `Store` can be sent between threads but it cannot generally be shared
- * concurrently between threads. Memory associated with WebAssembly instances
- * will be deallocated when the `Store` is deallocated.
- */
-class Store {
-  struct deleter {
-    void operator()(wasmtime_store_t *p) const { wasmtime_store_delete(p); }
-  };
-
-  std::unique_ptr<wasmtime_store_t, deleter> ptr;
-
-public:
-  /// Creates a new `Store` within the provided `Engine`.
-  explicit Store(Engine &engine)
-      : ptr(wasmtime_store_new(engine.ptr.get(), nullptr, nullptr)) {}
-
-  /**
-   * \brief An interior pointer into a `Store`.
-   *
-   * A `Context` object is created from either a `Store` or a `Caller`. It is an
-   * interior pointer into a `Store` and cannot be used outside the lifetime of
-   * the original object it was created from.
-   *
-   * This object is an argument to most APIs in Wasmtime but typically doesn't
-   * need to be constructed explicitly since it can be created from a `Store&`
-   * or a `Caller&`.
-   */
-  class Context {
-    friend class Global;
-    friend class Table;
-    friend class Memory;
-    friend class Func;
-    friend class Instance;
-    friend class Linker;
-    wasmtime_context_t *ptr;
-
-    Context(wasmtime_context_t *ptr) : ptr(ptr) {}
-
-  public:
-    /// Creates a context referencing the provided `Store`.
-    Context(Store &store) : Context(wasmtime_store_context(store.ptr.get())) {}
-    /// Creates a context referencing the provided `Store`.
-    Context(Store *store) : Context(*store) {}
-    /// Creates a context referencing the provided `Caller`.
-    Context(Caller &caller);
-    /// Creates a context referencing the provided `Caller`.
-    Context(Caller *caller);
-
-    /// Runs a garbage collection pass in the referenced store to collect loose
-    /// `externref` values, if any are available.
-    void gc() { wasmtime_context_gc(ptr); }
-
-    /// Injects fuel to be consumed within this store.
-    ///
-    /// Stores start with 0 fuel and if `Config::consume_fuel` is enabled then
-    /// this is required if you want to let WebAssembly actually execute.
-    ///
-    /// Returns an error if fuel consumption isn't enabled.
-    [[nodiscard]] Result<std::monostate> add_fuel(uint64_t fuel) {
-      auto *error = wasmtime_context_add_fuel(ptr, fuel);
-      if (error != nullptr) {
-        return Error(error);
-      }
-      return std::monostate();
-    }
-
-    /// Returns the amount of fuel consumed so far by executing WebAssembly.
-    ///
-    /// Returns `std::nullopt` if fuel consumption is not enabled.
-    std::optional<uint64_t> fuel_consumed() const {
-      uint64_t fuel = 0;
-      if (wasmtime_context_fuel_consumed(ptr, &fuel)) {
-        return fuel;
-      }
-      return std::nullopt;
-    }
-
-    /// Configures the WASI state used by this store.
-    ///
-    /// This will only have an effect if used in conjunction with
-    /// `Linker::define_wasi` because otherwise no host functions will use the
-    /// WASI state.
-    [[nodiscard]] Result<std::monostate> set_wasi(WasiConfig config) {
-      auto *error = wasmtime_context_set_wasi(ptr, config.ptr.release());
-      if (error != nullptr) {
-        return Error(error);
-      }
-      return std::monostate();
-    }
-
-    /// Returns a handle, which can be sent to another thread, which can be used
-    /// to interrupt execution of WebAssembly within this `Store`.
-    ///
-    /// This requires `Config::interruptable` to be enabled to retun a handle.
-    std::optional<InterruptHandle> interrupt_handle() {
-      auto *handle = wasmtime_interrupt_handle_new(ptr);
-      if (handle != nullptr) {
-        return InterruptHandle(handle);
-      }
-      return std::nullopt;
-    }
-  };
-
-  /// Explicit function to acquire a `Context` from this store.
-  Context context() { return this; }
-};
-
-/**
- * \brief Representation of a WebAssembly `externref` value.
- *
- * This class represents an value that cannot be forged by WebAssembly itself.
- * All `ExternRef` values are guaranteed to be created by the host and its
- * embedding. It's suitable to place private data structures in here which
- * WebAssembly will not have access to, only other host functions will have
- * access to them.
- */
-class ExternRef {
-  friend class Val;
-
-  struct deleter {
-    void operator()(wasmtime_externref_t *p) const {
-      wasmtime_externref_delete(p);
-    }
-  };
-
-  std::unique_ptr<wasmtime_externref_t, deleter> ptr;
-
-  static void finalizer(void *ptr) {
-    std::unique_ptr<std::any> _ptr(static_cast<std::any *>(ptr));
-  }
-
-  ExternRef(wasmtime_externref_t *ptr) : ptr(ptr) {}
-
-public:
-  /// Creates a new `externref` value from the provided argument.
-  ///
-  /// Note that `val` should be safe to send across threads and should own any
-  /// memory that it points to. Also note that `ExternRef` is similar to a
-  /// `std::shared_ptr` in that there can be many references to the same value.
-  explicit ExternRef(std::any val)
-      : ExternRef(wasmtime_externref_new(
-            std::make_unique<std::any>(std::move(val)).release(), finalizer)) {}
-  /// Performs a shallow copy of another `externref` value, creating another
-  /// reference to it.
-  ExternRef(const ExternRef &other)
-      : ExternRef(wasmtime_externref_clone(other.ptr.get())) {}
-  /// Performs a shallow copy of another `externref` value, creating another
-  /// reference to it.
-  ExternRef &operator=(const ExternRef &other) {
-    ptr.reset(wasmtime_externref_clone(other.ptr.get()));
-    return *this;
-  }
-  /// Moves the resources pointed to by `other` into `this`.
-  ExternRef(ExternRef &&other) = default;
-  /// Moves the resources pointed to by `other` into `this`.
-  ExternRef &operator=(ExternRef &&other) = default;
-  ~ExternRef() = default;
-
-  /// Returns the underlying host data associated with this `ExternRef`.
-  std::any &data() {
-    return *static_cast<std::any *>(wasmtime_externref_data(ptr.get()));
-  }
-};
-
-class Func;
-class Global;
-class Instance;
-class Memory;
-class Table;
-
-/// \typedef Extern
-/// \brief Representation of an external WebAssembly item
-typedef std::variant<Instance, Module, Func, Global, Memory, Table> Extern;
-
-/**
- * \brief Representation of a generic WebAssembly value.
- *
- * This is roughly equivalent to a tagged union of all possible WebAssembly
- * values. This is later used as an argument with functions, globals, tables,
- * etc.
- */
-class Val {
-  friend class Global;
-  friend class Table;
-  friend class Func;
-
-  wasmtime_val_t val;
-
-  Val() : val{} {
-    val.kind = WASMTIME_I32;
-    val.of.i32 = 0;
-  }
-  Val(wasmtime_val_t val) : val(val) {}
-
-public:
-  /// Creates a new `i32` WebAssembly value.
-  Val(int32_t i32) : val{} {
-    val.kind = WASMTIME_I32;
-    val.of.i32 = i32;
-  }
-  /// Creates a new `i64` WebAssembly value.
-  Val(int64_t i64) : val{} {
-    val.kind = WASMTIME_I64;
-    val.of.i64 = i64;
-  }
-  /// Creates a new `f32` WebAssembly value.
-  Val(float f32) : val{} {
-    val.kind = WASMTIME_F32;
-    val.of.f32 = f32;
-  }
-  /// Creates a new `f64` WebAssembly value.
-  Val(double f64) : val{} {
-    val.kind = WASMTIME_F64;
-    val.of.f64 = f64;
-  }
-  /// Creates a new `v128` WebAssembly value.
-  Val(const wasmtime_v128 &v128) : val{} {
-    val.kind = WASMTIME_V128;
-    val.of.i32 = 0;
-    memcpy(&val.of.v128[0], &v128[0], sizeof(wasmtime_v128));
-  }
-  /// Creates a new `funcref` WebAssembly value.
-  Val(std::optional<Func> func);
-  /// Creates a new `funcref` WebAssembly value which is not `ref.null func`.
-  Val(Func func);
-  /// Creates a new `externref` value.
-  Val(std::optional<ExternRef> ptr) : val{} {
-    val.kind = WASMTIME_EXTERNREF;
-    val.of.externref = nullptr;
-    if (ptr) {
-      val.of.externref = ptr->ptr.release();
-    }
-  }
-  /// Creates a new `externref` WebAssembly value which is not `ref.null
-  /// extern`.
-  Val(ExternRef ptr);
-  /// Copies the contents of another value into this one.
-  Val(const Val &other) : val{} {
-    val.kind = WASMTIME_I32;
-    val.of.i32 = 0;
-    wasmtime_val_copy(&val, &other.val);
-  }
-  /// Moves the resources from another value into this one.
-  Val(Val &&other) noexcept : val{} {
-    val.kind = WASMTIME_I32;
-    val.of.i32 = 0;
-    std::swap(val, other.val);
-  }
-
-  ~Val() {
-    if (val.kind == WASMTIME_EXTERNREF && val.of.externref != nullptr) {
-      wasmtime_externref_delete(val.of.externref);
-    }
-  }
-
-  /// Copies the contents of another value into this one.
-  Val &operator=(const Val &other) noexcept {
-    if (val.kind == WASMTIME_EXTERNREF && val.of.externref != nullptr) {
-      wasmtime_externref_delete(val.of.externref);
-    }
-    wasmtime_val_copy(&val, &other.val);
-    return *this;
-  }
-  /// Moves the resources from another value into this one.
-  Val &operator=(Val &&other) noexcept {
-    std::swap(val, other.val);
-    return *this;
-  }
-
-  /// Returns the kind of value that this value has.
-  ValKind kind() const {
-    switch (val.kind) {
-    case WASMTIME_I32:
-      return ValKind::I32;
-    case WASMTIME_I64:
-      return ValKind::I64;
-    case WASMTIME_F32:
-      return ValKind::F32;
-    case WASMTIME_F64:
-      return ValKind::F64;
-    case WASMTIME_FUNCREF:
-      return ValKind::FuncRef;
-    case WASMTIME_EXTERNREF:
-      return ValKind::ExternRef;
-    case WASMTIME_V128:
-      return ValKind::V128;
-    }
-    std::abort();
-  }
-
-  /// Returns the underlying `i32`, requires `kind() == KindI32` or aborts the
-  /// process.
-  int32_t i32() const {
-    if (val.kind != WASMTIME_I32) {
-      std::abort();
-    }
-    return val.of.i32;
-  }
-
-  /// Returns the underlying `i64`, requires `kind() == KindI64` or aborts the
-  /// process.
-  int64_t i64() const {
-    if (val.kind != WASMTIME_I64) {
-      std::abort();
-    }
-    return val.of.i64;
-  }
-
-  /// Returns the underlying `f32`, requires `kind() == KindF32` or aborts the
-  /// process.
-  float f32() const {
-    if (val.kind != WASMTIME_F32) {
-      std::abort();
-    }
-    return val.of.f32;
-  }
-
-  /// Returns the underlying `f64`, requires `kind() == KindF64` or aborts the
-  /// process.
-  double f64() const {
-    if (val.kind != WASMTIME_F64) {
-      std::abort();
-    }
-    return val.of.f64;
-  }
-
-  /// Returns the underlying `v128`, requires `kind() == KindV128` or aborts
-  /// the process.
-  const wasmtime_v128 &v128() const {
-    if (val.kind != WASMTIME_V128) {
-      std::abort();
-    }
-    return val.of.v128;
-  }
-
-  /// Returns the underlying `externref`, requires `kind() == KindExternRef` or
-  /// aborts the process.
-  ///
-  /// Note that `externref` is a nullable reference, hence the `optional` return
-  /// value.
-  std::optional<ExternRef> externref() const {
-    if (val.kind != WASMTIME_EXTERNREF) {
-      std::abort();
-    }
-    if (val.of.externref != nullptr) {
-      return ExternRef(wasmtime_externref_clone(val.of.externref));
-    }
-    return std::nullopt;
-  }
-
-  /// Returns the underlying `funcref`, requires `kind() == KindFuncRef` or
-  /// aborts the process.
-  ///
-  /// Note that `funcref` is a nullable reference, hence the `optional` return
-  /// value.
-  std::optional<Func> funcref() const;
-};
-
-/**
- * \brief Structure provided to host functions to lookup caller information or
- * acquire a `Store::Context`.
- *
- * This structure is passed to all host functions created with `Func`. It can be
- * used to create a `Store::Context`.
- */
-class Caller {
-  friend class Func;
-  friend class Store;
-  wasmtime_caller_t *ptr;
-  Caller(wasmtime_caller_t *ptr) : ptr(ptr) {}
-
-public:
-  /// Attempts to load an exported item from the calling instance.
-  ///
-  /// For more information see the Rust documentation -
-  /// https://docs.wasmtime.dev/api/wasmtime/struct.Caller.html#method.get_export
-  std::optional<Extern> get_export(std::string_view name);
-
-  /// Explicitly acquire a `Store::Context` from this `Caller`.
-  Store::Context context() { return this; }
-};
-
-inline Store::Context::Context(Caller &caller)
-    : Context(wasmtime_caller_context(caller.ptr)) {}
-inline Store::Context::Context(Caller *caller) : Context(*caller) {}
-
-/**
- * \brief Representation of a WebAssembly function.
- *
- * This class represents a WebAssembly function, either created through
- * instantiating a module or a host function.
- *
- * Note that this type does not itself own any resources. It points to resources
- * owned within a `Store` and the `Store` must be passed in as the first
- * argument to the functions defined on `Func`. Note that if the wrong `Store`
- * is passed in then the process will be aborted.
- */
-class Func {
-  friend class Val;
-  friend class Instance;
-
-  wasmtime_func_t func;
-
-  template <typename F>
-  static wasm_trap_t *raw_callback(void *env, wasmtime_caller_t *caller,
-                                   const wasmtime_val_t *args, size_t nargs,
-                                   wasmtime_val_t *results, size_t nresults) {
-    F *func = reinterpret_cast<F *>(env);                          // NOLINT
-    Span<const Val> args_span(reinterpret_cast<const Val *>(args), // NOLINT
-                              nargs);
-    Span<Val> results_span(reinterpret_cast<Val *>(results), // NOLINT
-                           nresults);
-    Result<std::monostate, Trap> result =
-        (*func)(Caller(caller), args_span, results_span);
-    if (!result) {
-      return result.err().ptr.release();
-    }
-    return nullptr;
-  }
-
-  template <typename F> static void raw_finalize(void *env) {
-    std::unique_ptr<F> ptr(reinterpret_cast<F *>(env)); // NOLINT
-  }
-
-public:
-  /// Creates a new function from the raw underlying C API representation.
-  Func(wasmtime_func_t func) : func(func) {}
-
-  /**
-   * \brief Creates a new host-defined function.
-   *
-   * This constructor is used to create a host function within the store
-   * provided. This is how WebAssembly can call into the host and make use of
-   * external functionality.
-   *
-   * \param cx the store to create the function within
-   * \param ty the type of the function that will be created
-   * \param f the host callback to be executed when this function is called.
-   *
-   * The parameter `f` is expected to be a lambda (or a lambda lookalike) which
-   * takes three parameters:
-   *
-   * * The first parameter is a `Caller` to get recursive access to the store
-   *   and other caller state.
-   * * The second parameter is a `Span<const Val>` which is the list of
-   *   parameters to the function. These parameters are guaranteed to be of the
-   *   types specified by `ty` when constructing this function.
-   * * The last argument is `Span<Val>` which is where to write the return
-   *   values of the function. The function must produce the types of values
-   *   specified by `ty` or otherwise a trap will be raised.
-   *
-   * The parameter `f` is expected to return `Result<std::monostate, Trap>`.
-   * This allows `f` to raise a trap if desired, or otherwise return no trap and
-   * finish successfully. If a trap is raised then the results pointer does not
-   * need to be written to.
-   */
-  template <typename F>
-  Func(Store::Context cx, const FuncType &ty, F f) : func({}) {
-    wasmtime_func_new(cx.ptr, ty.ptr.get(), raw_callback<F>,
-                      std::make_unique<F>(f).release(), raw_finalize<F>, &func);
-  }
-
-  /**
-   * \brief Invoke a WebAssembly function.
-   *
-   * This function will execute this WebAssembly function. This function muts be
-   * defined within the `cx`'s store provided. The `params` argument is the list
-   * of parameters that are passed to the wasm function, and the types of the
-   * values within `params` must match the type signature of this function.
-   *
-   * This may return one of three values:
-   *
-   * * First the function could succeed, returning a vector of values
-   *   representing the results of the function.
-   * * Otherwise a `Trap` might be generated by the WebAssembly function.
-   * * Finally an `Error` could be returned indicating that `params` were not of
-   *   the right type.
-   */
-  [[nodiscard]] TrapResult<std::vector<Val>>
-  call(Store::Context cx, const std::vector<Val> &params) const {
-    std::vector<wasmtime_val_t> raw_params;
-    raw_params.reserve(params.size());
-    for (const auto &param : params) {
-      raw_params.push_back(param.val);
-    }
-    size_t nresults = this->type(cx)->results().size();
-    std::vector<wasmtime_val_t> raw_results(nresults);
-
-    wasm_trap_t *trap = nullptr;
-    auto *error =
-        wasmtime_func_call(cx.ptr, &func, raw_params.data(), raw_params.size(),
-                           raw_results.data(), raw_results.capacity(), &trap);
-    if (error != nullptr) {
-      return TrapError(Error(error));
-    }
-    if (trap != nullptr) {
-      return TrapError(Trap(trap));
-    }
-
-    std::vector<Val> results;
-    results.reserve(nresults);
-    for (size_t i = 0; i < nresults; i++) {
-      results.push_back(raw_results[i]);
-    }
-    return results;
-  }
-
-  /// Returns the type of this function.
-  FuncType type(Store::Context cx) const {
-    return wasmtime_func_type(cx.ptr, &func);
-  }
-};
-
-inline Val::Val(std::optional<Func> func) : val{} {
-  val.kind = WASMTIME_FUNCREF;
-  val.of.funcref.store_id = 0;
-  val.of.funcref.index = 0;
-  if (func) {
-    val.of.funcref = (*func).func;
-  }
-}
-
-inline Val::Val(Func func) : Val(std::optional(func)) {}
-inline Val::Val(ExternRef ptr) : Val(std::optional(ptr)) {}
-
-inline std::optional<Func> Val::funcref() const {
-  if (val.kind != WASMTIME_FUNCREF) {
-    std::abort();
-  }
-  if (val.of.funcref.store_id == 0) {
-    return std::nullopt;
-  }
-  return Func(val.of.funcref);
-}
-
-/**
- * \brief A WebAssembly global.
- *
- * This class represents a WebAssembly global, either created through
- * instantiating a module or a host global. Globals contain a WebAssembly value
- * and can be read and optionally written to.
- *
- * Note that this type does not itself own any resources. It points to resources
- * owned within a `Store` and the `Store` must be passed in as the first
- * argument to the functions defined on `Global`. Note that if the wrong `Store`
- * is passed in then the process will be aborted.
- */
-class Global {
-  friend class Instance;
-  wasmtime_global_t global;
-
-public:
-  /// Creates as global from the raw underlying C API representation.
-  Global(wasmtime_global_t global) : global(global) {}
-
-  /**
-   * \brief Create a new WebAssembly global.
-   *
-   * \param cx the store in which to create the global
-   * \param ty the type that this global will have
-   * \param init the initial value of the global
-   *
-   * This function can fail if `init` does not have a value that matches `ty`.
-   */
-  [[nodiscard]] static Result<Global>
-  create(Store::Context cx, const GlobalType &ty, const Val &init) {
-    wasmtime_global_t global;
-    auto *error = wasmtime_global_new(cx.ptr, ty.ptr.get(), &init.val, &global);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Global(global);
-  }
-
-  /// Returns the type of this global.
-  GlobalType type(Store::Context cx) const {
-    return wasmtime_global_type(cx.ptr, &global);
-  }
-
-  /// Returns the current value of this global.
-  Val get(Store::Context cx) const {
-    Val val;
-    wasmtime_global_get(cx.ptr, &global, &val.val);
-    return val;
-  }
-
-  /// Sets this global to a new value.
-  ///
-  /// This can fail if `val` has the wrong type or if this global isn't mutable.
-  [[nodiscard]] Result<std::monostate> set(Store::Context cx,
-                                           const Val &val) const {
-    auto *error = wasmtime_global_set(cx.ptr, &global, &val.val);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-};
-
-/**
- * \brief A WebAssembly table.
- *
- * This class represents a WebAssembly table, either created through
- * instantiating a module or a host table. Tables are contiguous vectors of
- * WebAssembly reference types, currently either `externref` or `funcref`.
- *
- * Note that this type does not itself own any resources. It points to resources
- * owned within a `Store` and the `Store` must be passed in as the first
- * argument to the functions defined on `Table`. Note that if the wrong `Store`
- * is passed in then the process will be aborted.
- */
-class Table {
-  friend class Instance;
-  wasmtime_table_t table;
-
-public:
-  /// Creates a new table from the raw underlying C API representation.
-  Table(wasmtime_table_t table) : table(table) {}
-
-  /**
-   * \brief Creates a new host-defined table.
-   *
-   * \param cx the store in which to create the table.
-   * \param ty the type of the table to be created
-   * \param init the initial value for all table slots.
-   *
-   * Returns an error if `init` has the wrong value for the `ty` specified.
-   */
-  [[nodiscard]] static Result<Table>
-  create(Store::Context cx, const TableType &ty, const Val &init) {
-    wasmtime_table_t table;
-    auto *error = wasmtime_table_new(cx.ptr, ty.ptr.get(), &init.val, &table);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Table(table);
-  }
-
-  /// Returns the type of this table.
-  TableType type(Store::Context cx) const {
-    return wasmtime_table_type(cx.ptr, &table);
-  }
-
-  /// Returns the size, in elements, that the table currently has.
-  size_t size(Store::Context cx) const {
-    return wasmtime_table_size(cx.ptr, &table);
-  }
-
-  /// Loads a value from the specified index in this table.
-  ///
-  /// Returns `std::nullopt` if `idx` is out of bounds.
-  std::optional<Val> get(Store::Context cx, uint32_t idx) const {
-    Val val;
-    if (wasmtime_table_get(cx.ptr, &table, idx, &val.val)) {
-      return val;
-    }
-    return std::nullopt;
-  }
-
-  /// Stores a value into the specified index in this table.
-  ///
-  /// Returns an error if `idx` is out of bounds or if `val` has the wrong type.
-  [[nodiscard]] Result<std::monostate> set(Store::Context cx, uint32_t idx,
-                                           const Val &val) const {
-    auto *error = wasmtime_table_set(cx.ptr, &table, idx, &val.val);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// Grow this table.
-  ///
-  /// \param cx the store that owns this table.
-  /// \param delta the number of new elements to be added to this table.
-  /// \param init the initial value of all new elements in this table.
-  ///
-  /// Returns an error if `init` has the wrong type for this table. Otherwise
-  /// returns the previous size of the table before growth.
-  [[nodiscard]] Result<uint32_t> grow(Store::Context cx, uint32_t delta,
-                                      const Val &init) const {
-    uint32_t prev = 0;
-    auto *error = wasmtime_table_grow(cx.ptr, &table, delta, &init.val, &prev);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return prev;
-  }
-};
-
-/**
- * \brief A WebAssembly linear memory.
- *
- * This class represents a WebAssembly memory, either created through
- * instantiating a module or a host memory.
- *
- * Note that this type does not itself own any resources. It points to resources
- * owned within a `Store` and the `Store` must be passed in as the first
- * argument to the functions defined on `Table`. Note that if the wrong `Store`
- * is passed in then the process will be aborted.
- */
-class Memory {
-  friend class Instance;
-  wasmtime_memory_t memory;
-
-public:
-  /// Creates a new memory from the raw underlying C API representation.
-  Memory(wasmtime_memory_t memory) : memory(memory) {}
-
-  /// Creates a new host-defined memory with the type specified.
-  [[nodiscard]] static Result<Memory> create(Store::Context cx,
-                                             const MemoryType &ty) {
-    wasmtime_memory_t memory;
-    auto *error = wasmtime_memory_new(cx.ptr, ty.ptr.get(), &memory);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Memory(memory);
-  }
-
-  /// Returns the type of this memory.
-  MemoryType type(Store::Context cx) const {
-    return wasmtime_memory_type(cx.ptr, &memory);
-  }
-
-  /// Returns the size, in WebAssembly pages, of this memory.
-  uint32_t size(Store::Context cx) const {
-    return wasmtime_memory_size(cx.ptr, &memory);
-  }
-
-  /// Returns a `span` of where this memory is located in the host.
-  ///
-  /// Note that embedders need to be very careful in their usage of the returned
-  /// `span`. It can be invalidated with calls to `grow` and/or calls into
-  /// WebAssembly.
-  Span<uint8_t> data(Store::Context cx) const {
-    auto *base = wasmtime_memory_data(cx.ptr, &memory);
-    auto size = wasmtime_memory_data_size(cx.ptr, &memory);
-    return {base, size};
-  }
-
-  /// Grows the memory by `delta` WebAssembly pages.
-  ///
-  /// On success returns the previous size of this memory in units of
-  /// WebAssembly pages.
-  [[nodiscard]] Result<uint32_t> grow(Store::Context cx, uint32_t delta) const {
-    uint32_t prev = 0;
-    auto *error = wasmtime_memory_grow(cx.ptr, &memory, delta, &prev);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return prev;
-  }
-};
-
-/**
- * \brief A WebAssembly instance.
- *
- * This class represents a WebAssembly instance, created by instantiating a
- * module. An instance is the collection of items exported by the module, which
- * can be accessed through the `Store` that owns the instance.
- *
- * Note that this type does not itself own any resources. It points to resources
- * owned within a `Store` and the `Store` must be passed in as the first
- * argument to the functions defined on `Instance`. Note that if the wrong
- * `Store` is passed in then the process will be aborted.
- */
-class Instance {
-  friend class Linker;
-  friend class Caller;
-
-  wasmtime_instance_t instance;
-
-  static Extern cvt(wasmtime_extern_t &e) {
-    switch (e.kind) {
-    case WASMTIME_EXTERN_FUNC:
-      return Func(e.of.func);
-    case WASMTIME_EXTERN_GLOBAL:
-      return Global(e.of.global);
-    case WASMTIME_EXTERN_MEMORY:
-      return Memory(e.of.memory);
-    case WASMTIME_EXTERN_TABLE:
-      return Table(e.of.table);
-    case WASMTIME_EXTERN_INSTANCE:
-      return Instance(e.of.instance);
-    case WASMTIME_EXTERN_MODULE:
-      return Module(e.of.module);
-    }
-    std::abort();
-  }
-
-  static void cvt(const Extern &e, wasmtime_extern_t &raw) {
-    if (const auto *func = std::get_if<Func>(&e)) {
-      raw.kind = WASMTIME_EXTERN_FUNC;
-      raw.of.func = func->func;
-    } else if (const auto *global = std::get_if<Global>(&e)) {
-      raw.kind = WASMTIME_EXTERN_GLOBAL;
-      raw.of.global = global->global;
-    } else if (const auto *table = std::get_if<Table>(&e)) {
-      raw.kind = WASMTIME_EXTERN_TABLE;
-      raw.of.table = table->table;
-    } else if (const auto *memory = std::get_if<Memory>(&e)) {
-      raw.kind = WASMTIME_EXTERN_MEMORY;
-      raw.of.memory = memory->memory;
-    } else if (const auto *instance = std::get_if<Instance>(&e)) {
-      raw.kind = WASMTIME_EXTERN_INSTANCE;
-      raw.of.instance = instance->instance;
-    } else if (const auto *module = std::get_if<Module>(&e)) {
-      raw.kind = WASMTIME_EXTERN_MODULE;
-      raw.of.module = module->ptr.get();
-    } else {
-      std::abort();
-    }
-  }
-
-public:
-  /// Creates a new instance from the raw underlying C API representation.
-  Instance(wasmtime_instance_t instance) : instance(instance) {}
-
-  /**
-   * \brief Instantiates the module `m` with the provided `imports`
-   *
-   * \param cx the store in which to instantiate the provided module
-   * \param m the module to instantiate
-   * \param imports the list of imports to use to instantiate the module
-   *
-   * This `imports` parameter is expected to line up 1:1 with the imports
-   * required by the `m`. The type of `m` can be inspected to determine in which
-   * order to provide the imports. Note that this is a relatively low-level API
-   * and it's generally recommended to use `Linker` instead for name-based
-   * instantiation.
-   *
-   * This function can return an error if any of the `imports` have the wrong
-   * type, or if the wrong number of `imports` is provided.
-   */
-  [[nodiscard]] static TrapResult<Instance>
-  create(Store::Context cx, const Module &m,
-         const std::vector<Extern> &imports) {
-    std::vector<wasmtime_extern_t> raw_imports;
-    for (const auto &item : imports) {
-      raw_imports.push_back(wasmtime_extern_t{});
-      auto &last = raw_imports.back();
-      Instance::cvt(item, last);
-    }
-    wasmtime_instance_t instance;
-    wasm_trap_t *trap = nullptr;
-    auto *error = wasmtime_instance_new(cx.ptr, m.ptr.get(), raw_imports.data(),
-                                        raw_imports.size(), &instance, &trap);
-    if (error != nullptr) {
-      return TrapError(Error(error));
-    }
-    if (trap != nullptr) {
-      return TrapError(Trap(trap));
-    }
-    return Instance(instance);
-  }
-
-  /// Returns the type of this instance.
-  InstanceType type(Store::Context cx) const {
-    return wasmtime_instance_type(cx.ptr, &instance);
-  }
-
-  /**
-   * \brief Load an instance's export by name.
-   *
-   * This function will look for an export named `name` on this instance and, if
-   * found, return it as an `Extern`.
-   */
-  std::optional<Extern> get(Store::Context cx, std::string_view name) {
-    wasmtime_extern_t e;
-    if (!wasmtime_instance_export_get(cx.ptr, &instance, name.data(),
-                                      name.size(), &e)) {
-      return std::nullopt;
-    }
-    return Instance::cvt(e);
-  }
-
-  /**
-   * \brief Load an instance's export by index.
-   *
-   * This function will look for the `idx`th export of this instance. This will
-   * return both the name of the export as well as the exported item itself.
-   */
-  std::optional<std::pair<std::string_view, Extern>> get(Store::Context cx,
-                                                         size_t idx) {
-    wasmtime_extern_t e;
-    // I'm not sure why clang-tidy thinks this is using va_list or anything
-    // related to that...
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
-    char *name = nullptr;
-    size_t len = 0;
-    if (!wasmtime_instance_export_nth(cx.ptr, &instance, idx, &name, &len,
-                                      &e)) {
-      return std::nullopt;
-    }
-    std::string_view n(name, len);
-    return std::pair(n, Instance::cvt(e));
-  }
-};
-
-inline std::optional<Extern> Caller::get_export(std::string_view name) {
-  wasmtime_extern_t item;
-  if (wasmtime_caller_export_get(ptr, name.data(), name.size(), &item)) {
-    return Instance::cvt(item);
-  }
-  return std::nullopt;
-}
-
-/**
- * \brief Helper class for linking modules together with name-based resolution.
- *
- * This class is used for easily instantiating `Module`s by defining names into
- * the linker and performing name-based resolution during instantiation. A
- * `Linker` can also be used to link in WASI functions to instantiate a module.
- */
-class Linker {
-  struct deleter {
-    void operator()(wasmtime_linker_t *p) const { wasmtime_linker_delete(p); }
-  };
-
-  std::unique_ptr<wasmtime_linker_t, deleter> ptr;
-
-public:
-  /// Creates a new linker which will instantiate in the given engine.
-  explicit Linker(Engine &engine)
-      : ptr(wasmtime_linker_new(engine.ptr.get())) {}
-
-  /// Configures whether shadowing previous names is allowed or not.
-  ///
-  /// By default shadowing is not allowed.
-  void allow_shadowing(bool allow) {
-    wasmtime_linker_allow_shadowing(ptr.get(), allow);
-  }
-
-  /// Defines the provided item into this linker with the given name.
-  [[nodiscard]] Result<std::monostate>
-  define(std::string_view module, std::string_view name, const Extern &item) {
-    wasmtime_extern_t raw;
-    Instance::cvt(item, raw);
-    auto *error =
-        wasmtime_linker_define(ptr.get(), module.data(), module.size(),
-                               name.data(), name.size(), &raw);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// Defines WASI functions within this linker.
-  ///
-  /// Note that `Store::Context::set_wasi` must also be used for instantiated
-  /// modules to have access to configured WASI state.
-  [[nodiscard]] Result<std::monostate> define_wasi() {
-    auto *error = wasmtime_linker_define_wasi(ptr.get());
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// Defines all exports of the `instance` provided in this linker with the
-  /// given module name of `name`.
-  [[nodiscard]] Result<std::monostate>
-  define_instance(Store::Context cx, std::string_view name, Instance instance) {
-    auto *error = wasmtime_linker_define_instance(
-        ptr.get(), cx.ptr, name.data(), name.size(), &instance.instance);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// Instantiates the module `m` provided within the store `cx` using the items
-  /// defined within this linker.
-  [[nodiscard]] TrapResult<Instance> instantiate(Store::Context cx,
-                                                 const Module &m) {
-    wasmtime_instance_t instance;
-    wasm_trap_t *trap = nullptr;
-    auto *error = wasmtime_linker_instantiate(ptr.get(), cx.ptr, m.ptr.get(),
-                                              &instance, &trap);
-    if (error != nullptr) {
-      return TrapError(Error(error));
-    }
-    if (trap != nullptr) {
-      return TrapError(Trap(trap));
-    }
-    return Instance(instance);
-  }
-
-  /// Defines instantiations of the module `m` within this linker under the
-  /// given `name`.
-  [[nodiscard]] Result<std::monostate>
-  module(Store::Context cx, std::string_view name, const Module &m) {
-    auto *error = wasmtime_linker_module(ptr.get(), cx.ptr, name.data(),
-                                         name.size(), m.ptr.get());
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return std::monostate();
-  }
-
-  /// Attempts to load the specified named item from this linker, returning
-  /// `std::nullopt` if it was not defiend.
-  [[nodiscard]] std::optional<Extern>
-  get(Store::Context cx, std::string_view module, std::string_view name) {
-    wasmtime_extern_t item;
-    if (wasmtime_linker_get(ptr.get(), cx.ptr, module.data(), module.size(),
-                            name.data(), name.size(), &item)) {
-      return Instance::cvt(item);
-    }
-    return std::nullopt;
-  }
-
-  /// Loads the "default" function, according to WASI commands and reactors, of
-  /// the module named `name` in this linker.
-  [[nodiscard]] Result<Func> get_default(Store::Context cx,
-                                         std::string_view name) {
-    wasmtime_func_t item;
-    auto *error = wasmtime_linker_get_default(ptr.get(), cx.ptr, name.data(),
-                                              name.size(), &item);
-    if (error != nullptr) {
-      return Error(error);
-    }
-    return Func(item);
-  }
-};
-
-} // namespace wasmtime
-
-#endif // WASMTIME_HH
diff --git a/replica/database.cc b/replica/database.cc
index 8d30b69e804b..550bc6d3be4f 100644
--- a/replica/database.cc
+++ b/replica/database.cc
@@ -361,7 +361,7 @@ database::database(const db::config& cfg, database_config dbcfg, service::migrat
     , _feat(feat)
     , _shared_token_metadata(stm)
     , _sst_dir_semaphore(sst_dir_sem)
-    , _wasm_engine(std::make_unique<wasm::engine>())
+    , _wasm_engine(std::make_unique<rust::Box<wasmtime::Engine>>(wasmtime::create_engine()))
     , _stop_barrier(std::move(barrier))
     , _update_memtable_flush_static_shares_action([this, &cfg] { return _memtable_controller.update_static_shares(cfg.memtable_flush_static_shares()); })
     , _memtable_flush_static_shares_observer(cfg.memtable_flush_static_shares.observe(_update_memtable_flush_static_shares_action.make_observer()))
diff --git a/replica/database.hh b/replica/database.hh
index bfdaeac5f657..21087a5acb5d 100644
--- a/replica/database.hh
+++ b/replica/database.hh
@@ -70,6 +70,7 @@
 #include "db/operation_type.hh"
 #include "utils/serialized_action.hh"
 #include "compaction/compaction_manager.hh"
+#include "rust/wasmtime_bindings.hh"
 
 class cell_locker;
 class cell_locker_stats;
@@ -126,10 +127,6 @@ future<> system_keyspace_make(distributed<replica::database>& db, distributed<se
 
 }
 
-namespace wasm {
-class engine;
-}
-
 class mutation_reordered_with_truncate_exception : public std::exception {};
 
 class column_family_test;
@@ -1354,7 +1351,7 @@ private:
 
     sharded<semaphore>& _sst_dir_semaphore;
 
-    std::unique_ptr<wasm::engine> _wasm_engine;
+    std::unique_ptr<rust::Box<wasmtime::Engine>> _wasm_engine;
     utils::cross_shard_barrier _stop_barrier;
 
     db::rate_limiter _rate_limiter;
@@ -1371,7 +1368,7 @@ public:
     future<> apply_in_memory(const frozen_mutation& m, schema_ptr m_schema, db::rp_handle&&, db::timeout_clock::time_point timeout);
     future<> apply_in_memory(const mutation& m, column_family& cf, db::rp_handle&&, db::timeout_clock::time_point timeout);
 
-    wasm::engine* wasm_engine() {
+    rust::Box<wasmtime::Engine>* wasm_engine() {
         return _wasm_engine.get();
     }