react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboCxxModule.cpp

@@ -33,24 +33,23 @@ CxxModule::Callback makeTurboCxxModuleCallback(
       return;
     }
 
-    strongWrapper->jsInvoker().invokeAsync([weakWrapper, args]() {
-      auto strongWrapper2 = weakWrapper.lock();
-      if (!strongWrapper2) {
-        return;
-      }
+    strongWrapper->jsInvoker().invokeAsync(
+        [weakWrapper, args](jsi::Runtime& rt) {
+          auto strongWrapper2 = weakWrapper.lock();
+          if (!strongWrapper2) {
+            return;
+          }
 
-      std::vector<jsi::Value> innerArgs;
-      for (auto& a : args) {
-        innerArgs.push_back(
-            jsi::valueFromDynamic(strongWrapper2->runtime(), a));
-      }
-      strongWrapper2->callback().call(
-          strongWrapper2->runtime(),
-          (const jsi::Value*)innerArgs.data(),
-          innerArgs.size());
+          std::vector<jsi::Value> innerArgs;
+          innerArgs.reserve(args.size());
+          for (auto& a : args) {
+            innerArgs.push_back(jsi::valueFromDynamic(rt, a));
+          }
+          strongWrapper2->callback().call(
+              rt, (const jsi::Value*)innerArgs.data(), innerArgs.size());
 
-      strongWrapper2->destroy();
-    });
+          strongWrapper2->destroy();
+        });
 
     wrapperWasCalled = true;
   };

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModule.cpp

@@ -40,25 +40,22 @@ TurboModule::TurboModule(
     : name_(std::move(name)), jsInvoker_(std::move(jsInvoker)) {}
 
 void TurboModule::emitDeviceEvent(
-    jsi::Runtime& runtime,
     const std::string& eventName,
     ArgFactory argFactory) {
-  jsInvoker_->invokeAsync([&runtime, eventName, argFactory]() {
-    jsi::Value emitter =
-        runtime.global().getProperty(runtime, "__rctDeviceEventEmitter");
+  jsInvoker_->invokeAsync([eventName, argFactory](jsi::Runtime& rt) {
+    jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
     if (!emitter.isUndefined()) {
-      jsi::Object emitterObject = emitter.asObject(runtime);
+      jsi::Object emitterObject = emitter.asObject(rt);
       // TODO: consider caching these
       jsi::Function emitFunction =
-          emitterObject.getPropertyAsFunction(runtime, "emit");
+          emitterObject.getPropertyAsFunction(rt, "emit");
       std::vector<jsi::Value> args;
-      args.emplace_back(
-          jsi::String::createFromAscii(runtime, eventName.c_str()));
+      args.emplace_back(jsi::String::createFromAscii(rt, eventName.c_str()));
       if (argFactory) {
-        argFactory(runtime, args);
+        argFactory(rt, args);
       }
       emitFunction.callWithThis(
-          runtime, emitterObject, (const jsi::Value*)args.data(), args.size());
+          rt, emitterObject, (const jsi::Value*)args.data(), args.size());
     }
   });
 }

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -7,12 +7,14 @@
 
 #pragma once
 
+#include <memory>
 #include <string>
 #include <unordered_map>
 
 #include <jsi/jsi.h>
 
 #include <ReactCommon/CallInvoker.h>
+#include <react/bridging/EventEmitter.h>
 
 namespace facebook::react {
 
@@ -89,6 +91,8 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
         size_t count);
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
+      eventEmitterMap_;
 
   using ArgFactory =
       std::function<void(jsi::Runtime& runtime, std::vector<jsi::Value>& args)>;
@@ -106,20 +110,25 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
    *  });
    */
   void emitDeviceEvent(
-      jsi::Runtime& runtime,
       const std::string& eventName,
       ArgFactory argFactory = nullptr);
 
+  // Backwards compatibility version
+  void emitDeviceEvent(
+      jsi::Runtime& /*runtime*/,
+
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr) {
+    emitDeviceEvent(eventName, std::move(argFactory));
+  }
+
   virtual jsi::Value create(
       jsi::Runtime& runtime,
       const jsi::PropNameID& propName) {
     std::string propNameUtf8 = propName.utf8(runtime);
-    auto p = methodMap_.find(propNameUtf8);
-    if (p == methodMap_.end()) {
-      // Method was not found, let JS decide what to do.
-      return facebook::jsi::Value::undefined();
-    } else {
-      const MethodMetadata& meta = p->second;
+    if (auto methodIter = methodMap_.find(propNameUtf8);
+        methodIter != methodMap_.end()) {
+      const MethodMetadata& meta = methodIter->second;
       return jsi::Function::createFromHostFunction(
           runtime,
           propName,
@@ -129,7 +138,12 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
               [[maybe_unused]] const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) { return meta.invoker(rt, *this, args, count); });
+    } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
+               eventEmitterIter != eventEmitterMap_.end()) {
+      return eventEmitterIter->second->get(runtime, jsInvoker_);
     }
+    // Neither Method nor EventEmitter were not found, let JS decide what to do.
+    return facebook::jsi::Value::undefined();
   }
 
  private:

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.cpp

@@ -8,7 +8,7 @@
 #include "TurboModuleBinding.h"
 
 #include <cxxreact/SystraceSection.h>
-#include <react/utils/jsi.h>
+#include <react/utils/jsi-utils.h>
 #include <stdexcept>
 #include <string>
 
@@ -67,9 +67,11 @@ class BridgelessNativeModuleProxy : public jsi::HostObject {
  */
 
 TurboModuleBinding::TurboModuleBinding(
+    jsi::Runtime& runtime,
     TurboModuleProviderFunctionType&& moduleProvider,
     std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
-    : moduleProvider_(std::move(moduleProvider)),
+    : runtime_(runtime),
+      moduleProvider_(std::move(moduleProvider)),
       longLivedObjectCollection_(std::move(longLivedObjectCollection)) {}
 
 void TurboModuleBinding::install(
@@ -85,7 +87,7 @@ void TurboModuleBinding::install(
           jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
           1,
           [binding = TurboModuleBinding(
-               std::move(moduleProvider), longLivedObjectCollection)](
+               runtime, std::move(moduleProvider), longLivedObjectCollection)](
               jsi::Runtime& rt,
               const jsi::Value& thisVal,
               const jsi::Value* args,
@@ -102,7 +104,9 @@ void TurboModuleBinding::install(
     bool rnTurboInterop = legacyModuleProvider != nullptr;
     auto turboModuleBinding = legacyModuleProvider
         ? std::make_unique<TurboModuleBinding>(
-              std::move(legacyModuleProvider), longLivedObjectCollection)
+              runtime,
+              std::move(legacyModuleProvider),
+              longLivedObjectCollection)
         : nullptr;
     auto nativeModuleProxy = std::make_shared<BridgelessNativeModuleProxy>(
         std::move(turboModuleBinding));
@@ -119,7 +123,7 @@ TurboModuleBinding::~TurboModuleBinding() {
   if (longLivedObjectCollection_) {
     longLivedObjectCollection_->clear();
   } else {
-    LongLivedObjectCollection::get().clear();
+    LongLivedObjectCollection::get(runtime_).clear();
   }
 }
 

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.h

@@ -9,9 +9,10 @@
 
 #include <string>
 
-#include <ReactCommon/LongLivedObject.h>
-#include <ReactCommon/TurboModule.h>
 #include <jsi/jsi.h>
+#include <react/bridging/LongLivedObject.h>
+
+#include <ReactCommon/TurboModule.h>
 
 namespace facebook::react {
 
@@ -34,6 +35,7 @@ class TurboModuleBinding {
           nullptr);
 
   TurboModuleBinding(
+      jsi::Runtime& runtime,
       TurboModuleProviderFunctionType&& moduleProvider,
       std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
 
@@ -49,6 +51,7 @@ class TurboModuleBinding {
   jsi::Value getModule(jsi::Runtime& runtime, const std::string& moduleName)
       const;
 
+  jsi::Runtime& runtime_;
   TurboModuleProviderFunctionType moduleProvider_;
   std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
 };

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleUtils.cpp

@@ -63,7 +63,9 @@ jsi::Array deepCopyJSIArray(jsi::Runtime& rt, const jsi::Array& arr) {
 }
 
 Promise::Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject)
-    : runtime_(rt), resolve_(std::move(resolve)), reject_(std::move(reject)) {}
+    : LongLivedObject(rt),
+      resolve_(std::move(resolve)),
+      reject_(std::move(reject)) {}
 
 void Promise::resolve(const jsi::Value& result) {
   resolve_.call(runtime_, result);

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -11,9 +11,8 @@
 #include <string>
 
 #include <jsi/jsi.h>
-
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/CallbackWrapper.h>
+#include <react/bridging/CallbackWrapper.h>
+#include <react/bridging/LongLivedObject.h>
 
 namespace facebook::react {
 
@@ -26,7 +25,6 @@ struct Promise : public LongLivedObject {
   void resolve(const jsi::Value& result);
   void reject(const std::string& error);
 
-  jsi::Runtime& runtime_;
   jsi::Function resolve_;
   jsi::Function reject_;
 };

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -86,12 +86,17 @@ struct JNIArgs {
   std::vector<jobject> globalRefs_;
 };
 
+jsi::Value createJSRuntimeError(jsi::Runtime& runtime, jsi::Value&& message) {
+  return runtime.global()
+      .getPropertyAsFunction(runtime, "Error")
+      .call(runtime, std::move(message));
+}
+
 jsi::Value createJSRuntimeError(
     jsi::Runtime& runtime,
     const std::string& message) {
-  return runtime.global()
-      .getPropertyAsFunction(runtime, "Error")
-      .call(runtime, message);
+  return createJSRuntimeError(
+      runtime, jsi::String::createFromUtf8(runtime, message));
 }
 
 jsi::Value createRejectionError(jsi::Runtime& rt, const folly::dynamic& args) {
@@ -102,10 +107,8 @@ jsi::Value createRejectionError(jsi::Runtime& rt, const folly::dynamic& args) {
   react_native_assert(value.isObject() && "promise reject should return a map");
 
   const jsi::Object& valueAsObject = value.asObject(rt);
-
-  auto messageProperty = valueAsObject.getProperty(rt, "message");
   auto jsError =
-      createJSRuntimeError(rt, messageProperty.asString(rt).utf8(rt));
+      createJSRuntimeError(rt, valueAsObject.getProperty(rt, "message"));
 
   auto jsErrorAsObject = jsError.asObject(rt);
   auto propertyNames = valueAsObject.getPropertyNames(rt);
@@ -480,7 +483,8 @@ jsi::JSError convertThrowableToJSError(
 
   jsi::Object cause(runtime);
   auto name = throwable->getClass()->getCanonicalName()->toStdString();
-  auto message = throwable->getMessage()->toStdString();
+  auto messageStr = throwable->getMessage();
+  auto message = messageStr != nullptr ? messageStr->toStdString() : name;
   cause.setProperty(runtime, "name", name);
   cause.setProperty(runtime, "message", message);
   cause.setProperty(runtime, "stackElements", std::move(stackElements));
@@ -915,11 +919,12 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       // JS Stack at the time when the promise is created.
       std::optional<std::string> jsInvocationStack;
       if (traceTurboModulePromiseRejections()) {
-        jsInvocationStack = createJSRuntimeError(runtime, "")
-                                .asObject(runtime)
-                                .getProperty(runtime, "stack")
-                                .toString(runtime)
-                                .utf8(runtime);
+        jsInvocationStack =
+            createJSRuntimeError(runtime, jsi::Value::undefined())
+                .asObject(runtime)
+                .getProperty(runtime, "stack")
+                .toString(runtime)
+                .utf8(runtime);
       }
 
       const char* moduleName = name_.c_str();

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h

@@ -22,6 +22,12 @@ struct JTurboModule : jni::JavaClass<JTurboModule> {
       "Lcom/facebook/react/turbomodule/core/interfaces/TurboModule;";
 };
 
+struct JTurboModuleWithJSIBindings
+    : jni::JavaClass<JTurboModuleWithJSIBindings> {
+  static auto constexpr kJavaDescriptor =
+      "Lcom/facebook/react/turbomodule/core/interfaces/TurboModuleWithJSIBindings;";
+};
+
 class JSI_EXPORT JavaTurboModule : public TurboModule {
  public:
   // TODO(T65603471): Should we unify this with a Fabric abstraction?

package/ReactCommon/react/nativemodule/core/platform/ios/React-NativeModulesApple.podspec

@@ -36,7 +36,7 @@ Pod::Spec.new do |s|
     s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
     s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\" \"$(PODS_ROOT)/Headers/Private/React-Core\"",
                                 "USE_HEADERMAP" => "YES",
-                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
     if ENV['USE_FRAMEWORKS']
         s.header_mappings_dir     = './'

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTRuntimeExecutor.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#import <Foundation/Foundation.h>
+
 #import <ReactCommon/RuntimeExecutor.h>
 #import <jsi/jsi.h>
 

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.h

@@ -31,7 +31,7 @@ class Instance;
 namespace TurboModuleConvertUtils {
 jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
 id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
-}
+} // namespace TurboModuleConvertUtils
 
 /**
  * ObjC++ specific TurboModule base class.

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm

@@ -184,7 +184,7 @@ id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, s
     return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
   }
 
-  throw std::runtime_error("Unsupported jsi::jsi::Value kind");
+  throw std::runtime_error("Unsupported jsi::Value kind");
 }
 
 static jsi::Value createJSRuntimeError(jsi::Runtime &runtime, const std::string &message)
@@ -227,7 +227,7 @@ static jsi::Value convertJSErrorDetailsToJSRuntimeError(jsi::Runtime &runtime, N
   return jsError;
 }
 
-}
+} // namespace TurboModuleConvertUtils
 
 jsi::Value ObjCTurboModule::createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke)
 {
@@ -813,5 +813,5 @@ void ObjCTurboModule::setMethodArgConversionSelector(NSString *methodName, size_
   methodArgConversionSelectors_[methodName][argIndex] = selectorValue;
 }
 
-}
-} // namespace facebook::react
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.h

@@ -10,7 +10,6 @@
 #import <memory>
 
 #import <React/RCTBridgeModuleDecorator.h>
-#import <React/RCTBridgeProxy.h>
 #import <React/RCTDefines.h>
 #import <React/RCTTurboModuleRegistry.h>
 #import <ReactCommon/RuntimeExecutor.h>
@@ -18,6 +17,7 @@
 
 #import "RCTTurboModule.h"
 
+@class RCTBridgeProxy;
 @class RCTTurboModuleManager;
 
 @protocol RCTTurboModuleManagerDelegate <NSObject>

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm

@@ -19,6 +19,8 @@
 #import <React/RCTBridge+Private.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTBridgeProxy.h>
+#import <React/RCTCallInvoker.h>
+#import <React/RCTCallInvokerModule.h>
 #import <React/RCTConstants.h>
 #import <React/RCTCxxModule.h>
 #import <React/RCTInitializing.h>
@@ -28,6 +30,7 @@
 #import <React/RCTRuntimeExecutorModule.h>
 #import <React/RCTUtils.h>
 #import <ReactCommon/CxxTurboModuleUtils.h>
+#import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
 #import <ReactCommon/TurboCxxModule.h>
 #import <ReactCommon/TurboModulePerfLogger.h>
 #import <ReactCommon/TurboModuleUtils.h>
@@ -165,7 +168,7 @@ bool isTurboModuleInstance(id module)
 {
   return isTurboModuleClass([module class]);
 }
-}
+} // namespace
 
 // Fallback lookup since RCT class prefix is sometimes stripped in the existing NativeModule system.
 // This will be removed in the future.
@@ -178,6 +181,11 @@ static Class getFallbackClassFromName(const char *name)
   return moduleClass;
 }
 
+typedef struct {
+  id<RCTBridgeModule> module;
+  dispatch_queue_t methodQueue;
+} ModuleQueuePair;
+
 @implementation RCTTurboModuleManager {
   std::shared_ptr<CallInvoker> _jsInvoker;
   __weak id<RCTTurboModuleManagerDelegate> _delegate;
@@ -209,7 +217,6 @@ static Class getFallbackClassFromName(const char *name)
   RCTBridgeProxy *_bridgeProxy;
   RCTBridgeModuleDecorator *_bridgeModuleDecorator;
 
-  BOOL _enableSharedModuleQueue;
   dispatch_queue_t _sharedModuleQueue;
 }
 
@@ -226,11 +233,7 @@ static Class getFallbackClassFromName(const char *name)
     _bridgeProxy = bridgeProxy;
     _bridgeModuleDecorator = bridgeModuleDecorator;
     _invalidating = false;
-    _enableSharedModuleQueue = RCTTurboModuleSharedQueueEnabled();
-
-    if (_enableSharedModuleQueue) {
-      _sharedModuleQueue = dispatch_queue_create("com.meta.react.turbomodulemanager.queue", DISPATCH_QUEUE_SERIAL);
-    }
+    _sharedModuleQueue = dispatch_queue_create("com.meta.react.turbomodulemanager.queue", DISPATCH_QUEUE_SERIAL);
 
     if (RCTTurboModuleInteropEnabled()) {
       // TODO(T174674274): Implement lazy loading of legacy modules in the new architecture.
@@ -298,7 +301,7 @@ static Class getFallbackClassFromName(const char *name)
  * (for now).
  */
 
-- (std::shared_ptr<TurboModule>)provideTurboModule:(const char *)moduleName
+- (std::shared_ptr<TurboModule>)provideTurboModule:(const char *)moduleName runtime:(jsi::Runtime *)runtime
 {
   auto turboModuleLookup = _turboModuleCache.find(moduleName);
   if (turboModuleLookup != _turboModuleCache.end()) {
@@ -402,6 +405,10 @@ static Class getFallbackClassFromName(const char *name)
       RCTLogError(@"TurboModule \"%@\"'s getTurboModule: method returned nil.", moduleClass);
     }
     _turboModuleCache.insert({moduleName, turboModule});
+
+    if ([module respondsToSelector:@selector(installJSIBindingsWithRuntime:)]) {
+      [(id<RCTTurboModuleWithJSIBindings>)module installJSIBindingsWithRuntime:*runtime];
+    }
     return turboModule;
   }
 
@@ -573,9 +580,8 @@ static Class getFallbackClassFromName(const char *name)
         if (!strongSelf) {
           return;
         }
-        module = [strongSelf _createAndSetUpObjCModule:moduleClass
-                                            moduleName:moduleName
-                                              moduleId:moduleHolder->getModuleId()];
+        module = [strongSelf _createAndSetUpObjCModule:moduleClass moduleName:moduleName moduleId:moduleHolder
+                      ->getModuleId()];
       };
 
       if ([self _requiresMainQueueSetup:moduleClass]) {
@@ -693,6 +699,12 @@ static Class getFallbackClassFromName(const char *name)
     [(id<RCTRuntimeExecutorModule>)module setRuntimeExecutor:runtimeExecutor];
   }
 
+  // This is a more performant alternative for conformsToProtocol:@protocol(RCTCallInvokerModule)
+  if ([module respondsToSelector:@selector(setCallInvoker:)]) {
+    RCTCallInvoker *callInvoker = [[RCTCallInvoker alloc] initWithCallInvoker:_jsInvoker];
+    [(id<RCTCallInvokerModule>)module setCallInvoker:callInvoker];
+  }
+
   /**
    * Some modules need their own queues, but don't provide any, so we need to create it for them.
    * These modules typically have the following:
@@ -711,12 +723,7 @@ static Class getFallbackClassFromName(const char *name)
    * following if condition's block.
    */
   if (!methodQueue) {
-    if (_enableSharedModuleQueue) {
-      methodQueue = _sharedModuleQueue;
-    } else {
-      NSString *methodQueueName = [NSString stringWithFormat:@"com.facebook.react.%sQueue", moduleName];
-      methodQueue = dispatch_queue_create(methodQueueName.UTF8String, DISPATCH_QUEUE_SERIAL);
-    }
+    methodQueue = _sharedModuleQueue;
 
     if (moduleHasMethodQueueGetter) {
       /**
@@ -759,7 +766,7 @@ static Class getFallbackClassFromName(const char *name)
    * Attach method queue to id<RCTBridgeModule> object.
    * This is necessary because the id<RCTBridgeModule> object can be eagerly created/initialized before the method
    * queue is required. The method queue is required for an id<RCTBridgeModule> for JS -> Native calls. So, we need it
-   * before we create the id<RCTBridgeModule>'s TurboModule jsi::HostObject in provideTurboModule:.
+   * before we create the id<RCTBridgeModule>'s TurboModule jsi::HostObject in provideTurboModule:runtime:.
    */
   objc_setAssociatedObject(module, &kAssociatedMethodQueueKey, methodQueue, OBJC_ASSOCIATION_RETAIN);
 
@@ -909,7 +916,8 @@ static Class getFallbackClassFromName(const char *name)
    * aren't any strong references to it in ObjC. Hence, we give
    * __turboModuleProxy a strong reference to TurboModuleManager.
    */
-  auto turboModuleProvider = [self](const std::string &name) -> std::shared_ptr<react::TurboModule> {
+  auto turboModuleProvider = [self,
+                              runtime = &runtime](const std::string &name) -> std::shared_ptr<react::TurboModule> {
     auto moduleName = name.c_str();
 
     TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
@@ -923,7 +931,7 @@ static Class getFallbackClassFromName(const char *name)
      * Additionally, if a TurboModule with the name `name` isn't found, then we
      * trigger an assertion failure.
      */
-    auto turboModule = [self provideTurboModule:moduleName];
+    auto turboModule = [self provideTurboModule:moduleName runtime:runtime];
 
     if (moduleWasNotInitialized && [self moduleIsInitialized:moduleName]) {
       [self->_bridge.performanceLogger markStopForTag:RCTPLTurboModuleSetup];
@@ -1033,7 +1041,7 @@ static Class getFallbackClassFromName(const char *name)
 {
   // Backward-compatibility: RCTInvalidating handling.
   dispatch_group_t moduleInvalidationGroup = dispatch_group_create();
-
+  std::vector<ModuleQueuePair> modulesToInvalidate;
   for (auto &pair : _moduleHolders) {
     std::string moduleName = pair.first;
     ModuleHolder *moduleHolder = &pair.second;
@@ -1056,22 +1064,31 @@ static Class getFallbackClassFromName(const char *name)
             [module class]);
         continue;
       }
+      modulesToInvalidate.push_back({module, methodQueue});
+    }
+  }
 
-      dispatch_group_enter(moduleInvalidationGroup);
-      dispatch_block_t invalidateModule = ^{
-        [((id<RCTInvalidating>)module) invalidate];
-        dispatch_group_leave(moduleInvalidationGroup);
-      };
+  for (auto unused : modulesToInvalidate) {
+    dispatch_group_enter(moduleInvalidationGroup);
+  }
 
-      if (_bridge) {
-        [_bridge dispatchBlock:invalidateModule queue:methodQueue];
+  for (auto &moduleQueuePair : modulesToInvalidate) {
+    id<RCTBridgeModule> module = moduleQueuePair.module;
+    dispatch_queue_t methodQueue = moduleQueuePair.methodQueue;
+
+    dispatch_block_t invalidateModule = ^{
+      [((id<RCTInvalidating>)module) invalidate];
+      dispatch_group_leave(moduleInvalidationGroup);
+    };
+
+    if (_bridge) {
+      [_bridge dispatchBlock:invalidateModule queue:methodQueue];
+    } else {
+      // Bridgeless mode
+      if (methodQueue == RCTJSThread) {
+        invalidateModule();
       } else {
-        // Bridgeless mode
-        if (methodQueue == RCTJSThread) {
-          invalidateModule();
-        } else {
-          dispatch_async(methodQueue, invalidateModule);
-        }
+        dispatch_async(methodQueue, invalidateModule);
       }
     }
   }

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleWithJSIBindings.h

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+#include <jsi/jsi.h>
+#endif
+
+@protocol RCTTurboModuleWithJSIBindings <NSObject>
+
+#ifdef __cplusplus
+- (void)installJSIBindingsWithRuntime:(facebook::jsi::Runtime &)runtime;
+#endif
+
+@end

package/ReactCommon/react/nativemodule/defaults/CMakeLists.txt

@@ -0,0 +1,27 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(
+        -fexceptions
+        -frtti
+        -std=c++20
+        -Wall
+        -Wpedantic
+        -DLOG_TAG=\"ReactNative\")
+
+file(GLOB react_nativemodule_defaults_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_nativemodule_defaults SHARED ${react_nativemodule_defaults_SRC})
+
+target_include_directories(react_nativemodule_defaults PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_nativemodule_defaults
+        react_nativemodule_dom
+        react_nativemodule_featureflags
+        react_nativemodule_microtasks
+        react_nativemodule_idlecallbacks
+)