diff --git a/Cargo.toml b/Cargo.toml
index 0fb928b5..5a731a1e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,17 +44,13 @@ unstable-debug-counters = ["future", "once_cell"]
 crossbeam-channel = "0.5.5"
 crossbeam-epoch = "0.9.9"
 crossbeam-utils = "0.8"
+moka-arc = { git = "https://gitlab.com/moka-labs/moka-gh440-remove-triomphe/moka-arc.git" }
 parking_lot = "0.12"
 smallvec = "1.8"
 tagptr = "0.2"
 thiserror = "1.0"
 uuid = { version = "1.1", features = ["v4"] }
 
-# Opt-out serde and stable_deref_trait features
-# https://github.com/Manishearth/triomphe/pull/5
-# 0.1.12 requires Rust 1.76
-triomphe = { version = ">=0.1.3, <0.1.12", default-features = false }
-
 # Optional dependencies (enabled by default)
 quanta = { version = "0.12.2", optional = true }
 
diff --git a/src/common/concurrent.rs b/src/common/concurrent.rs
index 2f7e6d8e..95686327 100644
--- a/src/common/concurrent.rs
+++ b/src/common/concurrent.rs
@@ -3,7 +3,7 @@ use crate::common::{deque::DeqNode, time::Instant};
 use parking_lot::Mutex;
 use std::{fmt, ptr::NonNull, sync::Arc};
 use tagptr::TagNonNull;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 pub(crate) mod constants;
 pub(crate) mod deques;
@@ -64,13 +64,13 @@ impl<K> Clone for KeyHash<K> {
 }
 
 pub(crate) struct KeyHashDate<K> {
-    entry_info: TrioArc<EntryInfo<K>>,
+    entry_info: MiniArc<EntryInfo<K>>,
 }
 
 impl<K> KeyHashDate<K> {
-    pub(crate) fn new(entry_info: &TrioArc<EntryInfo<K>>) -> Self {
+    pub(crate) fn new(entry_info: &MiniArc<EntryInfo<K>>) -> Self {
         Self {
-            entry_info: TrioArc::clone(entry_info),
+            entry_info: MiniArc::clone(entry_info),
         }
     }
 
@@ -101,11 +101,11 @@ impl<K> KeyHashDate<K> {
 
 pub(crate) struct KvEntry<K, V> {
     pub(crate) key: Arc<K>,
-    pub(crate) entry: TrioArc<ValueEntry<K, V>>,
+    pub(crate) entry: MiniArc<ValueEntry<K, V>>,
 }
 
 impl<K, V> KvEntry<K, V> {
-    pub(crate) fn new(key: Arc<K>, entry: TrioArc<ValueEntry<K, V>>) -> Self {
+    pub(crate) fn new(key: Arc<K>, entry: MiniArc<ValueEntry<K, V>>) -> Self {
         Self { key, entry }
     }
 }
@@ -114,7 +114,7 @@ impl<K, V> Clone for KvEntry<K, V> {
     fn clone(&self) -> Self {
         Self {
             key: Arc::clone(&self.key),
-            entry: TrioArc::clone(&self.entry),
+            entry: MiniArc::clone(&self.entry),
         }
     }
 }
@@ -177,33 +177,33 @@ impl<K> DeqNodes<K> {
 
 pub(crate) struct ValueEntry<K, V> {
     pub(crate) value: V,
-    info: TrioArc<EntryInfo<K>>,
-    nodes: TrioArc<Mutex<DeqNodes<K>>>,
+    info: MiniArc<EntryInfo<K>>,
+    nodes: MiniArc<Mutex<DeqNodes<K>>>,
 }
 
 impl<K, V> ValueEntry<K, V> {
-    pub(crate) fn new(value: V, entry_info: TrioArc<EntryInfo<K>>) -> Self {
+    pub(crate) fn new(value: V, entry_info: MiniArc<EntryInfo<K>>) -> Self {
         #[cfg(feature = "unstable-debug-counters")]
         self::debug_counters::InternalGlobalDebugCounters::value_entry_created();
 
         Self {
             value,
             info: entry_info,
-            nodes: TrioArc::new(Mutex::new(DeqNodes::default())),
+            nodes: MiniArc::new(Mutex::new(DeqNodes::default())),
         }
     }
 
-    pub(crate) fn new_from(value: V, entry_info: TrioArc<EntryInfo<K>>, other: &Self) -> Self {
+    pub(crate) fn new_from(value: V, entry_info: MiniArc<EntryInfo<K>>, other: &Self) -> Self {
         #[cfg(feature = "unstable-debug-counters")]
         self::debug_counters::InternalGlobalDebugCounters::value_entry_created();
         Self {
             value,
             info: entry_info,
-            nodes: TrioArc::clone(&other.nodes),
+            nodes: MiniArc::clone(&other.nodes),
         }
     }
 
-    pub(crate) fn entry_info(&self) -> &TrioArc<EntryInfo<K>> {
+    pub(crate) fn entry_info(&self) -> &MiniArc<EntryInfo<K>> {
         &self.info
     }
 
@@ -224,7 +224,7 @@ impl<K, V> ValueEntry<K, V> {
         self.info.policy_weight()
     }
 
-    pub(crate) fn deq_nodes(&self) -> &TrioArc<Mutex<DeqNodes<K>>> {
+    pub(crate) fn deq_nodes(&self) -> &MiniArc<Mutex<DeqNodes<K>>> {
         &self.nodes
     }
 
@@ -278,7 +278,7 @@ impl<K, V> Drop for ValueEntry<K, V> {
     }
 }
 
-impl<K, V> AccessTime for TrioArc<ValueEntry<K, V>> {
+impl<K, V> AccessTime for MiniArc<ValueEntry<K, V>> {
     #[inline]
     fn last_accessed(&self) -> Option<Instant> {
         self.info.last_accessed()
@@ -302,7 +302,7 @@ impl<K, V> AccessTime for TrioArc<ValueEntry<K, V>> {
 
 pub(crate) enum ReadOp<K, V> {
     Hit {
-        value_entry: TrioArc<ValueEntry<K, V>>,
+        value_entry: MiniArc<ValueEntry<K, V>>,
         is_expiry_modified: bool,
     },
     // u64 is the hash of the key.
@@ -312,7 +312,7 @@ pub(crate) enum ReadOp<K, V> {
 pub(crate) enum WriteOp<K, V> {
     Upsert {
         key_hash: KeyHash<K>,
-        value_entry: TrioArc<ValueEntry<K, V>>,
+        value_entry: MiniArc<ValueEntry<K, V>>,
         /// Entry generation after the operation.
         entry_gen: u16,
         old_weight: u32,
@@ -324,7 +324,7 @@ pub(crate) enum WriteOp<K, V> {
     },
 }
 
-/// Cloning a `WriteOp` is safe and cheap because it uses `Arc` and `TrioArc` pointers to
+/// Cloning a `WriteOp` is safe and cheap because it uses `Arc` and `MiniArc` pointers to
 /// the actual data.
 impl<K, V> Clone for WriteOp<K, V> {
     fn clone(&self) -> Self {
@@ -337,7 +337,7 @@ impl<K, V> Clone for WriteOp<K, V> {
                 new_weight,
             } => Self::Upsert {
                 key_hash: key_hash.clone(),
-                value_entry: TrioArc::clone(value_entry),
+                value_entry: MiniArc::clone(value_entry),
                 entry_gen: *entry_gen,
                 old_weight: *old_weight,
                 new_weight: *new_weight,
@@ -366,13 +366,13 @@ impl<K, V> WriteOp<K, V> {
     pub(crate) fn new_upsert(
         key: &Arc<K>,
         hash: u64,
-        value_entry: &TrioArc<ValueEntry<K, V>>,
+        value_entry: &MiniArc<ValueEntry<K, V>>,
         entry_generation: u16,
         old_weight: u32,
         new_weight: u32,
     ) -> Self {
         let key_hash = KeyHash::new(Arc::clone(key), hash);
-        let value_entry = TrioArc::clone(value_entry);
+        let value_entry = MiniArc::clone(value_entry);
         Self::Upsert {
             key_hash,
             value_entry,
@@ -384,15 +384,15 @@ impl<K, V> WriteOp<K, V> {
 }
 
 pub(crate) struct OldEntryInfo<K, V> {
-    pub(crate) entry: TrioArc<ValueEntry<K, V>>,
+    pub(crate) entry: MiniArc<ValueEntry<K, V>>,
     pub(crate) last_accessed: Option<Instant>,
     pub(crate) last_modified: Option<Instant>,
 }
 
 impl<K, V> OldEntryInfo<K, V> {
-    pub(crate) fn new(entry: &TrioArc<ValueEntry<K, V>>) -> Self {
+    pub(crate) fn new(entry: &MiniArc<ValueEntry<K, V>>) -> Self {
         Self {
-            entry: TrioArc::clone(entry),
+            entry: MiniArc::clone(entry),
             last_accessed: entry.last_accessed(),
             last_modified: entry.last_modified(),
         }
diff --git a/src/common/concurrent/deques.rs b/src/common/concurrent/deques.rs
index 424fc104..37245b1e 100644
--- a/src/common/concurrent/deques.rs
+++ b/src/common/concurrent/deques.rs
@@ -6,7 +6,8 @@ use crate::common::{
 
 use std::ptr::NonNull;
 use tagptr::TagNonNull;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
+
 pub(crate) struct Deques<K> {
     pub(crate) window: Deque<KeyHashDate<K>>, //    Not used yet.
     pub(crate) probation: Deque<KeyHashDate<K>>,
@@ -50,7 +51,7 @@ impl<K> Deques<K> {
         &mut self,
         region: CacheRegion,
         khd: KeyHashDate<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         let node = Box::new(DeqNode::new(khd));
         let node = match region {
@@ -66,14 +67,14 @@ impl<K> Deques<K> {
     pub(crate) fn push_back_wo<V>(
         &mut self,
         kd: KeyHashDate<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         let node = Box::new(DeqNode::new(kd));
         let node = self.write_order.push_back(node);
         entry.set_write_order_q_node(Some(node));
     }
 
-    pub(crate) fn move_to_back_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_ao<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(tagged_node) = entry.access_order_q_node() {
             let (node, tag) = tagged_node.decompose();
             let p = unsafe { node.as_ref() };
@@ -95,7 +96,7 @@ impl<K> Deques<K> {
     pub(crate) fn move_to_back_ao_in_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(tagged_node) = entry.access_order_q_node() {
             let (node, tag) = tagged_node.decompose();
@@ -111,7 +112,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn move_to_back_wo<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
             if self.write_order.contains(p) {
@@ -122,7 +123,7 @@ impl<K> Deques<K> {
 
     pub(crate) fn move_to_back_wo_in_deque<V>(
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.write_order_q_node() {
             let p = unsafe { node.as_ref() };
@@ -132,7 +133,7 @@ impl<K> Deques<K> {
         }
     }
 
-    pub(crate) fn unlink_ao<V>(&mut self, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_ao<V>(&mut self, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_access_order_q_node() {
             self.unlink_node_ao(node);
         }
@@ -141,14 +142,14 @@ impl<K> Deques<K> {
     pub(crate) fn unlink_ao_from_deque<V>(
         deq_name: &str,
         deq: &mut Deque<KeyHashDate<K>>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) {
         if let Some(node) = entry.take_access_order_q_node() {
             unsafe { Self::unlink_node_ao_from_deque(deq_name, deq, node) };
         }
     }
 
-    pub(crate) fn unlink_wo<V>(deq: &mut Deque<KeyHashDate<K>>, entry: &TrioArc<ValueEntry<K, V>>) {
+    pub(crate) fn unlink_wo<V>(deq: &mut Deque<KeyHashDate<K>>, entry: &MiniArc<ValueEntry<K, V>>) {
         if let Some(node) = entry.take_write_order_q_node() {
             Self::unlink_node_wo(deq, node);
         }
diff --git a/src/common/timer_wheel.rs b/src/common/timer_wheel.rs
index aa78affa..73add563 100644
--- a/src/common/timer_wheel.rs
+++ b/src/common/timer_wheel.rs
@@ -20,7 +20,7 @@ use super::{
 };
 
 use parking_lot::Mutex;
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 const BUCKET_COUNTS: &[u64] = &[
     64, // roughly seconds
@@ -69,16 +69,16 @@ pub(crate) enum TimerNode<K> {
         /// The position (level and index) of the timer wheel bucket.
         pos: Option<(u8, u8)>,
         /// An Arc pointer to the `EntryInfo` of the cache entry (`ValueEntry`).
-        entry_info: TrioArc<EntryInfo<K>>,
+        entry_info: MiniArc<EntryInfo<K>>,
         /// An Arc pointer to the `DeqNodes` of the cache entry (`ValueEntry`).
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
     },
 }
 
 impl<K> TimerNode<K> {
     fn new(
-        entry_info: TrioArc<EntryInfo<K>>,
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        entry_info: MiniArc<EntryInfo<K>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
         level: usize,
         index: usize,
     ) -> Self {
@@ -118,7 +118,7 @@ impl<K> TimerNode<K> {
         matches!(self, Self::Sentinel)
     }
 
-    pub(crate) fn entry_info(&self) -> &TrioArc<EntryInfo<K>> {
+    pub(crate) fn entry_info(&self) -> &MiniArc<EntryInfo<K>> {
         if let Self::Entry { entry_info, .. } = &self {
             entry_info
         } else {
@@ -209,8 +209,8 @@ impl<K> TimerWheel<K> {
     /// Schedules a timer event for the node.
     pub(crate) fn schedule(
         &mut self,
-        entry_info: TrioArc<EntryInfo<K>>,
-        deq_nodes: TrioArc<Mutex<DeqNodes<K>>>,
+        entry_info: MiniArc<EntryInfo<K>>,
+        deq_nodes: MiniArc<Mutex<DeqNodes<K>>>,
     ) -> Option<NonNull<DeqNode<TimerNode<K>>>> {
         debug_assert!(self.is_enabled());
 
@@ -397,7 +397,7 @@ pub(crate) enum TimerEvent<K> {
     // from one wheel to another in a lower level of the hierarchy. (This variant
     // is mainly used for testing)
     #[cfg(test)]
-    Rescheduled(TrioArc<EntryInfo<K>>),
+    Rescheduled(MiniArc<EntryInfo<K>>),
     #[cfg(not(test))]
     Rescheduled(()),
     /// This timer node (containing a cache entry) has been removed from the timer.
@@ -517,7 +517,7 @@ impl<'iter, K> Iterator for TimerEventsIter<'iter, K> {
                     // Get the entry info before rescheduling (mutating) the node to
                     // avoid Stacked Borrows/Tree Borrows violations on `node_p`.
                     let entry_info =
-                        TrioArc::clone(unsafe { node_p.as_ref() }.element.entry_info());
+                        MiniArc::clone(unsafe { node_p.as_ref() }.element.entry_info());
 
                     match self.timer_wheel.schedule_existing_node(node_p) {
                         ReschedulingResult::Rescheduled => {
@@ -564,7 +564,7 @@ mod tests {
         time::{CheckedTimeOps, Clock, Instant, Mock},
     };
 
-    use triomphe::Arc as TrioArc;
+    use moka_arc::MiniArc;
 
     #[test]
     fn test_bucket_indices() {
@@ -654,10 +654,10 @@ mod tests {
             let hash = key as u64;
             let key_hash = KeyHash::new(Arc::new(key), hash);
             let policy_weight = 0;
-            let entry_info = TrioArc::new(EntryInfo::new(key_hash, now, policy_weight));
+            let entry_info = MiniArc::new(EntryInfo::new(key_hash, now, policy_weight));
             entry_info.set_expiration_time(Some(now.checked_add(ttl).unwrap()));
             let deq_nodes = Default::default();
-            let timer_node = timer.schedule(entry_info, TrioArc::clone(&deq_nodes));
+            let timer_node = timer.schedule(entry_info, MiniArc::clone(&deq_nodes));
             deq_nodes.lock().set_timer_node(timer_node);
         }
 
diff --git a/src/future/base_cache.rs b/src/future/base_cache.rs
index 0c9d0a5f..f302b66a 100644
--- a/src/future/base_cache.rs
+++ b/src/future/base_cache.rs
@@ -51,7 +51,7 @@ use std::{
     },
     time::{Duration, Instant as StdInstant},
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 pub(crate) type HouseKeeperArc = Arc<Housekeeper>;
 
@@ -127,7 +127,7 @@ impl<K, V, S> BaseCache<K, V, S> {
     pub(crate) fn notify_invalidate(
         &self,
         key: &Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) -> BoxFuture<'static, ()>
     where
         K: Send + Sync + 'static,
@@ -335,7 +335,7 @@ where
                     let ent = Entry::new(maybe_key, entry.value.clone(), false, false);
                     let maybe_op = if record_read {
                         Some(ReadOp::Hit {
-                            value_entry: TrioArc::clone(entry),
+                            value_entry: MiniArc::clone(entry),
                             is_expiry_modified,
                         })
                     } else {
@@ -758,11 +758,11 @@ impl<K, V, S> BaseCache<K, V, S> {
         value: V,
         timestamp: Instant,
         policy_weight: u32,
-    ) -> (TrioArc<ValueEntry<K, V>>, u16) {
+    ) -> (MiniArc<ValueEntry<K, V>>, u16) {
         let key_hash = KeyHash::new(Arc::clone(key), hash);
-        let info = TrioArc::new(EntryInfo::new(key_hash, timestamp, policy_weight));
+        let info = MiniArc::new(EntryInfo::new(key_hash, timestamp, policy_weight));
         let gen: u16 = info.entry_gen();
-        (TrioArc::new(ValueEntry::new(value, info)), gen)
+        (MiniArc::new(ValueEntry::new(value, info)), gen)
     }
 
     #[inline]
@@ -772,15 +772,15 @@ impl<K, V, S> BaseCache<K, V, S> {
         timestamp: Instant,
         policy_weight: u32,
         other: &ValueEntry<K, V>,
-    ) -> (TrioArc<ValueEntry<K, V>>, u16) {
-        let info = TrioArc::clone(other.entry_info());
+    ) -> (MiniArc<ValueEntry<K, V>>, u16) {
+        let info = MiniArc::clone(other.entry_info());
         // To prevent this updated ValueEntry from being evicted by an expiration
         // policy, increment the entry generation.
         let gen = info.incr_entry_gen();
         info.set_last_accessed(timestamp);
         info.set_last_modified(timestamp);
         info.set_policy_weight(policy_weight);
-        (TrioArc::new(ValueEntry::new_from(value, info, other)), gen)
+        (MiniArc::new(ValueEntry::new_from(value, info, other)), gen)
     }
 
     fn expire_after_create(
@@ -901,7 +901,7 @@ impl<'a, K, V> EvictionState<'a, K, V> {
     async fn notify_entry_removal(
         &mut self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         cause: RemovalCause,
     ) where
         K: Send + Sync + 'static,
@@ -991,7 +991,7 @@ enum AdmissionResult<K> {
     Rejected,
 }
 
-type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, TrioArc<ValueEntry<K, V>>, S>;
+type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, MiniArc<ValueEntry<K, V>>, S>;
 
 struct Clocks {
     // Lock for this Clocks instance. Used when the `expiration_clock` is set.
@@ -1285,7 +1285,7 @@ where
     where
         K: Borrow<Q>,
         Q: Hash + Eq + ?Sized,
-        F: FnOnce(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> T,
+        F: FnOnce(&Arc<K>, &MiniArc<ValueEntry<K, V>>) -> T,
     {
         self.cache
             .get_key_value_and(hash, |k| (k as &K).borrow() == key, with_entry)
@@ -1296,7 +1296,7 @@ where
     where
         K: Borrow<Q>,
         Q: Hash + Eq + ?Sized,
-        F: FnOnce(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> Option<T>,
+        F: FnOnce(&Arc<K>, &MiniArc<ValueEntry<K, V>>) -> Option<T>,
     {
         self.cache
             .get_key_value_and_then(hash, |k| (k as &K).borrow() == key, with_entry)
@@ -1337,7 +1337,7 @@ where
 
     /// Returns `true` if the entry is invalidated by `invalidate_entries_if` method.
     #[inline]
-    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool
+    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>) -> bool
     where
         V: Clone,
     {
@@ -1667,7 +1667,7 @@ where
     async fn handle_upsert(
         &self,
         kh: KeyHash<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: u16,
         old_weight: u32,
         new_weight: u32,
@@ -1717,7 +1717,7 @@ where
                     kh.hash,
                     |k| k == &kh.key,
                     |_, current_entry| {
-                        TrioArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
+                        MiniArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
                             && current_entry.entry_info().entry_gen() == gen
                     },
                 );
@@ -1822,7 +1822,7 @@ where
                     kh.hash,
                     |k| k == &key,
                     |_, current_entry| {
-                        TrioArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
+                        MiniArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
                             && current_entry.entry_info().entry_gen() == gen
                     },
                 );
@@ -1926,7 +1926,7 @@ where
 
     fn handle_admit(
         &self,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         policy_weight: u32,
         deqs: &mut Deques<K>,
         timer_wheel: &mut TimerWheel<K>,
@@ -1951,7 +1951,7 @@ where
     /// NOTE: This method may enable the timer wheel.
     fn update_timer_wheel(
         &self,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         timer_wheel: &mut TimerWheel<K>,
     ) {
         // Enable the timer wheel if needed.
@@ -1971,8 +1971,8 @@ where
             // expiration time and not registered to the timer wheel.
             (true, None) => {
                 let timer = timer_wheel.schedule(
-                    TrioArc::clone(entry.entry_info()),
-                    TrioArc::clone(entry.deq_nodes()),
+                    MiniArc::clone(entry.entry_info()),
+                    MiniArc::clone(entry.deq_nodes()),
                 );
                 entry.set_timer_node(timer);
             }
@@ -2000,7 +2000,7 @@ where
     fn handle_remove(
         deqs: &mut Deques<K>,
         timer_wheel: &mut TimerWheel<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: Option<u16>,
         counters: &mut EvictionCounters,
     ) {
@@ -2012,7 +2012,7 @@ where
 
     fn handle_remove_without_timer_wheel(
         deqs: &mut Deques<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: Option<u16>,
         counters: &mut EvictionCounters,
     ) {
@@ -2035,7 +2035,7 @@ where
         ao_deq: &mut Deque<KeyHashDate<K>>,
         wo_deq: &mut Deque<KeyHashDate<K>>,
         timer_wheel: &mut TimerWheel<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         counters: &mut EvictionCounters,
     ) {
         if let Some(timer) = entry.take_timer_node() {
@@ -2576,7 +2576,7 @@ where
     pub(crate) async fn notify_single_removal(
         &self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         cause: RemovalCause,
     ) {
         if let Some(notifier) = &self.removal_notifier {
@@ -2588,7 +2588,7 @@ where
     fn notify_upsert(
         &self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         last_accessed: Option<Instant>,
         last_modified: Option<Instant>,
     ) -> BoxFuture<'static, ()> {
@@ -2629,7 +2629,7 @@ where
     fn notify_invalidate(
         &self,
         key: &Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
     ) -> BoxFuture<'static, ()> {
         use futures_util::future::FutureExt;
 
@@ -2715,7 +2715,7 @@ where
 
 /// Returns `true` if this entry is expired by its per-entry TTL.
 #[inline]
-fn is_expired_by_per_entry_ttl<K>(entry_info: &TrioArc<EntryInfo<K>>, now: Instant) -> bool {
+fn is_expired_by_per_entry_ttl<K>(entry_info: &MiniArc<EntryInfo<K>>, now: Instant) -> bool {
     if let Some(ts) = entry_info.expiration_time() {
         ts <= now
     } else {
diff --git a/src/future/invalidator.rs b/src/future/invalidator.rs
index 4c159f6c..27e8f1e2 100644
--- a/src/future/invalidator.rs
+++ b/src/future/invalidator.rs
@@ -16,7 +16,7 @@ use std::{
         Arc,
     },
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 use uuid::Uuid;
 
 pub(crate) type PredicateFun<K, V> = Arc<dyn Fn(&K, &V) -> bool + Send + Sync + 'static>;
@@ -141,7 +141,7 @@ impl<K, V, S> Invalidator<K, V, S> {
 
     // This method will be called by the get method of Cache.
     #[inline]
-    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool
+    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>) -> bool
     where
         K: Hash + Eq + Send + Sync + 'static,
         V: Clone + Send + Sync + 'static,
@@ -296,7 +296,7 @@ where
         key: &Arc<K>,
         hash: u64,
         ts: Instant,
-    ) -> Option<TrioArc<ValueEntry<K, V>>>
+    ) -> Option<MiniArc<ValueEntry<K, V>>>
     where
         K: Send + Sync + 'static,
         V: Clone + Send + Sync + 'static,
diff --git a/src/future/key_lock.rs b/src/future/key_lock.rs
index fc06ff2f..6449aa10 100644
--- a/src/future/key_lock.rs
+++ b/src/future/key_lock.rs
@@ -6,11 +6,11 @@ use std::{
 use crate::cht::SegmentedHashMap;
 
 use async_lock::{Mutex, MutexGuard};
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 const LOCK_MAP_NUM_SEGMENTS: usize = 64;
 
-type LockMap<K, S> = SegmentedHashMap<Arc<K>, TrioArc<Mutex<()>>, S>;
+type LockMap<K, S> = SegmentedHashMap<Arc<K>, MiniArc<Mutex<()>>, S>;
 
 // We need the `where` clause here because of the Drop impl.
 pub(crate) struct KeyLock<'a, K, S>
@@ -21,7 +21,7 @@ where
     map: &'a LockMap<K, S>,
     key: Arc<K>,
     hash: u64,
-    lock: TrioArc<Mutex<()>>,
+    lock: MiniArc<Mutex<()>>,
 }
 
 impl<'a, K, S> Drop for KeyLock<'a, K, S>
@@ -30,11 +30,11 @@ where
     S: BuildHasher,
 {
     fn drop(&mut self) {
-        if TrioArc::count(&self.lock) <= 2 {
+        if MiniArc::count(&self.lock) <= 2 {
             self.map.remove_if(
                 self.hash,
                 |k| k == &self.key,
-                |_k, v| TrioArc::count(v) <= 2,
+                |_k, v| MiniArc::count(v) <= 2,
             );
         }
     }
@@ -45,7 +45,7 @@ where
     K: Eq + Hash,
     S: BuildHasher,
 {
-    fn new(map: &'a LockMap<K, S>, key: &Arc<K>, hash: u64, lock: TrioArc<Mutex<()>>) -> Self {
+    fn new(map: &'a LockMap<K, S>, key: &Arc<K>, hash: u64, lock: MiniArc<Mutex<()>>) -> Self {
         Self {
             map,
             key: Arc::clone(key),
@@ -76,7 +76,7 @@ where
 
     pub(crate) fn key_lock(&self, key: &Arc<K>) -> KeyLock<'_, K, S> {
         let hash = self.locks.hash(key);
-        let kl = TrioArc::new(Mutex::new(()));
+        let kl = MiniArc::new(Mutex::new(()));
         match self
             .locks
             .insert_if_not_present(Arc::clone(key), hash, kl.clone())
diff --git a/src/future/value_initializer.rs b/src/future/value_initializer.rs
index 63b7a341..53d40929 100644
--- a/src/future/value_initializer.rs
+++ b/src/future/value_initializer.rs
@@ -8,7 +8,7 @@ use std::{
     pin::Pin,
     sync::Arc,
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 use crate::{
     ops::compute::{CompResult, Op},
@@ -49,7 +49,7 @@ impl<V> fmt::Debug for WaiterValue<V> {
     }
 }
 
-type Waiter<V> = TrioArc<RwLock<WaiterValue<V>>>;
+type Waiter<V> = MiniArc<RwLock<WaiterValue<V>>>;
 type WaiterMap<K, V, S> = crate::cht::SegmentedHashMap<(Arc<K>, TypeId), Waiter<V>, S>;
 
 struct WaiterGuard<'a, K, V, S>
@@ -116,7 +116,7 @@ pub(crate) struct ValueInitializer<K, V, S> {
     // try_get_with method. We use the type ID as a part of the key to ensure that we
     // can always downcast the trait object ErrorObject (in Waiter<V>) into its
     // concrete type.
-    waiters: TrioArc<WaiterMap<K, V, S>>,
+    waiters: MiniArc<WaiterMap<K, V, S>>,
 }
 
 impl<K, V, S> ValueInitializer<K, V, S>
@@ -127,7 +127,7 @@ where
 {
     pub(crate) fn with_hasher(hasher: S) -> Self {
         Self {
-            waiters: TrioArc::new(crate::cht::SegmentedHashMap::with_num_segments_and_hasher(
+            waiters: MiniArc::new(crate::cht::SegmentedHashMap::with_num_segments_and_hasher(
                 WAITER_MAP_NUM_SEGMENTS,
                 hasher,
             )),
@@ -172,7 +172,7 @@ where
 
         let (w_key, w_hash) = waiter_key_hash(&self.waiters, c_key, type_id);
 
-        let waiter = TrioArc::new(RwLock::new(WaiterValue::Computing));
+        let waiter = MiniArc::new(RwLock::new(WaiterValue::Computing));
         // NOTE: We have to acquire a write lock before `try_insert_waiter`,
         // so that any concurrent attempt will get our lock and wait on it.
         let lock = waiter.write().await;
@@ -281,7 +281,7 @@ where
 
         let type_id = TypeId::of::<ComputeNone>();
         let (w_key, w_hash) = waiter_key_hash(&self.waiters, &c_key, type_id);
-        let waiter = TrioArc::new(RwLock::new(WaiterValue::Computing));
+        let waiter = MiniArc::new(RwLock::new(WaiterValue::Computing));
         // NOTE: We have to acquire a write lock before `try_insert_waiter`,
         // so that any concurrent attempt will get our lock and wait on it.
         let lock = waiter.write().await;
@@ -482,7 +482,7 @@ where
     (Arc<K>, TypeId): Eq + Hash,
     S: BuildHasher,
 {
-    let waiter = TrioArc::clone(waiter);
+    let waiter = MiniArc::clone(waiter);
     waiter_map.insert_if_not_present(w_key, w_hash, waiter)
 }
 
diff --git a/src/sync/value_initializer.rs b/src/sync/value_initializer.rs
index f66aa9ef..90528f46 100644
--- a/src/sync/value_initializer.rs
+++ b/src/sync/value_initializer.rs
@@ -5,7 +5,7 @@ use std::{
     hash::{BuildHasher, Hash},
     sync::Arc,
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 use crate::{
     ops::compute::{CompResult, Op},
@@ -38,7 +38,7 @@ impl<V> fmt::Debug for WaiterValue<V> {
     }
 }
 
-type Waiter<V> = TrioArc<RwLock<WaiterValue<V>>>;
+type Waiter<V> = MiniArc<RwLock<WaiterValue<V>>>;
 
 pub(crate) enum InitResult<V, E> {
     Initialized(V),
@@ -96,7 +96,7 @@ where
 
         let (w_key, w_hash) = self.waiter_key_hash(key, type_id);
 
-        let waiter = TrioArc::new(RwLock::new(WaiterValue::Computing));
+        let waiter = MiniArc::new(RwLock::new(WaiterValue::Computing));
         let mut lock = waiter.write();
 
         loop {
@@ -194,7 +194,7 @@ where
 
         let type_id = TypeId::of::<ComputeNone>();
         let (w_key, w_hash) = self.waiter_key_hash(&c_key, type_id);
-        let waiter = TrioArc::new(RwLock::new(WaiterValue::Computing));
+        let waiter = MiniArc::new(RwLock::new(WaiterValue::Computing));
         // NOTE: We have to acquire a write lock before `try_insert_waiter`,
         // so that any concurrent attempt will get our lock and wait on it.
         let mut lock = waiter.write();
@@ -370,7 +370,7 @@ where
         w_hash: u64,
         waiter: &Waiter<V>,
     ) -> Option<Waiter<V>> {
-        let waiter = TrioArc::clone(waiter);
+        let waiter = MiniArc::clone(waiter);
         self.waiters.insert_if_not_present(w_key, w_hash, waiter)
     }
 
diff --git a/src/sync_base/base_cache.rs b/src/sync_base/base_cache.rs
index fe951d29..d262cd59 100644
--- a/src/sync_base/base_cache.rs
+++ b/src/sync_base/base_cache.rs
@@ -45,7 +45,7 @@ use std::{
     },
     time::{Duration, Instant as StdInstant},
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 pub(crate) type HouseKeeperArc = Arc<Housekeeper>;
 
@@ -109,7 +109,7 @@ impl<K, V, S> BaseCache<K, V, S> {
         self.inner.current_time_from_expiration_clock()
     }
 
-    pub(crate) fn notify_invalidate(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>)
+    pub(crate) fn notify_invalidate(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>)
     where
         K: Send + Sync + 'static,
         V: Clone + Send + Sync + 'static,
@@ -306,7 +306,7 @@ where
                 } else {
                     // Valid entry.
                     let maybe_key = if need_key { Some(Arc::clone(k)) } else { None };
-                    Some((maybe_key, TrioArc::clone(entry)))
+                    Some((maybe_key, MiniArc::clone(entry)))
                 }
             });
 
@@ -630,11 +630,11 @@ impl<K, V, S> BaseCache<K, V, S> {
         value: V,
         timestamp: Instant,
         policy_weight: u32,
-    ) -> (TrioArc<ValueEntry<K, V>>, u16) {
+    ) -> (MiniArc<ValueEntry<K, V>>, u16) {
         let key_hash = KeyHash::new(Arc::clone(key), hash);
-        let info = TrioArc::new(EntryInfo::new(key_hash, timestamp, policy_weight));
+        let info = MiniArc::new(EntryInfo::new(key_hash, timestamp, policy_weight));
         let gen: u16 = info.entry_gen();
-        (TrioArc::new(ValueEntry::new(value, info)), gen)
+        (MiniArc::new(ValueEntry::new(value, info)), gen)
     }
 
     #[inline]
@@ -644,15 +644,15 @@ impl<K, V, S> BaseCache<K, V, S> {
         timestamp: Instant,
         policy_weight: u32,
         other: &ValueEntry<K, V>,
-    ) -> (TrioArc<ValueEntry<K, V>>, u16) {
-        let info = TrioArc::clone(other.entry_info());
+    ) -> (MiniArc<ValueEntry<K, V>>, u16) {
+        let info = MiniArc::clone(other.entry_info());
         // To prevent this updated ValueEntry from being evicted by an expiration
         // policy, increment the entry generation.
         let gen = info.incr_entry_gen();
         info.set_last_accessed(timestamp);
         info.set_last_modified(timestamp);
         info.set_policy_weight(policy_weight);
-        (TrioArc::new(ValueEntry::new_from(value, info, other)), gen)
+        (MiniArc::new(ValueEntry::new_from(value, info, other)), gen)
     }
 
     fn expire_after_create(
@@ -773,7 +773,7 @@ impl<'a, K, V> EvictionState<'a, K, V> {
     fn notify_entry_removal(
         &mut self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         cause: RemovalCause,
     ) where
         K: Send + Sync + 'static,
@@ -863,7 +863,7 @@ enum AdmissionResult<K> {
     Rejected,
 }
 
-type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, TrioArc<ValueEntry<K, V>>, S>;
+type CacheStore<K, V, S> = crate::cht::SegmentedHashMap<Arc<K>, MiniArc<ValueEntry<K, V>>, S>;
 
 struct Clocks {
     has_expiration_clock: AtomicBool,
@@ -1140,7 +1140,7 @@ where
     where
         K: Borrow<Q>,
         Q: Hash + Eq + ?Sized,
-        F: FnOnce(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> T,
+        F: FnOnce(&Arc<K>, &MiniArc<ValueEntry<K, V>>) -> T,
     {
         self.cache
             .get_key_value_and(hash, |k| (k as &K).borrow() == key, with_entry)
@@ -1151,7 +1151,7 @@ where
     where
         K: Borrow<Q>,
         Q: Hash + Eq + ?Sized,
-        F: FnOnce(&Arc<K>, &TrioArc<ValueEntry<K, V>>) -> Option<T>,
+        F: FnOnce(&Arc<K>, &MiniArc<ValueEntry<K, V>>) -> Option<T>,
     {
         self.cache
             .get_key_value_and_then(hash, |k| (k as &K).borrow() == key, with_entry)
@@ -1192,7 +1192,7 @@ where
 
     /// Returns `true` if the entry is invalidated by `invalidate_entries_if` method.
     #[inline]
-    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool
+    fn is_invalidated_entry(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>) -> bool
     where
         V: Clone,
     {
@@ -1515,7 +1515,7 @@ where
     fn handle_upsert(
         &self,
         kh: KeyHash<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: u16,
         old_weight: u32,
         new_weight: u32,
@@ -1561,7 +1561,7 @@ where
                     kh.hash,
                     |k| k == &kh.key,
                     |_, current_entry| {
-                        TrioArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
+                        MiniArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
                             && current_entry.entry_info().entry_gen() == gen
                     },
                 );
@@ -1658,7 +1658,7 @@ where
                     kh.hash,
                     |k| k == &key,
                     |_, current_entry| {
-                        TrioArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
+                        MiniArc::ptr_eq(entry.entry_info(), current_entry.entry_info())
                             && current_entry.entry_info().entry_gen() == gen
                     },
                 );
@@ -1760,7 +1760,7 @@ where
 
     fn handle_admit(
         &self,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         policy_weight: u32,
         deqs: &mut Deques<K>,
         timer_wheel: &mut TimerWheel<K>,
@@ -1785,7 +1785,7 @@ where
     /// NOTE: This method may enable the timer wheel.
     fn update_timer_wheel(
         &self,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         timer_wheel: &mut TimerWheel<K>,
     ) {
         // Enable the timer wheel if needed.
@@ -1805,8 +1805,8 @@ where
             // expiration time and not registered to the timer wheel.
             (true, None) => {
                 let timer = timer_wheel.schedule(
-                    TrioArc::clone(entry.entry_info()),
-                    TrioArc::clone(entry.deq_nodes()),
+                    MiniArc::clone(entry.entry_info()),
+                    MiniArc::clone(entry.deq_nodes()),
                 );
                 entry.set_timer_node(timer);
             }
@@ -1834,7 +1834,7 @@ where
     fn handle_remove(
         deqs: &mut Deques<K>,
         timer_wheel: &mut TimerWheel<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: Option<u16>,
         counters: &mut EvictionCounters,
     ) {
@@ -1846,7 +1846,7 @@ where
 
     fn handle_remove_without_timer_wheel(
         deqs: &mut Deques<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         gen: Option<u16>,
         counters: &mut EvictionCounters,
     ) {
@@ -1869,7 +1869,7 @@ where
         ao_deq: &mut Deque<KeyHashDate<K>>,
         wo_deq: &mut Deque<KeyHashDate<K>>,
         timer_wheel: &mut TimerWheel<K>,
-        entry: TrioArc<ValueEntry<K, V>>,
+        entry: MiniArc<ValueEntry<K, V>>,
         counters: &mut EvictionCounters,
     ) {
         if let Some(timer) = entry.take_timer_node() {
@@ -2368,7 +2368,7 @@ where
     pub(crate) fn notify_single_removal(
         &self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         cause: RemovalCause,
     ) {
         if let Some(notifier) = &self.removal_notifier {
@@ -2380,7 +2380,7 @@ where
     fn notify_upsert(
         &self,
         key: Arc<K>,
-        entry: &TrioArc<ValueEntry<K, V>>,
+        entry: &MiniArc<ValueEntry<K, V>>,
         last_accessed: Option<Instant>,
         last_modified: Option<Instant>,
     ) {
@@ -2407,7 +2407,7 @@ where
     }
 
     #[inline]
-    fn notify_invalidate(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) {
+    fn notify_invalidate(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>) {
         let now = self.current_time_from_expiration_clock();
         let exp = &self.expiration_policy;
 
@@ -2480,7 +2480,7 @@ where
 
 /// Returns `true` if this entry is expired by its per-entry TTL.
 #[inline]
-fn is_expired_by_per_entry_ttl<K>(entry_info: &TrioArc<EntryInfo<K>>, now: Instant) -> bool {
+fn is_expired_by_per_entry_ttl<K>(entry_info: &MiniArc<EntryInfo<K>>, now: Instant) -> bool {
     if let Some(ts) = entry_info.expiration_time() {
         ts <= now
     } else {
diff --git a/src/sync_base/invalidator.rs b/src/sync_base/invalidator.rs
index dfb62c42..f281f709 100644
--- a/src/sync_base/invalidator.rs
+++ b/src/sync_base/invalidator.rs
@@ -16,7 +16,7 @@ use std::{
         Arc,
     },
 };
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 use uuid::Uuid;
 
 pub(crate) type PredicateFun<K, V> = Arc<dyn Fn(&K, &V) -> bool + Send + Sync + 'static>;
@@ -141,7 +141,7 @@ impl<K, V, S> Invalidator<K, V, S> {
 
     // This method will be called by the get method of Cache.
     #[inline]
-    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &TrioArc<ValueEntry<K, V>>) -> bool
+    pub(crate) fn apply_predicates(&self, key: &Arc<K>, entry: &MiniArc<ValueEntry<K, V>>) -> bool
     where
         K: Hash + Eq + Send + Sync + 'static,
         V: Clone + Send + Sync + 'static,
@@ -296,7 +296,7 @@ where
         key: &Arc<K>,
         hash: u64,
         ts: Instant,
-    ) -> Option<TrioArc<ValueEntry<K, V>>>
+    ) -> Option<MiniArc<ValueEntry<K, V>>>
     where
         K: Send + Sync + 'static,
         V: Clone + Send + Sync + 'static,
diff --git a/src/sync_base/key_lock.rs b/src/sync_base/key_lock.rs
index abc96873..fc5ad402 100644
--- a/src/sync_base/key_lock.rs
+++ b/src/sync_base/key_lock.rs
@@ -6,11 +6,11 @@ use std::{
 use crate::cht::SegmentedHashMap;
 
 use parking_lot::{Mutex, MutexGuard};
-use triomphe::Arc as TrioArc;
+use moka_arc::MiniArc;
 
 const LOCK_MAP_NUM_SEGMENTS: usize = 64;
 
-type LockMap<K, S> = SegmentedHashMap<Arc<K>, TrioArc<Mutex<()>>, S>;
+type LockMap<K, S> = SegmentedHashMap<Arc<K>, MiniArc<Mutex<()>>, S>;
 
 // We need the `where` clause here because of the Drop impl.
 pub(crate) struct KeyLock<'a, K, S>
@@ -21,7 +21,7 @@ where
     map: &'a LockMap<K, S>,
     key: Arc<K>,
     hash: u64,
-    lock: TrioArc<Mutex<()>>,
+    lock: MiniArc<Mutex<()>>,
 }
 
 impl<'a, K, S> Drop for KeyLock<'a, K, S>
@@ -30,11 +30,11 @@ where
     S: BuildHasher,
 {
     fn drop(&mut self) {
-        if TrioArc::count(&self.lock) <= 2 {
+        if MiniArc::count(&self.lock) <= 2 {
             self.map.remove_if(
                 self.hash,
                 |k| k == &self.key,
-                |_k, v| TrioArc::count(v) <= 2,
+                |_k, v| MiniArc::count(v) <= 2,
             );
         }
     }
@@ -45,7 +45,7 @@ where
     K: Eq + Hash,
     S: BuildHasher,
 {
-    fn new(map: &'a LockMap<K, S>, key: &Arc<K>, hash: u64, lock: TrioArc<Mutex<()>>) -> Self {
+    fn new(map: &'a LockMap<K, S>, key: &Arc<K>, hash: u64, lock: MiniArc<Mutex<()>>) -> Self {
         Self {
             map,
             key: Arc::clone(key),
@@ -76,7 +76,7 @@ where
 
     pub(crate) fn key_lock(&self, key: &Arc<K>) -> KeyLock<'_, K, S> {
         let hash = self.locks.hash(key);
-        let kl = TrioArc::new(Mutex::new(()));
+        let kl = MiniArc::new(Mutex::new(()));
         match self
             .locks
             .insert_if_not_present(Arc::clone(key), hash, kl.clone())