react-native-tvos 0.64.2-2 → 0.66.3-0

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

@@ -6,10 +6,12 @@
  */
 
 #import "RCTTurboModule.h"
+#import "RCTBlockGuard.h"
 
 #import <objc/message.h>
 #import <objc/runtime.h>
 #import <atomic>
+#import <iostream>
 #import <sstream>
 #import <vector>
 
@@ -98,28 +100,38 @@ static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
   return jsi::Value::undefined();
 }
 
-static id
-convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
+static id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback);
 static NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value)
 {
   return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
 }
 
-static NSArray *
-convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker)
+static NSArray *convertJSIArrayToNSArray(
+    jsi::Runtime &runtime,
+    const jsi::Array &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   size_t size = value.size(runtime);
   NSMutableArray *result = [NSMutableArray new];
   for (size_t i = 0; i < size; i++) {
     // Insert kCFNull when it's `undefined` value to preserve the indices.
     [result
-        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker) ?: (id)kCFNull];
+        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker, retainJSCallback)
+            ?: (id)kCFNull];
   }
   return [result copy];
 }
 
-static NSDictionary *
-convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)
+static NSDictionary *convertJSIObjectToNSDictionary(
+    jsi::Runtime &runtime,
+    const jsi::Object &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   jsi::Array propertyNames = value.getPropertyNames(runtime);
   size_t size = propertyNames.size(runtime);
@@ -127,7 +139,7 @@ convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value,
   for (size_t i = 0; i < size; i++) {
     jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
     NSString *k = convertJSIStringToNSString(runtime, name);
-    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker);
+    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker, retainJSCallback);
     if (v) {
       result[k] = v;
     }
@@ -135,10 +147,16 @@ convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value,
   return [result copy];
 }
 
-static RCTResponseSenderBlock
-convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker);
-static id
-convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+static RCTResponseSenderBlock convertJSIFunctionToCallback(
+    jsi::Runtime &runtime,
+    const jsi::Function &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback);
+static id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   if (value.isUndefined() || value.isNull()) {
     return nil;
@@ -155,21 +173,33 @@ convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std:
   if (value.isObject()) {
     jsi::Object o = value.getObject(runtime);
     if (o.isArray(runtime)) {
-      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker);
+      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker, retainJSCallback);
     }
     if (o.isFunction(runtime)) {
-      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker);
+      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker, retainJSCallback);
     }
-    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
+    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker, retainJSCallback);
   }
 
   throw std::runtime_error("Unsupported jsi::jsi::Value kind");
 }
 
-static RCTResponseSenderBlock
-convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker)
+static RCTResponseSenderBlock convertJSIFunctionToCallback(
+    jsi::Runtime &runtime,
+    const jsi::Function &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
-  auto weakWrapper = CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  auto weakWrapper = retainJSCallback != nil
+      ? retainJSCallback(value.getFunction(runtime), runtime, jsInvoker)
+      : CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  RCTBlockGuard *blockGuard = [[RCTBlockGuard alloc] initWithCleanup:^() {
+    auto strongWrapper = weakWrapper.lock();
+    if (strongWrapper) {
+      strongWrapper->destroy();
+    }
+  }];
+
   BOOL __block wrapperWasCalled = NO;
   RCTResponseSenderBlock callback = ^(NSArray *responses) {
     if (wrapperWasCalled) {
@@ -181,7 +211,7 @@ convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value,
       return;
     }
 
-    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses]() {
+    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses, blockGuard]() {
       auto strongWrapper2 = weakWrapper.lock();
       if (!strongWrapper2) {
         return;
@@ -190,31 +220,28 @@ convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value,
       std::vector<jsi::Value> args = convertNSArrayToStdVector(strongWrapper2->runtime(), responses);
       strongWrapper2->callback().call(strongWrapper2->runtime(), (const jsi::Value *)args.data(), args.size());
       strongWrapper2->destroy();
+
+      // Delete the CallbackWrapper when the block gets dealloced without being invoked.
+      (void)blockGuard;
     });
 
     wrapperWasCalled = YES;
   };
 
-  if (RCTTurboModuleBlockCopyEnabled()) {
-    return [callback copy];
-  }
-
-  return callback;
+  return [callback copy];
 }
 
 namespace facebook {
 namespace react {
 
-jsi::Value ObjCTurboModule::createPromise(
-    jsi::Runtime &runtime,
-    std::shared_ptr<CallInvoker> jsInvoker,
-    PromiseInvocationBlock invoke)
+jsi::Value ObjCTurboModule::createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke)
 {
   if (!invoke) {
     return jsi::Value::undefined();
   }
 
   jsi::Function Promise = runtime.global().getPropertyAsFunction(runtime, "Promise");
+  std::string moduleName = name_;
 
   // Note: the passed invoke() block is not retained by default, so let's retain it here to help keep it longer.
   // Otherwise, there's a risk of it getting released before the promise function below executes.
@@ -223,28 +250,50 @@ jsi::Value ObjCTurboModule::createPromise(
       runtime,
       jsi::PropNameID::forAscii(runtime, "fn"),
       2,
-      [invokeCopy, jsInvoker](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
+      [invokeCopy, jsInvoker = jsInvoker_, moduleName, methodName, retainJSCallback = retainJSCallback_](
+          jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
+        std::string moduleMethod = moduleName + "." + methodName + "()";
+
         if (count != 2) {
           throw std::invalid_argument(
-              "Promise must pass constructor function two args. Passed " + std::to_string(count) + " args.");
+              moduleMethod + ": Promise must pass constructor function two args. Passed " + std::to_string(count) +
+              " args.");
         }
         if (!invokeCopy) {
           return jsi::Value::undefined();
         }
 
-        auto weakResolveWrapper = CallbackWrapper::createWeak(args[0].getObject(rt).getFunction(rt), rt, jsInvoker);
-        auto weakRejectWrapper = CallbackWrapper::createWeak(args[1].getObject(rt).getFunction(rt), rt, jsInvoker);
+        auto weakResolveWrapper = retainJSCallback != nil
+            ? retainJSCallback(args[0].getObject(rt).getFunction(rt), rt, jsInvoker)
+            : CallbackWrapper::createWeak(args[0].getObject(rt).getFunction(rt), rt, jsInvoker);
+        auto weakRejectWrapper = retainJSCallback != nil
+            ? retainJSCallback(args[1].getObject(rt).getFunction(rt), rt, jsInvoker)
+            : CallbackWrapper::createWeak(args[1].getObject(rt).getFunction(rt), rt, jsInvoker);
 
         __block BOOL resolveWasCalled = NO;
         __block BOOL rejectWasCalled = NO;
 
+        RCTBlockGuard *blockGuard = [[RCTBlockGuard alloc] initWithCleanup:^() {
+          auto strongResolveWrapper = weakResolveWrapper.lock();
+          if (strongResolveWrapper) {
+            strongResolveWrapper->destroy();
+          }
+
+          auto strongRejectWrapper = weakRejectWrapper.lock();
+          if (strongRejectWrapper) {
+            strongRejectWrapper->destroy();
+          }
+        }];
+
         RCTPromiseResolveBlock resolveBlock = ^(id result) {
           if (rejectWasCalled) {
-            throw std::runtime_error("Tried to resolve a promise after it's already been rejected.");
+            RCTLogError(@"%s: Tried to resolve a promise after it's already been rejected.", moduleMethod.c_str());
+            return;
           }
 
           if (resolveWasCalled) {
-            throw std::runtime_error("Tried to resolve a promise more than once.");
+            RCTLogError(@"%s: Tried to resolve a promise more than once.", moduleMethod.c_str());
+            return;
           }
 
           auto strongResolveWrapper = weakResolveWrapper.lock();
@@ -253,7 +302,7 @@ jsi::Value ObjCTurboModule::createPromise(
             return;
           }
 
-          strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result]() {
+          strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result, blockGuard]() {
             auto strongResolveWrapper2 = weakResolveWrapper.lock();
             auto strongRejectWrapper2 = weakRejectWrapper.lock();
             if (!strongResolveWrapper2 || !strongRejectWrapper2) {
@@ -266,6 +315,7 @@ jsi::Value ObjCTurboModule::createPromise(
 
             strongResolveWrapper2->destroy();
             strongRejectWrapper2->destroy();
+            (void)blockGuard;
           });
 
           resolveWasCalled = YES;
@@ -273,11 +323,13 @@ jsi::Value ObjCTurboModule::createPromise(
 
         RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
           if (resolveWasCalled) {
-            throw std::runtime_error("Tried to reject a promise after it's already been resolved.");
+            RCTLogError(@"%s: Tried to reject a promise after it's already been resolved.", moduleMethod.c_str());
+            return;
           }
 
           if (rejectWasCalled) {
-            throw std::runtime_error("Tried to reject a promise more than once.");
+            RCTLogError(@"%s: Tried to reject a promise more than once.", moduleMethod.c_str());
+            return;
           }
 
           auto strongResolveWrapper = weakResolveWrapper.lock();
@@ -287,7 +339,7 @@ jsi::Value ObjCTurboModule::createPromise(
           }
 
           NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
-          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError]() {
+          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError, blockGuard]() {
             auto strongResolveWrapper2 = weakResolveWrapper.lock();
             auto strongRejectWrapper2 = weakRejectWrapper.lock();
             if (!strongResolveWrapper2 || !strongRejectWrapper2) {
@@ -300,6 +352,7 @@ jsi::Value ObjCTurboModule::createPromise(
 
             strongResolveWrapper2->destroy();
             strongRejectWrapper2->destroy();
+            (void)blockGuard;
           });
 
           rejectWasCalled = YES;
@@ -538,7 +591,7 @@ NSInvocation *ObjCTurboModule::getMethodInvocation(
     /**
      * Convert arg to ObjC objects.
      */
-    id objCArg = convertJSIValueToObjCObject(runtime, *arg, jsInvoker_);
+    id objCArg = convertJSIValueToObjCObject(runtime, *arg, jsInvoker_, retainJSCallback_);
 
     if (objCArg) {
       NSString *methodNameNSString = @(methodName);
@@ -610,7 +663,8 @@ ObjCTurboModule::ObjCTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(params.instance),
       nativeInvoker_(params.nativeInvoker),
-      isSyncModule_(params.isSyncModule)
+      isSyncModule_(params.isSyncModule),
+      retainJSCallback_(params.retainJSCallback)
 {
 }
 
@@ -638,15 +692,10 @@ jsi::Value ObjCTurboModule::invokeObjCMethod(
   jsi::Value returnValue = returnType == PromiseKind
       ? createPromise(
             runtime,
-            jsInvoker_,
+            methodNameStr,
             ^(RCTPromiseResolveBlock resolveBlock, RCTPromiseRejectBlock rejectBlock) {
-              RCTPromiseResolveBlock resolveCopy = resolveBlock;
-              RCTPromiseRejectBlock rejectCopy = rejectBlock;
-
-              if (RCTTurboModuleBlockCopyEnabled()) {
-                resolveCopy = [resolveBlock copy];
-                rejectCopy = [rejectBlock copy];
-              }
+              RCTPromiseResolveBlock resolveCopy = [resolveBlock copy];
+              RCTPromiseRejectBlock rejectCopy = [rejectBlock copy];
 
               [inv setArgument:(void *)&resolveCopy atIndex:count + 2];
               [inv setArgument:(void *)&rejectCopy atIndex:count + 3];

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

@@ -15,16 +15,10 @@
 
 @protocol RCTTurboModuleManagerDelegate <NSObject>
 
-// TODO: Move to xplat codegen.
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
-                                                     initParams:
-                                                         (const facebook::react::ObjCTurboModule::InitParams &)params;
 @optional
 - (NSArray<NSString *> *)getEagerInitModuleNames;
 - (NSArray<NSString *> *)getEagerInitMainQueueModuleNames;
 
-@optional
-
 /**
  * Given a module name, return its actual class. If not provided, basic ObjC class lookup is performed.
  */

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

@@ -18,6 +18,7 @@
 #import <React/RCTBridge+Private.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTCxxModule.h>
+#import <React/RCTInitializing.h>
 #import <React/RCTLog.h>
 #import <React/RCTModuleData.h>
 #import <React/RCTPerformanceLogger.h>
@@ -172,6 +173,10 @@ static Class getFallbackClassFromName(const char *name)
   std::shared_timed_mutex _turboModuleHoldersSharedMutex;
   std::mutex _turboModuleHoldersMutex;
   std::atomic<bool> _invalidating;
+
+  RCTModuleRegistry *_moduleRegistry;
+  RCTRetainJSCallback _retainJSCallback;
+  std::shared_ptr<LongLivedObjectCollection> _longLivedObjectCollection;
 }
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge
@@ -183,6 +188,9 @@ static Class getFallbackClassFromName(const char *name)
     _delegate = delegate;
     _bridge = bridge;
     _invalidating = false;
+    _moduleRegistry = [RCTModuleRegistry new];
+    [_moduleRegistry setBridge:bridge];
+    [_moduleRegistry setTurboModuleRegistry:self];
 
     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(bridgeWillInvalidateModules:)
@@ -192,6 +200,23 @@ static Class getFallbackClassFromName(const char *name)
                                              selector:@selector(bridgeDidInvalidateModules:)
                                                  name:RCTBridgeDidInvalidateModulesNotification
                                                object:_bridge.parentBridge];
+
+    if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScope) {
+      // Use LongLivedObjectCollection singleton regularly
+      _retainJSCallback = nil;
+    } else if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScopeUsingRetainJSCallback) {
+      // Use LongLivedObjectCollection singleton via the _retainJSCallback
+      _retainJSCallback = ^(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker2) {
+        return CallbackWrapper::createWeak(std::move(callback), runtime, jsInvoker2);
+      };
+    } else if (RCTGetTurboModuleCleanupMode() == kRCTTurboModuleManagerScope) {
+      // Use a LongLivedObjectCollection scoped to the TurboModuleManager
+      _longLivedObjectCollection = std::make_shared<LongLivedObjectCollection>();
+      __block std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection = _longLivedObjectCollection;
+      _retainJSCallback = ^(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker2) {
+        return CallbackWrapper::createWeak(longLivedObjectCollection, std::move(callback), runtime, jsInvoker2);
+      };
+    }
   }
   return self;
 }
@@ -263,6 +288,9 @@ static Class getFallbackClassFromName(const char *name)
   Class moduleClass = [module class];
 
   dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);
+  if (methodQueue == nil) {
+    RCTLogError(@"TurboModule \"%@\" was not associated with a method queue.", moduleClass);
+  }
 
   /**
    * Step 2c: Create and native CallInvoker from the TurboModule's method queue.
@@ -277,23 +305,6 @@ static Class getFallbackClassFromName(const char *name)
     nativeInvoker = [_bridge decorateNativeCallInvoker:nativeInvoker];
   }
 
-  ObjCTurboModule::InitParams params = {
-      .moduleName = moduleName,
-      .instance = module,
-      .jsInvoker = _jsInvoker,
-      .nativeInvoker = nativeInvoker,
-      .isSyncModule = methodQueue == RCTJSThread,
-  };
-
-  // If RCTTurboModule supports creating its own C++ TurboModule object,
-  // allow it to do so.
-  if ([module respondsToSelector:@selector(getTurboModule:)]) {
-    auto turboModule = [module getTurboModule:params];
-    assert(turboModule != nullptr);
-    _turboModuleCache.insert({moduleName, turboModule});
-    return turboModule;
-  }
-
   /**
    * Step 2d: If the moduleClass is a legacy CxxModule, return a TurboCxxModule instance that
    * wraps CxxModule.
@@ -306,13 +317,23 @@ static Class getFallbackClassFromName(const char *name)
     return turboModule;
   }
 
+  ObjCTurboModule::InitParams params = {
+      .moduleName = moduleName,
+      .instance = module,
+      .jsInvoker = _jsInvoker,
+      .nativeInvoker = nativeInvoker,
+      .isSyncModule = methodQueue == RCTJSThread,
+      .retainJSCallback = _retainJSCallback,
+  };
+
   /**
    * Step 2e: Return an exact sub-class of ObjC TurboModule
    */
-  auto turboModule = [_delegate getTurboModule:moduleName initParams:params];
-  if (turboModule != nullptr) {
-    _turboModuleCache.insert({moduleName, turboModule});
+  auto turboModule = [module getTurboModule:params];
+  if (turboModule == nullptr) {
+    RCTLogError(@"TurboModule \"%@\"'s getTurboModule: method returned nil.", moduleClass);
   }
+  _turboModuleCache.insert({moduleName, turboModule});
   return turboModule;
 }
 
@@ -353,6 +374,10 @@ static Class getFallbackClassFromName(const char *name)
  */
 - (id<RCTTurboModule>)provideRCTTurboModule:(const char *)moduleName
 {
+  if (strncmp("RCT", moduleName, 3) == 0) {
+    moduleName = [[[NSString stringWithUTF8String:moduleName] substringFromIndex:3] UTF8String];
+  }
+
   TurboModuleHolder *moduleHolder = [self _getOrCreateTurboModuleHolder:moduleName];
 
   if (!moduleHolder) {
@@ -495,10 +520,6 @@ static Class getFallbackClassFromName(const char *name)
 
   TurboModulePerfLogger::moduleCreateSetUpStart(moduleName, moduleId);
 
-  if ([module respondsToSelector:@selector(setTurboModuleRegistry:)]) {
-    [module setTurboModuleRegistry:self];
-  }
-
   /**
    * It is reasonable for NativeModules to not want/need the bridge.
    * In such cases, they won't have `@synthesize bridge = _bridge` in their
@@ -535,6 +556,25 @@ static Class getFallbackClassFromName(const char *name)
     }
   }
 
+  /**
+   * Attach the RCTModuleRegistry to this TurboModule, which allows this TurboModule
+   * To load other NativeModules & TurboModules.
+   *
+   * Usage: In the NativeModule @implementation, include:
+   *   `@synthesize moduleRegistry = _moduleRegistry`
+   */
+  if ([module respondsToSelector:@selector(moduleRegistry)] && _moduleRegistry) {
+    @try {
+      [(id)module setValue:_moduleRegistry forKey:@"moduleRegistry"];
+    } @catch (NSException *exception) {
+      RCTLogError(
+          @"%@ has no setter or ivar for its module registry, which is not "
+           "permitted. You must either @synthesize the moduleRegistry property, "
+           "or provide your own setter method.",
+          RCTBridgeModuleNameForClass([module class]));
+    }
+  }
+
   /**
    * 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:
@@ -579,6 +619,20 @@ static Class getFallbackClassFromName(const char *name)
     }
   }
 
+  /**
+   * Decorate TurboModules with bridgeless-compatible APIs that call into the bridge.
+   */
+  if (_bridge) {
+    [_bridge attachBridgeAPIsToTurboModule:module];
+  }
+
+  /**
+   * If the TurboModule conforms to RCTInitializing, invoke its initialize method.
+   */
+  if ([module respondsToSelector:@selector(initialize)]) {
+    [(id<RCTInitializing>)module initialize];
+  }
+
   /**
    * Attach method queue to id<RCTTurboModule> object.
    * This is necessary because the id<RCTTurboModule> object can be eagerly created/initialized before the method
@@ -595,7 +649,12 @@ static Class getFallbackClassFromName(const char *name)
    * rollout.
    */
   if (_bridge) {
-    RCTModuleData *data = [[RCTModuleData alloc] initWithModuleInstance:(id<RCTBridgeModule>)module bridge:_bridge];
+    RCTModuleData *data = [[RCTModuleData alloc] initWithModuleInstance:(id<RCTBridgeModule>)module
+                                                                 bridge:_bridge
+                                                         moduleRegistry:_moduleRegistry
+                                                viewRegistry_DEPRECATED:nil
+                                                          bundleManager:nil
+                                                      callableJSModules:nil];
     [_bridge registerModuleForFrameUpdates:(id<RCTBridgeModule>)module withModuleData:data];
   }
 
@@ -686,8 +745,7 @@ 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, const jsi::Value *schema) -> std::shared_ptr<react::TurboModule> {
+  auto turboModuleProvider = [self](const std::string &name) -> std::shared_ptr<react::TurboModule> {
     auto moduleName = name.c_str();
 
     TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);
@@ -717,9 +775,17 @@ static Class getFallbackClassFromName(const char *name)
     return turboModule;
   };
 
-  runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider)](jsi::Runtime &runtime) {
-    react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider));
-  });
+  if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScope ||
+      RCTGetTurboModuleCleanupMode() == kRCTGlobalScopeUsingRetainJSCallback) {
+    runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider)](jsi::Runtime &runtime) {
+      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider));
+    });
+  } else if (RCTGetTurboModuleCleanupMode() == kRCTTurboModuleManagerScope) {
+    runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider),
+                     longLivedObjectCollection = _longLivedObjectCollection](jsi::Runtime &runtime) {
+      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider), longLivedObjectCollection);
+    });
+  }
 }
 
 #pragma mark RCTTurboModuleRegistry
@@ -731,6 +797,12 @@ static Class getFallbackClassFromName(const char *name)
 
 - (id)moduleForName:(const char *)moduleName warnOnLookupFailure:(BOOL)warnOnLookupFailure
 {
+  // When the bridge is invalidating, TurboModules will be nil.
+  // Therefore, don't (1) do the lookup, and (2) warn on lookup.
+  if (_invalidating) {
+    return nil;
+  }
+
   id<RCTTurboModule> module = [self provideRCTTurboModule:moduleName];
 
   if (warnOnLookupFailure && !module) {
@@ -778,6 +850,27 @@ static Class getFallbackClassFromName(const char *name)
     return;
   }
 
+  [self _enterInvalidatingState];
+}
+
+- (void)bridgeDidInvalidateModules:(NSNotification *)notification
+{
+  RCTBridge *bridge = notification.userInfo[@"bridge"];
+  if (bridge != _bridge) {
+    return;
+  }
+
+  [self _invalidateModules];
+}
+
+- (void)invalidate
+{
+  [self _enterInvalidatingState];
+  [self _invalidateModules];
+}
+
+- (void)_enterInvalidatingState
+{
   // This should halt all insertions into _turboModuleHolders
   if (RCTTurboModuleSharedMutexInitEnabled()) {
     std::unique_lock<std::shared_timed_mutex> guard(_turboModuleHoldersSharedMutex);
@@ -788,13 +881,8 @@ static Class getFallbackClassFromName(const char *name)
   }
 }
 
-- (void)bridgeDidInvalidateModules:(NSNotification *)notification
+- (void)_invalidateModules
 {
-  RCTBridge *bridge = notification.userInfo[@"bridge"];
-  if (bridge != _bridge) {
-    return;
-  }
-
   // Backward-compatibility: RCTInvalidating handling.
   dispatch_group_t moduleInvalidationGroup = dispatch_group_create();
 
@@ -812,20 +900,31 @@ static Class getFallbackClassFromName(const char *name)
                                                shouldPerfLog:NO];
 
     if ([module respondsToSelector:@selector(invalidate)]) {
-      if ([module respondsToSelector:@selector(methodQueue)]) {
-        dispatch_queue_t methodQueue = [module performSelector:@selector(methodQueue)];
-        if (methodQueue) {
-          dispatch_group_enter(moduleInvalidationGroup);
-          [bridge
-              dispatchBlock:^{
-                [((id<RCTInvalidating>)module) invalidate];
-                dispatch_group_leave(moduleInvalidationGroup);
-              }
-                      queue:methodQueue];
-          continue;
+      dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);
+
+      if (methodQueue == nil) {
+        RCTLogError(
+            @"TurboModuleManager: Couldn't invalidate TurboModule \"%@\", because its method queue is nil.",
+            [module class]);
+        continue;
+      }
+
+      dispatch_group_enter(moduleInvalidationGroup);
+      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 {
+          dispatch_async(methodQueue, invalidateModule);
         }
       }
-      [((id<RCTInvalidating>)module) invalidate];
     }
   }
 
@@ -837,26 +936,4 @@ static Class getFallbackClassFromName(const char *name)
   _turboModuleCache.clear();
 }
 
-- (void)invalidate
-{
-  if (RCTTurboModuleSharedMutexInitEnabled()) {
-    std::unique_lock<std::shared_timed_mutex> guard(_turboModuleHoldersSharedMutex);
-    _invalidating = true;
-  } else {
-    std::lock_guard<std::mutex> guard(_turboModuleHoldersMutex);
-    _invalidating = true;
-  }
-
-  // Backward-compatibility: RCTInvalidating handling, but not adhering to desired methodQueue.
-  for (const auto &p : _turboModuleHolders) {
-    id<RCTTurboModule> module = p.second.getModule();
-    if ([module respondsToSelector:@selector(invalidate)]) {
-      [((id<RCTInvalidating>)module) invalidate];
-    }
-  }
-
-  _turboModuleHolders.clear();
-  _turboModuleCache.clear();
-}
-
 @end