diff --git a/Makefile b/Makefile
index e4ed72643e..e7005afb2f 100644
--- a/Makefile
+++ b/Makefile
@@ -65,7 +65,7 @@ TELEMETRY_URL ?= #Default empty
 
 BUILD_HOSTNAME := $(shell ./build/get-build-hostname.sh)
 
-RELEASE_BUILD_IMAGE := golang:$(GOVERSION)-bullseye
+RELEASE_BUILD_IMAGE := golang:$(GOVERSION)-bookworm
 
 RELEASE_DIR ?= _release/$(VERSION)
 
diff --git a/build/ensure-windows-toolchain.sh b/build/ensure-windows-toolchain.sh
index e3ad5549d5..2cacd67543 100755
--- a/build/ensure-windows-toolchain.sh
+++ b/build/ensure-windows-toolchain.sh
@@ -7,4 +7,5 @@ PKG=gcc-mingw-w64-x86-64
 type -f ${CC} 2>/dev/null && exit 0
 
 apt-get update && \
-  apt-get install --no-install-recommends -y ${PKG}
+  apt-get install --no-install-recommends -y ${PKG} && \
+  apt-get install --no-install-recommends -y binutils-mingw-w64-x86-64
diff --git a/go.mod b/go.mod
index 7a2a7ecfba..f6001b3d6c 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/OneOfOne/xxhash v1.2.8
 	github.com/agnivade/levenshtein v1.1.1
 	github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883
-	github.com/bytecodealliance/wasmtime-go/v3 v3.0.2
+	github.com/bytecodealliance/wasmtime-go/v17 v17.0.0
 	github.com/containerd/containerd v1.7.12
 	github.com/dgraph-io/badger/v3 v3.2103.5
 	github.com/fortytw2/leaktest v1.3.0
diff --git a/go.sum b/go.sum
index 548e4b2186..f528194c44 100644
--- a/go.sum
+++ b/go.sum
@@ -17,8 +17,8 @@ github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdK
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bytecodealliance/wasmtime-go/v3 v3.0.2 h1:3uZCA/BLTIu+DqCfguByNMJa2HVHpXvjfy0Dy7g6fuA=
-github.com/bytecodealliance/wasmtime-go/v3 v3.0.2/go.mod h1:RnUjnIXxEJcL6BgCvNyzCCRzZcxCgsZCi+RNlvYor5Q=
+github.com/bytecodealliance/wasmtime-go/v17 v17.0.0 h1:Cqs/IPBXQZW/rXKGJEn9aUTbjSiEugHPCdl6bz05Bf0=
+github.com/bytecodealliance/wasmtime-go/v17 v17.0.0/go.mod h1:Xc5PsJLgMNsHdxFh4wwEdxTYe/AmwlkhPgmemK7FuNs=
 github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
 github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/internal/wasm/sdk/internal/wasm/bindings.go b/internal/wasm/sdk/internal/wasm/bindings.go
index f90031c532..bc1dc7d7c9 100644
--- a/internal/wasm/sdk/internal/wasm/bindings.go
+++ b/internal/wasm/sdk/internal/wasm/bindings.go
@@ -16,7 +16,7 @@ import (
 	"strconv"
 	"time"
 
-	wasmtime "github.com/bytecodealliance/wasmtime-go/v3"
+	wasmtime "github.com/bytecodealliance/wasmtime-go/v17"
 
 	"github.com/open-policy-agent/opa/ast"
 	"github.com/open-policy-agent/opa/metrics"
diff --git a/internal/wasm/sdk/internal/wasm/pool.go b/internal/wasm/sdk/internal/wasm/pool.go
index bfc211240b..d366b4b11f 100644
--- a/internal/wasm/sdk/internal/wasm/pool.go
+++ b/internal/wasm/sdk/internal/wasm/pool.go
@@ -9,7 +9,7 @@ import (
 	"context"
 	"sync"
 
-	wasmtime "github.com/bytecodealliance/wasmtime-go/v3"
+	wasmtime "github.com/bytecodealliance/wasmtime-go/v17"
 
 	"github.com/open-policy-agent/opa/internal/wasm/sdk/opa/errors"
 	"github.com/open-policy-agent/opa/internal/wasm/util"
diff --git a/internal/wasm/sdk/internal/wasm/vm.go b/internal/wasm/sdk/internal/wasm/vm.go
index 40453682c4..a29cd9b7fe 100644
--- a/internal/wasm/sdk/internal/wasm/vm.go
+++ b/internal/wasm/sdk/internal/wasm/vm.go
@@ -14,7 +14,7 @@ import (
 	"strings"
 	"time"
 
-	wasmtime "github.com/bytecodealliance/wasmtime-go/v3"
+	wasmtime "github.com/bytecodealliance/wasmtime-go/v17"
 
 	"github.com/open-policy-agent/opa/ast"
 	sdk_errors "github.com/open-policy-agent/opa/internal/wasm/sdk/opa/errors"
@@ -94,11 +94,11 @@ func newVM(opts vmOpts, engine *wasmtime.Engine) (*VM, error) {
 	v.dispatcher = newBuiltinDispatcher()
 	externs := opaFunctions(v.dispatcher, store)
 	for name, extern := range externs {
-		if err := linker.Define("env", name, extern); err != nil {
+		if err := linker.Define(store, "env", name, extern); err != nil {
 			return nil, fmt.Errorf("linker: env.%s: %w", name, err)
 		}
 	}
-	if err := linker.Define("env", "memory", memory); err != nil {
+	if err := linker.Define(store, "env", "memory", memory); err != nil {
 		return nil, fmt.Errorf("linker: env.memory: %w", err)
 	}
 
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/BUILD.bazel b/vendor/github.com/bytecodealliance/wasmtime-go/v17/BUILD.bazel
similarity index 92%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/BUILD.bazel
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/BUILD.bazel
index 58a2c5019d..7eda60cfae 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/BUILD.bazel
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/BUILD.bazel
@@ -6,6 +6,7 @@ cc_library(
         "@io_bazel_rules_go//go/platform:darwin_amd64": ["build/macos-x86_64/libwasmtime.a"],
         "@io_bazel_rules_go//go/platform:linux_amd64": ["build/linux-x86_64/libwasmtime.a"],
         "@io_bazel_rules_go//go/platform:windows_amd64": ["build/windows-x86_64/libwasmtime.a"],
+        "@io_bazel_rules_go//go/platform:darwin_arm64": ["build/macos-aarch64/libwasmtime.a"],
     }),
     hdrs = glob(["build/include/**/*.h"]),
     includes = ["build/include"],
@@ -62,7 +63,7 @@ go_library(
         ],
         "//conditions:default": [],
     }),
-    importpath = "github.com/bytecodealliance/wasmtime-go/v3",
+    importpath = "github.com/bytecodealliance/wasmtime-go/v17",
     visibility = ["//visibility:public"],
 )
 
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/LICENSE b/vendor/github.com/bytecodealliance/wasmtime-go/v17/LICENSE
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/LICENSE
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/LICENSE
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/README.md b/vendor/github.com/bytecodealliance/wasmtime-go/v17/README.md
similarity index 84%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/README.md
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/README.md
index 38fe65713c..df6f799a53 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/README.md
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/README.md
@@ -12,8 +12,8 @@
     <a href="https://github.com/bytecodealliance/wasmtime-go/actions?query=workflow%3ACI">
       <img src="https://github.com/bytecodealliance/wasmtime-go/workflows/CI/badge.svg" alt="CI status"/>
     </a>
-    <a href="https://pkg.go.dev/github.com/bytecodealliance/wasmtime-go/v3">
-      <img src="https://godoc.org/github.com/bytecodealliance/wasmtime-go/v3?status.svg" alt="Documentation"/>
+    <a href="https://pkg.go.dev/github.com/bytecodealliance/wasmtime-go/v17">
+      <img src="https://godoc.org/github.com/bytecodealliance/wasmtime-go/v17?status.svg" alt="Documentation"/>
     </a>
     <a href="https://bytecodealliance.github.io/wasmtime-go/coverage.html">
       <img src="https://img.shields.io/badge/coverage-main-green" alt="Code Coverage"/>
@@ -25,7 +25,7 @@
 ## Installation
 
 ```sh
-go get -u github.com/bytecodealliance/wasmtime-go/v3@v3.0.2
+go get -u github.com/bytecodealliance/wasmtime-go/v17@v17.0.0
 ```
 
 Be sure to check out the [API documentation][api]!
@@ -39,7 +39,7 @@ need to arrange to build Wasmtime and use `CGO_*` env vars to compile correctly.
 
 This project has been tested with Go 1.13 or later.
 
-[api]: https://pkg.go.dev/github.com/bytecodealliance/wasmtime-go/v3
+[api]: https://pkg.go.dev/github.com/bytecodealliance/wasmtime-go/v17
 [wasmtime]: https://github.com/bytecodealliance/wasmtime
 
 If you are a bazel user, add following to your WORKSPACE file:
@@ -47,8 +47,8 @@ If you are a bazel user, add following to your WORKSPACE file:
 ```
 go_repository(
     name = "com_github_bytecodealliance_wasmtime_go",
-    importpath = "github.com/bytecodealliance/wasmtime-go/v3",
-    version = "v3.0.2",
+    importpath = "github.com/bytecodealliance/wasmtime-go/v17",
+    version = "v17.0.0",
 )
 ```
 
@@ -61,7 +61,7 @@ package main
 
 import (
     "fmt"
-    "github.com/bytecodealliance/wasmtime-go/v3"
+    "github.com/bytecodealliance/wasmtime-go/v17"
 )
 
 func main() {
@@ -151,3 +151,36 @@ $ go test
 ```
 
 And after that you should be good to go!
+
+### Release Checklist
+
+First run:
+
+```
+$ python3 ci/download-wasmtime.py
+$ go test
+```
+
+Make sure everything passes at the current version.
+
+Next run:
+
+```
+$ git ls-files | xargs sed -i 's/v16/v17/g'
+$ python3 ci/download-wasmtime.py
+$ go test
+```
+
+Fix all errors and such and then commit and make a PR.
+
+Once merged checkout `main` and do:
+
+```
+$ rm .gitignore
+$ python3 ci/download-wasmtime.py
+$ git add .
+$ git commit -m 'v17.0.0 release artifacts'
+$ git tag v17.0.0
+```
+
+and push up the tag
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/WORKSPACE b/vendor/github.com/bytecodealliance/wasmtime-go/v17/WORKSPACE
similarity index 90%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/WORKSPACE
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/WORKSPACE
index 361778a490..6aff04531f 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/WORKSPACE
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/WORKSPACE
@@ -2,10 +2,10 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
     name = "io_bazel_rules_go",
-    sha256 = "685052b498b6ddfe562ca7a97736741d87916fe536623afb7da2824c0211c369",
+    sha256 = "91585017debb61982f7054c9688857a2ad1fd823fc3f9cb05048b0025c47d023",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.33.0/rules_go-v0.33.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.33.0/rules_go-v0.33.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.42.0/rules_go-v0.42.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.42.0/rules_go-v0.42.0.zip",
     ],
 )
 
@@ -63,6 +63,6 @@ go_repository(
 
 go_rules_dependencies()
 
-go_register_toolchains(version = "1.16")
+go_register_toolchains(version = "1.21.1")
 
 gazelle_dependencies()
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/doc-wasm.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/doc-wasm.h
similarity index 99%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/doc-wasm.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/doc-wasm.h
index 6bad15c744..45afbecf91 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/doc-wasm.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/doc-wasm.h
@@ -1,3 +1,5 @@
+/* clang-format off */
+
 /**
  * \file wasm.h
  *
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasi.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasi.h
similarity index 60%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasi.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasi.h
index f3d1dfd452..1f520cb265 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasi.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasi.h
@@ -8,6 +8,7 @@
 #define WASI_H
 
 #include "wasm.h"
+#include <stdint.h>
 
 #ifndef WASI_API_EXTERN
 #ifdef _WIN32
@@ -23,9 +24,9 @@ extern "C" {
 
 #define own
 
-#define WASI_DECLARE_OWN(name) \
-  typedef struct wasi_##name##_t wasi_##name##_t; \
-  WASI_API_EXTERN void wasi_##name##_delete(own wasi_##name##_t*);
+#define WASI_DECLARE_OWN(name)                                                 \
+  typedef struct wasi_##name##_t wasi_##name##_t;                              \
+  WASI_API_EXTERN void wasi_##name##_delete(own wasi_##name##_t *);
 
 /**
  * \typedef wasi_config_t
@@ -44,7 +45,7 @@ WASI_DECLARE_OWN(config)
  *
  * The caller is expected to deallocate the returned configuration
  */
-WASI_API_EXTERN own wasi_config_t* wasi_config_new();
+WASI_API_EXTERN own wasi_config_t *wasi_config_new();
 
 /**
  * \brief Sets the argv list for this configuration object.
@@ -55,13 +56,14 @@ WASI_API_EXTERN own wasi_config_t* wasi_config_new();
  * The arguments are copied into the `config` object as part of this function
  * call, so the `argv` pointer only needs to stay alive for this function call.
  */
-WASI_API_EXTERN void wasi_config_set_argv(wasi_config_t* config, int argc, const char* argv[]);
+WASI_API_EXTERN void wasi_config_set_argv(wasi_config_t *config, int argc,
+                                          const char *argv[]);
 
 /**
  * \brief Indicates that the argv list should be inherited from this process's
  * argv list.
  */
-WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t *config);
 
 /**
  * \brief Sets the list of environment variables available to the WASI instance.
@@ -75,13 +77,15 @@ WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t* config);
  * call, so the `names` and `values` pointers only need to stay alive for this
  * function call.
  */
-WASI_API_EXTERN void wasi_config_set_env(wasi_config_t* config, int envc, const char* names[], const char* values[]);
+WASI_API_EXTERN void wasi_config_set_env(wasi_config_t *config, int envc,
+                                         const char *names[],
+                                         const char *values[]);
 
 /**
  * \brief Indicates that the entire environment of the calling process should be
  * inherited by this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t *config);
 
 /**
  * \brief Configures standard input to be taken from the specified file.
@@ -92,23 +96,26 @@ WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t* config);
  * If the stdin location does not exist or it cannot be opened for reading then
  * `false` is returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stdin_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stdin_file(wasi_config_t *config,
+                                                const char *path);
 
 /**
- * \brief Configures standard input to be taken from the specified #wasm_byte_vec_t.
+ * \brief Configures standard input to be taken from the specified
+ * #wasm_byte_vec_t.
  *
  * By default WASI programs have no stdin, but this configures the specified
  * bytes to be used as stdin for this configuration.
  *
  * This function takes ownership of the `binary` argument.
  */
-WASI_API_EXTERN void wasi_config_set_stdin_bytes(wasi_config_t* config, wasm_byte_vec_t* binary);
+WASI_API_EXTERN void wasi_config_set_stdin_bytes(wasi_config_t *config,
+                                                 wasm_byte_vec_t *binary);
 
 /**
  * \brief Configures this process's own stdin stream to be used as stdin for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t *config);
 
 /**
  * \brief Configures standard output to be written to the specified file.
@@ -119,13 +126,14 @@ WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t* config);
  * If the stdout location could not be opened for writing then `false` is
  * returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stdout_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stdout_file(wasi_config_t *config,
+                                                 const char *path);
 
 /**
  * \brief Configures this process's own stdout stream to be used as stdout for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t *config);
 
 /**
  * \brief Configures standard output to be written to the specified file.
@@ -136,30 +144,49 @@ WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t* config);
  * If the stderr location could not be opened for writing then `false` is
  * returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stderr_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stderr_file(wasi_config_t *config,
+                                                 const char *path);
 
 /**
  * \brief Configures this process's own stderr stream to be used as stderr for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stderr(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stderr(wasi_config_t *config);
 
 /**
  * \brief Configures a "preopened directory" to be available to WASI APIs.
  *
  * By default WASI programs do not have access to anything on the filesystem.
  * This API can be used to grant WASI programs access to a directory on the
- * filesystem, but only that directory (its whole contents but nothing above it).
+ * filesystem, but only that directory (its whole contents but nothing above
+ * it).
  *
  * The `path` argument here is a path name on the host filesystem, and
  * `guest_path` is the name by which it will be known in wasm.
  */
-WASI_API_EXTERN bool wasi_config_preopen_dir(wasi_config_t* config, const char* path, const char* guest_path);
+WASI_API_EXTERN bool wasi_config_preopen_dir(wasi_config_t *config,
+                                             const char *path,
+                                             const char *guest_path);
+
+/**
+ * \brief Configures a "preopened" listen socket to be available to WASI APIs.
+ *
+ * By default WASI programs do not have access to open up network sockets on
+ * the host. This API can be used to grant WASI programs access to a network
+ * socket file descriptor on the host.
+ *
+ * The fd_num argument is the number of the file descriptor by which it will be
+ * known in WASM and the host_port is the IP address and port (e.g.
+ * "127.0.0.1:8080") requested to listen on.
+ */
+WASI_API_EXTERN bool wasi_config_preopen_socket(wasi_config_t *config,
+                                                uint32_t fd_num,
+                                                const char *host_port);
 
 #undef own
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
-#endif  // #ifdef WASI_H
+#endif // #ifdef WASI_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasm.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasm.h
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasm.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasm.h
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime.h
similarity index 92%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime.h
index c70fd8b713..9dac550e49 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime.h
@@ -57,7 +57,8 @@
  *
  * * Linux - `-lpthread -ldl -lm`
  * * macOS - no extra flags needed
- * * Windows - `ws2_32.lib advapi32.lib userenv.lib ntdll.lib shell32.lib ole32.lib bcrypt.lib`
+ * * Windows - `ws2_32.lib advapi32.lib userenv.lib ntdll.lib shell32.lib
+ * ole32.lib bcrypt.lib`
  *
  * ## Building from Source
  *
@@ -181,6 +182,8 @@
 #define WASMTIME_API_H
 
 #include <wasi.h>
+// clang-format off
+// IWYU pragma: begin_exports
 #include <wasmtime/config.h>
 #include <wasmtime/engine.h>
 #include <wasmtime/error.h>
@@ -195,6 +198,26 @@
 #include <wasmtime/table.h>
 #include <wasmtime/trap.h>
 #include <wasmtime/val.h>
+#include <wasmtime/async.h>
+// IWYU pragma: end_exports
+// clang-format on
+
+/**
+ * \brief Wasmtime version string.
+ */
+#define WASMTIME_VERSION "17.0.0"
+/**
+ * \brief Wasmtime major version number.
+ */
+#define WASMTIME_VERSION_MAJOR 17
+/**
+ * \brief Wasmtime minor version number.
+ */
+#define WASMTIME_VERSION_MINOR 0
+/**
+ * \brief Wasmtime patch version number.
+ */
+#define WASMTIME_VERSION_PATCH 0
 
 #ifdef __cplusplus
 extern "C" {
@@ -203,11 +226,11 @@ extern "C" {
 /**
  * \brief Converts from the text format of WebAssembly to to the binary format.
  *
- * \param wat this it the input pointer with the WebAssembly Text Format inside of
- *   it. This will be parsed and converted to the binary format.
+ * \param wat this it the input pointer with the WebAssembly Text Format inside
+ *        of it. This will be parsed and converted to the binary format.
  * \param wat_len this it the length of `wat`, in bytes.
- * \param ret if the conversion is successful, this byte vector is filled in with
- *   the WebAssembly binary format.
+ * \param ret if the conversion is successful, this byte vector is filled in
+ *        with the WebAssembly binary format.
  *
  * \return a non-null error if parsing fails, or returns `NULL`. If parsing
  * fails then `ret` isn't touched.
@@ -215,14 +238,11 @@ extern "C" {
  * This function does not take ownership of `wat`, and the caller is expected to
  * deallocate the returned #wasmtime_error_t and #wasm_byte_vec_t.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_wat2wasm(
-    const char *wat,
-    size_t wat_len,
-    wasm_byte_vec_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_wat2wasm(const char *wat, size_t wat_len, wasm_byte_vec_t *ret);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_API_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/async.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/async.h
new file mode 100644
index 0000000000..bb2e986f78
--- /dev/null
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/async.h
@@ -0,0 +1,369 @@
+/**
+ * \file wasmtime/async.h
+ *
+ * \brief Wasmtime async functionality
+ *
+ * Async functionality in Wasmtime is well documented here:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_support
+ *
+ * All WebAssembly executes synchronously, but an async support enables the Wasm
+ * code be executed on a seperate stack, so it can be paused and resumed. There
+ * are three mechanisms for yielding control from wasm to the caller: fuel,
+ * epochs, and async host functions.
+ *
+ * When WebAssembly is executed, a #wasmtime_call_future_t is returned. This
+ * struct represents the state of the execution and each call to
+ * #wasmtime_call_future_poll will execute the WebAssembly code on a seperate
+ * stack until the function returns or yields control back to the caller.
+ *
+ * It's expected these futures are pulled in a loop until completed, at which
+ * point the future should be deleted. Functions that return a
+ * #wasmtime_call_future_t are special in that all parameters to that function
+ * should not be modified in any way and must be kept alive until the future is
+ * deleted. This includes concurrent calls for a single store - another function
+ * on a store should not be called while there is a #wasmtime_call_future_t
+ * alive.
+ *
+ * As for asynchronous host calls - the reverse contract is upheld. Wasmtime
+ * will keep all parameters to the function alive and unmodified until the
+ * #wasmtime_func_async_continuation_callback_t returns true.
+ *
+ */
+
+#ifndef WASMTIME_ASYNC_H
+#define WASMTIME_ASYNC_H
+
+#include <wasm.h>
+#include <wasmtime/config.h>
+#include <wasmtime/error.h>
+#include <wasmtime/func.h>
+#include <wasmtime/linker.h>
+#include <wasmtime/store.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief Whether or not to enable support for asynchronous functions in
+ * Wasmtime.
+ *
+ * When enabled, the config can optionally define host functions with async.
+ * Instances created and functions called with this Config must be called
+ * through their asynchronous APIs, however. For example using
+ * wasmtime_func_call will panic when used with this config.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_support
+ */
+WASMTIME_CONFIG_PROP(void, async_support, bool)
+
+/**
+ * \brief Configures the size of the stacks used for asynchronous execution.
+ *
+ * This setting configures the size of the stacks that are allocated for
+ * asynchronous execution.
+ *
+ * The value cannot be less than max_wasm_stack.
+ *
+ * The amount of stack space guaranteed for host functions is async_stack_size -
+ * max_wasm_stack, so take care not to set these two values close to one
+ * another; doing so may cause host functions to overflow the stack and abort
+ * the process.
+ *
+ * By default this option is 2 MiB.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_stack_size
+ */
+WASMTIME_CONFIG_PROP(void, async_stack_size, uint64_t)
+
+/**
+ * \brief Configures a Store to yield execution of async WebAssembly code
+ * periodically.
+ *
+ * When a Store is configured to consume fuel with
+ * `wasmtime_config_consume_fuel` this method will configure what happens when
+ * fuel runs out. Specifically executing WebAssembly will be suspended and
+ * control will be yielded back to the caller.
+ *
+ * This is only suitable with use of a store associated with an async config
+ * because only then are futures used and yields are possible.
+ *
+ * \param context the context for the store to configure.
+ * \param interval the amount of fuel at which to yield. A value of 0 will
+ *        disable yielding.
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_fuel_async_yield_interval(wasmtime_context_t *context,
+                                           uint64_t interval);
+
+/**
+ * \brief Configures epoch-deadline expiration to yield to the async caller and
+ * the update the deadline.
+ *
+ * This is only suitable with use of a store associated with an async config
+ * because only then are futures used and yields are possible.
+ *
+ * See the Rust documentation for more:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Store.html#method.epoch_deadline_async_yield_and_update
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_epoch_deadline_async_yield_and_update(
+    wasmtime_context_t *context, uint64_t delta);
+
+/**
+ * The callback to determine a continuation's current state.
+ *
+ * Return true if the host call has completed, otherwise false will
+ * continue to yield WebAssembly execution.
+ */
+typedef bool (*wasmtime_func_async_continuation_callback_t)(void *env);
+
+/**
+ * A continuation for the current state of the host function's execution.
+ */
+typedef struct wasmtime_async_continuation_t {
+  /// Callback for if the async function has completed.
+  wasmtime_func_async_continuation_callback_t callback;
+  /// User-provided argument to pass to the callback.
+  void *env;
+  /// A finalizer for the user-provided *env
+  void (*finalizer)(void *);
+} wasmtime_async_continuation_t;
+
+/**
+ * \brief Callback signature for #wasmtime_linker_define_async_func.
+ *
+ * This is a host function that returns a continuation to be called later.
+ *
+ * All the arguments to this function will be kept alive until the continuation
+ * returns that it has errored or has completed.
+ *
+ * \param env user-provided argument passed to
+ *        #wasmtime_linker_define_async_func
+ * \param caller a temporary object that can only be used during this function
+ *        call. Used to acquire #wasmtime_context_t or caller's state
+ * \param args the arguments provided to this function invocation
+ * \param nargs how many arguments are provided
+ * \param results where to write the results of this function
+ * \param nresults how many results must be produced
+ * \param trap_ret if assigned a not `NULL` value then the called
+ *        function will trap with the returned error. Note that ownership of
+ *        trap is transferred to wasmtime.
+ * \param continuation_ret the returned continuation
+ *        that determines when the async function has completed executing.
+ *
+ * Only supported for async stores.
+ *
+ * See #wasmtime_func_callback_t for more information.
+ */
+typedef void (*wasmtime_func_async_callback_t)(
+    void *env, wasmtime_caller_t *caller, const wasmtime_val_t *args,
+    size_t nargs, wasmtime_val_t *results, size_t nresults,
+    wasm_trap_t **trap_ret, wasmtime_async_continuation_t *continuation_ret);
+
+/**
+ * \brief The structure representing a asynchronously running function.
+ *
+ * This structure is always owned by the caller and must be deleted using
+ * #wasmtime_call_future_delete.
+ *
+ * Functions that return this type require that the parameters to the function
+ * are unmodified until this future is destroyed.
+ */
+typedef struct wasmtime_call_future wasmtime_call_future_t;
+
+/**
+ * \brief Executes WebAssembly in the function.
+ *
+ * Returns true if the function call has completed. After this function returns
+ * true, it should *not* be called again for a given future.
+ *
+ * This function returns false if execution has yielded either due to being out
+ * of fuel (see wasmtime_context_fuel_async_yield_interval), or the epoch has
+ * been incremented enough (see
+ * wasmtime_context_epoch_deadline_async_yield_and_update). The function may
+ * also return false if asynchronous host functions have been called, which then
+ * calling this  function will call the continuation from the async host
+ * function.
+ *
+ * For more see the information at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#asynchronous-wasm
+ *
+ */
+WASM_API_EXTERN bool wasmtime_call_future_poll(wasmtime_call_future_t *future);
+
+/**
+ * /brief Frees the underlying memory for a future.
+ *
+ * All wasmtime_call_future_t are owned by the caller and should be deleted
+ * using this function.
+ */
+WASM_API_EXTERN void
+wasmtime_call_future_delete(wasmtime_call_future_t *future);
+
+/**
+ * \brief Invokes this function with the params given, returning the results
+ * asynchronously.
+ *
+ * This function is the same as wasmtime_func_call except that it is
+ * asynchronous. This is only compatible with stores associated with an
+ * asynchronous config.
+ *
+ * The result is a future that is owned by the caller and must be deleted via
+ * #wasmtime_call_future_delete.
+ *
+ * The `args` and `results` pointers may be `NULL` if the corresponding length
+ * is zero. The `trap_ret` and `error_ret` pointers may *not* be `NULL`.
+ *
+ * Does not take ownership of #wasmtime_val_t arguments or #wasmtime_val_t
+ * results, and all parameters to this function must be kept alive and not
+ * modified until the returned #wasmtime_call_future_t is deleted. This includes
+ * the context and store parameters. Only a single future can be alive for a
+ * given store at a single time (meaning only call this function after the
+ * previous call's future was deleted).
+ *
+ * See the header documentation for for more information.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Func.html#method.call_async
+ */
+WASM_API_EXTERN wasmtime_call_future_t *wasmtime_func_call_async(
+    wasmtime_context_t *context, const wasmtime_func_t *func,
+    const wasmtime_val_t *args, size_t nargs, wasmtime_val_t *results,
+    size_t nresults, wasm_trap_t **trap_ret, wasmtime_error_t **error_ret);
+
+/**
+ * \brief Defines a new async function in this linker.
+ *
+ * This function behaves similar to #wasmtime_linker_define_func, except it
+ * supports async callbacks.
+ *
+ * The callback `cb` will be invoked on another stack (fiber for Windows).
+ */
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_async_func(
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_async_callback_t cb, void *data, void (*finalizer)(void *));
+
+/**
+ * \brief Instantiates a #wasm_module_t with the items defined in this linker
+ * for an async store.
+ *
+ * This is the same as #wasmtime_linker_instantiate but used for async stores
+ * (which requires functions are called asynchronously). The returning
+ * #wasmtime_call_future_t must be polled using #wasmtime_call_future_poll, and
+ * is owned and must be deleted using #wasmtime_call_future_delete.
+ *
+ * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned
+ * memory is owned by the caller.
+ *
+ * All arguments to this function must outlive the returned future and be
+ * unmodified until the future is deleted.
+ */
+WASM_API_EXTERN wasmtime_call_future_t *wasmtime_linker_instantiate_async(
+    const wasmtime_linker_t *linker, wasmtime_context_t *store,
+    const wasmtime_module_t *module, wasmtime_instance_t *instance,
+    wasm_trap_t **trap_ret, wasmtime_error_t **error_ret);
+
+/**
+ * \brief Instantiates instance within the given store.
+ *
+ * This will also run the function's startup function, if there is one.
+ *
+ * For more information on async instantiation see
+ * #wasmtime_linker_instantiate_async.
+ *
+ * \param instance_pre the pre-initialized instance
+ * \param store the store in which to create the instance
+ * \param instance where to store the returned instance
+ * \param trap_ret where to store the returned trap
+ * \param error_ret where to store the returned trap
+ *
+ * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned
+ * memory is owned by the caller.
+ *
+ * All arguments to this function must outlive the returned future and be
+ * unmodified until the future is deleted.
+ */
+WASM_API_EXTERN wasmtime_call_future_t *wasmtime_instance_pre_instantiate_async(
+    const wasmtime_instance_pre_t *instance_pre, wasmtime_context_t *store,
+    wasmtime_instance_t *instance, wasm_trap_t **trap_ret,
+    wasmtime_error_t **error_ret);
+
+/**
+ * A callback to get the top of the stack address and the length of the stack,
+ * excluding guard pages.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackMemory.html
+ */
+typedef uint8_t *(*wasmtime_stack_memory_get_callback_t)(void *env,
+                                                         size_t *out_len);
+
+/**
+ * A Stack instance created from a #wasmtime_new_stack_memory_callback_t.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackMemory.html
+ */
+typedef struct {
+  /// User provided value to be passed to get_memory and grow_memory
+  void *env;
+  /// Callback to get the memory and size of this LinearMemory
+  wasmtime_stack_memory_get_callback_t get_stack_memory;
+  /// An optional finalizer for env
+  void (*finalizer)(void *);
+} wasmtime_stack_memory_t;
+
+/**
+ * A callback to create a new StackMemory from the specified parameters.
+ *
+ * The result should be written to `stack_ret` and wasmtime will own the values
+ * written into that struct.
+ *
+ * This callback must be thread-safe.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackCreator.html#tymethod.new_stack
+ */
+typedef wasmtime_error_t *(*wasmtime_new_stack_memory_callback_t)(
+    void *env, size_t size, wasmtime_stack_memory_t *stack_ret);
+
+/**
+ * A representation of custom stack creator.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackCreator.html
+ */
+typedef struct {
+  /// User provided value to be passed to new_stack
+  void *env;
+  /// The callback to create a new stack, must be thread safe
+  wasmtime_new_stack_memory_callback_t new_stack;
+  /// An optional finalizer for env.
+  void (*finalizer)(void *);
+} wasmtime_stack_creator_t;
+
+/**
+ * Sets a custom stack creator.
+ *
+ * Custom memory creators are used when creating creating async instance stacks
+ * for the on-demand instance allocation strategy.
+ *
+ * The config does **not** take ownership of the #wasmtime_stack_creator_t
+ * passed in, but instead copies all the values in the struct.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.with_host_stack
+ */
+WASM_API_EXTERN void
+wasmtime_config_host_stack_creator_set(wasm_config_t *,
+                                       wasmtime_stack_creator_t *);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_ASYNC_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/config.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/config.h
similarity index 50%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/config.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/config.h
index 77c1193632..9bd2a4e7ef 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/config.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/config.h
@@ -80,10 +80,14 @@ enum wasmtime_profiling_strategy_enum { // ProfilingStrategy
   ///
   /// Note that this isn't always enabled at build time.
   WASMTIME_PROFILING_STRATEGY_VTUNE,
+  /// Linux's simple "perfmap" support in `perf` is enabled and when Wasmtime is
+  /// run under `perf` necessary calls will be made to profile generated JIT
+  /// code.
+  WASMTIME_PROFILING_STRATEGY_PERFMAP,
 };
 
-#define WASMTIME_CONFIG_PROP(ret, name, ty) \
-    WASM_API_EXTERN ret wasmtime_config_##name##_set(wasm_config_t*, ty);
+#define WASMTIME_CONFIG_PROP(ret, name, ty)                                    \
+  WASM_API_EXTERN ret wasmtime_config_##name##_set(wasm_config_t *, ty);
 
 /**
  * \brief Configures whether DWARF debug information is constructed at runtime
@@ -161,6 +165,22 @@ WASMTIME_CONFIG_PROP(void, wasm_reference_types, bool)
  */
 WASMTIME_CONFIG_PROP(void, wasm_simd, bool)
 
+/**
+ * \brief Configures whether the WebAssembly relaxed SIMD proposal is
+ * enabled.
+ *
+ * This setting is `false` by default.
+ */
+WASMTIME_CONFIG_PROP(void, wasm_relaxed_simd, bool)
+
+/**
+ * \brief Configures whether the WebAssembly relaxed SIMD proposal is
+ * in deterministic mode.
+ *
+ * This setting is `false` by default.
+ */
+WASMTIME_CONFIG_PROP(void, wasm_relaxed_simd_deterministic, bool)
+
 /**
  * \brief Configures whether the WebAssembly bulk memory proposal is
  * enabled.
@@ -200,6 +220,15 @@ WASMTIME_CONFIG_PROP(void, wasm_memory64, bool)
  */
 WASMTIME_CONFIG_PROP(void, strategy, wasmtime_strategy_t)
 
+/**
+ * \brief Configure whether wasmtime should compile a module using multiple
+ * threads.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.parallel_compilation.
+ */
+WASMTIME_CONFIG_PROP(void, parallel_compilation, bool)
+
 /**
  * \brief Configures whether Cranelift's debug verifier is enabled.
  *
@@ -211,18 +240,20 @@ WASMTIME_CONFIG_PROP(void, strategy, wasmtime_strategy_t)
 WASMTIME_CONFIG_PROP(void, cranelift_debug_verifier, bool)
 
 /**
- * \brief Configures whether Cranelift should perform a NaN-canonicalization pass.
+ * \brief Configures whether Cranelift should perform a NaN-canonicalization
+ * pass.
  *
  * When Cranelift is used as a code generation backend this will configure
  * it to replace NaNs with a single canonical value. This is useful for users
  * requiring entirely deterministic WebAssembly computation.
- * 
- * This is not required by the WebAssembly spec, so it is not enabled by default.
- * 
+ *
+ * This is not required by the WebAssembly spec, so it is not enabled by
+ * default.
+ *
  * The default value for this is `false`
  */
 WASMTIME_CONFIG_PROP(void, cranelift_nan_canonicalization, bool)
-  
+
 /**
  * \brief Configures Cranelift's optimization level for JIT code.
  *
@@ -237,6 +268,16 @@ WASMTIME_CONFIG_PROP(void, cranelift_opt_level, wasmtime_opt_level_t)
  */
 WASMTIME_CONFIG_PROP(void, profiler, wasmtime_profiling_strategy_t)
 
+/**
+ * \brief Configures the “static” style of memory to always be used.
+ *
+ * This setting is `false` by default.
+ *
+ * For more information see the Rust documentation at
+ * https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Config.html#method.static_memory_forced.
+ */
+WASMTIME_CONFIG_PROP(void, static_memory_forced, bool)
+
 /**
  * \brief Configures the maximum size for memory to be considered "static"
  *
@@ -261,6 +302,26 @@ WASMTIME_CONFIG_PROP(void, static_memory_guard_size, uint64_t)
  */
 WASMTIME_CONFIG_PROP(void, dynamic_memory_guard_size, uint64_t)
 
+/**
+ * \brief Configures the size, in bytes, of the extra virtual memory space
+ * reserved after a “dynamic” memory for growing into.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.dynamic_memory_reserved_for_growth
+ */
+WASMTIME_CONFIG_PROP(void, dynamic_memory_reserved_for_growth, uint64_t)
+
+/**
+ * \brief Configures whether to generate native unwind information (e.g.
+ * .eh_frame on Linux).
+ *
+ * This option defaults to true.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.native_unwind_info
+ */
+WASMTIME_CONFIG_PROP(void, native_unwind_info, bool)
+
 /**
  * \brief Enables Wasmtime's cache and loads configuration from the specified
  * path.
@@ -273,11 +334,167 @@ WASMTIME_CONFIG_PROP(void, dynamic_memory_guard_size, uint64_t)
  * An error is returned if the cache configuration could not be loaded or if the
  * cache could not be enabled.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_config_cache_config_load(wasm_config_t*, const char*);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_config_cache_config_load(wasm_config_t *, const char *);
+
+/**
+ * \brief Configures the target triple that this configuration will produce
+ * machine code for.
+ *
+ * This option defaults to the native host. Calling this method will
+ * additionally disable inference of the native features of the host (e.g.
+ * detection of SSE4.2 on x86_64 hosts). Native features can be reenabled with
+ * the `cranelift_flag_{set,enable}` properties.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.config
+ */
+WASMTIME_CONFIG_PROP(wasmtime_error_t *, target, const char *)
+
+/**
+ * \brief Enables a target-specific flag in Cranelift.
+ *
+ * This can be used, for example, to enable SSE4.2 on x86_64 hosts. Settings can
+ * be explored with `wasmtime settings` on the CLI.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_enable
+ */
+WASM_API_EXTERN void wasmtime_config_cranelift_flag_enable(wasm_config_t *,
+                                                           const char *);
+
+/**
+ * \brief Sets a target-specific flag in Cranelift to the specified value.
+ *
+ * This can be used, for example, to enable SSE4.2 on x86_64 hosts. Settings can
+ * be explored with `wasmtime settings` on the CLI.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_set
+ */
+WASM_API_EXTERN void wasmtime_config_cranelift_flag_set(wasm_config_t *,
+                                                        const char *key,
+                                                        const char *value);
+
+/**
+ * \brief Configures whether, when on macOS, Mach ports are used for exception
+ * handling instead of traditional Unix-based signal handling.
+ *
+ * This option defaults to true, using Mach ports by default.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.macos_use_mach_ports
+ */
+WASMTIME_CONFIG_PROP(void, macos_use_mach_ports, bool)
+
+/**
+ * Return the data from a LinearMemory instance.
+ *
+ * The size in bytes as well as the maximum number of bytes that can be
+ * allocated should be returned as well.
+ *
+ * For more information about see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html
+ */
+typedef uint8_t *(*wasmtime_memory_get_callback_t)(void *env, size_t *byte_size,
+                                                   size_t *maximum_byte_size);
+
+/**
+ * Grow the memory to the `new_size` in bytes.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html#tymethod.grow_to
+ */
+typedef wasmtime_error_t *(*wasmtime_memory_grow_callback_t)(void *env,
+                                                             size_t new_size);
+
+/**
+ * A LinearMemory instance created from a #wasmtime_new_memory_callback_t.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html
+ */
+typedef struct wasmtime_linear_memory {
+  /// User provided value to be passed to get_memory and grow_memory
+  void *env;
+  /// Callback to get the memory and size of this LinearMemory
+  wasmtime_memory_get_callback_t get_memory;
+  /// Callback to request growing the memory
+  wasmtime_memory_grow_callback_t grow_memory;
+  /// An optional finalizer for env
+  void (*finalizer)(void *);
+} wasmtime_linear_memory_t;
+
+/**
+ * A callback to create a new LinearMemory from the specified parameters.
+ *
+ * The result should be written to `memory_ret` and wasmtime will own the values
+ * written into that struct.
+ *
+ * This callback must be thread-safe.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.MemoryCreator.html#tymethod.new_memory
+ */
+typedef wasmtime_error_t *(*wasmtime_new_memory_callback_t)(
+    void *env, const wasm_memorytype_t *ty, size_t minimum, size_t maximum,
+    size_t reserved_size_in_bytes, size_t guard_size_in_bytes,
+    wasmtime_linear_memory_t *memory_ret);
+
+/**
+ * A representation of custom memory creator and methods for an instance of
+ * LinearMemory.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.MemoryCreator.html
+ */
+typedef struct wasmtime_memory_creator {
+  /// User provided value to be passed to new_memory
+  void *env;
+  /// The callback to create new memory, must be thread safe
+  wasmtime_new_memory_callback_t new_memory;
+  /// An optional finalizer for env.
+  void (*finalizer)(void *);
+} wasmtime_memory_creator_t;
+
+/**
+ * Sets a custom memory creator.
+ *
+ * Custom memory creators are used when creating host Memory objects or when
+ * creating instance linear memories for the on-demand instance allocation
+ * strategy.
+ *
+ * The config does **not** take ownership of the #wasmtime_memory_creator_t
+ * passed in, but instead copies all the values in the struct.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.with_host_memory
+ */
+WASM_API_EXTERN void
+wasmtime_config_host_memory_creator_set(wasm_config_t *,
+                                        wasmtime_memory_creator_t *);
+
+/**
+ * \brief Configures whether copy-on-write memory-mapped data is used to
+ * initialize a linear memory.
+ *
+ * Initializing linear memory via a copy-on-write mapping can drastically
+ * improve instantiation costs of a WebAssembly module because copying memory is
+ * deferred. Additionally if a page of memory is only ever read from WebAssembly
+ * and never written too then the same underlying page of data will be reused
+ * between all instantiations of a module meaning that if a module is
+ * instantiated many times this can lower the overall memory required needed to
+ * run that module.
+ *
+ * This option defaults to true.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.memory_init_cow
+ */
+WASMTIME_CONFIG_PROP(void, memory_init_cow, bool)
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_CONFIG_H
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/engine.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/engine.h
similarity index 97%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/engine.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/engine.h
index 1b8336f460..d68cf4e8fe 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/engine.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/engine.h
@@ -28,9 +28,7 @@ extern "C" {
 WASM_API_EXTERN void wasmtime_engine_increment_epoch(wasm_engine_t *engine);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_ENGINE_H
-
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/error.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/error.h
similarity index 81%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/error.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/error.h
index cfa0c9690e..ad91725436 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/error.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/error.h
@@ -30,6 +30,11 @@ extern "C" {
  */
 typedef struct wasmtime_error wasmtime_error_t;
 
+/**
+ * \brief Creates a new error with the provided message.
+ */
+WASM_API_EXTERN wasmtime_error_t *wasmtime_error_new(const char *);
+
 /**
  * \brief Deletes an error.
  */
@@ -43,10 +48,8 @@ WASM_API_EXTERN void wasmtime_error_delete(wasmtime_error_t *error);
  * uninitialized before this function is called and the caller is responsible
  * for deallocating it with #wasm_byte_vec_delete afterwards.
  */
-WASM_API_EXTERN void wasmtime_error_message(
-    const wasmtime_error_t *error,
-    wasm_name_t *message
-);
+WASM_API_EXTERN void wasmtime_error_message(const wasmtime_error_t *error,
+                                            wasm_name_t *message);
 
 /**
  * \brief Attempts to extract a WASI-specific exit status from this error.
@@ -55,7 +58,8 @@ WASM_API_EXTERN void wasmtime_error_message(
  * If `true` is returned then the exit status is returned through the `status`
  * pointer. If `false` is returned then this is not a wasi exit trap.
  */
-WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t*, int *status);
+WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t *,
+                                                int *status);
 
 /**
  * \brief Attempts to extract a WebAssembly trace from this error.
@@ -64,10 +68,11 @@ WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t*, int *st
  * as input. The `out` argument will be filled in with the wasm trace, if
  * present.
  */
-WASM_API_EXTERN void wasmtime_error_wasm_trace(const wasmtime_error_t*, wasm_frame_vec_t *out);
+WASM_API_EXTERN void wasmtime_error_wasm_trace(const wasmtime_error_t *,
+                                               wasm_frame_vec_t *out);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_ERROR_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/extern.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/extern.h
similarity index 87%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/extern.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/extern.h
index 29dcb217fe..427c5ba7f9 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/extern.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/extern.h
@@ -97,14 +97,14 @@ typedef uint8_t wasmtime_extern_kind_t;
  * various kinds of items an extern wasm item can be.
  */
 typedef union wasmtime_extern_union {
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_FUNC
-    wasmtime_func_t func;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_GLOBAL
-    wasmtime_global_t global;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_TABLE
-    wasmtime_table_t table;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_MEMORY
-    wasmtime_memory_t memory;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_FUNC
+  wasmtime_func_t func;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_GLOBAL
+  wasmtime_global_t global;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_TABLE
+  wasmtime_table_t table;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_MEMORY
+  wasmtime_memory_t memory;
 } wasmtime_extern_union_t;
 
 /**
@@ -121,10 +121,10 @@ typedef union wasmtime_extern_union {
  * deallocate the value.
  */
 typedef struct wasmtime_extern {
-    /// Discriminant of which field of #of is valid.
-    wasmtime_extern_kind_t kind;
-    /// Container for the extern item's value.
-    wasmtime_extern_union_t of;
+  /// Discriminant of which field of #of is valid.
+  wasmtime_extern_kind_t kind;
+  /// Container for the extern item's value.
+  wasmtime_extern_union_t of;
 } wasmtime_extern_t;
 
 /// \brief Deletes a #wasmtime_extern_t.
@@ -135,11 +135,11 @@ void wasmtime_extern_delete(wasmtime_extern_t *val);
 ///
 /// Does not take ownership of `context` or `val`, but the returned
 /// #wasm_externtype_t is an owned value that needs to be deleted.
-wasm_externtype_t *wasmtime_extern_type(wasmtime_context_t *context, wasmtime_extern_t *val);
+wasm_externtype_t *wasmtime_extern_type(wasmtime_context_t *context,
+                                        wasmtime_extern_t *val);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_EXTERN_H
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/func.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/func.h
similarity index 81%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/func.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/func.h
index e65d002c66..41ff907c37 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/func.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/func.h
@@ -8,9 +8,9 @@
 #define WASMTIME_FUNC_H
 
 #include <wasm.h>
-#include <wasmtime/val.h>
-#include <wasmtime/store.h>
 #include <wasmtime/extern.h>
+#include <wasmtime/store.h>
+#include <wasmtime/val.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,13 +54,9 @@ typedef struct wasmtime_caller wasmtime_caller_t;
  * should be raised in WebAssembly. It's expected that in this case the caller
  * relinquishes ownership of the trap and it is passed back to the engine.
  */
-typedef wasm_trap_t* (*wasmtime_func_callback_t)(
-    void *env,
-    wasmtime_caller_t* caller,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults);
+typedef wasm_trap_t *(*wasmtime_func_callback_t)(
+    void *env, wasmtime_caller_t *caller, const wasmtime_val_t *args,
+    size_t nargs, wasmtime_val_t *results, size_t nresults);
 
 /**
  * \brief Creates a new host-defined function.
@@ -78,14 +74,11 @@ typedef wasm_trap_t* (*wasmtime_func_callback_t)(
  *
  * The returned function can only be used with the specified `store`.
  */
-WASM_API_EXTERN void wasmtime_func_new(
-  wasmtime_context_t *store,
-  const wasm_functype_t* type,
-  wasmtime_func_callback_t callback,
-  void *env,
-  void (*finalizer)(void*),
-  wasmtime_func_t *ret
-);
+WASM_API_EXTERN void wasmtime_func_new(wasmtime_context_t *store,
+                                       const wasm_functype_t *type,
+                                       wasmtime_func_callback_t callback,
+                                       void *env, void (*finalizer)(void *),
+                                       wasmtime_func_t *ret);
 
 /**
  * \brief Callback signature for #wasmtime_func_new_unchecked.
@@ -120,10 +113,8 @@ WASM_API_EXTERN void wasmtime_func_new(
  * array. Results are also written starting at index 0, which will overwrite
  * the arguments.
  */
-typedef wasm_trap_t* (*wasmtime_func_unchecked_callback_t)(
-    void *env,
-    wasmtime_caller_t* caller,
-    wasmtime_val_raw_t *args_and_results,
+typedef wasm_trap_t *(*wasmtime_func_unchecked_callback_t)(
+    void *env, wasmtime_caller_t *caller, wasmtime_val_raw_t *args_and_results,
     size_t num_args_and_results);
 
 /**
@@ -151,23 +142,18 @@ typedef wasm_trap_t* (*wasmtime_func_unchecked_callback_t)(
  * existence).
  */
 WASM_API_EXTERN void wasmtime_func_new_unchecked(
-  wasmtime_context_t *store,
-  const wasm_functype_t* type,
-  wasmtime_func_unchecked_callback_t callback,
-  void *env,
-  void (*finalizer)(void*),
-  wasmtime_func_t *ret
-);
+    wasmtime_context_t *store, const wasm_functype_t *type,
+    wasmtime_func_unchecked_callback_t callback, void *env,
+    void (*finalizer)(void *), wasmtime_func_t *ret);
 
 /**
  * \brief Returns the type of the function specified
  *
  * The returned #wasm_functype_t is owned by the caller.
  */
-WASM_API_EXTERN wasm_functype_t* wasmtime_func_type(
-    const wasmtime_context_t *store,
-    const wasmtime_func_t *func
-);
+WASM_API_EXTERN wasm_functype_t *
+wasmtime_func_type(const wasmtime_context_t *store,
+                   const wasmtime_func_t *func);
 
 /**
  * \brief Call a WebAssembly function.
@@ -204,15 +190,11 @@ WASM_API_EXTERN wasm_functype_t* wasmtime_func_type(
  * Does not take ownership of #wasmtime_val_t arguments. Gives ownership of
  * #wasmtime_val_t results.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
-    wasmtime_context_t *store,
-    const wasmtime_func_t *func,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_func_call(wasmtime_context_t *store, const wasmtime_func_t *func,
+                   const wasmtime_val_t *args, size_t nargs,
+                   wasmtime_val_t *results, size_t nresults,
+                   wasm_trap_t **trap);
 
 /**
  * \brief Call a WebAssembly function in an "unchecked" fashion.
@@ -233,6 +215,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
  *
  * * The `args_and_results` pointer has enough space to hold all the parameters
  *   and all the results (but not at the same time).
+ * * The `args_and_results_len` contains the length of the `args_and_results`
+ *   buffer.
  * * Parameters must all be configured as if they were the correct type.
  * * Values such as `externref` and `funcref` are valid within the store being
  *   called.
@@ -241,12 +225,11 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
  * faster than that function, but the tradeoff is that embeddings must uphold
  * more invariants rather than relying on Wasmtime to check them for you.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call_unchecked(
-    wasmtime_context_t *store,
-    const wasmtime_func_t *func,
-    wasmtime_val_raw_t *args_and_results,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_func_call_unchecked(wasmtime_context_t *store,
+                             const wasmtime_func_t *func,
+                             wasmtime_val_raw_t *args_and_results,
+                             size_t args_and_results_len, wasm_trap_t **trap);
 
 /**
  * \brief Loads a #wasmtime_extern_t from the caller's context
@@ -266,17 +249,16 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call_unchecked(
  * Returns a nonzero value if the export was found, or 0 if the export wasn't
  * found. If the export wasn't found then `item` isn't written to.
  */
-WASM_API_EXTERN bool wasmtime_caller_export_get(
-    wasmtime_caller_t *caller,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+WASM_API_EXTERN bool wasmtime_caller_export_get(wasmtime_caller_t *caller,
+                                                const char *name,
+                                                size_t name_len,
+                                                wasmtime_extern_t *item);
 
 /**
  * \brief Returns the store context of the caller object.
  */
-WASM_API_EXTERN wasmtime_context_t* wasmtime_caller_context(wasmtime_caller_t* caller);
+WASM_API_EXTERN wasmtime_context_t *
+wasmtime_caller_context(wasmtime_caller_t *caller);
 
 /**
  * \brief Converts a `raw` nonzero `funcref` value from #wasmtime_val_raw_t
@@ -291,21 +273,18 @@ WASM_API_EXTERN wasmtime_context_t* wasmtime_caller_context(wasmtime_caller_t* c
  * #wasmtime_context_t that they were produced from. Providing arbitrary values
  * to `raw` here or cross-context values with `context` is UB.
  */
-WASM_API_EXTERN void wasmtime_func_from_raw(
-    wasmtime_context_t* context,
-    size_t raw,
-    wasmtime_func_t *ret);
+WASM_API_EXTERN void wasmtime_func_from_raw(wasmtime_context_t *context,
+                                            void *raw, wasmtime_func_t *ret);
 
 /**
  * \brief Converts a `func`  which belongs to `context` into a `usize`
  * parameter that is suitable for insertion into a #wasmtime_val_raw_t.
  */
-WASM_API_EXTERN size_t wasmtime_func_to_raw(
-    wasmtime_context_t* context,
-    const wasmtime_func_t *func);
+WASM_API_EXTERN void *wasmtime_func_to_raw(wasmtime_context_t *context,
+                                           const wasmtime_func_t *func);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_FUNC_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/global.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/global.h
similarity index 70%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/global.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/global.h
index 4e244285a5..5d69c19f53 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/global.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/global.h
@@ -33,22 +33,18 @@ extern "C" {
  * This function does not take ownership of any of its arguments but error is
  * owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_global_new(
-    wasmtime_context_t *store,
-    const wasm_globaltype_t *type,
-    const wasmtime_val_t *val,
-    wasmtime_global_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_global_new(wasmtime_context_t *store, const wasm_globaltype_t *type,
+                    const wasmtime_val_t *val, wasmtime_global_t *ret);
 
 /**
  * \brief Returns the wasm type of the specified global.
  *
  * The returned #wasm_globaltype_t is owned by the caller.
  */
-WASM_API_EXTERN wasm_globaltype_t* wasmtime_global_type(
-    const wasmtime_context_t *store,
-    const wasmtime_global_t *global
-);
+WASM_API_EXTERN wasm_globaltype_t *
+wasmtime_global_type(const wasmtime_context_t *store,
+                     const wasmtime_global_t *global);
 
 /**
  * \brief Get the value of the specified global.
@@ -60,11 +56,9 @@ WASM_API_EXTERN wasm_globaltype_t* wasmtime_global_type(
  * This function returns ownership of the contents of `out`, so
  * #wasmtime_val_delete may need to be called on the value.
  */
-WASM_API_EXTERN void wasmtime_global_get(
-    wasmtime_context_t *store,
-    const wasmtime_global_t *global,
-    wasmtime_val_t *out
-);
+WASM_API_EXTERN void wasmtime_global_get(wasmtime_context_t *store,
+                                         const wasmtime_global_t *global,
+                                         wasmtime_val_t *out);
 
 /**
  * \brief Sets a global to a new value.
@@ -76,16 +70,15 @@ WASM_API_EXTERN void wasmtime_global_get(
  * This function may return an error if `global` is not mutable or if `val` has
  * the wrong type for `global`.
  *
- * THis does not take ownership of any argument but returns ownership of the error.
+ * THis does not take ownership of any argument but returns ownership of the
+ * error.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_global_set(
-    wasmtime_context_t *store,
-    const wasmtime_global_t *global,
-    const wasmtime_val_t *val
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_global_set(wasmtime_context_t *store, const wasmtime_global_t *global,
+                    const wasmtime_val_t *val);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_GLOBAL_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/instance.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/instance.h
similarity index 58%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/instance.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/instance.h
index 544661f9d8..0d63cfb7a4 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/instance.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/instance.h
@@ -62,14 +62,11 @@ typedef struct wasmtime_instance {
  * This function does not take ownership of any of its arguments, but all return
  * values are owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_new(
-    wasmtime_context_t *store,
-    const wasmtime_module_t *module,
-    const wasmtime_extern_t* imports,
-    size_t nimports,
-    wasmtime_instance_t *instance,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_instance_new(wasmtime_context_t *store,
+                      const wasmtime_module_t *module,
+                      const wasmtime_extern_t *imports, size_t nimports,
+                      wasmtime_instance_t *instance, wasm_trap_t **trap);
 
 /**
  * \brief Get an export by name from an instance.
@@ -87,12 +84,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_new(
  * #wasmtime_extern_t.
  */
 WASM_API_EXTERN bool wasmtime_instance_export_get(
-    wasmtime_context_t *store,
-    const wasmtime_instance_t *instance,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+    wasmtime_context_t *store, const wasmtime_instance_t *instance,
+    const char *name, size_t name_len, wasmtime_extern_t *item);
 
 /**
  * \brief Get an export by index from an instance.
@@ -113,16 +106,64 @@ WASM_API_EXTERN bool wasmtime_instance_export_get(
  * #wasmtime_context_t.
  */
 WASM_API_EXTERN bool wasmtime_instance_export_nth(
-    wasmtime_context_t *store,
-    const wasmtime_instance_t *instance,
-    size_t index,
-    char **name,
-    size_t *name_len,
-    wasmtime_extern_t *item
-);
+    wasmtime_context_t *store, const wasmtime_instance_t *instance,
+    size_t index, char **name, size_t *name_len, wasmtime_extern_t *item);
+
+/**
+ * \brief A #wasmtime_instance_t, pre-instantiation, that is ready to be
+ * instantiated.
+ *
+ * Must be deleted using #wasmtime_instance_pre_delete.
+ *
+ * For more information see the Rust documentation:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.InstancePre.html
+ */
+typedef struct wasmtime_instance_pre wasmtime_instance_pre_t;
+
+/**
+ * \brief Delete a previously created wasmtime_instance_pre_t.
+ */
+WASM_API_EXTERN void
+wasmtime_instance_pre_delete(wasmtime_instance_pre_t *instance_pre);
+
+/**
+ * \brief Instantiates instance within the given store.
+ *
+ * This will also run the function's startup function, if there is one.
+ *
+ * For more information on instantiation see #wasmtime_instance_new.
+ *
+ * \param instance_pre the pre-initialized instance
+ * \param store the store in which to create the instance
+ * \param instance where to store the returned instance
+ * \param trap_ptr where to store the returned trap
+ *
+ * \return One of three things can happen as a result of this function. First
+ * the module could be successfully instantiated and returned through
+ * `instance`, meaning the return value and `trap` are both set to `NULL`.
+ * Second the start function may trap, meaning the return value and `instance`
+ * are set to `NULL` and `trap` describes the trap that happens. Finally
+ * instantiation may fail for another reason, in which case an error is returned
+ * and `trap` and `instance` are set to `NULL`.
+ *
+ * This function does not take ownership of any of its arguments, and all return
+ * values are owned by the caller.
+ */
+WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_pre_instantiate(
+    const wasmtime_instance_pre_t *instance_pre, wasmtime_store_t *store,
+    wasmtime_instance_t *instance, wasm_trap_t **trap_ptr);
+
+/**
+ * \brief Get the module (as a shallow clone) for a instance_pre.
+ *
+ * The returned module is owned by the caller and the caller **must**
+ * delete it via `wasmtime_module_delete`.
+ */
+WASM_API_EXTERN wasmtime_module_t *
+wasmtime_instance_pre_module(wasmtime_instance_pre_t *instance_pre);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_INSTANCE_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/linker.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/linker.h
similarity index 71%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/linker.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/linker.h
index edd52442df..c704234956 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/linker.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/linker.h
@@ -9,8 +9,8 @@
 
 #include <wasm.h>
 #include <wasmtime/error.h>
-#include <wasmtime/store.h>
 #include <wasmtime/extern.h>
+#include <wasmtime/store.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,12 +40,12 @@ typedef struct wasmtime_linker wasmtime_linker_t;
  * This function does not take ownership of the engine argument, and the caller
  * is expected to delete the returned linker.
  */
-WASM_API_EXTERN wasmtime_linker_t* wasmtime_linker_new(wasm_engine_t* engine);
+WASM_API_EXTERN wasmtime_linker_t *wasmtime_linker_new(wasm_engine_t *engine);
 
 /**
  * \brief Deletes a linker
  */
-WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t* linker);
+WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t *linker);
 
 /**
  * \brief Configures whether this linker allows later definitions to shadow
@@ -53,12 +53,14 @@ WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t* linker);
  *
  * By default this setting is `false`.
  */
-WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t* linker, bool allow_shadowing);
+WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t *linker,
+                                                     bool allow_shadowing);
 
 /**
  * \brief Defines a new item in this linker.
  *
  * \param linker the linker the name is being defined in.
+ * \param store the store that the `item` is owned by.
  * \param module the module name the item is defined under.
  * \param module_len the byte length of `module`
  * \param name the field name the item is defined under
@@ -71,14 +73,10 @@ WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t* linker,
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasmtime_extern_t *item
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_define(wasmtime_linker_t *linker, wasmtime_context_t *store,
+                       const char *module, size_t module_len, const char *name,
+                       size_t name_len, const wasmtime_extern_t *item);
 
 /**
  * \brief Defines a new function in this linker.
@@ -90,7 +88,8 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
  * \param name_len the byte length of `name`
  * \param ty the type of the function that's being defined
  * \param cb the host callback to invoke when the function is called
- * \param data the host-provided data to provide as the first argument to the callback
+ * \param data the host-provided data to provide as the first argument to the
+ *        callback
  * \param finalizer an optional finalizer for the `data` argument.
  *
  * \return On success `NULL` is returned, otherwise an error is returned which
@@ -105,17 +104,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
  *
  * For more information about host callbacks see #wasmtime_func_new.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasm_functype_t *ty,
-    wasmtime_func_callback_t cb,
-    void *data,
-    void (*finalizer)(void*)
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_func(
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_callback_t cb, void *data, void (*finalizer)(void *));
 
 /**
  * \brief Defines a new function in this linker.
@@ -126,17 +118,11 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func(
  * information as well as #wasmtime_func_new_unchecked for why this is an
  * unsafe API.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func_unchecked(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasm_functype_t *ty,
-    wasmtime_func_unchecked_callback_t cb,
-    void *data,
-    void (*finalizer)(void*)
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_func_unchecked(
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_unchecked_callback_t cb, void *data,
+    void (*finalizer)(void *));
 
 /**
  * \brief Defines WASI functions in this linker.
@@ -155,9 +141,8 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func_unchecked(
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_wasi(
-    wasmtime_linker_t *linker
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_define_wasi(wasmtime_linker_t *linker);
 
 /**
  * \brief Defines an instance under the specified name in this linker.
@@ -178,13 +163,9 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_wasi(
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_instance(
-    wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    const wasmtime_instance_t *instance
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_instance(
+    wasmtime_linker_t *linker, wasmtime_context_t *store, const char *name,
+    size_t name_len, const wasmtime_instance_t *instance);
 
 /**
  * \brief Instantiates a #wasm_module_t with the items defined in this linker.
@@ -208,13 +189,11 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_instance(
  * defined in the linker than an error is returned. (or if the previously
  * defined item is of the wrong type).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_instantiate(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const wasmtime_module_t *module,
-    wasmtime_instance_t *instance,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_instantiate(const wasmtime_linker_t *linker,
+                            wasmtime_context_t *store,
+                            const wasmtime_module_t *module,
+                            wasmtime_instance_t *instance, wasm_trap_t **trap);
 
 /**
  * \brief Defines automatic instantiations of a #wasm_module_t in this linker.
@@ -235,13 +214,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_instantiate(
  * For more information see the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#method.module).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_module(
-    wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    const wasmtime_module_t *module
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_module(wasmtime_linker_t *linker, wasmtime_context_t *store,
+                       const char *name, size_t name_len,
+                       const wasmtime_module_t *module);
 
 /**
  * \brief Acquires the "default export" of the named module in this linker.
@@ -258,13 +234,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_module(
  * For more information see the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#method.get_default).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_get_default(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    wasmtime_func_t *func
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_get_default(const wasmtime_linker_t *linker,
+                            wasmtime_context_t *store, const char *name,
+                            size_t name_len, wasmtime_func_t *func);
 
 /**
  * \brief Loads an item by name from this linker.
@@ -280,18 +253,32 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_get_default(
  * \return A nonzero value if the item is defined, in which case `item` is also
  * filled in. Otherwise zero is returned.
  */
-WASM_API_EXTERN bool wasmtime_linker_get(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+WASM_API_EXTERN bool wasmtime_linker_get(const wasmtime_linker_t *linker,
+                                         wasmtime_context_t *store,
+                                         const char *module, size_t module_len,
+                                         const char *name, size_t name_len,
+                                         wasmtime_extern_t *item);
+
+/**
+ * \brief Preform all the checks for instantiating `module` with the linker,
+ *        except that instantiation doesn't actually finish.
+ *
+ * \param linker the linker used to instantiate the provided module.
+ * \param module the module that is being instantiated.
+ * \param instance_pre the returned instance_pre, if successful.
+ *
+ * \return An error or `NULL` if successful.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Linker.html#method.instantiate_pre
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_instantiate_pre(const wasmtime_linker_t *linker,
+                                const wasmtime_module_t *module,
+                                wasmtime_instance_pre_t **instance_pre);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_LINKER_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/memory.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/memory.h
similarity index 65%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/memory.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/memory.h
index 6aecbaffbf..a22b93c97a 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/memory.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/memory.h
@@ -8,9 +8,9 @@
 #define WASMTIME_MEMORY_H
 
 #include <wasm.h>
+#include <wasmtime/error.h>
 #include <wasmtime/extern.h>
 #include <wasmtime/store.h>
-#include <wasmtime/error.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,7 +22,10 @@ extern "C" {
  * Note that this function is preferred over #wasm_memorytype_new for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min, bool max_present, uint64_t max, bool is_64);
+WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min,
+                                                           bool max_present,
+                                                           uint64_t max,
+                                                           bool is_64);
 
 /**
  * \brief Returns the minimum size, in pages, of the specified memory type.
@@ -30,7 +33,8 @@ WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min, bool ma
  * Note that this function is preferred over #wasm_memorytype_limits for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN uint64_t wasmtime_memorytype_minimum(const wasm_memorytype_t *ty);
+WASM_API_EXTERN uint64_t
+wasmtime_memorytype_minimum(const wasm_memorytype_t *ty);
 
 /**
  * \brief Returns the maximum size, in pages, of the specified memory type.
@@ -42,7 +46,8 @@ WASM_API_EXTERN uint64_t wasmtime_memorytype_minimum(const wasm_memorytype_t *ty
  * Note that this function is preferred over #wasm_memorytype_limits for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN bool wasmtime_memorytype_maximum(const wasm_memorytype_t *ty, uint64_t *max);
+WASM_API_EXTERN bool wasmtime_memorytype_maximum(const wasm_memorytype_t *ty,
+                                                 uint64_t *max);
 
 /**
  * \brief Returns whether this type of memory represents a 64-bit memory.
@@ -59,43 +64,34 @@ WASM_API_EXTERN bool wasmtime_memorytype_is64(const wasm_memorytype_t *ty);
  * If an error happens when creating the memory it's returned and owned by the
  * caller. If an error happens then `ret` is not filled in.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_memory_new(
-    wasmtime_context_t *store,
-    const wasm_memorytype_t* ty,
-    wasmtime_memory_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_memory_new(wasmtime_context_t *store, const wasm_memorytype_t *ty,
+                    wasmtime_memory_t *ret);
 
 /**
- * \brief Returns the tyep of the memory specified
+ * \brief Returns the type of the memory specified
  */
-WASM_API_EXTERN wasm_memorytype_t* wasmtime_memory_type(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN wasm_memorytype_t *
+wasmtime_memory_type(const wasmtime_context_t *store,
+                     const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the base pointer in memory where the linear memory starts.
  */
-WASM_API_EXTERN uint8_t *wasmtime_memory_data(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN uint8_t *wasmtime_memory_data(const wasmtime_context_t *store,
+                                              const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the byte length of this linear memory.
  */
 WASM_API_EXTERN size_t wasmtime_memory_data_size(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+    const wasmtime_context_t *store, const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the length, in WebAssembly pages, of this linear memory
  */
-WASM_API_EXTERN uint64_t wasmtime_memory_size(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN uint64_t wasmtime_memory_size(const wasmtime_context_t *store,
+                                              const wasmtime_memory_t *memory);
 
 /**
  * \brief Attempts to grow the specified memory by `delta` pages.
@@ -109,15 +105,12 @@ WASM_API_EXTERN uint64_t wasmtime_memory_size(
  * returned. Otherwise `prev_size` is set to the previous size of the memory, in
  * WebAssembly pages, and `NULL` is returned.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_memory_grow(
-    wasmtime_context_t *store,
-    const wasmtime_memory_t *memory,
-    uint64_t delta,
-    uint64_t *prev_size
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_memory_grow(wasmtime_context_t *store, const wasmtime_memory_t *memory,
+                     uint64_t delta, uint64_t *prev_size);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_MEMORY_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/module.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/module.h
similarity index 67%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/module.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/module.h
index deb6bcec1e..48f437c514 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/module.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/module.h
@@ -41,12 +41,10 @@ typedef struct wasmtime_module wasmtime_module_t;
  * This function does not take ownership of any of its arguments, but the
  * returned error and module are owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_new(
-    wasm_engine_t *engine,
-    const uint8_t *wasm,
-    size_t wasm_len,
-    wasmtime_module_t **ret
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_module_new(wasm_engine_t *engine,
+                                                      const uint8_t *wasm,
+                                                      size_t wasm_len,
+                                                      wasmtime_module_t **ret);
 
 /**
  * \brief Deletes a module.
@@ -62,18 +60,14 @@ WASM_API_EXTERN wasmtime_module_t *wasmtime_module_clone(wasmtime_module_t *m);
 /**
  * \brief Same as #wasm_module_imports, but for #wasmtime_module_t.
  */
-WASM_API_EXTERN void wasmtime_module_imports(
-    const wasmtime_module_t *module,
-    wasm_importtype_vec_t *out
-);
+WASM_API_EXTERN void wasmtime_module_imports(const wasmtime_module_t *module,
+                                             wasm_importtype_vec_t *out);
 
 /**
  * \brief Same as #wasm_module_exports, but for #wasmtime_module_t.
  */
-WASM_API_EXTERN void wasmtime_module_exports(
-    const wasmtime_module_t *module,
-    wasm_exporttype_vec_t *out
-);
+WASM_API_EXTERN void wasmtime_module_exports(const wasmtime_module_t *module,
+                                             wasm_exporttype_vec_t *out);
 
 /**
  * \brief Validate a WebAssembly binary.
@@ -87,18 +81,16 @@ WASM_API_EXTERN void wasmtime_module_exports(
  * If the binary validates then `NULL` is returned, otherwise the error returned
  * describes why the binary did not validate.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_validate(
-    wasm_engine_t *engine,
-    const uint8_t *wasm,
-    size_t wasm_len
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_validate(wasm_engine_t *engine, const uint8_t *wasm,
+                         size_t wasm_len);
 
 /**
  * \brief This function serializes compiled module artifacts as blob data.
  *
  * \param module the module
- * \param ret if the conversion is successful, this byte vector is filled in with
- *   the serialized compiled module.
+ * \param ret if the conversion is successful, this byte vector is filled in
+ * with the serialized compiled module.
  *
  * \return a non-null error if parsing fails, or returns `NULL`. If parsing
  * fails then `ret` isn't touched.
@@ -106,10 +98,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_module_validate(
  * This function does not take ownership of `module`, and the caller is
  * expected to deallocate the returned #wasmtime_error_t and #wasm_byte_vec_t.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_module_serialize(
-    wasmtime_module_t* module,
-    wasm_byte_vec_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_serialize(wasmtime_module_t *module, wasm_byte_vec_t *ret);
 
 /**
  * \brief Build a module from serialized data.
@@ -121,12 +111,9 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_module_serialize(
  * documentation for more information on what inputs are safe to pass in here
  * (e.g. only that of #wasmtime_module_serialize)
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize(
-    wasm_engine_t *engine,
-    const uint8_t *bytes,
-    size_t bytes_len,
-    wasmtime_module_t **ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_deserialize(wasm_engine_t *engine, const uint8_t *bytes,
+                            size_t bytes_len, wasmtime_module_t **ret);
 
 /**
  * \brief Deserialize a module from an on-disk file.
@@ -142,14 +129,27 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize(
  * documentation for more information on what inputs are safe to pass in here
  * (e.g. only that of #wasmtime_module_serialize)
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize_file(
-    wasm_engine_t *engine,
-    const char *path,
-    wasmtime_module_t **ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_deserialize_file(wasm_engine_t *engine, const char *path,
+                                 wasmtime_module_t **ret);
+
+/**
+ * \brief Returns the range of bytes in memory where this module’s compilation
+ * image resides.
+ *
+ * The compilation image for a module contains executable code, data, debug
+ * information, etc. This is roughly the same as the wasmtime_module_serialize
+ * but not the exact same.
+ *
+ * For more details see:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Module.html#method.image_range
+ */
+WASM_API_EXTERN void
+wasmtime_module_image_range(const wasmtime_module_t *module, size_t *start,
+                            size_t *end);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_MODULE_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/store.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/store.h
new file mode 100644
index 0000000000..60ba3447f8
--- /dev/null
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/store.h
@@ -0,0 +1,244 @@
+/**
+ * \file wasmtime/store.h
+ *
+ * Wasmtime definition of a "store".
+ */
+
+#ifndef WASMTIME_STORE_H
+#define WASMTIME_STORE_H
+
+#include <wasi.h>
+#include <wasm.h>
+#include <wasmtime/error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \typedef wasmtime_store_t
+ * \brief Convenience alias for #wasmtime_store_t
+ *
+ * \struct wasmtime_store
+ * \brief Storage of WebAssembly objects
+ *
+ * A store is the unit of isolation between WebAssembly instances in an
+ * embedding of Wasmtime. Values in one #wasmtime_store_t cannot flow into
+ * another #wasmtime_store_t. Stores are cheap to create and cheap to dispose.
+ * It's expected that one-off stores are common in embeddings.
+ *
+ * Objects stored within a #wasmtime_store_t are referenced with integer handles
+ * rather than interior pointers. This means that most APIs require that the
+ * store be explicitly passed in, which is done via #wasmtime_context_t. It is
+ * safe to move a #wasmtime_store_t to any thread at any time. A store generally
+ * cannot be concurrently used, however.
+ */
+typedef struct wasmtime_store wasmtime_store_t;
+
+/**
+ * \typedef wasmtime_context_t
+ * \brief Convenience alias for #wasmtime_context
+ *
+ * \struct wasmtime_context
+ * \brief An interior pointer into a #wasmtime_store_t which is used as
+ * "context" for many functions.
+ *
+ * This context pointer is used pervasively throught Wasmtime's API. This can be
+ * acquired from #wasmtime_store_context or #wasmtime_caller_context. The
+ * context pointer for a store is the same for the entire lifetime of a store,
+ * so it can safely be stored adjacent to a #wasmtime_store_t itself.
+ *
+ * Usage of a #wasmtime_context_t must not outlive the original
+ * #wasmtime_store_t. Additionally #wasmtime_context_t can only be used in
+ * situations where it has explicitly been granted access to doing so. For
+ * example finalizers cannot use #wasmtime_context_t because they are not given
+ * access to it.
+ */
+typedef struct wasmtime_context wasmtime_context_t;
+
+/**
+ * \brief Creates a new store within the specified engine.
+ *
+ * \param engine the compilation environment with configuration this store is
+ * connected to
+ * \param data user-provided data to store, can later be acquired with
+ * #wasmtime_context_get_data.
+ * \param finalizer an optional finalizer for `data`
+ *
+ * This function creates a fresh store with the provided configuration settings.
+ * The returned store must be deleted with #wasmtime_store_delete.
+ */
+WASM_API_EXTERN wasmtime_store_t *wasmtime_store_new(wasm_engine_t *engine,
+                                                     void *data,
+                                                     void (*finalizer)(void *));
+
+/**
+ * \brief Returns the interior #wasmtime_context_t pointer to this store
+ */
+WASM_API_EXTERN wasmtime_context_t *
+wasmtime_store_context(wasmtime_store_t *store);
+
+/**
+ * \brief Provides limits for a store. Used by hosts to limit resource
+ * consumption of instances. Use negative value to keep the default value
+ * for the limit.
+ *
+ * \param store store where the limits should be set.
+ * \param memory_size the maximum number of bytes a linear memory can grow to.
+ * Growing a linear memory beyond this limit will fail. By default,
+ * linear memory will not be limited.
+ * \param table_elements the maximum number of elements in a table.
+ * Growing a table beyond this limit will fail. By default, table elements
+ * will not be limited.
+ * \param instances the maximum number of instances that can be created
+ * for a Store. Module instantiation will fail if this limit is exceeded.
+ * This value defaults to 10,000.
+ * \param tables the maximum number of tables that can be created for a Store.
+ * Module instantiation will fail if this limit is exceeded. This value
+ * defaults to 10,000.
+ * \param memories the maximum number of linear memories that can be created
+ * for a Store. Instantiation will fail with an error if this limit is exceeded.
+ * This value defaults to 10,000.
+ *
+ * Use any negative value for the parameters that should be kept on
+ * the default values.
+ *
+ * Note that the limits are only used to limit the creation/growth of
+ * resources in the future, this does not retroactively attempt to apply
+ * limits to the store.
+ */
+WASM_API_EXTERN void wasmtime_store_limiter(wasmtime_store_t *store,
+                                            int64_t memory_size,
+                                            int64_t table_elements,
+                                            int64_t instances, int64_t tables,
+                                            int64_t memories);
+
+/**
+ * \brief Deletes a store.
+ */
+WASM_API_EXTERN void wasmtime_store_delete(wasmtime_store_t *store);
+
+/**
+ * \brief Returns the user-specified data associated with the specified store
+ */
+WASM_API_EXTERN void *
+wasmtime_context_get_data(const wasmtime_context_t *context);
+
+/**
+ * \brief Overwrites the user-specified data associated with this store.
+ *
+ * Note that this does not execute the original finalizer for the provided data,
+ * and the original finalizer will be executed for the provided data when the
+ * store is deleted.
+ */
+WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t *context,
+                                               void *data);
+
+/**
+ * \brief Perform garbage collection within the given context.
+ *
+ * Garbage collects `externref`s that are used within this store. Any
+ * `externref`s that are discovered to be unreachable by other code or objects
+ * will have their finalizers run.
+ *
+ * The `context` argument must not be NULL.
+ */
+WASM_API_EXTERN void wasmtime_context_gc(wasmtime_context_t *context);
+
+/**
+ * \brief Set fuel to this context's store for wasm to consume while executing.
+ *
+ * For this method to work fuel consumption must be enabled via
+ * #wasmtime_config_consume_fuel_set. By default a store starts with 0 fuel
+ * for wasm to execute with (meaning it will immediately trap).
+ * This function must be called for the store to have
+ * some fuel to allow WebAssembly to execute.
+ *
+ * Note that when fuel is entirely consumed it will cause wasm to trap.
+ *
+ * If fuel is not enabled within this store then an error is returned. If fuel
+ * is successfully added then NULL is returned.
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_set_fuel(wasmtime_context_t *store, uint64_t fuel);
+
+/**
+ * \brief Returns the amount of fuel remaining in this context's store.
+ *
+ * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set
+ * then this function will return an error. Otherwise `NULL` is returned and the
+ * fuel parameter is filled in with fuel consumed so far.
+ *
+ * Also note that fuel, if enabled, must be originally configured via
+ * #wasmtime_context_set_fuel.
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_get_fuel(const wasmtime_context_t *context, uint64_t *fuel);
+
+/**
+ * \brief Configures WASI state within the specified store.
+ *
+ * This function is required if #wasmtime_linker_define_wasi is called. This
+ * will configure the WASI state for instances defined within this store to the
+ * configuration specified.
+ *
+ * This function does not take ownership of `context` but it does take ownership
+ * of `wasi`. The caller should no longer use `wasi` after calling this function
+ * (even if an error is returned).
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_set_wasi(wasmtime_context_t *context, wasi_config_t *wasi);
+
+/**
+ * \brief Configures the relative deadline at which point WebAssembly code will
+ * trap or invoke the callback function.
+ *
+ * This function configures the store-local epoch deadline after which point
+ * WebAssembly code will trap or invoke the callback function.
+ *
+ * See also #wasmtime_config_epoch_interruption_set and
+ * #wasmtime_store_epoch_deadline_callback.
+ */
+WASM_API_EXTERN void
+wasmtime_context_set_epoch_deadline(wasmtime_context_t *context,
+                                    uint64_t ticks_beyond_current);
+
+/// \brief An enum for the behavior before extending the epoch deadline.
+typedef uint8_t wasmtime_update_deadline_kind_t;
+/// \brief Directly continue to updating the deadline and executing WebAssembly.
+#define WASMTIME_UPDATE_DEADLINE_CONTINUE 0
+/// \brief Yield control (via async support) then update the deadline.
+#define WASMTIME_UPDATE_DEADLINE_YIELD 1
+
+/**
+ * \brief Configures epoch deadline callback to C function.
+ *
+ * This function configures a store-local callback function that will be
+ * called when the running WebAssembly function has exceeded its epoch
+ * deadline. That function can:
+ * - return a #wasmtime_error_t to terminate the function
+ * - set the delta argument and return NULL to update the
+ *   epoch deadline delta and resume function execution.
+ * - set the delta argument, update the epoch deadline,
+ *   set update_kind to WASMTIME_UPDATE_DEADLINE_YIELD,
+ *   and return NULL to yield (via async support) and
+ *   resume function execution.
+ *
+ * To use WASMTIME_UPDATE_DEADLINE_YIELD async support must be enabled
+ * for this store.
+ *
+ * See also #wasmtime_config_epoch_interruption_set and
+ * #wasmtime_context_set_epoch_deadline.
+ */
+WASM_API_EXTERN void wasmtime_store_epoch_deadline_callback(
+    wasmtime_store_t *store,
+    wasmtime_error_t *(*func)(wasmtime_context_t *context, void *data,
+                              uint64_t *epoch_deadline_delta,
+                              wasmtime_update_deadline_kind_t *update_kind),
+    void *data, void (*finalizer)(void *));
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_STORE_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/table.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/table.h
similarity index 68%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/table.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/table.h
index 630cee9eca..9ec8f3796c 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/table.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/table.h
@@ -8,9 +8,9 @@
 #define WASMTIME_TABLE_H
 
 #include <wasm.h>
+#include <wasmtime/error.h>
 #include <wasmtime/extern.h>
 #include <wasmtime/store.h>
-#include <wasmtime/error.h>
 #include <wasmtime/val.h>
 
 #ifdef __cplusplus
@@ -29,22 +29,19 @@ extern "C" {
  * ownership of returned error. This function may return an error if the `init`
  * value does not match `ty`, for example.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_new(
-    wasmtime_context_t *store,
-    const wasm_tabletype_t *ty,
-    const wasmtime_val_t *init,
-    wasmtime_table_t *table
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_table_new(wasmtime_context_t *store,
+                                                     const wasm_tabletype_t *ty,
+                                                     const wasmtime_val_t *init,
+                                                     wasmtime_table_t *table);
 
 /**
  * \brief Returns the type of this table.
  *
  * The caller has ownership of the returned #wasm_tabletype_t
  */
-WASM_API_EXTERN wasm_tabletype_t* wasmtime_table_type(
-    const wasmtime_context_t *store,
-    const wasmtime_table_t *table
-);
+WASM_API_EXTERN wasm_tabletype_t *
+wasmtime_table_type(const wasmtime_context_t *store,
+                    const wasmtime_table_t *table);
 
 /**
  * \brief Gets a value in a table.
@@ -58,12 +55,9 @@ WASM_API_EXTERN wasm_tabletype_t* wasmtime_table_type(
  * returned then `val` is filled in and is owned by the caller. Otherwise zero
  * is returned because the `index` is out-of-bounds.
  */
-WASM_API_EXTERN bool wasmtime_table_get(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t index,
-    wasmtime_val_t *val
-);
+WASM_API_EXTERN bool wasmtime_table_get(wasmtime_context_t *store,
+                                        const wasmtime_table_t *table,
+                                        uint32_t index, wasmtime_val_t *val);
 
 /**
  * \brief Sets a value in a table.
@@ -78,20 +72,15 @@ WASM_API_EXTERN bool wasmtime_table_get(
  * This function can fail if `value` has the wrong type for the table, or if
  * `index` is out of bounds.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_set(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t index,
-    const wasmtime_val_t *value
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_table_set(wasmtime_context_t *store, const wasmtime_table_t *table,
+                   uint32_t index, const wasmtime_val_t *value);
 
 /**
  * \brief Returns the size, in elements, of the specified table
  */
-WASM_API_EXTERN uint32_t wasmtime_table_size(
-    const wasmtime_context_t *store,
-    const wasmtime_table_t *table
-);
+WASM_API_EXTERN uint32_t wasmtime_table_size(const wasmtime_context_t *store,
+                                             const wasmtime_table_t *table);
 
 /**
  * \brief Grows a table.
@@ -110,17 +99,13 @@ WASM_API_EXTERN uint32_t wasmtime_table_size(
  *
  * This function does not take ownership of any of its arguments.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_grow(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t delta,
-    const wasmtime_val_t *init,
-    uint32_t *prev_size
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_table_grow(wasmtime_context_t *store, const wasmtime_table_t *table,
+                    uint32_t delta, const wasmtime_val_t *init,
+                    uint32_t *prev_size);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_TABLE_H
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/trap.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/trap.h
similarity index 86%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/trap.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/trap.h
index 6346cf443b..0d2385bb00 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/trap.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/trap.h
@@ -28,7 +28,8 @@ enum wasmtime_trap_code_enum {
   WASMTIME_TRAP_CODE_STACK_OVERFLOW,
   /// An out-of-bounds memory access.
   WASMTIME_TRAP_CODE_MEMORY_OUT_OF_BOUNDS,
-  /// A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
+  /// A wasm atomic operation was presented with a not-naturally-aligned
+  /// linear-memory address.
   WASMTIME_TRAP_CODE_HEAP_MISALIGNED,
   /// An out-of-bounds access to a table.
   WASMTIME_TRAP_CODE_TABLE_OUT_OF_BOUNDS,
@@ -46,6 +47,8 @@ enum wasmtime_trap_code_enum {
   WASMTIME_TRAP_CODE_UNREACHABLE_CODE_REACHED,
   /// Execution has potentially run too long and may be interrupted.
   WASMTIME_TRAP_CODE_INTERRUPT,
+  /// Execution has run out of the configured fuel amount.
+  WASMTIME_TRAP_CODE_OUT_OF_FUEL,
 };
 
 /**
@@ -67,7 +70,8 @@ WASM_API_EXTERN wasm_trap_t *wasmtime_trap_new(const char *msg, size_t msg_len);
  * an instruction trap -- traps can also be created using wasm_trap_new,
  * or occur with WASI modules exiting with a certain exit code.
  */
-WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t*, wasmtime_trap_code_t *code);
+WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t *,
+                                        wasmtime_trap_code_t *code);
 
 /**
  * \brief Returns a human-readable name for this frame's function.
@@ -77,7 +81,8 @@ WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t*, wasmtime_trap_code_t
  *
  * The lifetime of the returned name is the same as the #wasm_frame_t itself.
  */
-WASM_API_EXTERN const wasm_name_t *wasmtime_frame_func_name(const wasm_frame_t*);
+WASM_API_EXTERN const wasm_name_t *
+wasmtime_frame_func_name(const wasm_frame_t *);
 
 /**
  * \brief Returns a human-readable name for this frame's module.
@@ -87,11 +92,11 @@ WASM_API_EXTERN const wasm_name_t *wasmtime_frame_func_name(const wasm_frame_t*)
  *
  * The lifetime of the returned name is the same as the #wasm_frame_t itself.
  */
-WASM_API_EXTERN const wasm_name_t *wasmtime_frame_module_name(const wasm_frame_t*);
-
+WASM_API_EXTERN const wasm_name_t *
+wasmtime_frame_module_name(const wasm_frame_t *);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_TRAP_H
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/val.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/val.h
similarity index 91%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/val.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/val.h
index ae0a1961ce..61c82873be 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/val.h
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime/val.h
@@ -41,7 +41,8 @@ typedef struct wasmtime_externref wasmtime_externref_t;
  *
  * The returned value must be deleted with #wasmtime_externref_delete
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_new(void *data, void (*finalizer)(void*));
+WASM_API_EXTERN wasmtime_externref_t *
+wasmtime_externref_new(void *data, void (*finalizer)(void *));
 
 /**
  * \brief Get an `externref`'s wrapped data
@@ -55,7 +56,8 @@ WASM_API_EXTERN void *wasmtime_externref_data(wasmtime_externref_t *data);
  * \brief Creates a shallow copy of the `externref` argument, returning a
  * separately owned pointer (increases the reference count).
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_clone(wasmtime_externref_t *ref);
+WASM_API_EXTERN wasmtime_externref_t *
+wasmtime_externref_clone(wasmtime_externref_t *ref);
 
 /**
  * \brief Decrements the reference count of the `ref`, deleting it if it's the
@@ -70,7 +72,8 @@ WASM_API_EXTERN void wasmtime_externref_delete(wasmtime_externref_t *ref);
  * Note that the returned #wasmtime_externref_t is an owned value that must be
  * deleted via #wasmtime_externref_delete by the caller if it is non-null.
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_from_raw(wasmtime_context_t *context, size_t raw);
+WASM_API_EXTERN wasmtime_externref_t *
+wasmtime_externref_from_raw(wasmtime_context_t *context, void *raw);
 
 /**
  * \brief Converts a #wasmtime_externref_t to a raw value suitable for storing
@@ -82,9 +85,9 @@ WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_from_raw(wasmtime_conte
  * context of the store. Do not perform a GC between calling this function and
  * passing it to WebAssembly.
  */
-WASM_API_EXTERN size_t wasmtime_externref_to_raw(
-    wasmtime_context_t *context,
-    const wasmtime_externref_t *ref);
+WASM_API_EXTERN void *
+wasmtime_externref_to_raw(wasmtime_context_t *context,
+                          const wasmtime_externref_t *ref);
 
 /// \brief Discriminant stored in #wasmtime_val::kind
 typedef uint8_t wasmtime_valkind_t;
@@ -98,9 +101,11 @@ typedef uint8_t wasmtime_valkind_t;
 #define WASMTIME_F64 3
 /// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a v128
 #define WASMTIME_V128 4
-/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a funcref
+/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a
+/// funcref
 #define WASMTIME_FUNCREF 5
-/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is an externref
+/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is an
+/// externref
 #define WASMTIME_EXTERNREF 6
 
 /// \brief A 128-bit value representing the WebAssembly `v128` type. Bytes are
@@ -119,38 +124,24 @@ typedef uint8_t wasmtime_v128[16];
  */
 typedef union wasmtime_valunion {
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_I32
-  ///
-  /// Note that this field is always stored in a little-endian format.
   int32_t i32;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_I64
-  ///
-  /// Note that this field is always stored in a little-endian format.
   int64_t i64;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_F32
-  ///
-  /// Note that this field is always stored in a little-endian format.
   float32_t f32;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_F64
-  ///
-  /// Note that this field is always stored in a little-endian format.
   float64_t f64;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_FUNCREF
   ///
   /// If this value represents a `ref.null func` value then the `store_id` field
   /// is set to zero.
-  ///
-  /// Note that this field is always stored in a little-endian format.
   wasmtime_func_t funcref;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_EXTERNREF
   ///
   /// If this value represents a `ref.null extern` value then this pointer will
   /// be `NULL`.
-  ///
-  /// Note that this field is always stored in a little-endian format.
   wasmtime_externref_t *externref;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_V128
-  ///
-  /// Note that this field is always stored in a little-endian format.
   wasmtime_v128 v128;
 } wasmtime_valunion_t;
 
@@ -169,26 +160,40 @@ typedef union wasmtime_valunion {
  */
 typedef union wasmtime_val_raw {
   /// Field for when this val is a WebAssembly `i32` value.
+  ///
+  /// Note that this field is always stored in a little-endian format.
   int32_t i32;
   /// Field for when this val is a WebAssembly `i64` value.
+  ///
+  /// Note that this field is always stored in a little-endian format.
   int64_t i64;
   /// Field for when this val is a WebAssembly `f32` value.
+  ///
+  /// Note that this field is always stored in a little-endian format.
   float32_t f32;
   /// Field for when this val is a WebAssembly `f64` value.
+  ///
+  /// Note that this field is always stored in a little-endian format.
   float64_t f64;
   /// Field for when this val is a WebAssembly `v128` value.
+  ///
+  /// Note that this field is always stored in a little-endian format.
   wasmtime_v128 v128;
   /// Field for when this val is a WebAssembly `funcref` value.
   ///
   /// If this is set to 0 then it's a null funcref, otherwise this must be
   /// passed to `wasmtime_func_from_raw` to determine the `wasmtime_func_t`.
-  size_t funcref;
+  ///
+  /// Note that this field is always stored in a little-endian format.
+  void *funcref;
   /// Field for when this val is a WebAssembly `externref` value.
   ///
   /// If this is set to 0 then it's a null externref, otherwise this must be
   /// passed to `wasmtime_externref_from_raw` to determine the
   /// `wasmtime_externref_t`.
-  size_t externref;
+  ///
+  /// Note that this field is always stored in a little-endian format.
+  void *externref;
 } wasmtime_val_raw_t;
 
 /**
@@ -212,7 +217,7 @@ typedef struct wasmtime_val {
 } wasmtime_val_t;
 
 /**
- * \brief Delets an owned #wasmtime_val_t.
+ * \brief Deletes an owned #wasmtime_val_t.
  *
  * Note that this only deletes the contents, not the memory that `val` points to
  * itself (which is owned by the caller).
@@ -222,11 +227,11 @@ WASM_API_EXTERN void wasmtime_val_delete(wasmtime_val_t *val);
 /**
  * \brief Copies `src` into `dst`.
  */
-WASM_API_EXTERN void wasmtime_val_copy(wasmtime_val_t *dst, const wasmtime_val_t *src);
+WASM_API_EXTERN void wasmtime_val_copy(wasmtime_val_t *dst,
+                                       const wasmtime_val_t *src);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_VAL_H
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64/libwasmtime.a b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64/libwasmtime.a
similarity index 75%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64/libwasmtime.a
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64/libwasmtime.a
index b76b5d9aca..23c0b1847f 100644
Binary files a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64/libwasmtime.a and b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64/libwasmtime.a differ
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64/libwasmtime.a b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64/libwasmtime.a
similarity index 72%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64/libwasmtime.a
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64/libwasmtime.a
index ae507a6b72..9baa507748 100644
Binary files a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64/libwasmtime.a and b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64/libwasmtime.a differ
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64/libwasmtime.a b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64/libwasmtime.a
similarity index 69%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64/libwasmtime.a
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64/libwasmtime.a
index e3a8a1dc6c..c40a483bd6 100644
Binary files a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64/libwasmtime.a and b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64/libwasmtime.a differ
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64/libwasmtime.a b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64/libwasmtime.a
similarity index 70%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64/libwasmtime.a
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64/libwasmtime.a
index d017a269f3..498395c785 100644
Binary files a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64/libwasmtime.a and b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64/libwasmtime.a differ
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64/empty.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64/empty.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64/empty.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64/empty.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64/libwasmtime.a b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64/libwasmtime.a
similarity index 75%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64/libwasmtime.a
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64/libwasmtime.a
index b5b3046fdb..6672cc0e83 100644
Binary files a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64/libwasmtime.a and b/vendor/github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64/libwasmtime.a differ
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/config.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/config.go
similarity index 72%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/config.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/config.go
index 1290708846..16d00fcfa7 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/config.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/config.go
@@ -62,6 +62,15 @@ func (cfg *Config) SetDebugInfo(enabled bool) {
 	runtime.KeepAlive(cfg)
 }
 
+// SetMaxWasmStack configures the maximum stack size, in bytes, that JIT code can use.
+// The amount of stack space that wasm takes is always relative to the first invocation of wasm on the stack.
+// Recursive calls with host frames in the middle will all need to fit within this setting.
+// Note that this setting is not interpreted with 100% precision.
+func (cfg *Config) SetMaxWasmStack(size int) {
+	C.wasmtime_config_max_wasm_stack_set(cfg.ptr(), C.size_t(size))
+	runtime.KeepAlive(cfg)
+}
+
 // SetWasmThreads configures whether the wasm threads proposal is enabled
 func (cfg *Config) SetWasmThreads(enabled bool) {
 	C.wasmtime_config_wasm_threads_set(cfg.ptr(), C.bool(enabled))
@@ -173,6 +182,57 @@ func (cfg *Config) SetEpochInterruption(enable bool) {
 	runtime.KeepAlive(cfg)
 }
 
+// SetTarget configures the target triple that this configuration will produce
+// machine code for.
+//
+// This option defaults to the native host. Calling this method will
+// additionally disable inference of the native features of the host (e.g.
+// detection of SSE4.2 on x86_64 hosts). Native features can be reenabled with
+// the `cranelift_flag_{set,enable}` properties.
+//
+// For more information see the Rust documentation at
+// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.config
+func (cfg *Config) SetTarget(target string) error {
+	cstr := C.CString(target)
+	err := C.wasmtime_config_target_set(cfg.ptr(), cstr)
+	C.free(unsafe.Pointer(cstr))
+	runtime.KeepAlive(cfg)
+	if err != nil {
+		return mkError(err)
+	}
+	return nil
+}
+
+// EnableCraneliftFlag enables a target-specific flag in Cranelift.
+//
+// This can be used, for example, to enable SSE4.2 on x86_64 hosts. Settings can
+// be explored with `wasmtime settings` on the CLI.
+//
+// For more information see the Rust documentation at
+// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_enable
+func (cfg *Config) EnableCraneliftFlag(flag string) {
+	cstr := C.CString(flag)
+	C.wasmtime_config_cranelift_flag_enable(cfg.ptr(), cstr)
+	C.free(unsafe.Pointer(cstr))
+	runtime.KeepAlive(cfg)
+}
+
+// SetCraneliftFlag sets a target-specific flag in Cranelift to the specified value.
+//
+// This can be used, for example, to enable SSE4.2 on x86_64 hosts. Settings can
+// be explored with `wasmtime settings` on the CLI.
+//
+// For more information see the Rust documentation at
+// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_set
+func (cfg *Config) SetCraneliftFlag(name string, value string) {
+	cstrName := C.CString(name)
+	cstrValue := C.CString(value)
+	C.wasmtime_config_cranelift_flag_set(cfg.ptr(), cstrName, cstrValue)
+	C.free(unsafe.Pointer(cstrName))
+	C.free(unsafe.Pointer(cstrValue))
+	runtime.KeepAlive(cfg)
+}
+
 // See comments in `ffi.go` for what's going on here
 func (cfg *Config) ptr() *C.wasm_config_t {
 	ret := cfg._ptr
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/doc.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/doc.go
similarity index 93%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/doc.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/doc.go
index ef44184bc9..a37191bbf2 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/doc.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/doc.go
@@ -14,5 +14,6 @@ https://github.com/bytecodealliance/wasmtime-go/issues/new.
 
 It's also worth pointing out that the authors of this package up to this point
 primarily work in Rust, so if you've got suggestions of how to make this package
-more idiomatic for Go we'd love to hear your thoughts! */
+more idiomatic for Go we'd love to hear your thoughts!
+*/
 package wasmtime
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/engine.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/engine.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/engine.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/engine.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/error.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/error.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/error.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/error.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/exporttype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/exporttype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/exporttype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/exporttype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/extern.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/extern.go
similarity index 99%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/extern.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/extern.go
index 77166d5ea6..6d2fc7cc59 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/extern.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/extern.go
@@ -7,7 +7,6 @@ import "runtime"
 // Extern is an external value, which is the runtime representation of an entity that can be imported or exported.
 // It is an address denoting either a function instance, table instance, memory instance, or global instances in the shared store.
 // Read more in [spec](https://webassembly.github.io/spec/core/exec/runtime.html#external-values)
-//
 type Extern struct {
 	_ptr *C.wasmtime_extern_t
 }
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/externtype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/externtype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/externtype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/externtype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/ffi.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/ffi.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/ffi.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/ffi.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/func.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/func.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/func.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/func.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/functype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/functype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/functype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/functype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/global.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/global.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/global.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/global.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/globaltype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/globaltype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/globaltype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/globaltype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/importtype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/importtype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/importtype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/importtype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v17/includebuild.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/includebuild.go
new file mode 100644
index 0000000000..8edf8e296c
--- /dev/null
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/includebuild.go
@@ -0,0 +1,22 @@
+//go:build includebuild
+// +build includebuild
+
+package wasmtime
+
+// This file is not built and not included in BUILD.bazel;
+// it is only used to prevent "go mod vendor" to prune the
+// build directory.
+
+import (
+	// Import these build directories in order to have them
+	// included in vendored dependencies.
+	// Cf. https://github.com/golang/go/issues/26366
+
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/include"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64"
+	_ "github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64"
+)
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/instance.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/instance.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/instance.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/instance.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/linker.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/linker.go
similarity index 97%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/linker.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/linker.go
index df2f068965..449bbfdd66 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/linker.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/linker.go
@@ -40,10 +40,11 @@ func (l *Linker) AllowShadowing(allow bool) {
 
 // Define defines a new item in this linker with the given module/name pair. Returns
 // an error if shadowing is disallowed and the module/name is already defined.
-func (l *Linker) Define(module, name string, item AsExtern) error {
+func (l *Linker) Define(store Storelike, module, name string, item AsExtern) error {
 	extern := item.AsExtern()
 	err := C.wasmtime_linker_define(
 		l.ptr(),
+		store.Context(),
 		C._GoStringPtr(module),
 		C._GoStringLen(module),
 		C._GoStringPtr(name),
@@ -54,6 +55,7 @@ func (l *Linker) Define(module, name string, item AsExtern) error {
 	runtime.KeepAlive(module)
 	runtime.KeepAlive(name)
 	runtime.KeepAlive(item)
+	runtime.KeepAlive(store)
 	if err == nil {
 		return nil
 	}
@@ -65,7 +67,7 @@ func (l *Linker) Define(module, name string, item AsExtern) error {
 //
 // Returns an error if shadowing is disabled and the name is already defined.
 func (l *Linker) DefineFunc(store Storelike, module, name string, f interface{}) error {
-	return l.Define(module, name, WrapFunc(store, f))
+	return l.Define(store, module, name, WrapFunc(store, f))
 }
 
 // FuncNew defines a function in this linker in the same style as `NewFunc`
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/maybe_gc_actual.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/maybe_gc_actual.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/maybe_gc_actual.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/maybe_gc_actual.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/maybe_gc_no.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/maybe_gc_no.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/maybe_gc_no.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/maybe_gc_no.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/memory.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/memory.go
similarity index 93%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/memory.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/memory.go
index 4b0d1fd6ee..d5f222b0fc 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/memory.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/memory.go
@@ -56,13 +56,8 @@ func (mem *Memory) Data(store Storelike) unsafe.Pointer {
 // `m` alive for long enough while you're using the `[]byte` slice. If the
 // `[]byte` slice is used after `m` is GC'd then that is undefined behavior.
 func (mem *Memory) UnsafeData(store Storelike) []byte {
-	// see https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices
-	const MaxLen = 1 << 32
 	length := mem.DataSize(store)
-	if length >= MaxLen {
-		panic("memory is too big")
-	}
-	return (*[MaxLen]byte)(mem.Data(store))[:length:length]
+	return unsafe.Slice((*byte)(mem.Data(store)), length)
 }
 
 // DataSize returns the size, in bytes, that `Data()` is valid for
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/memorytype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/memorytype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/memorytype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/memorytype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/module.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/module.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/module.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/module.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/shims.c b/vendor/github.com/bytecodealliance/wasmtime-go/v17/shims.c
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/shims.c
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/shims.c
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/shims.h b/vendor/github.com/bytecodealliance/wasmtime-go/v17/shims.h
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/shims.h
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/shims.h
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/slab.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/slab.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/slab.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/slab.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/store.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/store.go
similarity index 84%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/store.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/store.go
index 7dc8c59fae..b689ca0043 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/store.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/store.go
@@ -227,23 +227,27 @@ func goFinalizeFuncWrap(env unsafe.Pointer) {
 	gEngineFuncWrapSlab.deallocate(idx)
 }
 
-// FuelConsumed returns the amount of fuel consumed by this context's store
-// execution so far.
+// GetFuel returns the amount of fuel remaining in this store.
 //
-// If fuel consumption is not enabled via `Config.SetConsumeFuel` then this function
-// will return false. Otherwise true is returned and the fuel parameter is
-// filled in with fuel consumed so far.
+// If fuel consumption is not enabled via `Config.SetConsumeFuel` then
+// this function will return an error. Otherwise this will retrieve the fuel
+// remaining and return it.
 //
-// Also note that fuel, if enabled, must be originally configured via `Store.AddFuel`.
-func (store *Store) FuelConsumed() (uint64, bool) {
-	fuel := C.uint64_t(0)
-	enable := C.wasmtime_context_fuel_consumed(store.Context(), &fuel)
+// Also note that fuel, if enabled, must be originally configured via
+// `Store.SetFuel`.
+func (store *Store) GetFuel() (uint64, error) {
+	var remaining uint64
+	c_remaining := C.uint64_t(remaining)
+	err := C.wasmtime_context_get_fuel(store.Context(), &c_remaining)
 	runtime.KeepAlive(store)
+	if err != nil {
+		return 0, mkError(err)
+	}
 
-	return uint64(fuel), bool(enable)
+	return uint64(c_remaining), nil
 }
 
-// AddFuel adds fuel to this context's store for wasm to consume while executing.
+// SetFuel sets this store's fuel to the specified value.
 //
 // For this method to work fuel consumption must be enabled via
 // `Config.SetConsumeFuel`. By default a store starts with 0 fuel
@@ -255,8 +259,8 @@ func (store *Store) FuelConsumed() (uint64, bool) {
 // wasm to trap. More usages of fuel are planned for the future.
 //
 // If fuel is not enabled within this store then an error is returned.
-func (store *Store) AddFuel(fuel uint64) error {
-	err := C.wasmtime_context_add_fuel(store.Context(), C.uint64_t(fuel))
+func (store *Store) SetFuel(fuel uint64) error {
+	err := C.wasmtime_context_set_fuel(store.Context(), C.uint64_t(fuel))
 	runtime.KeepAlive(store)
 	if err != nil {
 		return mkError(err)
@@ -265,24 +269,22 @@ func (store *Store) AddFuel(fuel uint64) error {
 	return nil
 }
 
-// ConsumeFuel attempts to manually consume fuel from the store.
-//
-// If fuel consumption is not enabled via `Config.SetConsumeFuel` then
-// this function will return an error. Otherwise this will attempt to consume
-// the specified amount of `fuel` from the store. If successful the remaining
-// amount of fuel is returned. If `fuel` couldn't be consumed
-// then an error is returned.
-//
-// Also note that fuel, if enabled, must be originally configured via
-// `Store.AddFuel`.
-func (store *Store) ConsumeFuel(fuel uint64) (uint64, error) {
-	var remaining uint64
-	c_remaining := C.uint64_t(remaining)
-	err := C.wasmtime_context_consume_fuel(store.Context(), C.uint64_t(fuel), &c_remaining)
-	runtime.KeepAlive(store)
-	if err != nil {
-		return 0, mkError(err)
-	}
-
-	return uint64(c_remaining), nil
+// Limiter provides limits for a store. Used by hosts to limit resource
+// consumption of instances. Use negative value to keep the default value
+// for the limit.
+func (store *Store) Limiter(
+	memorySize int64,
+	tableElements int64,
+	instances int64,
+	tables int64,
+	memories int64,
+) {
+	C.wasmtime_store_limiter(
+		store._ptr,
+		C.int64_t(memorySize),
+		C.int64_t(tableElements),
+		C.int64_t(instances),
+		C.int64_t(tables),
+		C.int64_t(memories),
+	)
 }
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/table.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/table.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/table.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/table.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/tabletype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/tabletype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/tabletype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/tabletype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/trap.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/trap.go
similarity index 98%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/trap.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/trap.go
index 3860e3d1c7..25d357558f 100644
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/trap.go
+++ b/vendor/github.com/bytecodealliance/wasmtime-go/v17/trap.go
@@ -50,6 +50,8 @@ const (
 	UnreachableCodeReached
 	// Interrupt: execution has been interrupted.
 	Interrupt
+	// OutOfFuel: Execution has run out of the configured fuel amount.
+	OutOfFuel
 )
 
 // NewTrap creates a new `Trap` with the `name` and the type provided.
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/val.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/val.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/val.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/val.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/valtype.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/valtype.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/valtype.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/valtype.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/wasi.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/wasi.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/wasi.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/wasi.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/wat2wasm.go b/vendor/github.com/bytecodealliance/wasmtime-go/v17/wat2wasm.go
similarity index 100%
rename from vendor/github.com/bytecodealliance/wasmtime-go/v3/wat2wasm.go
rename to vendor/github.com/bytecodealliance/wasmtime-go/v17/wat2wasm.go
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/store.h b/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/store.h
deleted file mode 100644
index 55c9f680bd..0000000000
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime/store.h
+++ /dev/null
@@ -1,185 +0,0 @@
-/**
- * \file wasmtime/store.h
- *
- * Wasmtime definition of a "store".
- */
-
-#ifndef WASMTIME_STORE_H
-#define WASMTIME_STORE_H
-
-#include <wasm.h>
-#include <wasi.h>
-#include <wasmtime/error.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \typedef wasmtime_store_t
- * \brief Convenience alias for #wasmtime_store_t
- *
- * \struct wasmtime_store
- * \brief Storage of WebAssembly objects
- *
- * A store is the unit of isolation between WebAssembly instances in an
- * embedding of Wasmtime. Values in one #wasmtime_store_t cannot flow into
- * another #wasmtime_store_t. Stores are cheap to create and cheap to dispose.
- * It's expected that one-off stores are common in embeddings.
- *
- * Objects stored within a #wasmtime_store_t are referenced with integer handles
- * rather than interior pointers. This means that most APIs require that the
- * store be explicitly passed in, which is done via #wasmtime_context_t. It is
- * safe to move a #wasmtime_store_t to any thread at any time. A store generally
- * cannot be concurrently used, however.
- */
-typedef struct wasmtime_store wasmtime_store_t;
-
-/**
- * \typedef wasmtime_context_t
- * \brief Convenience alias for #wasmtime_context
- *
- * \struct wasmtime_context
- * \brief An interior pointer into a #wasmtime_store_t which is used as
- * "context" for many functions.
- *
- * This context pointer is used pervasively throught Wasmtime's API. This can be
- * acquired from #wasmtime_store_context or #wasmtime_caller_context. The
- * context pointer for a store is the same for the entire lifetime of a store,
- * so it can safely be stored adjacent to a #wasmtime_store_t itself.
- *
- * Usage of a #wasmtime_context_t must not outlive the original
- * #wasmtime_store_t. Additionally #wasmtime_context_t can only be used in
- * situations where it has explicitly been granted access to doing so. For
- * example finalizers cannot use #wasmtime_context_t because they are not given
- * access to it.
- */
-typedef struct wasmtime_context wasmtime_context_t;
-
-/**
- * \brief Creates a new store within the specified engine.
- *
- * \param engine the compilation environment with configuration this store is
- * connected to
- * \param data user-provided data to store, can later be acquired with
- * #wasmtime_context_get_data.
- * \param finalizer an optional finalizer for `data`
- *
- * This function creates a fresh store with the provided configuration settings.
- * The returned store must be deleted with #wasmtime_store_delete.
- */
-WASM_API_EXTERN wasmtime_store_t *wasmtime_store_new(
-    wasm_engine_t *engine,
-    void *data,
-    void (*finalizer)(void*)
-);
-
-/**
- * \brief Returns the interior #wasmtime_context_t pointer to this store
- */
-WASM_API_EXTERN wasmtime_context_t *wasmtime_store_context(wasmtime_store_t *store);
-
-/**
- * \brief Deletes a store.
- */
-WASM_API_EXTERN void wasmtime_store_delete(wasmtime_store_t *store);
-
-/**
- * \brief Returns the user-specified data associated with the specified store
- */
-WASM_API_EXTERN void *wasmtime_context_get_data(const wasmtime_context_t* context);
-
-/**
- * \brief Overwrites the user-specified data associated with this store.
- *
- * Note that this does not execute the original finalizer for the provided data,
- * and the original finalizer will be executed for the provided data when the
- * store is deleted.
- */
-WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t* context, void *data);
-
-/**
- * \brief Perform garbage collection within the given context.
- *
- * Garbage collects `externref`s that are used within this store. Any
- * `externref`s that are discovered to be unreachable by other code or objects
- * will have their finalizers run.
- *
- * The `context` argument must not be NULL.
- */
-WASM_API_EXTERN void wasmtime_context_gc(wasmtime_context_t* context);
-
-/**
- * \brief Adds fuel to this context's store for wasm to consume while executing.
- *
- * For this method to work fuel consumption must be enabled via
- * #wasmtime_config_consume_fuel_set. By default a store starts with 0 fuel
- * for wasm to execute with (meaning it will immediately trap).
- * This function must be called for the store to have
- * some fuel to allow WebAssembly to execute.
- *
- * Note that at this time when fuel is entirely consumed it will cause
- * wasm to trap. More usages of fuel are planned for the future.
- *
- * If fuel is not enabled within this store then an error is returned. If fuel
- * is successfully added then NULL is returned.
- */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_add_fuel(wasmtime_context_t *store, uint64_t fuel);
-
-/**
- * \brief Returns the amount of fuel consumed by this context's store execution
- * so far.
- *
- * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set
- * then this function will return false. Otherwise true is returned and the
- * fuel parameter is filled in with fuel consuemd so far.
- *
- * Also note that fuel, if enabled, must be originally configured via
- * #wasmtime_context_add_fuel.
- */
-WASM_API_EXTERN bool wasmtime_context_fuel_consumed(const wasmtime_context_t *context, uint64_t *fuel);
-
-/**
- * \brief Attempt to manually consume fuel from the store.
- *
- * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set then
- * this function will return an error. Otherwise this will attempt to consume
- * the specified amount of `fuel` from the store. If successful the remaining
- * amount of fuel is stored into `remaining`. If `fuel` couldn't be consumed
- * then an error is returned.
- *
- * Also note that fuel, if enabled, must be originally configured via
- * #wasmtime_context_add_fuel.
- */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_consume_fuel(wasmtime_context_t *context, uint64_t fuel, uint64_t *remaining);
-
-/**
- * \brief Configures WASI state within the specified store.
- *
- * This function is required if #wasmtime_linker_define_wasi is called. This
- * will configure the WASI state for instances defined within this store to the
- * configuration specified.
- *
- * This function does not take ownership of `context` but it does take ownership
- * of `wasi`. The caller should no longer use `wasi` after calling this function
- * (even if an error is returned).
- */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_set_wasi(wasmtime_context_t *context, wasi_config_t *wasi);
-
-/**
- * \brief Configures the relative deadline at which point WebAssembly code will
- * trap.
- *
- * This function configures the store-local epoch deadline after which point
- * WebAssembly code will trap.
- *
- * See also #wasmtime_config_epoch_interruption_set.
- */
-WASM_API_EXTERN void wasmtime_context_set_epoch_deadline(wasmtime_context_t *context, uint64_t ticks_beyond_current);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif // WASMTIME_STORE_H
-
diff --git a/vendor/github.com/bytecodealliance/wasmtime-go/v3/includebuild.go b/vendor/github.com/bytecodealliance/wasmtime-go/v3/includebuild.go
deleted file mode 100644
index 6b234afcd4..0000000000
--- a/vendor/github.com/bytecodealliance/wasmtime-go/v3/includebuild.go
+++ /dev/null
@@ -1,22 +0,0 @@
-//go:build includebuild
-// +build includebuild
-
-package wasmtime
-
-// This file is not built and not included in BUILD.bazel;
-// it is only used to prevent "go mod vendor" to prune the
-// build directory.
-
-import (
-	// Import these build directories in order to have them
-	// included in vendored dependencies.
-	// Cf. https://github.com/golang/go/issues/26366
-
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/include"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64"
-	_ "github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64"
-)
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 2340956420..08e5f56a31 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -16,16 +16,16 @@ github.com/andreyvit/diff
 # github.com/beorn7/perks v1.0.1
 ## explicit; go 1.11
 github.com/beorn7/perks/quantile
-# github.com/bytecodealliance/wasmtime-go/v3 v3.0.2
+# github.com/bytecodealliance/wasmtime-go/v17 v17.0.0
 ## explicit; go 1.18
-github.com/bytecodealliance/wasmtime-go/v3
-github.com/bytecodealliance/wasmtime-go/v3/build/include
-github.com/bytecodealliance/wasmtime-go/v3/build/include/wasmtime
-github.com/bytecodealliance/wasmtime-go/v3/build/linux-aarch64
-github.com/bytecodealliance/wasmtime-go/v3/build/linux-x86_64
-github.com/bytecodealliance/wasmtime-go/v3/build/macos-aarch64
-github.com/bytecodealliance/wasmtime-go/v3/build/macos-x86_64
-github.com/bytecodealliance/wasmtime-go/v3/build/windows-x86_64
+github.com/bytecodealliance/wasmtime-go/v17
+github.com/bytecodealliance/wasmtime-go/v17/build/include
+github.com/bytecodealliance/wasmtime-go/v17/build/include/wasmtime
+github.com/bytecodealliance/wasmtime-go/v17/build/linux-aarch64
+github.com/bytecodealliance/wasmtime-go/v17/build/linux-x86_64
+github.com/bytecodealliance/wasmtime-go/v17/build/macos-aarch64
+github.com/bytecodealliance/wasmtime-go/v17/build/macos-x86_64
+github.com/bytecodealliance/wasmtime-go/v17/build/windows-x86_64
 # github.com/cenkalti/backoff/v4 v4.2.1
 ## explicit; go 1.18
 github.com/cenkalti/backoff/v4
