@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -8,12 +8,11 @@
 #include "ReactInstance.h"
 
 #include <ReactCommon/RuntimeExecutor.h>
-#include <cxxreact/ErrorUtils.h>
 #include <cxxreact/JSBigString.h>
-#include <cxxreact/JSExecutor.h>
 #include <cxxreact/ReactMarker.h>
 #include <cxxreact/TraceSection.h>
 #include <glog/logging.h>
+#include <jserrorhandler/ErrorUtils.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/hermes-interfaces.h>
 #include <jsi/instrumentation.h>
@@ -48,6 +47,16 @@ std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
   return scheduler;
 }
 
+void setHermesEventLoopControl(
+    jsi::Runtime& runtime,
+    facebook::hermes::IEventLoopControl* eventLoopControl) {
+  auto* setEventLoopControl =
+      jsi::castInterface<facebook::hermes::ISetEventLoopControl>(&runtime);
+  if (setEventLoopControl != nullptr) {
+    setEventLoopControl->setEventLoopControl(eventLoopControl);
+  }
+}
+
 std::string getSyntheticBundlePath(uint32_t bundleId) {
   std::array<char, 32> buffer{};
   std::snprintf(buffer.data(), buffer.size(), "seg-%u.js", bundleId);
@@ -156,6 +165,11 @@ ReactInstance::ReactInstance(
         });
   }
 
+  runtimeExecutor(
+      [runtimeScheduler = runtimeScheduler_.get()](jsi::Runtime& runtime) {
+        setHermesEventLoopControl(runtime, runtimeScheduler);
+      });
+
   bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
           std::function<void(jsi::Runtime & runtime)>&& callback) {
@@ -163,6 +177,11 @@ ReactInstance::ReactInstance(
       });
 }
 ReactInstance::~ReactInstance() noexcept {
+  // This is thread safe because there is no JSI call at this point, and there
+  // won't be any concurrent calls to getEventLoopControl().
+  // We need to clear this pointer before runtimeScheduler_ is destroyed.
+  setHermesEventLoopControl(runtime_->getRuntime(), nullptr);
+
   if (timerManager_ != nullptr) {
     timerManager_->quit();
   }
@@ -235,62 +254,63 @@ void ReactInstance::loadScript(
   std::shared_ptr<const jsi::Buffer> buffer(std::move(script));
   std::string scriptName = simpleBasename(sourceURL);
 
-  runtimeScheduler_->scheduleWork([this,
-                                   scriptName,
-                                   sourceURL,
-                                   buffer = std::move(buffer),
-                                   weakBufferedRuntimeExecuter =
-                                       std::weak_ptr<BufferedRuntimeExecutor>(
-                                           bufferedRuntimeExecutor_),
-                                   beforeLoad,
-                                   afterLoad](jsi::Runtime& runtime) mutable {
-    if (beforeLoad) {
-      beforeLoad(runtime);
-    }
-    TraceSection s("ReactInstance::loadScript");
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
-      ReactMarker::logMarkerBridgeless(ReactMarker::INIT_REACT_RUNTIME_START);
-      ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_START);
-    }
+  runtimeScheduler_->scheduleWork(
+      [jsErrorHandler = jsErrorHandler_,
+       scriptName,
+       sourceURL = sourceURL,
+       buffer = std::move(buffer),
+       weakBufferedRuntimeExecuter =
+           std::weak_ptr<BufferedRuntimeExecutor>(bufferedRuntimeExecutor_),
+       beforeLoad,
+       afterLoad](jsi::Runtime& runtime) mutable {
+        if (beforeLoad) {
+          beforeLoad(runtime);
+        }
+        TraceSection s("ReactInstance::loadScript");
+        bool hasLogger(ReactMarker::logTaggedMarkerImpl);
+        if (hasLogger) {
+          ReactMarker::logTaggedMarker(
+              ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+          ReactMarker::logMarker(ReactMarker::INIT_REACT_RUNTIME_START);
+          ReactMarker::logMarker(ReactMarker::APP_STARTUP_START);
+        }
 
-    // Check if the shermes unit is avaliable.
-    auto* shUnitAPI = jsi::castInterface<hermes::IHermesSHUnit>(&runtime);
-    auto* shUnitCreator = shUnitAPI ? shUnitAPI->getSHUnitCreator() : nullptr;
-    if (shUnitCreator) {
-      LOG(WARNING) << "ReactInstance: evaluateSHUnit";
-      auto* hermesAPI = jsi::castInterface<hermes::IHermes>(&runtime);
-      hermesAPI->evaluateSHUnit(shUnitCreator);
-    } else {
-      LOG(WARNING) << "ReactInstance: evaluateJavaScript() with JS bundle";
-      runtime.evaluateJavaScript(buffer, sourceURL);
-    }
+        // Check if the shermes unit is avaliable.
+        auto* shUnitAPI = jsi::castInterface<hermes::IHermesSHUnit>(&runtime);
+        auto* shUnitCreator =
+            shUnitAPI ? shUnitAPI->getSHUnitCreator() : nullptr;
+        if (shUnitCreator) {
+          LOG(WARNING) << "ReactInstance: evaluateSHUnit";
+          auto* hermesAPI = jsi::castInterface<hermes::IHermes>(&runtime);
+          hermesAPI->evaluateSHUnit(shUnitCreator);
+        } else {
+          LOG(WARNING) << "ReactInstance: evaluateJavaScript() with JS bundle";
+          runtime.evaluateJavaScript(buffer, sourceURL);
+        }
 
-    /**
-     * TODO(T183610671): We need a safe/reliable way to enable the js
-     * pipeline from javascript. Remove this after we figure that out, or
-     * after we just remove the js pipeline.
-     */
-    if (!jsErrorHandler_->hasHandledFatalError()) {
-      jsErrorHandler_->setRuntimeReady();
-    }
+        /**
+         * TODO(T183610671): We need a safe/reliable way to enable the js
+         * pipeline from javascript. Remove this after we figure that out, or
+         * after we just remove the js pipeline.
+         */
+        if (!jsErrorHandler->hasHandledFatalError()) {
+          jsErrorHandler->setRuntimeReady();
+        }
 
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
-      ReactMarker::logMarkerBridgeless(ReactMarker::INIT_REACT_RUNTIME_STOP);
-      ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
-    }
-    if (auto strongBufferedRuntimeExecuter =
-            weakBufferedRuntimeExecuter.lock()) {
-      strongBufferedRuntimeExecuter->flush();
-    }
-    if (afterLoad) {
-      afterLoad(runtime);
-    }
-  });
+        if (hasLogger) {
+          ReactMarker::logTaggedMarker(
+              ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
+          ReactMarker::logMarker(ReactMarker::INIT_REACT_RUNTIME_STOP);
+          ReactMarker::logMarker(ReactMarker::APP_STARTUP_STOP);
+        }
+        if (auto strongBufferedRuntimeExecuter =
+                weakBufferedRuntimeExecuter.lock()) {
+          strongBufferedRuntimeExecuter->flush();
+        }
+        if (afterLoad) {
+          afterLoad(runtime);
+        }
+      });
 }
 
 /*
@@ -369,21 +389,16 @@ void ReactInstance::registerSegment(
           "Empty segment registered with ID " + tag + " from " + segmentPath);
     }
 
-    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl != nullptr);
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
-    }
+    ReactMarker::logTaggedMarker(
+        ReactMarker::REGISTER_JS_SEGMENT_START, tag.c_str());
     LOG(WARNING) << "Starting to evaluate segment " << segmentId
                  << " in ReactInstance::registerSegment";
     runtime.evaluateJavaScript(
         std::move(script), getSyntheticBundlePath(segmentId));
     LOG(WARNING) << "Finished evaluating segment " << segmentId
                  << " in ReactInstance::registerSegment";
-    if (hasLogger) {
-      ReactMarker::logTaggedMarkerBridgeless(
-          ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
-    }
+    ReactMarker::logTaggedMarker(
+        ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
   });
 }
 

package/ReactCommon/react/runtime/hermes/HermesInstance.cpp

@@ -12,90 +12,11 @@
 #include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 
-#ifdef HERMES_ENABLE_DEBUGGER
-#include <hermes/inspector-modern/chrome/Registration.h>
-
-#ifndef HERMES_V1_ENABLED
-#include <hermes/inspector/RuntimeAdapter.h>
-#endif
-
-#include <jsi/decorator.h>
-#endif
-
 using namespace facebook::hermes;
 using namespace facebook::jsi;
 
 namespace facebook::react {
 
-#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-
-// Wrapper that strongly retains the HermesRuntime for on device debugging.
-//
-// HermesInstanceRuntimeAdapter needs to strongly retain the HermesRuntime. Why:
-//   - facebook::hermes::inspector_modern::chrome::Connection::Impl owns the
-//   Adapter
-//   - facebook::hermes::inspector_modern::chrome::Connection::Impl also owns
-//   jsi:: objects
-//   - jsi:: objects need to be deleted before the Runtime.
-//
-// If Adapter doesn't share ownership over jsi::Runtime, the runtime can be
-// deleted before Connection::Impl cleans up all its jsi:: Objects. This will
-// lead to a runtime crash.
-class HermesInstanceRuntimeAdapter : public inspector_modern::RuntimeAdapter {
- public:
-  HermesInstanceRuntimeAdapter(
-      std::shared_ptr<HermesRuntime> hermesRuntime,
-      std::shared_ptr<MessageQueueThread> msgQueueThread)
-      : hermesRuntime_(std::move(hermesRuntime)),
-        messageQueueThread_(std::move(msgQueueThread)) {}
-  virtual ~HermesInstanceRuntimeAdapter() = default;
-
-  HermesRuntime& getRuntime() override {
-    return *hermesRuntime_;
-  }
-
-  void tickleJs() override {
-    std::weak_ptr<HermesRuntime> weakRuntime(hermesRuntime_);
-    messageQueueThread_->runOnQueue([weakRuntime]() {
-      auto runtime = weakRuntime.lock();
-      if (!runtime) {
-        return;
-      }
-      jsi::Function func =
-          runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
-      func.call(*runtime);
-    });
-  }
-
- private:
-  std::shared_ptr<HermesRuntime> hermesRuntime_;
-  std::shared_ptr<MessageQueueThread> messageQueueThread_;
-};
-
-class DecoratedRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
- public:
-  DecoratedRuntime(
-      std::unique_ptr<HermesRuntime> runtime,
-      std::shared_ptr<MessageQueueThread> msgQueueThread)
-      : RuntimeDecorator<jsi::Runtime>(*runtime), runtime_(std::move(runtime)) {
-    auto adapter = std::make_unique<HermesInstanceRuntimeAdapter>(
-        runtime_, msgQueueThread);
-
-    debugToken_ = inspector_modern::chrome::enableDebugging(
-        std::move(adapter), "Hermes Bridgeless React Native");
-  }
-
-  ~DecoratedRuntime() {
-    inspector_modern::chrome::disableDebugging(debugToken_);
-  }
-
- private:
-  std::shared_ptr<HermesRuntime> runtime_;
-  inspector_modern::chrome::DebugSessionToken debugToken_;
-};
-
-#endif // defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-
 class HermesJSRuntime : public JSRuntime {
  public:
   HermesJSRuntime(
@@ -164,17 +85,7 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
                             .getPropertyAsObject(*hermesRuntime, "prototype");
   errorPrototype.setProperty(*hermesRuntime, "jsEngine", "hermes");
 
-#if defined(HERMES_ENABLE_DEBUGGER) && !defined(HERMES_V1_ENABLED)
-  auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
-  if (!inspectorFlags.getFuseboxEnabled()) {
-    std::unique_ptr<DecoratedRuntime> decoratedRuntime =
-        std::make_unique<DecoratedRuntime>(
-            std::move(hermesRuntime), msgQueueThread);
-    return std::make_unique<JSIRuntimeHolder>(std::move(decoratedRuntime));
-  }
-#else
   (void)msgQueueThread;
-#endif
 
   HermesRuntime& hermesRuntimeRef = *hermesRuntime;
   return std::make_unique<HermesJSRuntime>(

package/ReactCommon/react/runtime/iostests/MainQueueCoordinatorTests.mm

@@ -0,0 +1,99 @@
+/*
+ * 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 <XCTest/XCTest.h>
+
+#import <React/RCTUtils.h>
+#import <ReactCommon/RuntimeExecutor.h>
+#import <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
+#import <hermes/hermes.h>
+#import <chrono>
+#import <thread>
+
+using namespace facebook::react;
+
+@interface MainQueueCoordinatorTests : XCTestCase
+@end
+
+@implementation MainQueueCoordinatorTests
+
+- (void)testRCTUnsafeExecuteOnMainQueueSync_runsBlockOnMainFromBG
+{
+  XCTestExpectation *done = [self expectationWithDescription:@"BG-thread call completed"];
+  __block BOOL ranOnMain = NO;
+  __block BOOL returnedToBG = NO;
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      ranOnMain = RCTIsMainQueue();
+    });
+    returnedToBG = YES;
+    [done fulfill];
+  });
+
+  [self waitForExpectations:@[ done ] timeout:5.0];
+  XCTAssertTrue(ranOnMain, @"Block must execute on main queue");
+  XCTAssertTrue(returnedToBG, @"BG thread must resume after sync call returns");
+}
+
+- (void)testExecuteSynchronouslyOnSameThread_pumpsUITasksWhileWaitingForJS
+{
+  // A real runtime — needed only for the reference type. We never call into it.
+  auto runtime = facebook::hermes::makeHermesRuntime();
+
+  // A "JS thread" that the executor posts to. Sleeps before invoking the callback
+  // so that the main thread is forced to wait, giving us a window to post a UI task.
+  constexpr auto kJSDelay = std::chrono::milliseconds(300);
+
+  RuntimeExecutor slowJSExecutor = [&runtime, kJSDelay](std::function<void(facebook::jsi::Runtime &)> &&callback) {
+    std::thread([cb = std::move(callback), &runtime, kJSDelay]() mutable {
+      std::this_thread::sleep_for(kJSDelay);
+      cb(*runtime);
+    }).detach();
+  };
+
+  // Both writes happen on main, so plain ints are race-free. Held in a struct
+  // so we can capture a pointer from an ObjC block and a reference from a C++
+  // lambda without `__block` (which doesn't compose with lambdas).
+  struct State {
+    int sequence = 0;
+    int uiTaskOrder = 0;
+    int runtimeWorkOrder = 0;
+    BOOL uiTaskRanOnMain = NO;
+    BOOL runtimeWorkRanOnMain = NO;
+  };
+  State state;
+  State *statePtr = &state;
+
+  // Background thread posts a UI task ~100ms after the main thread enters the
+  // wait loop — well before the JS thread wakes up at +300ms.
+  XCTestExpectation *bgDone = [self expectationWithDescription:@"BG-thread sync call completed"];
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      statePtr->uiTaskOrder = ++statePtr->sequence;
+      statePtr->uiTaskRanOnMain = RCTIsMainQueue();
+    });
+    [bgDone fulfill];
+  });
+
+  // This call blocks main inside the coordinator's wait loop. While it waits,
+  // it should pump the UI task posted by the BG thread above.
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(slowJSExecutor, [&state](facebook::jsi::Runtime & /*_*/) {
+    state.runtimeWorkOrder = ++state.sequence;
+    state.runtimeWorkRanOnMain = RCTIsMainQueue();
+  });
+
+  [self waitForExpectations:@[ bgDone ] timeout:5.0];
+
+  XCTAssertTrue(state.uiTaskRanOnMain, @"UI task posted from BG should run on main");
+  XCTAssertTrue(state.runtimeWorkRanOnMain, @"runtimeWork should run on main");
+  XCTAssertEqual(state.uiTaskOrder, 1, @"UI task should be pumped before runtimeWork");
+  XCTAssertEqual(state.runtimeWorkOrder, 2, @"runtimeWork should run after the pumped UI task");
+}
+
+@end

package/ReactCommon/react/runtime/iostests/RCTInstanceTests.mm

@@ -0,0 +1,244 @@
+/*
+ * 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 <XCTest/XCTest.h>
+
+#import <OCMock/OCMock.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTBundleManager.h>
+#import <React/RCTJavaScriptLoader.h>
+#import <ReactCommon/RCTHermesInstance.h>
+#import <ReactCommon/RCTInstance.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+
+using namespace facebook::react;
+
+@interface FakeEagerModule : NSObject <RCTBridgeModule, RCTTurboModule>
+@property (class, readonly) NSCountedSet<NSString *> *initCounts;
+@property (class, nullable) void (^onInit)(void);
++ (void)reset;
+@end
+
+@implementation FakeEagerModule
+
+static NSCountedSet<NSString *> *sInitCounts;
+static void (^sOnInit)(void);
+
++ (NSCountedSet<NSString *> *)initCounts
+{
+  if (sInitCounts == nil) {
+    sInitCounts = [NSCountedSet new];
+  }
+  return sInitCounts;
+}
+
++ (void)setOnInit:(void (^)(void))block
+{
+  sOnInit = [block copy];
+}
+
++ (void (^)(void))onInit
+{
+  return sOnInit;
+}
+
++ (NSString *)moduleName
+{
+  return @"FakeEagerModule";
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
++ (void)reset
+{
+  [[FakeEagerModule initCounts] removeAllObjects];
+  sOnInit = nil;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    // Block FIRST, then bump the counter. This way "init has fully completed"
+    // is observable as count == 1, distinct from "init has been entered".
+    if (sOnInit) {
+      sOnInit();
+    }
+    @synchronized([FakeEagerModule initCounts]) {
+      [[FakeEagerModule initCounts] addObject:[[self class] moduleName]];
+    }
+  }
+  return self;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return nullptr;
+}
+
+@end
+
+@interface RCTInstanceTests : XCTestCase
+@end
+
+@implementation RCTInstanceTests {
+  id<RCTInstanceDelegate> _mockDelegate;
+  id<RCTTurboModuleManagerDelegate> _mockTMMDelegate;
+  id _bundleLoadObserver;
+}
+
+- (void)setUp
+{
+  [super setUp];
+  [FakeEagerModule reset];
+
+  _mockDelegate = OCMProtocolMock(@protocol(RCTInstanceDelegate));
+  _mockTMMDelegate = OCMProtocolMock(@protocol(RCTTurboModuleManagerDelegate));
+
+  // Match only FakeEagerModule by name; anything else returns nil so unrelated
+  // lookups (RCTDevMenu, RCTImageLoader, ...) don't accidentally instantiate it.
+  OCMStub([_mockTMMDelegate getModuleClassFromName:nullptr]).ignoringNonObjectArgs().andDo(^(NSInvocation *invocation) {
+    const char *requestedName = nullptr;
+    [invocation getArgument:&requestedName atIndex:2];
+    Class result =
+        (requestedName != nullptr && strcmp(requestedName, "FakeEagerModule") == 0) ? [FakeEagerModule class] : Nil;
+    [invocation setReturnValue:&result];
+  });
+}
+
+- (void)tearDown
+{
+  if (_bundleLoadObserver != nil) {
+    [[NSNotificationCenter defaultCenter] removeObserver:_bundleLoadObserver];
+    _bundleLoadObserver = nil;
+  }
+  [FakeEagerModule reset];
+  _mockDelegate = nil;
+  _mockTMMDelegate = nil;
+  [super tearDown];
+}
+
+- (RCTInstance *)makeInstance
+{
+  RCTBundleManager *bundleManager = [RCTBundleManager new];
+  // bundleURL asserts the bridgeless getter is non-nil; without it the NSException
+  // unwinds the JS-thread init callback before reaching _loadJSBundle:.
+  NSURL * (^urlGetter)(void) = ^{
+    return [NSURL URLWithString:@"file:///empty.bundle"];
+  };
+  [bundleManager setBridgelessBundleURLGetter:urlGetter
+                                    andSetter:^(NSURL *_) {
+                                    }
+                             andDefaultGetter:urlGetter];
+  return [[RCTInstance alloc] initWithDelegate:_mockDelegate
+                              jsRuntimeFactory:std::make_shared<RCTHermesInstance>()
+                                 bundleManager:bundleManager
+                    turboModuleManagerDelegate:_mockTMMDelegate
+                                moduleRegistry:[RCTModuleRegistry new]
+                         parentInspectorTarget:nullptr
+                                 launchOptions:nil];
+}
+
+- (void)testConsultsDelegateExactlyOnce
+{
+  OCMStub([_mockDelegate unstableModulesRequiringMainQueueSetup]).andReturn(@[]);
+
+  RCTInstance *instance = [self makeInstance];
+
+  OCMVerify(OCMTimes(1), [_mockDelegate unstableModulesRequiringMainQueueSetup]);
+
+  [instance invalidate];
+}
+
+- (void)testInstantiatesRequestedModuleOnMainQueue
+{
+  OCMStub([_mockDelegate unstableModulesRequiringMainQueueSetup]).andReturn(@[ FakeEagerModule.moduleName ]);
+
+  RCTInstance *instance = [self makeInstance];
+
+  XCTAssertEqual(
+      [FakeEagerModule.initCounts countForObject:FakeEagerModule.moduleName],
+      1u,
+      @"FakeEagerModule should have been constructed exactly once during eager setup");
+
+  [instance invalidate];
+}
+
+- (void)testBundleLoadAwaitsMainQueueModuleSetup
+{
+  OCMStub([_mockDelegate unstableModulesRequiringMainQueueSetup]).andReturn(@[ FakeEagerModule.moduleName ]);
+
+  // Hand the instance an empty bundle the moment it asks for one. The JS thread
+  // will then drive _loadScriptFromSource: which invokes the wait block before
+  // evaluating the script. RCTInstance posts RCTInstanceDidLoadBundle from the
+  // `afterLoad` lambda, i.e. after the wait block has returned.
+  RCTSource *emptySource = OCMClassMock([RCTSource class]);
+  OCMStub([emptySource url]).andReturn([NSURL URLWithString:@"file:///empty.bundle"]);
+  OCMStub([emptySource data]).andReturn([NSData data]);
+  OCMStub([_mockDelegate loadBundleAtURL:[OCMArg any] onProgress:[OCMArg any] onComplete:[OCMArg any]])
+      .andDo(^(NSInvocation *invocation) {
+        __unsafe_unretained RCTSourceLoadBlock onComplete;
+        [invocation getArgument:&onComplete atIndex:4];
+        onComplete(nil, emptySource);
+      });
+
+  dispatch_semaphore_t initEntered = dispatch_semaphore_create(0);
+  dispatch_semaphore_t releaseInit = dispatch_semaphore_create(0);
+
+  FakeEagerModule.onInit = ^{
+    dispatch_semaphore_signal(initEntered);
+    dispatch_semaphore_wait(releaseInit, DISPATCH_TIME_FOREVER);
+  };
+
+  XCTestExpectation *bundleLoaded = [self expectationWithDescription:@"RCTInstanceDidLoadBundle"];
+  __block NSUInteger initCountAtBundleLoad = 0;
+  _bundleLoadObserver = [[NSNotificationCenter defaultCenter]
+      addObserverForName:@"RCTInstanceDidLoadBundle"
+                  object:nil
+                   queue:nil
+              usingBlock:^(NSNotification *_) {
+                initCountAtBundleLoad = [FakeEagerModule.initCounts countForObject:FakeEagerModule.moduleName];
+                [bundleLoaded fulfill];
+              }];
+
+  XCTestExpectation *done = [self expectationWithDescription:@"orchestration complete"];
+  __block RCTInstance *instance = nil;
+
+  // Orchestration runs off-main so the main thread is free to service the
+  // RCTExecuteOnMainQueue block from _start, where FakeEagerModule.init runs.
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    instance = [self makeInstance];
+
+    XCTAssertEqual(
+        dispatch_semaphore_wait(initEntered, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+        0,
+        @"FakeEagerModule -init did not run on main queue within timeout");
+
+    // Releasing here unblocks main-queue setup, which signals the wait block,
+    // which lets the JS thread proceed past `beforeLoad` and post the bundle
+    // notification.
+    dispatch_semaphore_signal(releaseInit);
+
+    [done fulfill];
+  });
+
+  // Invalidate AFTER the notification fires; otherwise `_valid = false` makes
+  // _loadScriptFromSource: short-circuit and `afterLoad` never runs.
+  [self waitForExpectations:@[ bundleLoaded, done ] timeout:10.0];
+  [instance invalidate];
+
+  XCTAssertEqual(
+      initCountAtBundleLoad,
+      1u,
+      @"FakeEagerModule -init must have fully returned before the JS bundle finishes loading");
+}
+
+@end

package/ReactCommon/react/runtime/platform/ios/React-RuntimeApple.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "../../../../..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+source = { :git => 'https://github.com/facebook/react-native.git' }
 if version == '1000.0.0'
   # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
   source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")

package/ReactCommon/react/runtime/platform/ios/ReactCommon/ObjCTimerRegistry.h

@@ -23,7 +23,7 @@ class ObjCTimerRegistry : public facebook::react::PlatformTimerRegistry {
   void createTimer(uint32_t timerID, double delayMS) override;
   void deleteTimer(uint32_t timerID) override;
   void createRecurringTimer(uint32_t timerID, double delayMS) override;
-  void setTimerManager(std::weak_ptr<facebook::react::TimerManager> timerManager);
+  void setTimerManager(std::weak_ptr<facebook::react::TimerManager> timerManager) override;
   RCTTiming *_Null_unspecified timing;
 
  private: