upgrade wasmtime 42 and others (#43)

Addressed changes:
* wasmtime (wasmtime::Result)
* wit (FixedLengthList, Param, TypeDef)

Signed-off-by: markfisher <mark@modulewise.com>

Author: markfisher

Cargo.lock

@@ -19,7 +19,7 @@ edition = "2024"
 
 [workspace.dependencies]
 anyhow = "1"
-clap = { version = "4.5", features = ["derive"] }
+clap = { version = "4.6", features = ["derive"] }
 http-body-util = "0.1"
 hyper = { version = "1", features = ["http1", "http2"] }
 hyper-util = { version = "0.1", features = ["tokio"] }
@@ -28,18 +28,18 @@ serde_json = "1"
 tempfile = "3"
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "time"] }
 tracing = "0.1"
-wasm-encoder = "0.244"
-wasmparser = "0.244"
-wat = "1.244"
-wit-parser = "0.244"
+wasm-encoder = "0.245"
+wasmparser = "0.245"
+wat = "1.245"
+wit-parser = "0.245"
 
 [dependencies]
 anyhow.workspace = true
 clap.workspace = true
 composable-interceptor = { path = "crates/interceptor" }
 http-body-util.workspace = true
 hyper = { workspace = true, features = ["client", "http1", "http2"] }
-oci-client = "0.15"
+oci-client = "0.16"
 petgraph = "0.8"
 rustyline = "17"
 serde.workspace = true
@@ -53,13 +53,13 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uuid = { version = "1", features = ["v4"] }
 wac-graph = "0.9"
 wac-types = "0.9"
-wasm-pkg-client = "0.14"
-wasmtime = "41"
-wasmtime-wasi = "41"
-wasmtime-wasi-config = "41"
-wasmtime-wasi-http = "41"
-wasmtime-wasi-io = "41"
-wit-component = "0.244"
+wasm-pkg-client = "0.15"
+wasmtime = "42"
+wasmtime-wasi = "42"
+wasmtime-wasi-config = "42"
+wasmtime-wasi-http = "42"
+wasmtime-wasi-io = "42"
+wit-component = "0.245"
 wit-parser.workspace = true
 
 [dev-dependencies]

Cargo.toml

@@ -5,7 +5,7 @@ wit_bindgen::generate!({
 });
 
 use exports::modulewise::interceptor::advice::{
-    Arg, Value, AfterAction, BeforeAction, Guest, GuestInvocation,
+    AfterAction, Arg, BeforeAction, Guest, GuestInvocation, Value,
 };
 use wasi::logging::logging::{Level, log};
 
@@ -22,16 +22,27 @@ struct LoggingInvocation {
 
 impl GuestInvocation for LoggingInvocation {
     fn new(function_name: String, args: Vec<Arg>) -> Self {
-        Self { function_name, args }
+        Self {
+            function_name,
+            args,
+        }
     }
 
     fn before(&self) -> BeforeAction {
-        log(Level::Info, "logging-advice", &format!("Before {} with Args: {:?}", self.function_name, self.args));
+        log(
+            Level::Info,
+            "logging-advice",
+            &format!("Before {} with Args: {:?}", self.function_name, self.args),
+        );
         BeforeAction::Proceed(self.args.clone())
     }
 
     fn after(&self, ret: Option<Value>) -> AfterAction {
-        log(Level::Info, "logging-advice", &format!("After {} with Result: {:?}", self.function_name, ret));
+        log(
+            Level::Info,
+            "logging-advice",
+            &format!("After {} with Result: {:?}", self.function_name, ret),
+        );
         match ret {
             Some(Value::Str(s)) => AfterAction::Accept(Some(Value::Str(s.to_uppercase()))),
             Some(Value::NumS64(n)) => AfterAction::Accept(Some(Value::NumS64(n * n))),

crates/interceptor/examples/logging/Cargo.lock

@@ -5,7 +5,7 @@ wit_bindgen::generate!({
 });
 
 use exports::modulewise::interceptor::advice::{
-    Arg, Value, AfterAction, BeforeAction, Guest, GuestInvocation,
+    AfterAction, Arg, BeforeAction, Guest, GuestInvocation, Value,
 };
 
 struct Squarer;

crates/interceptor/examples/logging/logger/src/lib.rs

@@ -5,7 +5,7 @@ wit_bindgen::generate!({
 });
 
 use exports::modulewise::interceptor::advice::{
-    Arg, Value, AfterAction, BeforeAction, Guest, GuestInvocation,
+    AfterAction, Arg, BeforeAction, Guest, GuestInvocation, Value,
 };
 
 struct Uppercaser;

crates/interceptor/examples/square/squarer/Cargo.lock

@@ -229,7 +229,7 @@ pub fn encode_valtype(
                                 c.ty.as_ref()
                                     .map(|t| encode_valtype(resolve, t, enc, type_map))
                                     .transpose()?;
-                            Ok((c.name.as_str(), ty, None))
+                            Ok((c.name.as_str(), ty))
                         })
                         .collect::<Result<Vec<_>>>()?;
                     let index = enc.type_count();
@@ -332,10 +332,10 @@ pub fn encode_valtype(
                     enc.ty().defined_type().map(key, value);
                     ComponentValType::Type(index)
                 }
-                TypeDefKind::FixedSizeList(t, size) => {
+                TypeDefKind::FixedLengthList(t, size) => {
                     let inner = encode_valtype(resolve, t, enc, type_map)?;
                     let index = enc.type_count();
-                    enc.ty().defined_type().fixed_size_list(inner, *size);
+                    enc.ty().defined_type().fixed_length_list(inner, *size);
                     ComponentValType::Type(index)
                 }
                 TypeDefKind::Unknown => bail!("unknown type"),
@@ -375,7 +375,12 @@ pub fn encode_functype(
     let params: Vec<(&str, ComponentValType)> = func
         .params
         .iter()
-        .map(|(name, ty)| Ok((name.as_str(), encode_valtype(resolve, ty, enc, type_map)?)))
+        .map(|p| {
+            Ok((
+                p.name.as_str(),
+                encode_valtype(resolve, &p.ty, enc, type_map)?,
+            ))
+        })
         .collect::<Result<Vec<_>>>()?;
 
     let result = func

crates/interceptor/examples/square/squarer/src/lib.rs

@@ -111,7 +111,7 @@ fn extract_world_exports(
                     )));
                 }
             }
-            WorldItem::Type(_) => {}
+            WorldItem::Type { .. } => {}
         }
     }
 
@@ -184,10 +184,10 @@ fn collect_referenced_foreign_types(
             WorldExport::Interface(ie) => {
                 for fe in &ie.functions {
                     let func = fe.func();
-                    for (_, ty) in &func.params {
+                    for p in &func.params {
                         walk_type(
                             resolve,
-                            ty,
+                            &p.ty,
                             Some(ie.interface_id),
                             &mut referenced,
                             &mut visited,
@@ -206,8 +206,8 @@ fn collect_referenced_foreign_types(
             }
             WorldExport::Function(fe) => {
                 let func = fe.func();
-                for (_, ty) in &func.params {
-                    walk_type(resolve, ty, None, &mut referenced, &mut visited);
+                for p in &func.params {
+                    walk_type(resolve, &p.ty, None, &mut referenced, &mut visited);
                 }
                 if let Some(ty) = &func.result {
                     walk_type(resolve, ty, None, &mut referenced, &mut visited);
@@ -325,7 +325,7 @@ fn walk_type(
             walk_type(resolve, k, home_interface, referenced, visited);
             walk_type(resolve, v, home_interface, referenced, visited);
         }
-        TypeDefKind::FixedSizeList(t, _) => {
+        TypeDefKind::FixedLengthList(t, _) => {
             walk_type(resolve, t, home_interface, referenced, visited);
         }
         TypeDefKind::Flags(_)