From a67d67cc66f157bb67a2269e5448239f4f256e8a Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Tue, 10 Jun 2025 16:17:52 -0700 Subject: [PATCH 1/4] bump wit-bindgen to 0.42.1 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index b05a2e1..be91419 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,4 +37,4 @@ tracing = { version = "0.1", optional = true } tracing-error = { version = "0.2", optional = true } tracing-subscriber = { version = "0.3", features = ["env-filter", "json", "std"], optional = true } url = "2.4.1" -wit-bindgen = "0.36.0" +wit-bindgen = "0.42.1" From 70d3fc4b3448f4e2922c117a5c43a61a6a5cba10 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Tue, 10 Jun 2025 16:45:28 -0700 Subject: [PATCH 2/4] fix type error --- Cargo.lock | 69 +++++++++++++++++--------------------------- src/types/request.rs | 2 +- 2 files changed, 28 insertions(+), 43 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c2cde4e..9b4a8ba 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1401,9 +1401,6 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" -dependencies = [ - "ahash", -] [[package]] name = "hashbrown" @@ -1835,10 +1832,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] -name = "leb128" -version = "0.2.5" +name = "leb128fmt" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" @@ -2850,15 +2847,6 @@ dependencies = [ "windows-sys 0.52.0", ] -[[package]] -name = "spdx" -version = "0.10.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bae30cc7bfe3656d60ee99bf6836f472b0c53dddcbf335e253329abb16e535a2" -dependencies = [ - "smallvec", -] - [[package]] name = "spki" version = "0.7.3" @@ -3437,39 +3425,34 @@ checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6" [[package]] name = "wasm-encoder" -version = "0.220.0" +version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebf48234b389415b226a4daef6562933d38c7b28a8b8f64c5c4130dad1561ab7" +checksum = "d4349d0943718e6e434b51b9639e876293093dca4b96384fb136ab5bd5ce6660" dependencies = [ - "leb128", + "leb128fmt", "wasmparser", ] [[package]] name = "wasm-metadata" -version = "0.220.0" +version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f3e5f5920c5abfc45573c89b07b38efdaae1515ef86f83dad12d60e50ecd62b" +checksum = "1a52e010df5494f4289ccc68ce0c2a8c17555225a5e55cc41b98f5ea28d0844b" dependencies = [ "anyhow", "indexmap", - "serde", - "serde_derive", - "serde_json", - "spdx", "wasm-encoder", "wasmparser", ] [[package]] name = "wasmparser" -version = "0.220.0" +version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e246c2772ce3ebc83f89a2d4487ac5794cad6c309b2071818a88c7db7c36d87b" +checksum = "808198a69b5a0535583370a51d459baa14261dfab04800c4864ee9e1a14346ed" dependencies = [ - "ahash", "bitflags", - "hashbrown 0.14.5", + "hashbrown 0.15.2", "indexmap", "semver 1.0.24", ] @@ -3643,9 +3626,9 @@ dependencies = [ [[package]] name = "wit-bindgen" -version = "0.36.0" +version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a2b3e15cd6068f233926e7d8c7c588b2ec4fb7cc7bf3824115e7c7e2a8485a3" +checksum = "fa5b79cd8cb4b27a9be3619090c03cbb87fe7b1c6de254b4c9b4477188828af8" dependencies = [ "wit-bindgen-rt", "wit-bindgen-rust-macro", @@ -3653,9 +3636,9 @@ dependencies = [ [[package]] name = "wit-bindgen-core" -version = "0.36.0" +version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b632a5a0fa2409489bd49c9e6d99fcc61bb3d4ce9d1907d44662e75a28c71172" +checksum = "e35e550f614e16db196e051d22b0d4c94dd6f52c90cb1016240f71b9db332631" dependencies = [ "anyhow", "heck", @@ -3664,18 +3647,20 @@ dependencies = [ [[package]] name = "wit-bindgen-rt" -version = "0.36.0" +version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7947d0131c7c9da3f01dfde0ab8bd4c4cf3c5bd49b6dba0ae640f1fa752572ea" +checksum = "051105bab12bc78e161f8dfb3596e772dd6a01ebf9c4840988e00347e744966a" dependencies = [ "bitflags", + "futures", + "once_cell", ] [[package]] name = "wit-bindgen-rust" -version = "0.36.0" +version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4329de4186ee30e2ef30a0533f9b3c123c019a237a7c82d692807bf1b3ee2697" +checksum = "cb1e0a91fc85f4ef70e0b81cd86c2b49539d3cd14766fd82396184aadf8cb7d7" dependencies = [ "anyhow", "heck", @@ -3689,9 +3674,9 @@ dependencies = [ [[package]] name = "wit-bindgen-rust-macro" -version = "0.36.0" +version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "177fb7ee1484d113b4792cc480b1ba57664bbc951b42a4beebe573502135b1fc" +checksum = "ce69f52c5737705881d5da5a1dd06f47f8098d094a8d65a3e44292942edb571f" dependencies = [ "anyhow", "prettyplease", @@ -3704,9 +3689,9 @@ dependencies = [ [[package]] name = "wit-component" -version = "0.220.0" +version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73ccedf54cc65f287da268d64d2bf4f7530d2cfb2296ffbe3ad5f65567e4cf53" +checksum = "b607b15ead6d0e87f5d1613b4f18c04d4e80ceeada5ffa608d8360e6909881df" dependencies = [ "anyhow", "bitflags", @@ -3723,9 +3708,9 @@ dependencies = [ [[package]] name = "wit-parser" -version = "0.220.0" +version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b7117ce3adc0b4354b46dc1cf3190b00b333e65243d244c613ffcc58bdec84d" +checksum = "679fde5556495f98079a8e6b9ef8c887f731addaffa3d48194075c1dd5cd611b" dependencies = [ "anyhow", "id-arena", diff --git a/src/types/request.rs b/src/types/request.rs index f8435eb..04838ab 100644 --- a/src/types/request.rs +++ b/src/types/request.rs @@ -280,7 +280,7 @@ impl Request { metadata: self.metadata, capabilities: self.capabilities, }, - self.context.as_ref(), + self.context.as_ref().map(|v| &**v), self.blob.as_ref(), ); Ok(()) From 1eada037fa7a968d9e92326f3d5593f343b35458 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Wed, 11 Jun 2025 07:03:19 -0700 Subject: [PATCH 3/4] hypermap, sign: fix de(ser) impls --- src/hypermap.rs | 112 ++++++++++++++++++++++++++++++------------------ src/sign.rs | 73 ++++++++++++++++++++++--------- 2 files changed, 122 insertions(+), 63 deletions(-) diff --git a/src/hypermap.rs b/src/hypermap.rs index eb09967..5e7b0af 100644 --- a/src/hypermap.rs +++ b/src/hypermap.rs @@ -1536,36 +1536,20 @@ impl Serialize for CacherRequest { S: Serializer, { match self { - CacherRequest::GetManifest => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("GetManifest", &())?; - map.end() - } + CacherRequest::GetManifest => serializer.serialize_str("GetManifest"), CacherRequest::GetLogCacheContent(path) => { let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("GetLogCacheContent", path)?; map.end() } - CacherRequest::GetStatus => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("GetStatus", &())?; - map.end() - } + CacherRequest::GetStatus => serializer.serialize_str("GetStatus"), CacherRequest::GetLogsByRange(request) => { let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("GetLogsByRange", request)?; map.end() } - CacherRequest::StartProviding => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("StartProviding", &())?; - map.end() - } - CacherRequest::StopProviding => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("StopProviding", &())?; - map.end() - } + CacherRequest::StartProviding => serializer.serialize_str("StartProviding"), + CacherRequest::StopProviding => serializer.serialize_str("StopProviding"), CacherRequest::SetNodes(nodes) => { let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("SetNodes", nodes)?; @@ -1591,8 +1575,32 @@ impl<'de> Deserialize<'de> for CacherRequest { type Value = CacherRequest; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter - .write_str("a map with a single key representing the CacherRequest variant") + formatter.write_str("a string for unit variants or a map for other variants") + } + + fn visit_str(self, value: &str) -> Result + where + E: de::Error, + { + match value { + "GetManifest" => Ok(CacherRequest::GetManifest), + "GetStatus" => Ok(CacherRequest::GetStatus), + "StartProviding" => Ok(CacherRequest::StartProviding), + "StopProviding" => Ok(CacherRequest::StopProviding), + _ => Err(de::Error::unknown_variant( + value, + &[ + "GetManifest", + "GetLogCacheContent", + "GetStatus", + "GetLogsByRange", + "StartProviding", + "StopProviding", + "SetNodes", + "Reset", + ], + )), + } } fn visit_map(self, mut map: A) -> Result @@ -1603,19 +1611,20 @@ impl<'de> Deserialize<'de> for CacherRequest { .next_entry::()? .ok_or_else(|| de::Error::invalid_length(0, &self))?; + // Ensure there are no extra entries + if map.next_entry::()?.is_some() { + return Err(de::Error::custom("unexpected extra entries in map")); + } + match variant.as_str() { - "GetManifest" => Ok(CacherRequest::GetManifest), "GetLogCacheContent" => { let path = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(CacherRequest::GetLogCacheContent(path)) } - "GetStatus" => Ok(CacherRequest::GetStatus), "GetLogsByRange" => { let request = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(CacherRequest::GetLogsByRange(request)) } - "StartProviding" => Ok(CacherRequest::StartProviding), - "StopProviding" => Ok(CacherRequest::StopProviding), "SetNodes" => { let nodes = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(CacherRequest::SetNodes(nodes)) @@ -1641,7 +1650,7 @@ impl<'de> Deserialize<'de> for CacherRequest { } } - deserializer.deserialize_map(CacherRequestVisitor) + deserializer.deserialize_any(CacherRequestVisitor) } } @@ -1681,16 +1690,8 @@ impl Serialize for CacherResponse { map.serialize_entry("StopProviding", result)?; map.end() } - CacherResponse::Rejected => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("Rejected", &())?; - map.end() - } - CacherResponse::IsStarting => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("IsStarting", &())?; - map.end() - } + CacherResponse::Rejected => serializer.serialize_str("Rejected"), + CacherResponse::IsStarting => serializer.serialize_str("IsStarting"), CacherResponse::SetNodes(result) => { let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("SetNodes", result)?; @@ -1716,8 +1717,32 @@ impl<'de> Deserialize<'de> for CacherResponse { type Value = CacherResponse; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter - .write_str("a map with a single key representing the CacherResponse variant") + formatter.write_str("a string for unit variants or a map for other variants") + } + + fn visit_str(self, value: &str) -> Result + where + E: de::Error, + { + match value { + "Rejected" => Ok(CacherResponse::Rejected), + "IsStarting" => Ok(CacherResponse::IsStarting), + _ => Err(de::Error::unknown_variant( + value, + &[ + "GetManifest", + "GetLogCacheContent", + "GetStatus", + "GetLogsByRange", + "StartProviding", + "StopProviding", + "Rejected", + "IsStarting", + "SetNodes", + "Reset", + ], + )), + } } fn visit_map(self, mut map: A) -> Result @@ -1728,6 +1753,11 @@ impl<'de> Deserialize<'de> for CacherResponse { .next_entry::()? .ok_or_else(|| de::Error::invalid_length(0, &self))?; + // Ensure there are no extra entries + if map.next_entry::()?.is_some() { + return Err(de::Error::custom("unexpected extra entries in map")); + } + match variant.as_str() { "GetManifest" => { let manifest = serde_json::from_value(value).map_err(de::Error::custom)?; @@ -1753,8 +1783,6 @@ impl<'de> Deserialize<'de> for CacherResponse { let result = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(CacherResponse::StopProviding(result)) } - "Rejected" => Ok(CacherResponse::Rejected), - "IsStarting" => Ok(CacherResponse::IsStarting), "SetNodes" => { let result = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(CacherResponse::SetNodes(result)) @@ -1782,7 +1810,7 @@ impl<'de> Deserialize<'de> for CacherResponse { } } - deserializer.deserialize_map(CacherResponseVisitor) + deserializer.deserialize_any(CacherResponseVisitor) } } diff --git a/src/sign.rs b/src/sign.rs index deea1af..7611425 100644 --- a/src/sign.rs +++ b/src/sign.rs @@ -124,7 +124,6 @@ impl<'de> Deserialize<'de> for NetKeyVerifyRequest { ) } } - impl Serialize for SignRequest { fn serialize(&self, serializer: S) -> Result where @@ -132,19 +131,18 @@ impl Serialize for SignRequest { { match self { SignRequest::NetKeySign => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("NetKeySign", &())?; - map.end() + // Unit variants serialize as just the variant name string + serializer.serialize_str("NetKeySign") } SignRequest::NetKeyVerify(request) => { + // Newtype variants serialize as {"VariantName": content} let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("NetKeyVerify", request)?; map.end() } SignRequest::NetKeyMakeMessage => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("NetKeyMakeMessage", &())?; - map.end() + // Unit variants serialize as just the variant name string + serializer.serialize_str("NetKeyMakeMessage") } } } @@ -161,7 +159,21 @@ impl<'de> Deserialize<'de> for SignRequest { type Value = SignRequest; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a map with a single key representing the SignRequest variant") + formatter.write_str("a string for unit variants or a map for other variants") + } + + fn visit_str(self, value: &str) -> Result + where + E: de::Error, + { + match value { + "NetKeySign" => Ok(SignRequest::NetKeySign), + "NetKeyMakeMessage" => Ok(SignRequest::NetKeyMakeMessage), + _ => Err(de::Error::unknown_variant( + value, + &["NetKeySign", "NetKeyVerify", "NetKeyMakeMessage"], + )), + } } fn visit_map(self, mut map: A) -> Result @@ -172,13 +184,16 @@ impl<'de> Deserialize<'de> for SignRequest { .next_entry::()? .ok_or_else(|| de::Error::invalid_length(0, &self))?; + // Ensure there are no extra entries + if map.next_entry::()?.is_some() { + return Err(de::Error::custom("unexpected extra entries in map")); + } + match variant.as_str() { - "NetKeySign" => Ok(SignRequest::NetKeySign), "NetKeyVerify" => { let request = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(SignRequest::NetKeyVerify(request)) } - "NetKeyMakeMessage" => Ok(SignRequest::NetKeyMakeMessage), _ => Err(de::Error::unknown_variant( &variant, &["NetKeySign", "NetKeyVerify", "NetKeyMakeMessage"], @@ -187,7 +202,7 @@ impl<'de> Deserialize<'de> for SignRequest { } } - deserializer.deserialize_map(SignRequestVisitor) + deserializer.deserialize_any(SignRequestVisitor) } } @@ -198,19 +213,18 @@ impl Serialize for SignResponse { { match self { SignResponse::NetKeySign => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("NetKeySign", &())?; - map.end() + // Unit variants serialize as just the variant name string + serializer.serialize_str("NetKeySign") } SignResponse::NetKeyVerify(valid) => { + // Newtype variants serialize as {"VariantName": content} let mut map = serializer.serialize_map(Some(1))?; map.serialize_entry("NetKeyVerify", valid)?; map.end() } SignResponse::NetKeyMakeMessage => { - let mut map = serializer.serialize_map(Some(1))?; - map.serialize_entry("NetKeyMakeMessage", &())?; - map.end() + // Unit variants serialize as just the variant name string + serializer.serialize_str("NetKeyMakeMessage") } } } @@ -227,7 +241,21 @@ impl<'de> Deserialize<'de> for SignResponse { type Value = SignResponse; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("a map with a single key representing the SignResponse variant") + formatter.write_str("a string for unit variants or a map for other variants") + } + + fn visit_str(self, value: &str) -> Result + where + E: de::Error, + { + match value { + "NetKeySign" => Ok(SignResponse::NetKeySign), + "NetKeyMakeMessage" => Ok(SignResponse::NetKeyMakeMessage), + _ => Err(de::Error::unknown_variant( + value, + &["NetKeySign", "NetKeyVerify", "NetKeyMakeMessage"], + )), + } } fn visit_map(self, mut map: A) -> Result @@ -238,13 +266,16 @@ impl<'de> Deserialize<'de> for SignResponse { .next_entry::()? .ok_or_else(|| de::Error::invalid_length(0, &self))?; + // Ensure there are no extra entries + if map.next_entry::()?.is_some() { + return Err(de::Error::custom("unexpected extra entries in map")); + } + match variant.as_str() { - "NetKeySign" => Ok(SignResponse::NetKeySign), "NetKeyVerify" => { let valid = serde_json::from_value(value).map_err(de::Error::custom)?; Ok(SignResponse::NetKeyVerify(valid)) } - "NetKeyMakeMessage" => Ok(SignResponse::NetKeyMakeMessage), _ => Err(de::Error::unknown_variant( &variant, &["NetKeySign", "NetKeyVerify", "NetKeyMakeMessage"], @@ -253,6 +284,6 @@ impl<'de> Deserialize<'de> for SignResponse { } } - deserializer.deserialize_map(SignResponseVisitor) + deserializer.deserialize_any(SignResponseVisitor) } } From 08410e8c90c2233e3637f92b1dc9670d90dd6c10 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Wed, 11 Jun 2025 07:41:09 -0700 Subject: [PATCH 4/4] update `wit-bindgen` note in README & lib.rs --- README.md | 3 ++- src/lib.rs | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5786bab..3486eac 100644 --- a/README.md +++ b/README.md @@ -10,9 +10,10 @@ See the [Hyperware Book](https://book.hyperware.ai) for a guide on how to use th ## Dependencies -`process_lib` v`1.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.36.0`. +`process_lib` v`2.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.42.1`. Processes depending on `process_lib` must also use that version. `process_lib` version | `wit-bindgen` version --------------------- | --------------------- +`2.x.y` | `0.42.1` `1.x.y` | `0.36.0` diff --git a/src/lib.rs b/src/lib.rs index 0333649..4134715 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,11 +13,12 @@ //! for applications that want to maximize composability and introspectability. //! For blobs, we recommend bincode to serialize and deserialize to bytes. //! -//! `process_lib` v`1.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.36.0`. +//! `process_lib` v`2.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.42.1`. //! Processes depending on `process_lib` must also use that version. //! //! `process_lib` version | `wit-bindgen` version //! --------------------- | --------------------- +//! `2.x.y` | `0.42.1` //! `1.x.y` | `0.36.0` //! pub use crate::hyperware::process::standard::*;