react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -6,8 +6,10 @@
  */
 
 #include "JReactHostInspectorTarget.h"
+
 #include <fbjni/NativeRunnable.h>
 #include <jsinspector-modern/InspectorFlags.h>
+#include <react/jni/JWeakRefUtils.h>
 #include <react/jni/SafeReleaseJniRef.h>
 
 using namespace facebook::jni;
@@ -15,26 +17,23 @@ using namespace facebook::react::jsinspector_modern;
 
 namespace facebook::react {
 JReactHostInspectorTarget::JReactHostInspectorTarget(
-    alias_ref<JReactHostImpl::javaobject> reactHostImpl,
+    alias_ref<JReactHostImpl> reactHostImpl,
     alias_ref<JExecutor::javaobject> executor)
-    : javaReactHostImpl_(make_global(reactHostImpl)),
-      javaExecutor_(make_global(executor)) {
+    : javaReactHostImpl_(make_global(makeJWeakReference(reactHostImpl))),
+      inspectorExecutor_([javaExecutor =
+                              // Use a SafeReleaseJniRef because this lambda may
+                              // be copied to arbitrary threads.
+                          SafeReleaseJniRef(make_global(executor))](
+                             std::function<void()>&& callback) mutable {
+        auto jrunnable = JNativeRunnable::newObjectCxxArgs(std::move(callback));
+        javaExecutor->execute(jrunnable);
+      }) {
   auto& inspectorFlags = InspectorFlags::getInstance();
   if (inspectorFlags.getFuseboxEnabled()) {
-    inspectorTarget_ = HostTarget::create(
-        *this,
-        [javaExecutor =
-             // Use a SafeReleaseJniRef because this lambda may be copied to
-             // arbitrary threads.
-         SafeReleaseJniRef(javaExecutor_)](
-            std::function<void()>&& callback) mutable {
-          auto jrunnable =
-              JNativeRunnable::newObjectCxxArgs(std::move(callback));
-          javaExecutor->execute(jrunnable);
-        });
+    inspectorTarget_ = HostTarget::create(*this, inspectorExecutor_);
 
     inspectorPageId_ = getInspectorInstance().addPage(
-        "React Native Bridgeless (Experimental)",
+        "React Native Bridgeless",
         /* vm */ "",
         [inspectorTargetWeak = std::weak_ptr(inspectorTarget_)](
             std::unique_ptr<IRemoteConnection> remote)
@@ -51,16 +50,22 @@ JReactHostInspectorTarget::JReactHostInspectorTarget(
 
 JReactHostInspectorTarget::~JReactHostInspectorTarget() {
   if (inspectorPageId_.has_value()) {
-    getInspectorInstance().removePage(*inspectorPageId_);
+    // Remove the page (terminating all sessions) and destroy the target, both
+    // on the inspector queue.
+    inspectorExecutor_([inspectorPageId = *inspectorPageId_,
+                        inspectorTarget = std::move(inspectorTarget_)]() {
+      getInspectorInstance().removePage(inspectorPageId);
+      (void)inspectorTarget;
+    });
   }
 }
 
 local_ref<JReactHostInspectorTarget::jhybriddata>
 JReactHostInspectorTarget::initHybrid(
     alias_ref<JReactHostInspectorTarget::jhybridobject> self,
-    jni::alias_ref<JReactHostImpl::javaobject> reactHostImpl,
-    jni::alias_ref<JExecutor::javaobject> executor) {
-  return makeCxxInstance(reactHostImpl, executor);
+    jni::alias_ref<JReactHostImpl> reactHostImpl,
+    jni::alias_ref<JExecutor::javaobject> javaExecutor) {
+  return makeCxxInstance(reactHostImpl, javaExecutor);
 }
 
 void JReactHostInspectorTarget::sendDebuggerResumeCommand() {
@@ -84,18 +89,55 @@ void JReactHostInspectorTarget::registerNatives() {
 
 jsinspector_modern::HostTargetMetadata
 JReactHostInspectorTarget::getMetadata() {
-  return {
+  jsinspector_modern::HostTargetMetadata metadata = {
       .integrationName = "Android Bridgeless (ReactHostImpl)",
   };
+
+  if (auto javaReactHostImplStrong = javaReactHostImpl_->get()) {
+    auto javaMetadata = javaReactHostImplStrong->getHostMetadata();
+    auto getMethod = jni::JMap<jstring, jstring>::javaClassLocal()
+                         ->getMethod<jobject(jobject)>("get");
+
+    auto getStringOptional = [&](const std::string& key) {
+      auto result = getMethod(javaMetadata, make_jstring(key).get());
+      return result ? std::optional<std::string>(result->toString())
+                    : std::nullopt;
+    };
+
+    metadata.appDisplayName = getStringOptional("appDisplayName");
+    metadata.appIdentifier = getStringOptional("appIdentifier");
+    metadata.deviceName = getStringOptional("deviceName");
+    metadata.platform = getStringOptional("platform");
+    metadata.reactNativeVersion = getStringOptional("reactNativeVersion");
+  }
+
+  return metadata;
 }
 
 void JReactHostInspectorTarget::onReload(const PageReloadRequest& request) {
-  javaReactHostImpl_->reload("CDP Page.reload");
+  if (auto javaReactHostImplStrong = javaReactHostImpl_->get()) {
+    javaReactHostImplStrong->reload("CDP Page.reload");
+  }
 }
 
 void JReactHostInspectorTarget::onSetPausedInDebuggerMessage(
     const OverlaySetPausedInDebuggerMessageRequest& request) {
-  javaReactHostImpl_->setPausedInDebuggerMessage(request.message);
+  if (auto javaReactHostImplStrong = javaReactHostImpl_->get()) {
+    javaReactHostImplStrong->setPausedInDebuggerMessage(request.message);
+  }
+}
+
+void JReactHostInspectorTarget::loadNetworkResource(
+    const jsinspector_modern::LoadNetworkResourceRequest& params,
+    jsinspector_modern::ScopedExecutor<
+        jsinspector_modern::NetworkRequestListener> executor) {
+  // Construct InspectorNetworkRequestListener (hybrid class) from the C++ side
+  // (holding the ScopedExecutor), pass to the delegate.
+  auto listener = InspectorNetworkRequestListener::newObjectCxxArgs(executor);
+
+  if (auto javaReactHostImplStrong = javaReactHostImpl_->get()) {
+    javaReactHostImplStrong->loadNetworkResource(params.url, listener);
+  }
 }
 
 HostTarget* JReactHostInspectorTarget::getInspectorTarget() {

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -9,6 +9,7 @@
 
 #include <fbjni/fbjni.h>
 #include <jsinspector-modern/HostTarget.h>
+#include <react/jni/InspectorNetworkRequestListener.h>
 #include <react/jni/JExecutor.h>
 #include <string>
 
@@ -36,6 +37,27 @@ struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {
             "setPausedInDebuggerMessage");
     method(self(), message ? jni::make_jstring(*message) : nullptr);
   }
+
+  jni::local_ref<jni::JMap<jstring, jstring>> getHostMetadata() const {
+    static auto method =
+        javaClassStatic()
+            ->getMethod<jni::local_ref<jni::JMap<jstring, jstring>>()>(
+                "getHostMetadata");
+    return method(self());
+  }
+
+  void loadNetworkResource(
+      const std::string& url,
+      jni::local_ref<InspectorNetworkRequestListener::javaobject> listener)
+      const {
+    auto method =
+        javaClassStatic()
+            ->getMethod<void(
+                jni::local_ref<jni::JString>,
+                jni::local_ref<InspectorNetworkRequestListener::javaobject>)>(
+                "loadNetworkResource");
+    return method(self(), jni::make_jstring(url), listener);
+  }
 };
 
 class JReactHostInspectorTarget
@@ -49,8 +71,8 @@ class JReactHostInspectorTarget
 
   static jni::local_ref<JReactHostInspectorTarget::jhybriddata> initHybrid(
       jni::alias_ref<JReactHostInspectorTarget::jhybridobject> jThis,
-      jni::alias_ref<JReactHostImpl::javaobject> reactHost,
-      jni::alias_ref<JExecutor::javaobject>);
+      jni::alias_ref<JReactHostImpl> reactHost,
+      jni::alias_ref<JExecutor::javaobject> javaExecutor);
 
   static void registerNatives();
   void sendDebuggerResumeCommand();
@@ -62,13 +84,20 @@ class JReactHostInspectorTarget
   void onReload(const PageReloadRequest& request) override;
   void onSetPausedInDebuggerMessage(
       const OverlaySetPausedInDebuggerMessageRequest&) override;
+  void loadNetworkResource(
+      const jsinspector_modern::LoadNetworkResourceRequest& params,
+      jsinspector_modern::ScopedExecutor<
+          jsinspector_modern::NetworkRequestListener> executor) override;
 
  private:
   JReactHostInspectorTarget(
-      jni::alias_ref<JReactHostImpl::javaobject> reactHostImpl,
-      jni::alias_ref<JExecutor::javaobject> executor);
-  jni::global_ref<JReactHostImpl::javaobject> javaReactHostImpl_;
-  jni::global_ref<JExecutor::javaobject> javaExecutor_;
+      jni::alias_ref<JReactHostImpl> reactHostImpl,
+      jni::alias_ref<JExecutor::javaobject> javaExecutor);
+  // This weak reference breaks the cycle between the C++ HostTarget and the
+  // Java ReactHostImpl, preventing memory leaks in apps that create multiple
+  // ReactHostImpls over time.
+  jni::global_ref<jni::JWeakReference<JReactHostImpl>> javaReactHostImpl_;
+  jsinspector_modern::VoidExecutor inspectorExecutor_;
 
   std::shared_ptr<jsinspector_modern::HostTarget> inspectorTarget_;
   std::optional<int> inspectorPageId_;

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactInstance.cpp

@@ -74,6 +74,7 @@ JReactInstance::JReactInstance(
   timerManager->setRuntimeExecutor(bufferedRuntimeExecutor);
 
   ReactInstance::JSRuntimeFlags options = {.isProfiling = isProfiling};
+  // TODO T194671568 Consider moving runtime init to the JS thread.
   instance_->initializeRuntime(options, [this](jsi::Runtime& runtime) {
     react::Logger androidLogger =
         static_cast<void (*)(const std::string&, unsigned int)>(

package/ReactAndroid/src/main/jni/react/runtime/jsc/jni/CMakeLists.txt

@@ -8,15 +8,17 @@ set(CMAKE_VERBOSE_MAKEFILE on)
 
 add_compile_options(-fvisibility=hidden -fexceptions -frtti)
 
+include(${REACT_ANDROID_DIR}/src/main/jni/first-party/jni-lib-merge/SoMerging-utils.cmake)
+
 file(GLOB jscinstance_SRC CONFIGURE_DEPENDS "*.cpp")
-add_library(jscinstance SHARED ${jscinstance_SRC})
+
+add_library(jscinstance OBJECT ${jscinstance_SRC})
 
 target_include_directories(jscinstance PUBLIC .)
+target_merge_so(jscinstance)
 
-target_link_libraries(
-        jscinstance
-        bridgeless
+target_link_libraries(jscinstance
         jscruntime
         fbjni
-        reactnativejni
+        reactnative
 )

package/ReactAndroid/src/main/jni/react/turbomodule/CMakeLists.txt

@@ -19,7 +19,7 @@ add_compile_options(
 # TODO This should be exported to its own folder hierarchy
 add_library(
         callinvokerholder
-        STATIC
+        OBJECT
         ReactCommon/CallInvokerHolder.cpp
         ReactCommon/NativeMethodCallInvokerHolder.cpp
 )
@@ -40,15 +40,20 @@ target_link_libraries(callinvokerholder
 ### react_nativemodule_manager ###
 ##################################
 
+include(${REACT_ANDROID_DIR}/src/main/jni/first-party/jni-lib-merge/SoMerging-utils.cmake)
+
 # TODO: rename to react_nativemodule_manager
 add_library(
         turbomodulejsijni
-        SHARED
+        OBJECT
         ReactCommon/BindingsInstallerHolder.cpp
         ReactCommon/CompositeTurboModuleManagerDelegate.cpp
         ReactCommon/OnLoad.cpp
         ReactCommon/TurboModuleManager.cpp
+        $<TARGET_OBJECTS:logger>
+        $<TARGET_OBJECTS:react_bridging>
 )
+target_merge_so(turbomodulejsijni)
 
 target_include_directories(
         turbomodulejsijni

package/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include "TurboModuleManager.h"
+
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -18,8 +20,7 @@
 #include <ReactCommon/TurboCxxModule.h>
 #include <ReactCommon/TurboModuleBinding.h>
 #include <ReactCommon/TurboModulePerfLogger.h>
-
-#include "TurboModuleManager.h"
+#include <react/jni/CxxModuleWrapper.h>
 
 namespace facebook::react {
 
@@ -101,9 +102,7 @@ TurboModuleManager::TurboModuleManager(
     : runtimeExecutor_(std::move(runtimeExecutor)),
       jsCallInvoker_(std::move(jsCallInvoker)),
       nativeMethodCallInvoker_(std::move(nativeMethodCallInvoker)),
-      delegate_(jni::make_global(delegate)),
-      turboModuleCache_(std::make_shared<ModuleCache>()),
-      legacyModuleCache_(std::make_shared<ModuleCache>()) {}
+      delegate_(jni::make_global(delegate)) {}
 
 jni::local_ref<TurboModuleManager::jhybriddata> TurboModuleManager::initHybrid(
     jni::alias_ref<jhybridobject> /* unused */,
@@ -129,206 +128,199 @@ void TurboModuleManager::registerNatives() {
 
 TurboModuleProviderFunctionType TurboModuleManager::createTurboModuleProvider(
     jni::alias_ref<jhybridobject> javaPart,
-    jsi::Runtime* runtime,
-    bool enableSyncVoidMethods) {
-  return [turboModuleCache_ = std::weak_ptr<ModuleCache>(turboModuleCache_),
-          runtime,
-          jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
-          nativeMethodCallInvoker_ =
-              std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
-          weakDelegate = jni::make_weak(delegate_),
-          weakJavaPart = jni::make_weak(javaPart),
-          enableSyncVoidMethods](
+    jsi::Runtime* runtime) {
+  return [runtime, weakJavaPart = jni::make_weak(javaPart)](
              const std::string& name) -> std::shared_ptr<TurboModule> {
-    auto turboModuleCache = turboModuleCache_.lock();
-    auto jsCallInvoker = jsCallInvoker_.lock();
-    auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
-    auto delegate = weakDelegate.lockLocal();
     auto javaPart = weakJavaPart.lockLocal();
-
-    if (!turboModuleCache || !jsCallInvoker || !nativeMethodCallInvoker ||
-        !delegate || !javaPart) {
+    if (!javaPart) {
       return nullptr;
     }
 
-    const char* moduleName = name.c_str();
-
-    TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
-
-    auto turboModuleLookup = turboModuleCache->find(name);
-    if (turboModuleLookup != turboModuleCache->end()) {
-      TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
-      TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
-      return turboModuleLookup->second;
+    auto cxxPart = javaPart->cthis();
+    if (cxxPart == nullptr) {
+      return nullptr;
     }
 
-    TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
+    return cxxPart->getTurboModule(javaPart, name, *runtime);
+  };
+}
 
-    auto cxxModule = delegate->cthis()->getTurboModule(name, jsCallInvoker);
-    if (cxxModule) {
-      turboModuleCache->insert({name, cxxModule});
-      return cxxModule;
-    }
+std::shared_ptr<TurboModule> TurboModuleManager::getTurboModule(
+    jni::alias_ref<jhybridobject> javaPart,
+    const std::string& name,
+    jsi::Runtime& runtime) {
+  const char* moduleName = name.c_str();
+  TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
+
+  auto turboModuleLookup = turboModuleCache_.find(name);
+  if (turboModuleLookup != turboModuleCache_.end()) {
+    TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
+    TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
+    return turboModuleLookup->second;
+  }
 
-    auto& cxxTurboModuleMapProvider = globalExportedCxxTurboModuleMap();
-    auto it = cxxTurboModuleMapProvider.find(name);
-    if (it != cxxTurboModuleMapProvider.end()) {
-      auto turboModule = it->second(jsCallInvoker);
-      turboModuleCache->insert({name, turboModule});
-      return turboModule;
-    }
+  TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
 
-    static auto getTurboLegacyCxxModule =
-        javaPart->getClass()
-            ->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
-                const std::string&)>("getTurboLegacyCxxModule");
-    auto legacyCxxModule = getTurboLegacyCxxModule(javaPart.get(), name);
+  auto cxxDelegate = delegate_->cthis();
 
-    if (legacyCxxModule) {
-      TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
+  auto cxxModule = cxxDelegate->getTurboModule(name, jsCallInvoker_);
+  if (cxxModule) {
+    turboModuleCache_.insert({name, cxxModule});
+    return cxxModule;
+  }
 
-      auto turboModule = std::make_shared<react::TurboCxxModule>(
-          legacyCxxModule->cthis()->getModule(), jsCallInvoker);
-      turboModuleCache->insert({name, turboModule});
+  auto& cxxTurboModuleMapProvider = globalExportedCxxTurboModuleMap();
+  auto it = cxxTurboModuleMapProvider.find(name);
+  if (it != cxxTurboModuleMapProvider.end()) {
+    auto turboModule = it->second(jsCallInvoker_);
+    turboModuleCache_.insert({name, turboModule});
+    return turboModule;
+  }
 
-      TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
-      return turboModule;
+  static auto getTurboJavaModule =
+      javaPart->getClass()
+          ->getMethod<jni::alias_ref<JTurboModule>(const std::string&)>(
+              "getTurboJavaModule");
+  auto moduleInstance = getTurboJavaModule(javaPart.get(), name);
+  if (moduleInstance) {
+    TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
+    JavaTurboModule::InitParams params = {
+        .moduleName = name,
+        .instance = moduleInstance,
+        .jsInvoker = jsCallInvoker_,
+        .nativeMethodCallInvoker = nativeMethodCallInvoker_};
+
+    auto turboModule = cxxDelegate->getTurboModule(name, params);
+    if (moduleInstance->isInstanceOf(
+            JTurboModuleWithJSIBindings::javaClassStatic())) {
+      static auto getBindingsInstaller =
+          JTurboModuleWithJSIBindings::javaClassStatic()
+              ->getMethod<BindingsInstallerHolder::javaobject()>(
+                  "getBindingsInstaller");
+      auto installer = getBindingsInstaller(moduleInstance);
+      if (installer) {
+        installer->cthis()->installBindings(runtime);
+      }
     }
 
-    static auto getTurboJavaModule =
-        javaPart->getClass()
-            ->getMethod<jni::alias_ref<JTurboModule>(const std::string&)>(
-                "getTurboJavaModule");
-    auto moduleInstance = getTurboJavaModule(javaPart.get(), name);
-
-    if (moduleInstance) {
-      TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
-      JavaTurboModule::InitParams params = {
-          .moduleName = name,
-          .instance = moduleInstance,
-          .jsInvoker = jsCallInvoker,
-          .nativeMethodCallInvoker = nativeMethodCallInvoker,
-          .shouldVoidMethodsExecuteSync = enableSyncVoidMethods};
-
-      auto turboModule = delegate->cthis()->getTurboModule(name, params);
-      if (moduleInstance->isInstanceOf(
-              JTurboModuleWithJSIBindings::javaClassStatic())) {
-        static auto getBindingsInstaller =
-            JTurboModuleWithJSIBindings::javaClassStatic()
-                ->getMethod<BindingsInstallerHolder::javaobject()>(
-                    "getBindingsInstaller");
-        auto installer = getBindingsInstaller(moduleInstance);
-        if (installer) {
-          installer->cthis()->installBindings(*runtime);
-        }
-      }
+    turboModuleCache_.insert({name, turboModule});
+    TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
+    return turboModule;
+  }
 
-      turboModuleCache->insert({name, turboModule});
-      TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
-      return turboModule;
-    }
+  static auto getTurboLegacyCxxModule =
+      javaPart->getClass()
+          ->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
+              const std::string&)>("getTurboLegacyCxxModule");
+  auto legacyCxxModule = getTurboLegacyCxxModule(javaPart.get(), name);
+  if (legacyCxxModule) {
+    TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
 
-    return nullptr;
-  };
+    auto turboModule = std::make_shared<react::TurboCxxModule>(
+        legacyCxxModule->cthis()->getModule(), jsCallInvoker_);
+    turboModuleCache_.insert({name, turboModule});
+
+    TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
+    return turboModule;
+  }
+
+  return nullptr;
 }
 
 TurboModuleProviderFunctionType TurboModuleManager::createLegacyModuleProvider(
     jni::alias_ref<jhybridobject> javaPart) {
-  return [legacyModuleCache_ = std::weak_ptr<ModuleCache>(legacyModuleCache_),
-          jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
-          nativeMethodCallInvoker_ =
-              std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
-          weakDelegate = jni::make_weak(delegate_),
-          weakJavaPart = jni::make_weak(javaPart)](
+  return [weakJavaPart = jni::make_weak(javaPart)](
              const std::string& name) -> std::shared_ptr<TurboModule> {
-    auto legacyModuleCache = legacyModuleCache_.lock();
-    auto jsCallInvoker = jsCallInvoker_.lock();
-    auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
-    auto delegate = weakDelegate.lockLocal();
     auto javaPart = weakJavaPart.lockLocal();
-
-    if (!legacyModuleCache || !jsCallInvoker || !nativeMethodCallInvoker ||
-        !delegate || !javaPart) {
+    if (!javaPart) {
       return nullptr;
     }
 
-    const char* moduleName = name.c_str();
+    auto cxxPart = javaPart->cthis();
+    if (cxxPart == nullptr) {
+      return nullptr;
+    }
 
-    TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
+    return cxxPart->getLegacyModule(javaPart, name);
+  };
+}
 
-    auto legacyModuleLookup = legacyModuleCache->find(name);
-    if (legacyModuleLookup != legacyModuleCache->end()) {
-      TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
-      TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
-      return legacyModuleLookup->second;
-    }
+std::shared_ptr<TurboModule> TurboModuleManager::getLegacyModule(
+    jni::alias_ref<jhybridobject> javaPart,
+    const std::string& name) {
+  const char* moduleName = name.c_str();
+  TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
 
+  auto legacyModuleLookup = legacyModuleCache_.find(name);
+  if (legacyModuleLookup != legacyModuleCache_.end()) {
+    TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
     TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
+    return legacyModuleLookup->second;
+  }
 
-    static auto getLegacyCxxModule =
-        javaPart->getClass()
-            ->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
-                const std::string&)>("getLegacyCxxModule");
-    auto legacyCxxModule = getLegacyCxxModule(javaPart.get(), name);
+  TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
 
-    if (legacyCxxModule) {
-      TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
+  static auto getLegacyCxxModule =
+      javaPart->getClass()
+          ->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
+              const std::string&)>("getLegacyCxxModule");
+  auto legacyCxxModule = getLegacyCxxModule(javaPart.get(), name);
 
-      auto turboModule = std::make_shared<react::TurboCxxModule>(
-          legacyCxxModule->cthis()->getModule(), jsCallInvoker);
-      legacyModuleCache->insert({name, turboModule});
+  if (legacyCxxModule) {
+    TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
 
-      TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
-      return turboModule;
-    }
+    auto turboModule = std::make_shared<react::TurboCxxModule>(
+        legacyCxxModule->cthis()->getModule(), jsCallInvoker_);
+    legacyModuleCache_.insert({name, turboModule});
+
+    TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
+    return turboModule;
+  }
 
-    static auto getLegacyJavaModule =
+  static auto getLegacyJavaModule =
+      javaPart->getClass()
+          ->getMethod<jni::alias_ref<JNativeModule>(const std::string&)>(
+              "getLegacyJavaModule");
+  auto moduleInstance = getLegacyJavaModule(javaPart.get(), name);
+
+  if (moduleInstance) {
+    TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
+    JavaTurboModule::InitParams params = {
+        .moduleName = name,
+        .instance = moduleInstance,
+        .jsInvoker = jsCallInvoker_,
+        .nativeMethodCallInvoker = nativeMethodCallInvoker_};
+
+    static auto getMethodDescriptorsFromModule =
         javaPart->getClass()
-            ->getMethod<jni::alias_ref<JNativeModule>(const std::string&)>(
-                "getLegacyJavaModule");
-    auto moduleInstance = getLegacyJavaModule(javaPart.get(), name);
-
-    if (moduleInstance) {
-      TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
-      JavaTurboModule::InitParams params = {
-          .moduleName = name,
-          .instance = moduleInstance,
-          .jsInvoker = jsCallInvoker,
-          .nativeMethodCallInvoker = nativeMethodCallInvoker,
-          .shouldVoidMethodsExecuteSync = false};
-
-      static auto getMethodDescriptorsFromModule =
-          javaPart->getClass()
-              ->getStaticMethod<jni::alias_ref<
-                  jni::JList<JMethodDescriptor::javaobject>::javaobject>(
-                  jni::alias_ref<JNativeModule>)>(
-                  "getMethodDescriptorsFromModule");
-
-      auto javaMethodDescriptors =
-          getMethodDescriptorsFromModule(javaPart->getClass(), moduleInstance);
-
-      std::vector<JavaInteropTurboModule::MethodDescriptor> methodDescriptors;
-      for (jni::alias_ref<JMethodDescriptor> javaMethodDescriptor :
-           *javaMethodDescriptors) {
-        methodDescriptors.push_back(javaMethodDescriptor->toMethodDescriptor());
-      }
+            ->getStaticMethod<jni::alias_ref<
+                jni::JList<JMethodDescriptor::javaobject>::javaobject>(
+                jni::alias_ref<JNativeModule>)>(
+                "getMethodDescriptorsFromModule");
+
+    auto javaMethodDescriptors =
+        getMethodDescriptorsFromModule(javaPart->getClass(), moduleInstance);
+
+    std::vector<JavaInteropTurboModule::MethodDescriptor> methodDescriptors;
+    for (jni::alias_ref<JMethodDescriptor> javaMethodDescriptor :
+         *javaMethodDescriptors) {
+      methodDescriptors.push_back(javaMethodDescriptor->toMethodDescriptor());
+    }
 
-      auto turboModule =
-          std::make_shared<JavaInteropTurboModule>(params, methodDescriptors);
+    auto turboModule =
+        std::make_shared<JavaInteropTurboModule>(params, methodDescriptors);
 
-      legacyModuleCache->insert({name, turboModule});
-      TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
-      return turboModule;
-    }
+    legacyModuleCache_.insert({name, turboModule});
+    TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
+    return turboModule;
+  }
 
-    return nullptr;
-  };
+  return nullptr;
 }
 
 void TurboModuleManager::installJSIBindings(
     jni::alias_ref<jhybridobject> javaPart,
-    bool shouldCreateLegacyModules,
-    bool enableSyncVoidMethods) {
+    bool shouldCreateLegacyModules) {
   auto cxxPart = javaPart->cthis();
   if (cxxPart == nullptr || !cxxPart->jsCallInvoker_) {
     return; // Runtime doesn't exist when attached to Chrome debugger.
@@ -336,12 +328,10 @@ void TurboModuleManager::installJSIBindings(
 
   cxxPart->runtimeExecutor_([cxxPart,
                              javaPart = jni::make_global(javaPart),
-                             shouldCreateLegacyModules,
-                             enableSyncVoidMethods](jsi::Runtime& runtime) {
+                             shouldCreateLegacyModules](jsi::Runtime& runtime) {
     TurboModuleBinding::install(
         runtime,
-        cxxPart->createTurboModuleProvider(
-            javaPart, &runtime, enableSyncVoidMethods),
+        cxxPart->createTurboModuleProvider(javaPart, &runtime),
         shouldCreateLegacyModules
             ? cxxPart->createLegacyModuleProvider(javaPart)
             : nullptr);