swapped cache impl to mini-moka, sync on native, unsync in a mutex on wasm

Cargo.lock

···
 ]
 
 [[package]]
-name = "async-lock"
-version = "3.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
-dependencies = [
- "event-listener",
- "event-listener-strategy",
- "pin-project-lite",
-]
-
-[[package]]
 name = "async-trait"
 version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
 
 [[package]]
-name = "concurrent-queue"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
 name = "console"
 version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "event-listener"
-version = "5.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
-dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener-strategy"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
-dependencies = [
- "event-listener",
- "pin-project-lite",
-]
-
-[[package]]
 name = "expect-json"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "jacquard-common",
  "jacquard-lexicon",
  "miette",
- "moka",
+ "mini-moka",
  "n0-future",
  "percent-encoding",
  "reqwest",
···
 ]
 
 [[package]]
+name = "mini-moka"
+version = "0.11.0"
+source = "git+https://github.com/moka-rs/mini-moka?rev=da864e849f5d034f32e02197fee9bb5d5af36d3d#da864e849f5d034f32e02197fee9bb5d5af36d3d"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-utils",
+ "dashmap",
+ "smallvec",
+ "tagptr",
+ "triomphe",
+]
+
+[[package]]
 name = "minimal-lexical"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "libc",
  "wasi",
  "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "moka"
-version = "0.12.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
-dependencies = [
- "async-lock",
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "equivalent",
- "event-listener",
- "futures-util",
- "parking_lot",
- "portable-atomic",
- "rustc_version",
- "smallvec",
- "tagptr",
- "uuid",
 ]
 
 [[package]]
···
  "flate2",
  "miniz_oxide 0.8.9",
 ]
-
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "potential_utf"
···
 ]
 
 [[package]]
+name = "triomphe"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd69c5aa8f924c7519d6372789a74eac5b94fb0f8fcf0d4a97eb0bfc3e785f39"
+
+[[package]]
 name = "try-lock"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
- "getrandom 0.3.4",
  "js-sys",
  "wasm-bindgen",
 ]

Cargo.toml

···
 multihash = "0.19"
 dashmap = "6.1"
 moka = "0.12"
+mini-moka = "0.10"
 
 # Proc macros
 proc-macro2 = "1.0"

crates/jacquard-identity/Cargo.toml

···
 dns = ["dep:hickory-resolver"]
 tracing = ["dep:tracing"]
 streaming = ["jacquard-common/streaming", "dep:n0-future"]
-cache = ["dep:moka"]
+cache = ["dep:mini-moka"]
 
 [dependencies]
 trait-variant.workspace = true
···
 urlencoding.workspace = true
 tracing = { workspace = true, optional = true }
 n0-future = { workspace = true, optional = true }
+mini-moka = { git = "https://github.com/moka-rs/mini-moka", rev = "da864e849f5d034f32e02197fee9bb5d5af36d3d", optional = true }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
-moka = { workspace = true, features = ["future"], optional = true }
 hickory-resolver = { optional = true, version = "0.24", default-features = false, features = ["system-config", "tokio-runtime"]}
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 

crates/jacquard-identity/src/lexicon_resolver.rs

···
         #[cfg(feature = "cache")]
         if let Some(caches) = &self.caches {
             let authority = jacquard_common::smol_str::SmolStr::from(nsid.domain_authority());
-            if let Some(did) = caches.authority_to_did.get(&authority).await {
+            if let Some(did) = crate::cache_impl::get(&caches.authority_to_did, &authority) {
                 return Ok(did);
             }
         }
···
                 if let Some(caches) = &self.caches {
                     let authority =
                         jacquard_common::smol_str::SmolStr::from(nsid.domain_authority());
-                    caches.authority_to_did.insert(authority, did.clone()).await;
+                    crate::cache_impl::insert(&caches.authority_to_did, authority, did.clone());
                 }
             }
             Err(_) => {
···
         #[cfg(feature = "cache")]
         if let Some(caches) = &self.caches {
             let key = nsid.clone().into_static();
-            if let Some(schema) = caches.nsid_to_schema.get(&key).await {
+            if let Some(schema) = crate::cache_impl::get(&caches.nsid_to_schema, &key) {
                 return Ok((*schema).clone());
             }
         }
···
                 // Cache successful resolution
                 #[cfg(feature = "cache")]
                 if let Some(caches) = &self.caches {
-                    caches
-                        .nsid_to_schema
-                        .insert(nsid.clone().into_static(), std::sync::Arc::new(schema.clone()))
-                        .await;
+                    crate::cache_impl::insert(
+                        &caches.nsid_to_schema,
+                        nsid.clone().into_static(),
+                        std::sync::Arc::new(schema.clone()),
+                    );
                 }
                 Ok(schema)
             }

crates/jacquard-identity/src/lib.rs

···
 use {
     crate::lexicon_resolver::ResolvedLexiconSchema,
     jacquard_common::{smol_str::SmolStr, types::string::Nsid},
-    moka::future::Cache,
     std::time::Duration,
 };
 
···
 ))]
 use std::sync::Arc;
 
+// Platform-specific cache implementations
+#[cfg(all(feature = "cache", not(target_arch = "wasm32")))]
+mod cache_impl {
+    /// Native: Use sync cache (thread-safe, no mutex needed)
+    pub type Cache<K, V> = mini_moka::sync::Cache<K, V>;
+
+    pub fn new_cache<K, V>(max_capacity: u64, ttl: std::time::Duration) -> Cache<K, V>
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        mini_moka::sync::Cache::builder()
+            .max_capacity(max_capacity)
+            .time_to_live(ttl)
+            .build()
+    }
+
+    pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.get(key)
+    }
+
+    pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.insert(key, value);
+    }
+
+    pub fn invalidate<K, V>(cache: &Cache<K, V>, key: &K)
+    where
+        K: std::hash::Hash + Eq + Send + Sync + 'static,
+        V: Clone + Send + Sync + 'static,
+    {
+        cache.invalidate(key);
+    }
+}
+
+#[cfg(all(feature = "cache", target_arch = "wasm32"))]
+mod cache_impl {
+    use std::sync::{Arc, Mutex};
+
+    /// WASM: Use unsync cache in Arc<Mutex<_>> (no threads, but need interior mutability)
+    pub type Cache<K, V> = Arc<Mutex<mini_moka::unsync::Cache<K, V>>>;
+
+    pub fn new_cache<K, V>(max_capacity: u64, ttl: std::time::Duration) -> Cache<K, V>
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        Arc::new(Mutex::new(
+            mini_moka::unsync::Cache::builder()
+                .max_capacity(max_capacity)
+                .time_to_live(ttl)
+                .build(),
+        ))
+    }
+
+    pub fn get<K, V>(cache: &Cache<K, V>, key: &K) -> Option<V>
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().get(key).cloned()
+    }
+
+    pub fn insert<K, V>(cache: &Cache<K, V>, key: K, value: V)
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().insert(key, value);
+    }
+
+    pub fn invalidate<K, V>(cache: &Cache<K, V>, key: &K)
+    where
+        K: std::hash::Hash + Eq + 'static,
+        V: Clone + 'static,
+    {
+        cache.lock().unwrap().invalidate(key);
+    }
+}
+
 /// Configuration for resolver caching
 #[cfg(feature = "cache")]
 #[derive(Clone, Debug)]
···
 #[cfg(feature = "cache")]
 #[derive(Clone)]
 pub struct ResolverCaches {
-    pub handle_to_did: Cache<Handle<'static>, Did<'static>>,
-    pub did_to_doc: Cache<Did<'static>, Arc<DidDocResponse>>,
-    pub authority_to_did: Cache<SmolStr, Did<'static>>,
-    pub nsid_to_schema: Cache<Nsid<'static>, Arc<ResolvedLexiconSchema<'static>>>,
+    pub handle_to_did: cache_impl::Cache<Handle<'static>, Did<'static>>,
+    pub did_to_doc: cache_impl::Cache<Did<'static>, Arc<DidDocResponse>>,
+    pub authority_to_did: cache_impl::Cache<SmolStr, Did<'static>>,
+    pub nsid_to_schema: cache_impl::Cache<Nsid<'static>, Arc<ResolvedLexiconSchema<'static>>>,
 }
 
 #[cfg(feature = "cache")]
 impl ResolverCaches {
     pub fn new(config: &CacheConfig) -> Self {
         Self {
-            handle_to_did: Cache::builder()
-                .max_capacity(config.handle_to_did_capacity)
-                .time_to_live(config.handle_to_did_ttl)
-                .build(),
-            did_to_doc: Cache::builder()
-                .max_capacity(config.did_to_doc_capacity)
-                .time_to_live(config.did_to_doc_ttl)
-                .build(),
-            authority_to_did: Cache::builder()
-                .max_capacity(config.authority_to_did_capacity)
-                .time_to_live(config.authority_to_did_ttl)
-                .build(),
-            nsid_to_schema: Cache::builder()
-                .max_capacity(config.nsid_to_schema_capacity)
-                .time_to_live(config.nsid_to_schema_ttl)
-                .build(),
+            handle_to_did: cache_impl::new_cache(
+                config.handle_to_did_capacity,
+                config.handle_to_did_ttl,
+            ),
+            did_to_doc: cache_impl::new_cache(config.did_to_doc_capacity, config.did_to_doc_ttl),
+            authority_to_did: cache_impl::new_cache(
+                config.authority_to_did_capacity,
+                config.authority_to_did_ttl,
+            ),
+            nsid_to_schema: cache_impl::new_cache(
+                config.nsid_to_schema_capacity,
+                config.nsid_to_schema_ttl,
+            ),
         }
     }
 }
···
         #[cfg(feature = "cache")]
         if let Some(caches) = &self.caches {
             let key = handle.clone().into_static();
-            if let Some(did) = caches.handle_to_did.get(&key).await {
+            if let Some(did) = cache_impl::get(&caches.handle_to_did, &key) {
                 return Ok(did);
             }
         }
···
             // Cache successful resolution
             #[cfg(feature = "cache")]
             if let Some(caches) = &self.caches {
-                caches
-                    .handle_to_did
-                    .insert(handle.clone().into_static(), did.clone())
-                    .await;
+                cache_impl::insert(
+                    &caches.handle_to_did,
+                    handle.clone().into_static(),
+                    did.clone(),
+                );
             }
             Ok(did)
         } else {
···
         #[cfg(feature = "cache")]
         if let Some(caches) = &self.caches {
             let key = did.clone().into_static();
-            if let Some(doc_resp) = caches.did_to_doc.get(&key).await {
+            if let Some(doc_resp) = cache_impl::get(&caches.did_to_doc, &key) {
                 return Ok((*doc_resp).clone());
             }
         }
···
             // Cache successful resolution
             #[cfg(feature = "cache")]
             if let Some(caches) = &self.caches {
-                caches
-                    .did_to_doc
-                    .insert(did.clone().into_static(), Arc::new(doc_resp.clone()))
-                    .await;
+                cache_impl::insert(
+                    &caches.did_to_doc,
+                    did.clone().into_static(),
+                    Arc::new(doc_resp.clone()),
+                );
             }
             Ok(doc_resp)
         } else {
···
     async fn invalidate_handle_chain(&self, handle: &Handle<'_>) {
         if let Some(caches) = &self.caches {
             let key = handle.clone().into_static();
-            caches.handle_to_did.invalidate(&key).await;
+            cache_impl::invalidate(&caches.handle_to_did, &key);
         }
     }
 
···
         if let Some(caches) = &self.caches {
             let did_key = did.clone().into_static();
             // Get doc before evicting to extract handles
-            if let Some(doc_resp) = caches.did_to_doc.get(&did_key).await {
+            if let Some(doc_resp) = cache_impl::get(&caches.did_to_doc, &did_key) {
                 let doc_resp_clone = (*doc_resp).clone();
                 if let Ok(doc) = doc_resp_clone.parse() {
                     if let Some(aliases) = &doc.also_known_as {
···
                             if let Some(handle_str) = alias.as_ref().strip_prefix("at://") {
                                 if let Ok(handle) = Handle::new(handle_str) {
                                     let handle_key = handle.into_static();
-                                    caches.handle_to_did.invalidate(&handle_key).await;
+                                    cache_impl::invalidate(&caches.handle_to_did, &handle_key);
                                 }
                             }
                         }
                     }
                 }
             }
-            caches.did_to_doc.invalidate(&did_key).await;
+            cache_impl::invalidate(&caches.did_to_doc, &did_key);
         }
     }
 
···
     async fn invalidate_authority_chain(&self, authority: &str) {
         if let Some(caches) = &self.caches {
             let authority = SmolStr::from(authority);
-            caches.authority_to_did.invalidate(&authority).await;
+            cache_impl::invalidate(&caches.authority_to_did, &authority);
         }
     }
 
···
     async fn invalidate_lexicon_chain(&self, nsid: &jacquard_common::types::string::Nsid<'_>) {
         if let Some(caches) = &self.caches {
             let nsid_key = nsid.clone().into_static();
-            if let Some(schema) = caches.nsid_to_schema.get(&nsid_key).await {
+            if let Some(schema) = cache_impl::get(&caches.nsid_to_schema, &nsid_key) {
                 let authority = SmolStr::from(nsid.domain_authority());
-                caches.authority_to_did.invalidate(&authority).await;
+                cache_impl::invalidate(&caches.authority_to_did, &authority);
                 self.invalidate_did_chain(&schema.repo).await;
             }
-            caches.nsid_to_schema.invalidate(&nsid_key).await;
+            cache_impl::invalidate(&caches.nsid_to_schema, &nsid_key);
         }
     }