build fixes and cleanup

2023-08-31 22:01:00 -04:00
parent 779532b624
commit 9aeec3cfa8
21 changed files with 160 additions and 186 deletions
--- a/veilid-core/src/crypto/types/byte_array_types.rs
+++ b/veilid-core/src/crypto/types/byte_array_types.rs
@@ -293,17 +293,17 @@ macro_rules! byte_array_type {

 byte_array_type!(CryptoKey, CRYPTO_KEY_LENGTH, CRYPTO_KEY_LENGTH_ENCODED);

-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type PublicKey = CryptoKey;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type SecretKey = CryptoKey;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type HashDigest = CryptoKey;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type SharedSecret = CryptoKey;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type RouteId = CryptoKey;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type CryptoKeyDistance = CryptoKey;

 byte_array_type!(Signature, SIGNATURE_LENGTH, SIGNATURE_LENGTH_ENCODED);
--- a/veilid-core/src/crypto/types/crypto_typed.rs
+++ b/veilid-core/src/crypto/types/crypto_typed.rs
@@ -1,6 +1,7 @@
 use super::*;

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Tsify)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct CryptoTyped<K>
 where
    K: Clone
--- a/veilid-core/src/crypto/types/crypto_typed_group.rs
+++ b/veilid-core/src/crypto/types/crypto_typed_group.rs
@@ -1,8 +1,7 @@
 use super::*;

-#[derive(
-    Clone, Debug, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash, Default, Tsify,
-)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash, Default)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 #[serde(from = "Vec<CryptoTyped<K>>", into = "Vec<CryptoTyped<K>>")]
 // TODO: figure out hot to TS type this as `string`, since it's converted to string via the JSON API.
 pub struct CryptoTypedGroup<K = PublicKey>
--- a/veilid-core/src/crypto/types/mod.rs
+++ b/veilid-core/src/crypto/types/mod.rs
@@ -6,7 +6,7 @@ use core::fmt;
 use core::hash::Hash;

 /// Cryptography version fourcc code
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type CryptoKind = FourCC;

 /// Sort best crypto kinds first
@@ -52,24 +52,24 @@ pub use crypto_typed::*;
 pub use crypto_typed_group::*;
 pub use keypair::*;

-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedKey = CryptoTyped<PublicKey>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSecret = CryptoTyped<SecretKey>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedKeyPair = CryptoTyped<KeyPair>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSignature = CryptoTyped<Signature>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSharedSecret = CryptoTyped<SharedSecret>;

-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedKeyGroup = CryptoTypedGroup<PublicKey>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSecretGroup = CryptoTypedGroup<SecretKey>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedKeyPairGroup = CryptoTypedGroup<KeyPair>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSignatureGroup = CryptoTypedGroup<Signature>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TypedSharedSecretGroup = CryptoTypedGroup<SharedSecret>;
--- a/veilid-core/src/lib.rs
+++ b/veilid-core/src/lib.rs
@@ -56,6 +56,7 @@ mod table_store;
 mod veilid_api;
 mod veilid_config;
 mod veilid_layer_filter;
+mod wasm_helpers;

 pub use self::api_tracing_layer::ApiTracingLayer;
 pub use self::core_context::{api_startup, api_startup_json, UpdateCallback};
@@ -126,7 +127,5 @@ use serde::*;
 use stop_token::*;
 use thiserror::Error as ThisError;
 use tracing::*;
-use tsify::*;
-use tsify_async::*;
 use veilid_tools::*;
-use wasm_bindgen::prelude::*;
+use wasm_helpers::*;
--- a/veilid-core/src/veilid_api/error.rs
+++ b/veilid-core/src/veilid_api/error.rs
@@ -105,21 +105,10 @@ macro_rules! apibail_already_initialized {
 }

 #[derive(
-    ThisError,
-    Clone,
-    Debug,
-    PartialOrd,
-    PartialEq,
-    Eq,
-    Ord,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    Tsify,
-    TsifyAsync,
+    ThisError, Clone, Debug, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema,
 )]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))]
 #[serde(tag = "kind")]
-#[tsify(into_wasm_abi)]
 pub enum VeilidAPIError {
    #[error("Not initialized")]
    NotInitialized,
@@ -157,6 +146,7 @@ pub enum VeilidAPIError {
    #[error("Generic: {message}")]
    Generic { message: String },
 }
+from_impl_to_jsvalue!(VeilidAPIError);

 impl VeilidAPIError {
    pub fn not_initialized() -> Self {
@@ -225,7 +215,7 @@ impl VeilidAPIError {
    }
 }

-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type VeilidAPIResult<T> = Result<T, VeilidAPIError>;

 impl From<std::io::Error> for VeilidAPIError {
--- a/veilid-core/src/veilid_api/types/aligned_u64.rs
+++ b/veilid-core/src/veilid_api/types/aligned_u64.rs
@@ -6,19 +6,9 @@ use super::*;
 /// Supports serializing to string for JSON as well, since JSON can't handle 64-bit numbers to Javascript

 #[derive(
-    Clone,
-    Default,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Copy,
-    Hash,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    Tsify,
+    Clone, Default, PartialEq, Eq, PartialOrd, Ord, Copy, Hash, Serialize, Deserialize, JsonSchema,
 )]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 #[repr(C, align(8))]
 #[serde(transparent)]
 pub struct AlignedU64(
@@ -128,17 +118,17 @@ impl AlignedU64 {
 /////////////////////////////////////////////////////////////////////////////////////////////////////

 /// Microseconds since epoch
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type Timestamp = AlignedU64;
 pub fn get_aligned_timestamp() -> Timestamp {
    get_timestamp().into()
 }
 /// Microseconds duration
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type TimestampDuration = AlignedU64;
 /// Request/Response matching id
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type OperationId = AlignedU64;
 /// Number of bytes
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type ByteCount = AlignedU64;
--- a/veilid-core/src/veilid_api/types/app_message_call.rs
+++ b/veilid-core/src/veilid_api/types/app_message_call.rs
@@ -1,11 +1,12 @@
 use super::*;

 /// Direct statement blob passed to hosting application for processing
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidAppMessage {
    #[serde(with = "as_human_opt_string")]
    #[schemars(with = "Option<String>")]
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    sender: Option<TypedKey>,

    #[serde(with = "as_human_base64")]
@@ -30,11 +31,12 @@ impl VeilidAppMessage {
 }

 /// Direct question blob passed to hosting application for processing to send an eventual AppReply
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidAppCall {
    #[serde(with = "as_human_opt_string")]
    #[schemars(with = "Option<String>")]
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    sender: Option<TypedKey>,

    #[serde(with = "as_human_base64")]
--- a/veilid-core/src/veilid_api/types/dht/mod.rs
+++ b/veilid-core/src/veilid_api/types/dht/mod.rs
@@ -11,8 +11,8 @@ pub use value_data::*;
 pub use value_subkey_range_set::*;

 /// Value subkey
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type ValueSubkey = u32;
 /// Value sequence number
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type ValueSeqNum = u32;
--- a/veilid-core/src/veilid_api/types/dht/value_data.rs
+++ b/veilid-core/src/veilid_api/types/dht/value_data.rs
@@ -1,9 +1,8 @@
 use super::*;
 use veilid_api::VeilidAPIResult;

-#[derive(
-    Clone, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema, Tsify,
-)]
+#[derive(Clone, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct ValueData {
    /// An increasing sequence number to time-order the DHT record changes
    seq: ValueSeqNum,
--- a/veilid-core/src/veilid_api/types/fourcc.rs
+++ b/veilid-core/src/veilid_api/types/fourcc.rs
@@ -2,19 +2,9 @@ use super::*;

 /// FOURCC code
 #[derive(
-    Copy,
-    Default,
-    Clone,
-    Hash,
-    PartialOrd,
-    Ord,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    Tsify,
+    Copy, Default, Clone, Hash, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, JsonSchema,
 )]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 #[serde(try_from = "String")]
 #[serde(into = "String")]
 pub struct FourCC(pub [u8; 4]);
--- a/veilid-core/src/veilid_api/types/veilid_log.rs
+++ b/veilid-core/src/veilid_api/types/veilid_log.rs
@@ -2,9 +2,9 @@ use super::*;

 /// Log level for VeilidCore
 #[derive(
-    Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema, Tsify,
+    Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema,
 )]
-#[tsify(namespace)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(namespace))]
 pub enum VeilidLogLevel {
    Error = 1,
    Warn = 2,
@@ -80,10 +80,11 @@ impl fmt::Display for VeilidLogLevel {
    }
 }
 /// A VeilidCore log message with optional backtrace
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidLog {
    pub log_level: VeilidLogLevel,
    pub message: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub backtrace: Option<String>,
 }
--- a/veilid-core/src/veilid_api/types/veilid_state.rs
+++ b/veilid-core/src/veilid_api/types/veilid_state.rs
@@ -1,8 +1,12 @@
 use super::*;

 /// Attachment abstraction for network 'signal strength'
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema, Tsify)]
-#[tsify(namespace, from_wasm_abi, into_wasm_abi)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(
+    target_arch = "wasm32",
+    derive(Tsify),
+    tsify(namespace, from_wasm_abi, into_wasm_abi)
+)]
 pub enum AttachmentState {
    Detached = 0,
    Attaching = 1,
@@ -48,14 +52,16 @@ impl TryFrom<String> for AttachmentState {
    }
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidStateAttachment {
    pub state: AttachmentState,
    pub public_internet_ready: bool,
    pub local_network_ready: bool,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct PeerTableData {
    #[schemars(with = "Vec<String>")]
    pub node_ids: Vec<TypedKey>,
@@ -63,7 +69,8 @@ pub struct PeerTableData {
    pub peer_stats: PeerStats,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidStateNetwork {
    pub started: bool,
    pub bps_down: ByteCount,
@@ -71,7 +78,8 @@ pub struct VeilidStateNetwork {
    pub peers: Vec<PeerTableData>,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidRouteChange {
    #[schemars(with = "Vec<String>")]
    pub dead_routes: Vec<RouteId>,
@@ -79,12 +87,14 @@ pub struct VeilidRouteChange {
    pub dead_remote_routes: Vec<RouteId>,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidStateConfig {
    pub config: VeilidConfigInner,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidValueChange {
    #[schemars(with = "String")]
    pub key: TypedKey,
@@ -93,9 +103,9 @@ pub struct VeilidValueChange {
    pub value: ValueData,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify, TsifyAsync)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))]
 #[serde(tag = "kind")]
-#[tsify(into_wasm_abi)]
 pub enum VeilidUpdate {
    Log(VeilidLog),
    AppMessage(VeilidAppMessage),
@@ -107,11 +117,13 @@ pub enum VeilidUpdate {
    ValueChange(VeilidValueChange),
    Shutdown,
 }
+from_impl_to_jsvalue!(VeilidUpdate);

-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify, TsifyAsync)]
-#[tsify(into_wasm_abi)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))]
 pub struct VeilidState {
    pub attachment: VeilidStateAttachment,
    pub network: VeilidStateNetwork,
    pub config: VeilidStateConfig,
 }
+from_impl_to_jsvalue!(VeilidState);
--- a/veilid-core/src/veilid_config.rs
+++ b/veilid-core/src/veilid_config.rs
@@ -1,9 +1,9 @@
 use crate::*;

 ////////////////////////////////////////////////////////////////////////////////////////////////
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type ConfigCallbackReturn = VeilidAPIResult<Box<dyn core::any::Any + Send>>;
-#[declare]
+#[cfg_attr(target_arch = "wasm32", declare)]
 pub type ConfigCallback = Arc<dyn Fn(String) -> ConfigCallbackReturn + Send + Sync>;

 /// Enable and configure HTTPS access to the Veilid node
@@ -16,12 +16,13 @@ pub type ConfigCallback = Arc<dyn Fn(String) -> ConfigCallbackReturn + Send + Sy
 ///     url: 'https://localhost:5150'
 /// ```
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigHTTPS {
    pub enabled: bool,
    pub listen_address: String,
    pub path: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub url: Option<String>, // Fixed URL is not optional for TLS-based protocols and is dynamically validated
 }

@@ -35,12 +36,13 @@ pub struct VeilidConfigHTTPS {
 ///     url: 'https://localhost:5150'
 /// ```
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigHTTP {
    pub enabled: bool,
    pub listen_address: String,
    pub path: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub url: Option<String>,
 }

@@ -50,7 +52,8 @@ pub struct VeilidConfigHTTP {
 ///
 /// To be implemented...
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigApplication {
    pub https: VeilidConfigHTTPS,
    pub http: VeilidConfigHTTP,
@@ -66,12 +69,13 @@ pub struct VeilidConfigApplication {
 ///     public_address: ''
 /// ```
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigUDP {
    pub enabled: bool,
    pub socket_pool_size: u32,
    pub listen_address: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub public_address: Option<String>,
 }

@@ -85,13 +89,14 @@ pub struct VeilidConfigUDP {
 ///     listen_address: ':5150'
 ///     public_address: ''
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigTCP {
    pub connect: bool,
    pub listen: bool,
    pub max_connections: u32,
    pub listen_address: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub public_address: Option<String>,
 }

@@ -106,7 +111,8 @@ pub struct VeilidConfigTCP {
 ///     path: 'ws'
 ///     url: 'ws://localhost:5150/ws'
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]

 pub struct VeilidConfigWS {
    pub connect: bool,
@@ -114,7 +120,7 @@ pub struct VeilidConfigWS {
    pub max_connections: u32,
    pub listen_address: String,
    pub path: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub url: Option<String>,
 }

@@ -129,7 +135,8 @@ pub struct VeilidConfigWS {
 ///     path: 'ws'
 ///     url: ''
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]

 pub struct VeilidConfigWSS {
    pub connect: bool,
@@ -137,7 +144,7 @@ pub struct VeilidConfigWSS {
    pub max_connections: u32,
    pub listen_address: String,
    pub path: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub url: Option<String>, // Fixed URL is not optional for TLS-based protocols and is dynamically validated
 }

@@ -148,7 +155,8 @@ pub struct VeilidConfigWSS {
 /// All protocols are available by default, and the Veilid node will
 /// sort out which protocol is used for each peer connection.
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]

 pub struct VeilidConfigProtocol {
    pub udp: VeilidConfigUDP,
@@ -165,7 +173,8 @@ pub struct VeilidConfigProtocol {
 ///     private_key_path: /path/to/private/key
 ///     connection_initial_timeout_ms: 2000
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigTLS {
    pub certificate_path: String,
    pub private_key_path: String,
@@ -174,7 +183,8 @@ pub struct VeilidConfigTLS {

 /// Configure the Distributed Hash Table (DHT)
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigDHT {
    pub max_find_node_count: u32,
    pub resolve_node_timeout_ms: u32,
@@ -199,13 +209,14 @@ pub struct VeilidConfigDHT {

 /// Configure RPC
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigRPC {
    pub concurrency: u32,
    pub queue_size: u32,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub max_timestamp_behind_ms: Option<u32>,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub max_timestamp_ahead_ms: Option<u32>,
    pub timeout_ms: u32,
    pub max_route_hop_count: u8,
@@ -214,7 +225,8 @@ pub struct VeilidConfigRPC {

 /// Configure the network routing table
 ///
-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigRoutingTable {
    #[schemars(with = "Vec<String>")]
    pub node_id: TypedKeyGroup,
@@ -230,7 +242,8 @@ pub struct VeilidConfigRoutingTable {
    // xxx pub enable_local_network: bool,
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigNetwork {
    pub connection_initial_timeout_ms: u32,
    pub connection_inactivity_timeout_ms: u32,
@@ -241,7 +254,7 @@ pub struct VeilidConfigNetwork {
    pub client_whitelist_timeout_ms: u32,
    pub reverse_connection_receipt_time_ms: u32,
    pub hole_punch_receipt_time_ms: u32,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub network_key_password: Option<String>,
    pub routing_table: VeilidConfigRoutingTable,
    pub rpc: VeilidConfigRPC,
@@ -254,36 +267,41 @@ pub struct VeilidConfigNetwork {
    pub protocol: VeilidConfigProtocol,
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigTableStore {
    pub directory: String,
    pub delete: bool,
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigBlockStore {
    pub directory: String,
    pub delete: bool,
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigProtectedStore {
    pub allow_insecure_fallback: bool,
    pub always_use_insecure_storage: bool,
    pub directory: String,
    pub delete: bool,
    pub device_encryption_key_password: String,
-    #[tsify(optional)]
+    #[cfg_attr(target_arch = "wasm32", tsify(optional))]
    pub new_device_encryption_key_password: Option<String>,
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigCapabilities {
    pub disable: Vec<FourCC>,
 }

-#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, JsonSchema, Tsify)]
-#[tsify(namespace, from_wasm_abi)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
+#[cfg_attr(target_arch = "wasm32", tsify(namespace, from_wasm_abi))]
 pub enum VeilidConfigLogLevel {
    Off,
    Error,
@@ -370,7 +388,8 @@ impl fmt::Display for VeilidConfigLogLevel {
    }
 }

-#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[cfg_attr(target_arch = "wasm32", derive(Tsify))]
 pub struct VeilidConfigInner {
    pub program_name: String,
    pub namespace: String,
--- a/veilid-core/src/wasm_helpers.rs
+++ b/veilid-core/src/wasm_helpers.rs
@@ -0,0 +1,21 @@
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "wasm32")] {
+        pub use tsify::*;
+        pub use wasm_bindgen::prelude::*;
+
+        macro_rules! from_impl_to_jsvalue {
+            ($name: ident) => {
+                impl From<$name> for JsValue {
+                    fn from(value: $name) -> Self {
+                        serde_wasm_bindgen::to_value(&value).unwrap()
+                    }
+                }
+            }
+        }
+    } else {
+        macro_rules! from_impl_to_jsvalue {
+            ($name: ident) => {}
+        }
+    }
+}
+pub(crate) use from_impl_to_jsvalue;