diff --git a/rclrs/src/subscription/into_async_subscription_callback.rs b/rclrs/src/subscription/into_async_subscription_callback.rs
index 5ed7da9b..cd5b1683 100644
--- a/rclrs/src/subscription/into_async_subscription_callback.rs
+++ b/rclrs/src/subscription/into_async_subscription_callback.rs
@@ -31,7 +31,8 @@ where
     Out: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::Regular(Box::new(move |message| Box::pin(self(message)))).into()
+        NodeSubscriptionCallback::AsyncRegular(Box::new(move |message| Box::pin(self(message))))
+            .into()
     }
 }
 
@@ -42,7 +43,7 @@ where
     Out: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::RegularWithMessageInfo(Box::new(move |message, info| {
+        NodeSubscriptionCallback::AsyncRegularWithMessageInfo(Box::new(move |message, info| {
             Box::pin(self(message, info))
         }))
         .into()
@@ -56,7 +57,8 @@ where
     Out: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::Boxed(Box::new(move |message| Box::pin(self(message)))).into()
+        NodeSubscriptionCallback::AsyncBoxed(Box::new(move |message| Box::pin(self(message))))
+            .into()
     }
 }
 
@@ -67,7 +69,7 @@ where
     F: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::BoxedWithMessageInfo(Box::new(move |message, info| {
+        NodeSubscriptionCallback::AsyncBoxedWithMessageInfo(Box::new(move |message, info| {
             Box::pin(self(message, info))
         }))
         .into()
@@ -81,7 +83,8 @@ where
     F: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::Loaned(Box::new(move |message| Box::pin(self(message)))).into()
+        NodeSubscriptionCallback::AsyncLoaned(Box::new(move |message| Box::pin(self(message))))
+            .into()
     }
 }
 
@@ -92,7 +95,7 @@ where
     F: Future<Output = ()> + Send + 'static,
 {
     fn into_async_subscription_callback(mut self) -> AnySubscriptionCallback<T, ()> {
-        NodeSubscriptionCallback::LoanedWithMessageInfo(Box::new(move |message, info| {
+        NodeSubscriptionCallback::AsyncLoanedWithMessageInfo(Box::new(move |message, info| {
             Box::pin(self(message, info))
         }))
         .into()
@@ -110,68 +113,68 @@ mod tests {
         let cb = |_msg: TestMessage| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Regular(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncRegular(_)),
         ));
         let cb = |_msg: TestMessage, _info: MessageInfo| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::RegularWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncRegularWithMessageInfo(_)
             ),
         ));
         let cb = |_msg: Box<TestMessage>| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Boxed(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncBoxed(_)),
         ));
         let cb = |_msg: Box<TestMessage>, _info: MessageInfo| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::BoxedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncBoxedWithMessageInfo(_)
             ),
         ));
         let cb = |_msg: ReadOnlyLoanedMessage<TestMessage>| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Loaned(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncLoaned(_)),
         ));
         let cb = |_msg: ReadOnlyLoanedMessage<TestMessage>, _info: MessageInfo| async {};
         assert!(matches!(
             cb.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::LoanedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncLoanedWithMessageInfo(_)
             ),
         ));
 
         assert!(matches!(
             test_regular.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Regular(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncRegular(_)),
         ));
         assert!(matches!(
             test_regular_with_info.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::RegularWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncRegularWithMessageInfo(_)
             ),
         ));
         assert!(matches!(
             test_boxed.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Boxed(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncBoxed(_)),
         ));
         assert!(matches!(
             test_boxed_with_info.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::BoxedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncBoxedWithMessageInfo(_)
             ),
         ));
         assert!(matches!(
             test_loaned.into_async_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Loaned(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::AsyncLoaned(_)),
         ));
         assert!(matches!(
             test_loaned_with_info.into_async_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::LoanedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::AsyncLoanedWithMessageInfo(_)
             ),
         ));
     }
diff --git a/rclrs/src/subscription/into_node_subscription_callback.rs b/rclrs/src/subscription/into_node_subscription_callback.rs
index 927ff38b..e39d53de 100644
--- a/rclrs/src/subscription/into_node_subscription_callback.rs
+++ b/rclrs/src/subscription/into_node_subscription_callback.rs
@@ -4,17 +4,15 @@ use crate::{
     AnySubscriptionCallback, MessageInfo, NodeSubscriptionCallback, ReadOnlyLoanedMessage,
 };
 
-use std::sync::Arc;
-
 /// A trait for regular callbacks of subscriptions.
 ///
 /// Subscription callbacks support six signatures:
-/// - [`Fn`] ( `Message` )
-/// - [`Fn`] ( `Message`, [`MessageInfo`] )
-/// - [`Fn`] ( [`Box`]<`Message`> )
-/// - [`Fn`] ( [`Box`]<`Message`>, [`MessageInfo`] )
-/// - [`Fn`] ( [`ReadOnlyLoanedMessage`]<`Message`> )
-/// - [`Fn`] ( [`ReadOnlyLoanedMessage`]<`Message`>, [`MessageInfo`] )
+/// - [`FnMut`] ( `Message` )
+/// - [`FnMut`] ( `Message`, [`MessageInfo`] )
+/// - [`FnMut`] ( [`Box`]<`Message`> )
+/// - [`FnMut`] ( [`Box`]<`Message`>, [`MessageInfo`] )
+/// - [`FnMut`] ( [`ReadOnlyLoanedMessage`]<`Message`> )
+/// - [`FnMut`] ( [`ReadOnlyLoanedMessage`]<`Message`>, [`MessageInfo`] )
 pub trait IntoNodeSubscriptionCallback<T, Args>: Send + 'static
 where
     T: Message,
@@ -28,102 +26,60 @@ where
 impl<T, Func> IntoNodeSubscriptionCallback<T, (T,)> for Func
 where
     T: Message,
-    Func: Fn(T) + Send + Sync + 'static,
+    Func: FnMut(T) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::Regular(Box::new(move |message| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncRegular(Box::new(self)).into()
     }
 }
 
 impl<T, Func> IntoNodeSubscriptionCallback<T, (T, MessageInfo)> for Func
 where
     T: Message,
-    Func: Fn(T, MessageInfo) + Send + Sync + 'static,
+    Func: FnMut(T, MessageInfo) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::RegularWithMessageInfo(Box::new(move |message, info| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message, info);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncRegularWithMessageInfo(Box::new(self)).into()
     }
 }
 
 impl<T, Func> IntoNodeSubscriptionCallback<T, (Box<T>,)> for Func
 where
     T: Message,
-    Func: Fn(Box<T>) + Send + Sync + 'static,
+    Func: FnMut(Box<T>) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::Boxed(Box::new(move |message| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncBoxed(Box::new(self)).into()
     }
 }
 
 impl<T, Func> IntoNodeSubscriptionCallback<T, (Box<T>, MessageInfo)> for Func
 where
     T: Message,
-    Func: Fn(Box<T>, MessageInfo) + Send + Sync + 'static,
+    Func: FnMut(Box<T>, MessageInfo) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::BoxedWithMessageInfo(Box::new(move |message, info| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message, info);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncBoxedWithMessageInfo(Box::new(self)).into()
     }
 }
 
 impl<T, Func> IntoNodeSubscriptionCallback<T, (ReadOnlyLoanedMessage<T>,)> for Func
 where
     T: Message,
-    Func: Fn(ReadOnlyLoanedMessage<T>) + Send + Sync + 'static,
+    Func: FnMut(ReadOnlyLoanedMessage<T>) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::Loaned(Box::new(move |message| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncLoaned(Box::new(self)).into()
     }
 }
 
 impl<T, Func> IntoNodeSubscriptionCallback<T, (ReadOnlyLoanedMessage<T>, MessageInfo)> for Func
 where
     T: Message,
-    Func: Fn(ReadOnlyLoanedMessage<T>, MessageInfo) + Send + Sync + 'static,
+    Func: FnMut(ReadOnlyLoanedMessage<T>, MessageInfo) + Send + 'static,
 {
     fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
-        let func = Arc::new(self);
-        NodeSubscriptionCallback::LoanedWithMessageInfo(Box::new(move |message, info| {
-            let f = Arc::clone(&func);
-            Box::pin(async move {
-                f(message, info);
-            })
-        }))
-        .into()
+        NodeSubscriptionCallback::SyncLoanedWithMessageInfo(Box::new(self)).into()
     }
 }
 
@@ -138,68 +94,68 @@ mod tests {
         let cb = |_msg: TestMessage| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Regular(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncRegular(_)),
         ));
         let cb = |_msg: TestMessage, _info: MessageInfo| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::RegularWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncRegularWithMessageInfo(_)
             )
         ));
         let cb = |_msg: Box<TestMessage>| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Boxed(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncBoxed(_)),
         ));
         let cb = |_msg: Box<TestMessage>, _info: MessageInfo| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::BoxedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncBoxedWithMessageInfo(_)
             ),
         ));
         let cb = |_msg: ReadOnlyLoanedMessage<TestMessage>| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Loaned(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncLoaned(_)),
         ));
         let cb = |_msg: ReadOnlyLoanedMessage<TestMessage>, _info: MessageInfo| {};
         assert!(matches!(
             cb.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::LoanedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncLoanedWithMessageInfo(_)
             ),
         ));
 
         assert!(matches!(
             test_regular.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Regular(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncRegular(_)),
         ));
         assert!(matches!(
             test_regular_with_info.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::RegularWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncRegularWithMessageInfo(_)
             ),
         ));
         assert!(matches!(
             test_boxed.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Boxed(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncBoxed(_)),
         ));
         assert!(matches!(
             test_boxed_with_info.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::BoxedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncBoxedWithMessageInfo(_)
             ),
         ));
         assert!(matches!(
             test_loaned.into_node_subscription_callback(),
-            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::Loaned(_)),
+            AnySubscriptionCallback::Node(NodeSubscriptionCallback::<TestMessage>::SyncLoaned(_)),
         ));
         assert!(matches!(
             test_loaned_with_info.into_node_subscription_callback(),
             AnySubscriptionCallback::Node(
-                NodeSubscriptionCallback::<TestMessage>::LoanedWithMessageInfo(_)
+                NodeSubscriptionCallback::<TestMessage>::SyncLoanedWithMessageInfo(_)
             ),
         ));
     }
diff --git a/rclrs/src/subscription/node_subscription_callback.rs b/rclrs/src/subscription/node_subscription_callback.rs
index 0b9b6347..2ca138bc 100644
--- a/rclrs/src/subscription/node_subscription_callback.rs
+++ b/rclrs/src/subscription/node_subscription_callback.rs
@@ -16,20 +16,34 @@ use std::sync::Arc;
 /// [1]: crate::IntoNodeSubscriptionCallback
 /// [2]: crate::IntoAsyncSubscriptionCallback
 pub enum NodeSubscriptionCallback<T: Message> {
-    /// A callback with only the message as an argument.
-    Regular(Box<dyn FnMut(T) -> BoxFuture<'static, ()> + Send>),
-    /// A callback with the message and the message info as arguments.
-    RegularWithMessageInfo(Box<dyn FnMut(T, MessageInfo) -> BoxFuture<'static, ()> + Send>),
-    /// A callback with only the boxed message as an argument.
-    Boxed(Box<dyn FnMut(Box<T>) -> BoxFuture<'static, ()> + Send>),
-    /// A callback with the boxed message and the message info as arguments.
-    BoxedWithMessageInfo(Box<dyn FnMut(Box<T>, MessageInfo) -> BoxFuture<'static, ()> + Send>),
-    /// A callback with only the loaned message as an argument.
+    // Sync variants — callback is called directly, no async wrapping.
+    /// A synchronous callback with only the message as an argument.
+    SyncRegular(Box<dyn FnMut(T) + Send>),
+    /// A synchronous callback with the message and the message info as arguments.
+    SyncRegularWithMessageInfo(Box<dyn FnMut(T, MessageInfo) + Send>),
+    /// A synchronous callback with only the boxed message as an argument.
+    SyncBoxed(Box<dyn FnMut(Box<T>) + Send>),
+    /// A synchronous callback with the boxed message and the message info as arguments.
+    SyncBoxedWithMessageInfo(Box<dyn FnMut(Box<T>, MessageInfo) + Send>),
+    /// A synchronous callback with only the loaned message as an argument.
+    SyncLoaned(Box<dyn FnMut(ReadOnlyLoanedMessage<T>) + Send>),
+    /// A synchronous callback with the loaned message and the message info as arguments.
+    SyncLoanedWithMessageInfo(Box<dyn FnMut(ReadOnlyLoanedMessage<T>, MessageInfo) + Send>),
+    // Async variants — callback returns a future, dispatched via the executor task queue.
+    /// An async callback with only the message as an argument.
+    AsyncRegular(Box<dyn FnMut(T) -> BoxFuture<'static, ()> + Send>),
+    /// An async callback with the message and the message info as arguments.
+    AsyncRegularWithMessageInfo(Box<dyn FnMut(T, MessageInfo) -> BoxFuture<'static, ()> + Send>),
+    /// An async callback with only the boxed message as an argument.
+    AsyncBoxed(Box<dyn FnMut(Box<T>) -> BoxFuture<'static, ()> + Send>),
+    /// An async callback with the boxed message and the message info as arguments.
+    AsyncBoxedWithMessageInfo(Box<dyn FnMut(Box<T>, MessageInfo) -> BoxFuture<'static, ()> + Send>),
+    /// An async callback with only the loaned message as an argument.
     #[allow(clippy::type_complexity)]
-    Loaned(Box<dyn FnMut(ReadOnlyLoanedMessage<T>) -> BoxFuture<'static, ()> + Send>),
-    /// A callback with the loaned message and the message info as arguments.
+    AsyncLoaned(Box<dyn FnMut(ReadOnlyLoanedMessage<T>) -> BoxFuture<'static, ()> + Send>),
+    /// An async callback with the loaned message and the message info as arguments.
     #[allow(clippy::type_complexity)]
-    LoanedWithMessageInfo(
+    AsyncLoanedWithMessageInfo(
         Box<dyn FnMut(ReadOnlyLoanedMessage<T>, MessageInfo) -> BoxFuture<'static, ()> + Send>,
     ),
 }
@@ -42,27 +56,53 @@ impl<T: Message> NodeSubscriptionCallback<T> {
     ) -> Result<(), RclrsError> {
         let mut evaluate = || {
             match self {
-                NodeSubscriptionCallback::Regular(cb) => {
+                // Sync variants — call directly, no async overhead
+                NodeSubscriptionCallback::SyncRegular(cb) => {
+                    let (msg, _) = handle.take::<T>()?;
+                    cb(msg);
+                }
+                NodeSubscriptionCallback::SyncRegularWithMessageInfo(cb) => {
+                    let (msg, msg_info) = handle.take::<T>()?;
+                    cb(msg, msg_info);
+                }
+                NodeSubscriptionCallback::SyncBoxed(cb) => {
+                    let (msg, _) = handle.take_boxed::<T>()?;
+                    cb(msg);
+                }
+                NodeSubscriptionCallback::SyncBoxedWithMessageInfo(cb) => {
+                    let (msg, msg_info) = handle.take_boxed::<T>()?;
+                    cb(msg, msg_info);
+                }
+                NodeSubscriptionCallback::SyncLoaned(cb) => {
+                    let (msg, _) = handle.take_loaned::<T>()?;
+                    cb(msg);
+                }
+                NodeSubscriptionCallback::SyncLoanedWithMessageInfo(cb) => {
+                    let (msg, msg_info) = handle.take_loaned::<T>()?;
+                    cb(msg, msg_info);
+                }
+                // Async variants — dispatch through executor task queue
+                NodeSubscriptionCallback::AsyncRegular(cb) => {
                     let (msg, _) = handle.take::<T>()?;
                     commands.run_async(cb(msg));
                 }
-                NodeSubscriptionCallback::RegularWithMessageInfo(cb) => {
+                NodeSubscriptionCallback::AsyncRegularWithMessageInfo(cb) => {
                     let (msg, msg_info) = handle.take::<T>()?;
                     commands.run_async(cb(msg, msg_info));
                 }
-                NodeSubscriptionCallback::Boxed(cb) => {
+                NodeSubscriptionCallback::AsyncBoxed(cb) => {
                     let (msg, _) = handle.take_boxed::<T>()?;
                     commands.run_async(cb(msg));
                 }
-                NodeSubscriptionCallback::BoxedWithMessageInfo(cb) => {
+                NodeSubscriptionCallback::AsyncBoxedWithMessageInfo(cb) => {
                     let (msg, msg_info) = handle.take_boxed::<T>()?;
                     commands.run_async(cb(msg, msg_info));
                 }
-                NodeSubscriptionCallback::Loaned(cb) => {
+                NodeSubscriptionCallback::AsyncLoaned(cb) => {
                     let (msg, _) = handle.take_loaned::<T>()?;
                     commands.run_async(cb(msg));
                 }
-                NodeSubscriptionCallback::LoanedWithMessageInfo(cb) => {
+                NodeSubscriptionCallback::AsyncLoanedWithMessageInfo(cb) => {
                     let (msg, msg_info) = handle.take_loaned::<T>()?;
                     commands.run_async(cb(msg, msg_info));
                 }