diff --git a/packages/react-native/React/CxxBridge/RCTCxxBridge.mm b/packages/react-native/React/CxxBridge/RCTCxxBridge.mm
index d47c4aece7d309..777268dbb7eff4 100644
--- a/packages/react-native/React/CxxBridge/RCTCxxBridge.mm
+++ b/packages/react-native/React/CxxBridge/RCTCxxBridge.mm
@@ -1635,9 +1635,10 @@ - (void)invokeAsync:(std::function<void()> &&)func
   return _reactInstance ? _reactInstance->getJSCallInvoker() : nullptr;
 }
 
-- (std::shared_ptr<CallInvoker>)decorateNativeCallInvoker:(std::shared_ptr<CallInvoker>)nativeInvoker
+- (std::shared_ptr<NativeMethodCallInvoker>)decorateNativeMethodCallInvoker:
+    (std::shared_ptr<NativeMethodCallInvoker>)nativeInvoker
 {
-  return _reactInstance ? _reactInstance->getDecoratedNativeCallInvoker(nativeInvoker) : nullptr;
+  return _reactInstance ? _reactInstance->getDecoratedNativeMethodCallInvoker(nativeInvoker) : nullptr;
 }
 
 @end
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java
index 42e815bc6d8b5a..0563aee2cd618d 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java
@@ -1379,7 +1379,7 @@ private ReactApplicationContext createReactContext(
               catalystInstance.getRuntimeExecutor(),
               tmmDelegate,
               catalystInstance.getJSCallInvokerHolder(),
-              catalystInstance.getNativeCallInvokerHolder());
+              catalystInstance.getNativeMethodCallInvokerHolder());
 
       catalystInstance.setTurboModuleManager(turboModuleManager);
 
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java
index c0b4517f7e39a9..2623190edba006 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java
@@ -12,6 +12,7 @@
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder;
 import java.util.Collection;
 import java.util.List;
 
@@ -122,10 +123,10 @@ public interface CatalystInstance
   CallInvokerHolder getJSCallInvokerHolder();
 
   /**
-   * Returns a hybrid object that contains a pointer to a Native CallInvoker, which is used to
+   * Returns a hybrid object that contains a pointer to a NativeMethodCallInvoker, which is used to
    * schedule work on the NativeModules thread. Required for TurboModuleManager initialization.
    */
-  CallInvokerHolder getNativeCallInvokerHolder();
+  NativeMethodCallInvokerHolder getNativeMethodCallInvokerHolder();
 
   /**
    * For the time being, we want code relying on the old infra to also work with TurboModules.
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java
index 0329ae8e92b0b1..68817d66c7787f 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java
@@ -28,6 +28,7 @@
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.turbomodule.core.NativeMethodCallInvokerHolderImpl;
 import com.facebook.react.turbomodule.core.interfaces.TurboModuleRegistry;
 import com.facebook.systrace.Systrace;
 import com.facebook.systrace.TraceListener;
@@ -111,7 +112,7 @@ public String toString() {
 
   public native CallInvokerHolderImpl getJSCallInvokerHolder();
 
-  public native CallInvokerHolderImpl getNativeCallInvokerHolder();
+  public native NativeMethodCallInvokerHolderImpl getNativeMethodCallInvokerHolder();
 
   private CatalystInstanceImpl(
       final ReactQueueConfigurationSpec reactQueueConfigurationSpec,
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridgeless/ReactInstance.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridgeless/ReactInstance.java
index eb3f86afcbb656..1d8d27002919a7 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridgeless/ReactInstance.java
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridgeless/ReactInstance.java
@@ -44,6 +44,7 @@
 import com.facebook.react.modules.core.JavaTimerManager;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.turbomodule.core.NativeMethodCallInvokerHolderImpl;
 import com.facebook.react.turbomodule.core.TurboModuleManager;
 import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.uimanager.ComponentNameResolver;
@@ -193,7 +194,7 @@ public void onHostDestroy() {
             unbufferedRuntimeExecutor,
             turboModuleManagerDelegate,
             getJSCallInvokerHolder(),
-            getNativeCallInvokerHolder());
+            getNativeMethodCallInvokerHolder());
 
     // Eagerly initialize TurboModules
     for (String moduleName : mTurboModuleManager.getEagerInitModuleNames()) {
@@ -397,7 +398,7 @@ private native HybridData initHybrid(
 
   private native CallInvokerHolderImpl getJSCallInvokerHolder();
 
-  private native CallInvokerHolderImpl getNativeCallInvokerHolder();
+  private native NativeMethodCallInvokerHolderImpl getNativeMethodCallInvokerHolder();
 
   private native RuntimeExecutor getUnbufferedRuntimeExecutor();
 
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/NativeMethodCallInvokerHolderImpl.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/NativeMethodCallInvokerHolderImpl.java
new file mode 100644
index 00000000000000..79b2bea4707a01
--- /dev/null
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/NativeMethodCallInvokerHolderImpl.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.turbomodule.core;
+
+import com.facebook.jni.HybridData;
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder;
+import com.facebook.soloader.SoLoader;
+
+/**
+ * NativeMethodCallInvokerHolder is created at a different time/place (i.e: in CatalystInstance)
+ * than TurboModuleManager. Therefore, we need to wrap NativeMethodCallInvokerHolder within a hybrid
+ * class so that we may pass it from CatalystInstance, through Java, to
+ * TurboModuleManager::initHybrid.
+ */
+public class NativeMethodCallInvokerHolderImpl implements NativeMethodCallInvokerHolder {
+  private static volatile boolean sIsSoLibraryLoaded;
+
+  private final HybridData mHybridData;
+
+  private NativeMethodCallInvokerHolderImpl(HybridData hd) {
+    maybeLoadSoLibrary();
+    mHybridData = hd;
+  }
+
+  // Prevents issues with initializer interruptions. See T38996825 and D13793825 for more context.
+  private static synchronized void maybeLoadSoLibrary() {
+    if (!sIsSoLibraryLoaded) {
+      SoLoader.loadLibrary("turbomodulejsijni");
+      sIsSoLibraryLoaded = true;
+    }
+  }
+}
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/TurboModuleManager.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/TurboModuleManager.java
index c17a99bfef88db..aa29e666d26611 100644
--- a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/TurboModuleManager.java
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/TurboModuleManager.java
@@ -22,6 +22,7 @@
 import com.facebook.react.bridge.RuntimeExecutor;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import com.facebook.react.turbomodule.core.interfaces.TurboModuleRegistry;
 import com.facebook.soloader.SoLoader;
@@ -61,14 +62,14 @@ public TurboModuleManager(
       RuntimeExecutor runtimeExecutor,
       @Nullable final TurboModuleManagerDelegate delegate,
       CallInvokerHolder jsCallInvokerHolder,
-      CallInvokerHolder nativeCallInvokerHolder) {
+      NativeMethodCallInvokerHolder nativeMethodCallInvokerHolder) {
     maybeLoadSoLibrary();
     mDelegate = delegate;
     mHybridData =
         initHybrid(
             runtimeExecutor,
             (CallInvokerHolderImpl) jsCallInvokerHolder,
-            (CallInvokerHolderImpl) nativeCallInvokerHolder,
+            (NativeMethodCallInvokerHolderImpl) nativeMethodCallInvokerHolder,
             delegate);
     installJSIBindings(shouldCreateLegacyModules());
 
@@ -405,7 +406,7 @@ public static void logError(String message) {
   private native HybridData initHybrid(
       RuntimeExecutor runtimeExecutor,
       CallInvokerHolderImpl jsCallInvokerHolder,
-      CallInvokerHolderImpl nativeCallInvokerHolder,
+      NativeMethodCallInvokerHolderImpl nativeMethodCallInvoker,
       TurboModuleManagerDelegate tmmDelegate);
 
   private native void installJSIBindings(boolean shouldCreateLegacyModules);
diff --git a/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/interfaces/NativeMethodCallInvokerHolder.java b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/interfaces/NativeMethodCallInvokerHolder.java
new file mode 100644
index 00000000000000..c3c52f51f57f03
--- /dev/null
+++ b/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/interfaces/NativeMethodCallInvokerHolder.java
@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.turbomodule.core.interfaces;
+
+/**
+ * This interface represents the opaque Java object that contains a pointer to and instance of
+ * NativeMethodCallInvoker.
+ */
+public interface NativeMethodCallInvokerHolder {}
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.cpp b/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.cpp
index d5ce7517657ac5..4df09482a59492 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.cpp
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.cpp
@@ -19,7 +19,7 @@
 #include <jsi/jsi.h>
 #include <jsireact/JSIExecutor.h>
 #include <react/bridgeless/BridgelessJSCallInvoker.h>
-#include <react/bridgeless/BridgelessNativeCallInvoker.h>
+#include <react/bridgeless/BridgelessNativeMethodCallInvoker.h>
 #include <react/common/mapbuffer/JReadableMapBuffer.h>
 #include <react/jni/JRuntimeExecutor.h>
 #include <react/jni/JSLogging.h>
@@ -90,10 +90,12 @@ JReactInstance::JReactInstance(
       std::make_unique<BridgelessJSCallInvoker>(unbufferedRuntimeExecutor);
   jsCallInvokerHolder_ = jni::make_global(
       CallInvokerHolder::newObjectCxxArgs(std::move(jsInvoker)));
-  auto nativeInvoker = std::make_unique<BridgelessNativeCallInvoker>(
-      sharedNativeMessageQueueThread);
-  nativeCallInvokerHolder_ = jni::make_global(
-      CallInvokerHolder::newObjectCxxArgs(std::move(nativeInvoker)));
+  auto nativeMethodCallInvoker =
+      std::make_unique<BridgelessNativeMethodCallInvoker>(
+          sharedNativeMessageQueueThread);
+  nativeMethodCallInvokerHolder_ =
+      jni::make_global(NativeMethodCallInvokerHolder::newObjectCxxArgs(
+          std::move(nativeMethodCallInvoker)));
 
   // Storing this here to make sure the Java reference doesn't get destroyed
   unbufferedRuntimeExecutor_ = jni::make_global(
@@ -156,9 +158,9 @@ JReactInstance::getJSCallInvokerHolder() {
   return jsCallInvokerHolder_;
 }
 
-jni::alias_ref<CallInvokerHolder::javaobject>
-JReactInstance::getNativeCallInvokerHolder() {
-  return nativeCallInvokerHolder_;
+jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+JReactInstance::getNativeMethodCallInvokerHolder() {
+  return nativeMethodCallInvokerHolder_;
 }
 
 jni::global_ref<JJSTimerExecutor::javaobject>
@@ -211,8 +213,8 @@ void JReactInstance::registerNatives() {
       makeNativeMethod(
           "getJSCallInvokerHolder", JReactInstance::getJSCallInvokerHolder),
       makeNativeMethod(
-          "getNativeCallInvokerHolder",
-          JReactInstance::getNativeCallInvokerHolder),
+          "getNativeMethodCallInvokerHolder",
+          JReactInstance::getNativeMethodCallInvokerHolder),
       makeNativeMethod(
           "callFunctionOnModule", JReactInstance::callFunctionOnModule),
       makeNativeMethod(
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.h b/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.h
index 61dfa4debee201..99e7d80ebb8778 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.h
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/bridgeless/jni/JReactInstance.h
@@ -8,6 +8,7 @@
 #pragma once
 
 #include <ReactCommon/CallInvokerHolder.h>
+#include <ReactCommon/NativeMethodCallInvokerHolder.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <fb/fbjni.h>
 #include <jni.h>
@@ -92,14 +93,16 @@ class JReactInstance : public jni::HybridClass<JReactInstance> {
       bool isProfiling) noexcept;
 
   jni::alias_ref<CallInvokerHolder::javaobject> getJSCallInvokerHolder();
-  jni::alias_ref<CallInvokerHolder::javaobject> getNativeCallInvokerHolder();
+  jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+  getNativeMethodCallInvokerHolder();
 
   std::unique_ptr<ReactInstance> instance_;
   jni::global_ref<JRuntimeExecutor::javaobject> unbufferedRuntimeExecutor_;
   jni::global_ref<JRuntimeExecutor::javaobject> bufferedRuntimeExecutor_;
   jni::global_ref<JRuntimeScheduler::javaobject> runtimeScheduler_;
   jni::global_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder_;
-  jni::global_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder_;
+  jni::global_ref<NativeMethodCallInvokerHolder::javaobject>
+      nativeMethodCallInvokerHolder_;
   jni::global_ref<JReactExceptionManager::javaobject> jReactExceptionManager_;
   jni::global_ref<JBindingsInstaller::javaobject> jBindingsInstaller_;
 };
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp b/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp
index 043d5afcfaeb84..53688d625d4a19 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp
@@ -131,8 +131,8 @@ void CatalystInstanceImpl::registerNatives() {
           "getJSCallInvokerHolder",
           CatalystInstanceImpl::getJSCallInvokerHolder),
       makeNativeMethod(
-          "getNativeCallInvokerHolder",
-          CatalystInstanceImpl::getNativeCallInvokerHolder),
+          "getNativeMethodCallInvokerHolder",
+          CatalystInstanceImpl::getNativeMethodCallInvokerHolder),
       makeNativeMethod(
           "jniHandleMemoryPressure",
           CatalystInstanceImpl::handleMemoryPressure),
@@ -358,36 +358,41 @@ CatalystInstanceImpl::getJSCallInvokerHolder() {
   return jsCallInvokerHolder_;
 }
 
-jni::alias_ref<CallInvokerHolder::javaobject>
-CatalystInstanceImpl::getNativeCallInvokerHolder() {
-  if (!nativeCallInvokerHolder_) {
-    class NativeThreadCallInvoker : public CallInvoker {
+jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+CatalystInstanceImpl::getNativeMethodCallInvokerHolder() {
+  if (!nativeMethodCallInvokerHolder_) {
+    class NativeMethodCallInvokerImpl : public NativeMethodCallInvoker {
      private:
       std::shared_ptr<JMessageQueueThread> messageQueueThread_;
 
      public:
-      NativeThreadCallInvoker(
+      NativeMethodCallInvokerImpl(
           std::shared_ptr<JMessageQueueThread> messageQueueThread)
           : messageQueueThread_(messageQueueThread) {}
-      void invokeAsync(std::function<void()> &&work) override {
+      void invokeAsync(
+          const std::string &methodName,
+          std::function<void()> &&work) override {
         messageQueueThread_->runOnQueue(std::move(work));
       }
-      void invokeSync(std::function<void()> &&work) override {
+      void invokeSync(
+          const std::string &methodName,
+          std::function<void()> &&work) override {
         messageQueueThread_->runOnQueueSync(std::move(work));
       }
     };
 
-    std::shared_ptr<CallInvoker> nativeInvoker =
-        std::make_shared<NativeThreadCallInvoker>(moduleMessageQueue_);
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker =
+        std::make_shared<NativeMethodCallInvokerImpl>(moduleMessageQueue_);
 
-    std::shared_ptr<CallInvoker> decoratedNativeInvoker =
-        instance_->getDecoratedNativeCallInvoker(nativeInvoker);
+    std::shared_ptr<NativeMethodCallInvoker> decoratedNativeMethodCallInvoker =
+        instance_->getDecoratedNativeMethodCallInvoker(nativeMethodCallInvoker);
 
-    nativeCallInvokerHolder_ = jni::make_global(
-        CallInvokerHolder::newObjectCxxArgs(decoratedNativeInvoker));
+    nativeMethodCallInvokerHolder_ =
+        jni::make_global(NativeMethodCallInvokerHolder::newObjectCxxArgs(
+            decoratedNativeMethodCallInvoker));
   }
 
-  return nativeCallInvokerHolder_;
+  return nativeMethodCallInvokerHolder_;
 }
 
 jni::alias_ref<JRuntimeExecutor::javaobject>
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h b/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h
index bc07691e331a68..13d8a7db6ae65f 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include <ReactCommon/CallInvokerHolder.h>
+#include <ReactCommon/NativeMethodCallInvokerHolder.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <fbjni/fbjni.h>
 
@@ -96,7 +97,8 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
       NativeArray *arguments);
   void jniCallJSCallback(jint callbackId, NativeArray *arguments);
   jni::alias_ref<CallInvokerHolder::javaobject> getJSCallInvokerHolder();
-  jni::alias_ref<CallInvokerHolder::javaobject> getNativeCallInvokerHolder();
+  jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+  getNativeMethodCallInvokerHolder();
   jni::alias_ref<JRuntimeExecutor::javaobject> getRuntimeExecutor();
   jni::alias_ref<JRuntimeScheduler::javaobject> getRuntimeScheduler();
   void setGlobalVariable(std::string propName, std::string &&jsonValue);
@@ -111,7 +113,8 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
   std::shared_ptr<ModuleRegistry> moduleRegistry_;
   std::shared_ptr<JMessageQueueThread> moduleMessageQueue_;
   jni::global_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder_;
-  jni::global_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder_;
+  jni::global_ref<NativeMethodCallInvokerHolder::javaobject>
+      nativeMethodCallInvokerHolder_;
   jni::global_ref<JRuntimeExecutor::javaobject> runtimeExecutor_;
   jni::global_ref<JRuntimeScheduler::javaobject> runtimeScheduler_;
 };
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/CMakeLists.txt b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/CMakeLists.txt
index b5a9449bb9e1b1..748e1c6ca00f86 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/CMakeLists.txt
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/CMakeLists.txt
@@ -21,6 +21,7 @@ add_library(
         callinvokerholder
         STATIC
         ReactCommon/CallInvokerHolder.cpp
+        ReactCommon/NativeMethodCallInvokerHolder.cpp
 )
 
 target_include_directories(callinvokerholder
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.cpp b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.cpp
new file mode 100644
index 00000000000000..62d9b0de182faa
--- /dev/null
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "NativeMethodCallInvokerHolder.h"
+
+namespace facebook::react {
+
+NativeMethodCallInvokerHolder::NativeMethodCallInvokerHolder(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker)
+    : _nativeMethodCallInvoker(nativeMethodCallInvoker) {}
+
+std::shared_ptr<NativeMethodCallInvoker>
+NativeMethodCallInvokerHolder::getNativeMethodCallInvoker() {
+  return _nativeMethodCallInvoker;
+}
+
+void NativeMethodCallInvokerHolder::registerNatives() {}
+
+} // namespace facebook::react
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.h b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.h
new file mode 100644
index 00000000000000..ef8fa3b5a42395
--- /dev/null
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/NativeMethodCallInvokerHolder.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <fbjni/fbjni.h>
+#include <memory>
+
+namespace facebook::react {
+
+class NativeMethodCallInvokerHolder
+    : public jni::HybridClass<NativeMethodCallInvokerHolder> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/facebook/react/turbomodule/core/NativeMethodCallInvokerHolderImpl;";
+
+  static void registerNatives();
+  std::shared_ptr<NativeMethodCallInvoker> getNativeMethodCallInvoker();
+
+ private:
+  friend HybridBase;
+  NativeMethodCallInvokerHolder(
+      std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker);
+  std::shared_ptr<NativeMethodCallInvoker> _nativeMethodCallInvoker;
+};
+
+} // namespace facebook::react
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp
index 8b8f2c64611ff8..fdcee5f672d1ab 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp
@@ -106,12 +106,12 @@ TurboModuleManager::TurboModuleManager(
     jni::alias_ref<TurboModuleManager::javaobject> jThis,
     RuntimeExecutor runtimeExecutor,
     std::shared_ptr<CallInvoker> jsCallInvoker,
-    std::shared_ptr<CallInvoker> nativeCallInvoker,
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker,
     jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate)
     : javaPart_(jni::make_global(jThis)),
       runtimeExecutor_(runtimeExecutor),
       jsCallInvoker_(jsCallInvoker),
-      nativeCallInvoker_(nativeCallInvoker),
+      nativeMethodCallInvoker_(nativeMethodCallInvoker),
       delegate_(jni::make_global(delegate)),
       turboModuleCache_(std::make_shared<ModuleCache>()),
       legacyModuleCache_(std::make_shared<ModuleCache>()) {}
@@ -120,13 +120,14 @@ jni::local_ref<TurboModuleManager::jhybriddata> TurboModuleManager::initHybrid(
     jni::alias_ref<jhybridobject> jThis,
     jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
     jni::alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
-    jni::alias_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder,
+    jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+        nativeMethodCallInvokerHolder,
     jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate) {
   return makeCxxInstance(
       jThis,
       runtimeExecutor->cthis()->get(),
       jsCallInvokerHolder->cthis()->getCallInvoker(),
-      nativeCallInvokerHolder->cthis()->getCallInvoker(),
+      nativeMethodCallInvokerHolder->cthis()->getNativeMethodCallInvoker(),
       delegate);
 }
 
@@ -142,17 +143,18 @@ TurboModuleProviderFunctionType
 TurboModuleManager::createTurboModuleProvider() {
   return [turboModuleCache_ = std::weak_ptr<ModuleCache>(turboModuleCache_),
           jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
-          nativeCallInvoker_ = std::weak_ptr<CallInvoker>(nativeCallInvoker_),
+          nativeMethodCallInvoker_ =
+              std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
           delegate_ = jni::make_weak(delegate_),
           javaPart_ = jni::make_weak(javaPart_)](
              const std::string &name) -> std::shared_ptr<TurboModule> {
     auto turboModuleCache = turboModuleCache_.lock();
     auto jsCallInvoker = jsCallInvoker_.lock();
-    auto nativeCallInvoker = nativeCallInvoker_.lock();
+    auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
     auto delegate = delegate_.lockLocal();
     auto javaPart = javaPart_.lockLocal();
 
-    if (!turboModuleCache || !jsCallInvoker || !nativeCallInvoker ||
+    if (!turboModuleCache || !jsCallInvoker || !nativeMethodCallInvoker ||
         !delegate || !javaPart) {
       return nullptr;
     }
@@ -205,7 +207,7 @@ TurboModuleManager::createTurboModuleProvider() {
           .moduleName = name,
           .instance = moduleInstance,
           .jsInvoker = jsCallInvoker,
-          .nativeInvoker = nativeCallInvoker};
+          .nativeMethodCallInvoker = nativeMethodCallInvoker};
 
       auto turboModule = delegate->cthis()->getTurboModule(name, params);
       turboModuleCache->insert({name, turboModule});
@@ -221,17 +223,18 @@ TurboModuleProviderFunctionType
 TurboModuleManager::createLegacyModuleProvider() {
   return [legacyModuleCache_ = std::weak_ptr<ModuleCache>(legacyModuleCache_),
           jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
-          nativeCallInvoker_ = std::weak_ptr<CallInvoker>(nativeCallInvoker_),
+          nativeMethodCallInvoker_ =
+              std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
           delegate_ = jni::make_weak(delegate_),
           javaPart_ = jni::make_weak(javaPart_)](
              const std::string &name) -> std::shared_ptr<TurboModule> {
     auto legacyModuleCache = legacyModuleCache_.lock();
     auto jsCallInvoker = jsCallInvoker_.lock();
-    auto nativeCallInvoker = nativeCallInvoker_.lock();
+    auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
     auto delegate = delegate_.lockLocal();
     auto javaPart = javaPart_.lockLocal();
 
-    if (!legacyModuleCache || !jsCallInvoker || !nativeCallInvoker ||
+    if (!legacyModuleCache || !jsCallInvoker || !nativeMethodCallInvoker ||
         !delegate || !javaPart) {
       return nullptr;
     }
@@ -278,7 +281,7 @@ TurboModuleManager::createLegacyModuleProvider() {
           .moduleName = name,
           .instance = moduleInstance,
           .jsInvoker = jsCallInvoker,
-          .nativeInvoker = nativeCallInvoker};
+          .nativeMethodCallInvoker = nativeMethodCallInvoker};
 
       static auto getMethodDescriptorsFromModule =
           javaPart->getClass()
diff --git a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.h b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.h
index 03a0ad387009a6..47c8711bb60a28 100644
--- a/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.h
+++ b/packages/react-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.h
@@ -10,6 +10,7 @@
 #include <ReactCommon/CallInvokerHolder.h>
 #include <ReactCommon/JavaTurboModule.h>
 #include <ReactCommon/LongLivedObject.h>
+#include <ReactCommon/NativeMethodCallInvokerHolder.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModuleManagerDelegate.h>
@@ -30,7 +31,8 @@ class TurboModuleManager : public jni::HybridClass<TurboModuleManager> {
       jni::alias_ref<jhybridobject> jThis,
       jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
       jni::alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
-      jni::alias_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder,
+      jni::alias_ref<NativeMethodCallInvokerHolder::javaobject>
+          nativeMethodCallInvokerHolder,
       jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate);
   static void registerNatives();
 
@@ -39,7 +41,7 @@ class TurboModuleManager : public jni::HybridClass<TurboModuleManager> {
   jni::global_ref<TurboModuleManager::javaobject> javaPart_;
   RuntimeExecutor runtimeExecutor_;
   std::shared_ptr<CallInvoker> jsCallInvoker_;
-  std::shared_ptr<CallInvoker> nativeCallInvoker_;
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker_;
   jni::global_ref<TurboModuleManagerDelegate::javaobject> delegate_;
 
   using ModuleCache =
@@ -59,7 +61,7 @@ class TurboModuleManager : public jni::HybridClass<TurboModuleManager> {
       jni::alias_ref<TurboModuleManager::jhybridobject> jThis,
       RuntimeExecutor runtimeExecutor,
       std::shared_ptr<CallInvoker> jsCallInvoker,
-      std::shared_ptr<CallInvoker> nativeCallInvoker,
+      std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker,
       jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate);
 
   TurboModuleProviderFunctionType createTurboModuleProvider();
diff --git a/packages/react-native/ReactCommon/callinvoker/ReactCommon/CallInvoker.h b/packages/react-native/ReactCommon/callinvoker/ReactCommon/CallInvoker.h
index 55aa865bfad717..cec0abda69ee9d 100644
--- a/packages/react-native/ReactCommon/callinvoker/ReactCommon/CallInvoker.h
+++ b/packages/react-native/ReactCommon/callinvoker/ReactCommon/CallInvoker.h
@@ -32,4 +32,11 @@ class CallInvoker {
   virtual ~CallInvoker() {}
 };
 
+class NativeMethodCallInvoker {
+ public:
+  virtual void invokeAsync(const std::string &methodName, CallFunc &&func) = 0;
+  virtual void invokeSync(const std::string &methodName, CallFunc &&func) = 0;
+  virtual ~NativeMethodCallInvoker() {}
+};
+
 } // namespace facebook::react
diff --git a/packages/react-native/ReactCommon/cxxreact/Instance.cpp b/packages/react-native/ReactCommon/cxxreact/Instance.cpp
index 1dfa0e682a34b6..7cf9d3a148eda6 100644
--- a/packages/react-native/ReactCommon/cxxreact/Instance.cpp
+++ b/packages/react-native/ReactCommon/cxxreact/Instance.cpp
@@ -233,9 +233,11 @@ RuntimeExecutor Instance::getRuntimeExecutor() {
   return runtimeExecutor;
 }
 
-std::shared_ptr<CallInvoker> Instance::getDecoratedNativeCallInvoker(
-    std::shared_ptr<CallInvoker> nativeInvoker) {
-  return nativeToJsBridge_->getDecoratedNativeCallInvoker(nativeInvoker);
+std::shared_ptr<NativeMethodCallInvoker>
+Instance::getDecoratedNativeMethodCallInvoker(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) {
+  return nativeToJsBridge_->getDecoratedNativeMethodCallInvoker(
+      nativeMethodCallInvoker);
 }
 
 void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
diff --git a/packages/react-native/ReactCommon/cxxreact/Instance.h b/packages/react-native/ReactCommon/cxxreact/Instance.h
index 567e72fc124a84..ca0106de18f28f 100644
--- a/packages/react-native/ReactCommon/cxxreact/Instance.h
+++ b/packages/react-native/ReactCommon/cxxreact/Instance.h
@@ -101,10 +101,10 @@ class RN_EXPORT Instance {
   std::shared_ptr<CallInvoker> getJSCallInvoker();
 
   /**
-   * Native CallInvoker is used by TurboModules to schedule work on the
+   * NativeMethodCallInvoker is used by TurboModules to schedule work on the
    * NativeModule thread(s).
    *
-   * Why is the bridge decorating native CallInvoker?
+   * Why is the bridge decorating NativeMethodCallInvoker?
    *
    * - The bridge must be informed of all TurboModule async method calls. Why?
    *   When all queued NativeModule method calls are flushed by a call from
@@ -116,16 +116,16 @@ class RN_EXPORT Instance {
    *   since the last time the bridge was flushed. If this number is non-zero,
    *   we fire onBatchComplete.
    *
-   * Why can't we just create and return a new native CallInvoker?
+   * Why can't we just create and return a new NativeMethodCallInvoker?
    *
    * - On Android, we have one NativeModule thread. That thread is created and
    *   managed outside of NativeToJsBridge. On iOS, we have one MethodQueue per
    *   module. Those MethodQueues are also created and managed outside of
-   *   NativeToJsBridge. Therefore, we need to pass in a CallInvoker that
-   *   schedules work on the respective thread.
+   *   NativeToJsBridge. Therefore, we need to pass in a
+   * NativeMethodCallInvoker that schedules work on the respective thread.
    */
-  std::shared_ptr<CallInvoker> getDecoratedNativeCallInvoker(
-      std::shared_ptr<CallInvoker> nativeInvoker);
+  std::shared_ptr<NativeMethodCallInvoker> getDecoratedNativeMethodCallInvoker(
+      std::shared_ptr<NativeMethodCallInvoker> nativeInvoker);
 
   /**
    * RuntimeExecutor is used by Fabric to access the jsi::Runtime.
diff --git a/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.cpp b/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.cpp
index 456bfca43d583f..77eee51c3b4da5 100644
--- a/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.cpp
+++ b/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.cpp
@@ -310,33 +310,38 @@ void NativeToJsBridge::runOnExecutorQueue(
       });
 }
 
-std::shared_ptr<CallInvoker> NativeToJsBridge::getDecoratedNativeCallInvoker(
-    std::shared_ptr<CallInvoker> nativeInvoker) {
-  class NativeCallInvoker : public CallInvoker {
+std::shared_ptr<NativeMethodCallInvoker>
+NativeToJsBridge::getDecoratedNativeMethodCallInvoker(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) const {
+  class NativeMethodCallInvokerImpl : public NativeMethodCallInvoker {
    private:
     std::weak_ptr<JsToNativeBridge> m_jsToNativeBridge;
-    std::shared_ptr<CallInvoker> m_nativeInvoker;
+    std::shared_ptr<NativeMethodCallInvoker> m_nativeInvoker;
 
    public:
-    NativeCallInvoker(
+    NativeMethodCallInvokerImpl(
         std::weak_ptr<JsToNativeBridge> jsToNativeBridge,
-        std::shared_ptr<CallInvoker> nativeInvoker)
-        : m_jsToNativeBridge(jsToNativeBridge),
-          m_nativeInvoker(nativeInvoker) {}
+        std::shared_ptr<NativeMethodCallInvoker> nativeInvoker)
+        : m_jsToNativeBridge(std::move(jsToNativeBridge)),
+          m_nativeInvoker(std::move(nativeInvoker)) {}
 
-    void invokeAsync(std::function<void()> &&func) override {
+    void invokeAsync(
+        const std::string &methodName,
+        std::function<void()> &&func) override {
       if (auto strongJsToNativeBridge = m_jsToNativeBridge.lock()) {
         strongJsToNativeBridge->recordTurboModuleAsyncMethodCall();
       }
-      m_nativeInvoker->invokeAsync(std::move(func));
+      m_nativeInvoker->invokeAsync(methodName, std::move(func));
     }
 
-    void invokeSync(std::function<void()> &&func) override {
-      m_nativeInvoker->invokeSync(std::move(func));
+    void invokeSync(const std::string &methodName, std::function<void()> &&func)
+        override {
+      m_nativeInvoker->invokeSync(methodName, std::move(func));
     }
   };
 
-  return std::make_shared<NativeCallInvoker>(m_delegate, nativeInvoker);
+  return std::make_shared<NativeMethodCallInvokerImpl>(
+      m_delegate, std::move(nativeMethodCallInvoker));
 }
 
 } // namespace facebook::react
diff --git a/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.h b/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.h
index 13c358614e9bba..4d29fdd661f48a 100644
--- a/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.h
+++ b/packages/react-native/ReactCommon/cxxreact/NativeToJsBridge.h
@@ -100,11 +100,11 @@ class NativeToJsBridge {
   void runOnExecutorQueue(std::function<void(JSExecutor *)> task);
 
   /**
-   * Native CallInvoker is used by TurboModules to schedule work on the
+   * NativeMethodCallInvoker is used by TurboModules to schedule work on the
    * NativeModule thread(s).
    */
-  std::shared_ptr<CallInvoker> getDecoratedNativeCallInvoker(
-      std::shared_ptr<CallInvoker> nativeInvoker);
+  std::shared_ptr<NativeMethodCallInvoker> getDecoratedNativeMethodCallInvoker(
+      std::shared_ptr<NativeMethodCallInvoker> nativeInvoker) const;
 
  private:
   // This is used to avoid a race condition where a proxyCallback gets queued
diff --git a/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.cpp b/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.cpp
similarity index 57%
rename from packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.cpp
rename to packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.cpp
index b1785bbe0ae2bb..5a924edddca623 100644
--- a/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.cpp
+++ b/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.cpp
@@ -5,19 +5,23 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "BridgelessNativeCallInvoker.h"
+#include "BridgelessNativeMethodCallInvoker.h"
 
 namespace facebook::react {
 
-BridgelessNativeCallInvoker::BridgelessNativeCallInvoker(
+BridgelessNativeMethodCallInvoker::BridgelessNativeMethodCallInvoker(
     std::shared_ptr<MessageQueueThread> messageQueueThread)
     : messageQueueThread_(std::move(messageQueueThread)) {}
 
-void BridgelessNativeCallInvoker::invokeAsync(std::function<void()> &&func) {
+void BridgelessNativeMethodCallInvoker::invokeAsync(
+    const std::string &methodName,
+    std::function<void()> &&func) {
   messageQueueThread_->runOnQueue(std::move(func));
 }
 
-void BridgelessNativeCallInvoker::invokeSync(std::function<void()> &&func) {
+void BridgelessNativeMethodCallInvoker::invokeSync(
+    const std::string &methodName,
+    std::function<void()> &&func) {
   messageQueueThread_->runOnQueueSync(std::move(func));
 }
 
diff --git a/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.h b/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.h
similarity index 62%
rename from packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.h
rename to packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.h
index effddf81e6a503..775ed0daabc2f8 100644
--- a/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeCallInvoker.h
+++ b/packages/react-native/ReactCommon/react/bridgeless/BridgelessNativeMethodCallInvoker.h
@@ -12,12 +12,14 @@
 
 namespace facebook::react {
 
-class BridgelessNativeCallInvoker : public CallInvoker {
+class BridgelessNativeMethodCallInvoker : public NativeMethodCallInvoker {
  public:
-  explicit BridgelessNativeCallInvoker(
+  explicit BridgelessNativeMethodCallInvoker(
       std::shared_ptr<MessageQueueThread> messageQueueThread);
-  void invokeAsync(std::function<void()> &&func) override;
-  void invokeSync(std::function<void()> &&func) override;
+  void invokeAsync(const std::string &methodName, std::function<void()> &&func)
+      override;
+  void invokeSync(const std::string &methodName, std::function<void()> &&func)
+      override;
 
  private:
   std::shared_ptr<MessageQueueThread> messageQueueThread_;
diff --git a/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp b/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp
index 477d144773b852..9f57f4d2c7f59b 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp
+++ b/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp
@@ -31,7 +31,7 @@ namespace TMPL = TurboModulePerfLogger;
 JavaTurboModule::JavaTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(jni::make_global(params.instance)),
-      nativeInvoker_(params.nativeInvoker) {}
+      nativeMethodCallInvoker_(params.nativeMethodCallInvoker) {}
 
 JavaTurboModule::~JavaTurboModule() {
   /**
@@ -42,15 +42,16 @@ JavaTurboModule::~JavaTurboModule() {
     return;
   }
 
-  nativeInvoker_->invokeAsync([instance = std::move(instance_)]() mutable {
-    /**
-     * Reset the global NativeModule ref on the NativeModules thread. Why:
-     *   - ~JavaTurboModule() can be called on a non-JVM thread. If we reset the
-     *     global ref in ~JavaTurboModule(), we might access the JVM from a
-     *     non-JVM thread, which will crash the app.
-     */
-    instance.reset();
-  });
+  nativeMethodCallInvoker_->invokeAsync(
+      "~" + name_, [instance = std::move(instance_)]() mutable {
+        /**
+         * Reset the global NativeModule ref on the NativeModules thread. Why:
+         *   - ~JavaTurboModule() can be called on a non-JVM thread. If we reset
+         * the global ref in ~JavaTurboModule(), we might access the JVM from a
+         *     non-JVM thread, which will crash the app.
+         */
+        instance.reset();
+      });
 }
 
 namespace {
@@ -742,7 +743,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       TMPL::asyncMethodCallArgConversionEnd(moduleName, methodName);
       TMPL::asyncMethodCallDispatch(moduleName, methodName);
 
-      nativeInvoker_->invokeAsync(
+      nativeMethodCallInvoker_->invokeAsync(
+          methodName,
           [jargs,
            globalRefs,
            methodID,
@@ -841,7 +843,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
             TMPL::asyncMethodCallArgConversionEnd(moduleName, methodName);
             TMPL::asyncMethodCallDispatch(moduleName, methodName);
 
-            nativeInvoker_->invokeAsync(
+            nativeMethodCallInvoker_->invokeAsync(
+                methodName,
                 [jargs,
                  globalRefs,
                  methodID,
diff --git a/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h b/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h
index 950d3db3aad35f..63f7d456df1eac 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h
+++ b/packages/react-native/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h
@@ -31,7 +31,7 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
     std::string moduleName;
     jni::alias_ref<jobject> instance;
     std::shared_ptr<CallInvoker> jsInvoker;
-    std::shared_ptr<CallInvoker> nativeInvoker;
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker;
   };
 
   JavaTurboModule(const InitParams &params);
@@ -49,7 +49,7 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
  private:
   // instance_ can be of type JTurboModule, or JNativeModule
   jni::global_ref<jobject> instance_;
-  std::shared_ptr<CallInvoker> nativeInvoker_;
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker_;
 };
 
 } // namespace facebook::react
diff --git a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h
index 5b91c5b949da05..bdfbeeb596af52 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h
+++ b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h
@@ -43,7 +43,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
     std::string moduleName;
     id<RCTBridgeModule> instance;
     std::shared_ptr<CallInvoker> jsInvoker;
-    std::shared_ptr<CallInvoker> nativeInvoker;
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker;
     bool isSyncModule;
   };
 
@@ -58,7 +58,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       size_t count);
 
   id<RCTBridgeModule> instance_;
-  std::shared_ptr<CallInvoker> nativeInvoker_;
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker_;
 
  protected:
   void setMethodArgConversionSelector(NSString *methodName, int argIndex, NSString *fnName);
@@ -159,6 +159,6 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
  */
 @interface RCTBridge (RCTTurboModule)
 - (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
-- (std::shared_ptr<facebook::react::CallInvoker>)decorateNativeCallInvoker:
-    (std::shared_ptr<facebook::react::CallInvoker>)nativeInvoker;
+- (std::shared_ptr<facebook::react::NativeMethodCallInvoker>)decorateNativeMethodCallInvoker:
+    (std::shared_ptr<facebook::react::NativeMethodCallInvoker>)nativeMethodCallInvoker;
 @end
diff --git a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm
index ce9a0ffcf3035d..c1ed34e282f55f 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm
+++ b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm
@@ -424,7 +424,7 @@ id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, s
   } else {
     asyncCallCounter = getUniqueId();
     TurboModulePerfLogger::asyncMethodCallDispatch(moduleName, methodName);
-    nativeInvoker_->invokeAsync([block]() -> void { block(); });
+    nativeMethodCallInvoker_->invokeAsync(methodNameStr, [block]() -> void { block(); });
     return nil;
   }
 }
@@ -685,7 +685,7 @@ id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, s
 ObjCTurboModule::ObjCTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(params.instance),
-      nativeInvoker_(params.nativeInvoker),
+      nativeMethodCallInvoker_(params.nativeMethodCallInvoker),
       isSyncModule_(params.isSyncModule)
 {
 }
diff --git a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm
index 4b8ab526f04404..2b6b6883e0a63f 100644
--- a/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm
+++ b/packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm
@@ -111,13 +111,13 @@ bool isCreatingModule() const
   }
 };
 
-class MethodQueueNativeCallInvoker : public CallInvoker {
+class MethodQueueNativeMethodCallInvoker : public NativeMethodCallInvoker {
  private:
   dispatch_queue_t methodQueue_;
 
  public:
-  MethodQueueNativeCallInvoker(dispatch_queue_t methodQueue) : methodQueue_(methodQueue) {}
-  void invokeAsync(std::function<void()> &&work) override
+  MethodQueueNativeMethodCallInvoker(dispatch_queue_t methodQueue) : methodQueue_(methodQueue) {}
+  void invokeAsync(const std::string &methodName, std::function<void()> &&work) override
   {
     if (methodQueue_ == RCTJSThread) {
       work();
@@ -130,7 +130,7 @@ void invokeAsync(std::function<void()> &&work) override
     });
   }
 
-  void invokeSync(std::function<void()> &&work) override
+  void invokeSync(const std::string &methodName, std::function<void()> &&work) override
   {
     if (methodQueue_ == RCTJSThread) {
       work();
@@ -303,14 +303,15 @@ - (void)notifyAboutTurboModuleSetup:(const char *)name
   /**
    * Step 2c: Create and native CallInvoker from the TurboModule's method queue.
    */
-  std::shared_ptr<CallInvoker> nativeInvoker = std::make_shared<MethodQueueNativeCallInvoker>(methodQueue);
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker =
+      std::make_shared<MethodQueueNativeMethodCallInvoker>(methodQueue);
 
   /**
    * Have RCTCxxBridge decorate native CallInvoker, so that it's aware of TurboModule async method calls.
    * This helps the bridge fire onBatchComplete as readily as it should.
    */
-  if ([_bridge respondsToSelector:@selector(decorateNativeCallInvoker:)]) {
-    nativeInvoker = [_bridge decorateNativeCallInvoker:nativeInvoker];
+  if ([_bridge respondsToSelector:@selector(decorateNativeMethodCallInvoker:)]) {
+    nativeMethodCallInvoker = [_bridge decorateNativeMethodCallInvoker:nativeMethodCallInvoker];
   }
 
   /**
@@ -336,7 +337,7 @@ - (void)notifyAboutTurboModuleSetup:(const char *)name
         .moduleName = moduleName,
         .instance = module,
         .jsInvoker = _jsInvoker,
-        .nativeInvoker = nativeInvoker,
+        .nativeMethodCallInvoker = nativeMethodCallInvoker,
         .isSyncModule = methodQueue == RCTJSThread,
     };
 
@@ -381,7 +382,8 @@ - (void)notifyAboutTurboModuleSetup:(const char *)name
   }
 
   // Create a native call invoker from module's method queue
-  std::shared_ptr<CallInvoker> nativeInvoker = std::make_shared<MethodQueueNativeCallInvoker>(methodQueue);
+  std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker =
+      std::make_shared<MethodQueueNativeMethodCallInvoker>(methodQueue);
 
   // If module is a legacy cxx module, return TurboCxxModule
   if ([moduleClass isSubclassOfClass:RCTCxxModule.class]) {
@@ -397,7 +399,7 @@ - (void)notifyAboutTurboModuleSetup:(const char *)name
       .moduleName = moduleName,
       .instance = module,
       .jsInvoker = _jsInvoker,
-      .nativeInvoker = nativeInvoker,
+      .nativeMethodCallInvoker = std::move(nativeMethodCallInvoker),
       .isSyncModule = methodQueue == RCTJSThread,
   };