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

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -48,7 +48,9 @@
 
 #import "ObjCTimerRegistry.h"
 #import "RCTJSThreadManager.h"
+#ifndef RCT_REMOVE_LEGACY_COMPONENT_INTEROP
 #import "RCTLegacyUIManagerConstantsProvider.h"
+#endif
 #import "RCTPerformanceLoggerUtils.h"
 
 #if RCT_DEV_MENU && __has_include(<React/RCTDevLoadingViewProtocol.h>)
@@ -72,7 +74,9 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   sRuntimeDiagnosticFlags = [flags copy];
 }
 
-@interface RCTBridgelessDisplayLinkModuleHolder : NSObject <RCTDisplayLinkModuleHolder>
+__attribute__((deprecated(
+    "RCTBridgelessDisplayLinkModuleHolder is part of the legacy architecture and will be removed in a future React Native release.")))
+@interface RCTBridgelessDisplayLinkModuleHolder : NSObject<RCTDisplayLinkModuleHolder>
 - (instancetype)initWithModule:(id<RCTBridgeModule>)module;
 @end
 
@@ -113,6 +117,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   RCTPerformanceLogger *_performanceLogger;
   RCTDisplayLink *_displayLink;
   RCTTurboModuleManager *_turboModuleManager;
+  RCTBridgeProxy *_bridgeProxy;
   std::mutex _invalidationMutex;
   std::atomic<bool> _valid;
   RCTJSThreadManager *_jsThreadManager;
@@ -349,6 +354,8 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
           runtime:_reactInstance->getJavaScriptContext()
           launchOptions:_launchOptions];
   bridgeProxy.jsCallInvoker = jsCallInvoker;
+  bridgeProxy.performanceLogger = _performanceLogger;
+  _bridgeProxy = bridgeProxy;
   [RCTBridge setCurrentBridge:(RCTBridge *)bridgeProxy];
 
   // Set up TurboModules
@@ -371,38 +378,31 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   // Initialize RCTModuleRegistry so that TurboModules can require other TurboModules.
   [_bridgeModuleDecorator.moduleRegistry setTurboModuleRegistry:_turboModuleManager];
 
-  if (ReactNativeFeatureFlags::enableEagerMainQueueModulesOnIOS()) {
-    /**
-     * Some native modules need to capture uikit objects on the main thread.
-     * Start initializing those modules on the main queue here. The JavaScript thread
-     * will wait until this module init finishes, before executing the js bundle.
-     */
-    NSArray<NSString *> *modulesRequiringMainQueueSetup = [_delegate unstableModulesRequiringMainQueueSetup];
+  /**
+   * Some native modules need to capture uikit objects on the main thread.
+   * Start initializing those modules on the main queue here. The JavaScript thread
+   * will wait until this module init finishes, before executing the js bundle.
+   */
+  NSArray<NSString *> *modulesRequiringMainQueueSetup = [_delegate unstableModulesRequiringMainQueueSetup];
 
-    std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
-    std::shared_ptr<std::condition_variable> cv = std::make_shared<std::condition_variable>();
-    std::shared_ptr<bool> isReady = std::make_shared<bool>(false);
+  dispatch_semaphore_t moduleSetupComplete = dispatch_semaphore_create(0);
 
-    _waitUntilModuleSetupComplete = ^{
-      std::unique_lock<std::mutex> lock(*mutex);
-      cv->wait(lock, [isReady] { return *isReady; });
-    };
+  _waitUntilModuleSetupComplete = ^{
+    dispatch_semaphore_wait(moduleSetupComplete, DISPATCH_TIME_FOREVER);
+  };
 
-    // TODO(T218039767): Integrate perf logging into main queue module init
-    RCTExecuteOnMainQueue(^{
-      for (NSString *moduleName in modulesRequiringMainQueueSetup) {
-        [self->_bridgeModuleDecorator.moduleRegistry moduleForName:[moduleName UTF8String]];
-      }
+  // TODO(T218039767): Integrate perf logging into main queue module init
+  RCTExecuteOnMainQueue(^{
+    for (NSString *moduleName in modulesRequiringMainQueueSetup) {
+      [self->_bridgeModuleDecorator.moduleRegistry moduleForName:[moduleName UTF8String]];
+    }
 
-      RCTScreenSize();
-      RCTScreenScale();
-      RCTSwitchSize();
+    RCTScreenSize();
+    RCTScreenScale();
+    RCTSwitchSize();
 
-      std::lock_guard<std::mutex> lock(*mutex);
-      *isReady = true;
-      cv->notify_all();
-    });
-  }
+    dispatch_semaphore_signal(moduleSetupComplete);
+  });
 
   RCTLogSetBridgelessModuleRegistry(_bridgeModuleDecorator.moduleRegistry);
   RCTLogSetBridgelessCallableJSModules(_bridgeModuleDecorator.callableJSModules);
@@ -454,15 +454,20 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
     });
     RCTInstallNativeComponentRegistryBinding(runtime);
 
+#ifndef RCT_REMOVE_LEGACY_COMPONENT_INTEROP
     if (ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode()) {
       installLegacyUIManagerConstantsProviderBinding(runtime);
     }
+#endif
 
     [strongSelf->_delegate instance:strongSelf didInitializeRuntime:runtime];
 
-    // Set up Display Link
+// Set up Display Link
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     id<RCTDisplayLinkModuleHolder> moduleHolder = [[RCTBridgelessDisplayLinkModuleHolder alloc] initWithModule:timing];
     [strongSelf->_displayLink registerModuleForFrameUpdates:timing withModuleHolder:moduleHolder];
+#pragma clang diagnostic pop
     [strongSelf->_displayLink addToRunLoop:[NSRunLoop currentRunLoop]];
 
     // Attempt to load bundle synchronously, fallback to asynchronously.
@@ -609,8 +614,20 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
       waitUntilModuleSetupComplete();
     }
   };
-  auto afterLoad = [](jsi::Runtime &_) {
+  __weak __typeof(self) weakSelf = self;
+  auto afterLoad = [weakSelf](jsi::Runtime &) {
     [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTInstanceDidLoadBundle" object:nil];
+    __strong __typeof(weakSelf) strongSelf = weakSelf;
+    if (strongSelf) {
+      RCTBridgeProxy *bridgeProxy = strongSelf->_bridgeProxy;
+      // afterLoad runs on the JS thread; post on main like the legacy bridge so
+      // RCTJavaScriptDidLoadNotification observers aren't invoked off-main.
+      RCTExecuteOnMainQueue(^{
+        [[NSNotificationCenter defaultCenter] postNotificationName:RCTJavaScriptDidLoadNotification
+                                                            object:strongSelf
+                                                          userInfo:bridgeProxy ? @{@"bridge" : bridgeProxy} : @{}];
+      });
+    }
   };
   _reactInstance->loadScript(std::move(script), url, beforeLoad, afterLoad);
 }

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTJscInstance.mm

@@ -10,9 +10,10 @@
 
 namespace facebook::react {
 
-RCTJscInstance::RCTJscInstance() {}
+RCTJscInstance::RCTJscInstance() = default;
 
-std::unique_ptr<JSRuntime> RCTJscInstance::createJSRuntime(std::shared_ptr<MessageQueueThread> msgQueueThread) noexcept
+std::unique_ptr<JSRuntime> RCTJscInstance::createJSRuntime(
+    std::shared_ptr<MessageQueueThread> /*msgQueueThread*/) noexcept
 {
   return std::make_unique<JSIRuntimeHolder>(jsc::makeJSCRuntime());
 }

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTPerformanceLoggerUtils.mm

@@ -67,8 +67,9 @@ static void mapReactMarkerToPerformanceLogger(
 void registerPerformanceLoggerHooks(RCTPerformanceLogger *performanceLogger)
 {
   __weak RCTPerformanceLogger *weakPerformanceLogger = performanceLogger;
-  ReactMarker::logTaggedMarkerBridgelessImpl = [weakPerformanceLogger](
-                                                   const ReactMarker::ReactMarkerId markerId, const char *tag) {
+  ReactMarker::logTaggedMarkerImpl = [weakPerformanceLogger](
+                                         const ReactMarker::ReactMarkerId markerId, const char *tag) {
+    (void)tag;
     mapReactMarkerToPerformanceLogger(markerId, weakPerformanceLogger);
   };
 }

package/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -15,6 +15,7 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <hermes/hermes.h>
 #include <jserrorhandler/JsErrorHandler.h>
+#include <jsi/hermes-interfaces.h>
 #include <jsi/jsi.h>
 #include <react/runtime/ReactInstance.h>
 
@@ -26,9 +27,9 @@ namespace facebook::react {
 
 class MockTimerRegistry : public PlatformTimerRegistry {
  public:
-  MOCK_METHOD2(createTimer, void(uint32_t, double));
-  MOCK_METHOD2(createRecurringTimer, void(uint32_t, double));
-  MOCK_METHOD1(deleteTimer, void(uint32_t));
+  MOCK_METHOD(void, createTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, createRecurringTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, deleteTimer, (uint32_t), (override));
 };
 
 class MockMessageQueueThread : public MessageQueueThread {
@@ -138,6 +139,12 @@ class ReactInstanceTest : public ::testing::Test {
         std::move(onJsError));
     timerManager_->setRuntimeExecutor(instance_->getBufferedRuntimeExecutor());
 
+    // ReactInstance construction defers registering the RuntimeScheduler as the
+    // Hermes IEventLoopControl onto the runtime executor, which enqueues a
+    // callback on messageQueueThread_. Drain it so each test starts from an
+    // empty queue and its step() bookkeeping is unaffected.
+    step();
+
     // Install a C++ error handler
     errorHandler_ = std::make_shared<ErrorUtils>();
     runtime_->global().setProperty(
@@ -223,6 +230,23 @@ class ReactInstanceTest : public ::testing::Test {
   std::shared_ptr<ErrorUtils> errorHandler_;
 };
 
+TEST_F(ReactInstanceTest, testRegistersRuntimeSchedulerAsEventLoopControl) {
+  auto* setEventLoopControl =
+      jsi::castInterface<facebook::hermes::ISetEventLoopControl>(runtime_);
+  if (setEventLoopControl == nullptr) {
+    // This Hermes build does not implement ISetEventLoopControl, so
+    // ReactInstance's registration is a no-op and there is nothing to observe.
+    GTEST_SKIP()
+        << "Hermes runtime does not expose ISetEventLoopControl in this build";
+  }
+
+  // SetUp() already drained the deferred registration callback, so by now the
+  // RuntimeScheduler is registered as the runtime's event loop control.
+  facebook::hermes::IEventLoopControl* expected =
+      instance_->getRuntimeScheduler().get();
+  EXPECT_EQ(setEventLoopControl->getEventLoopControl(), expected);
+}
+
 TEST_F(ReactInstanceTest, testBridgelessFlagIsSet) {
   auto valBefore = tryEval("RN$Bridgeless === true", "false");
   EXPECT_EQ(valBefore.getBool(), false);

package/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <memory>
+#include <queue>
+#include <utility>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <hermes/hermes.h>
+#include <jserrorhandler/JsErrorHandler.h>
+#include <jsi/jsi.h>
+#include <react/runtime/ReactInstance.h>
+
+namespace facebook::react {
+
+namespace {
+
+class MockTimerRegistry : public PlatformTimerRegistry {
+ public:
+  MOCK_METHOD(void, createTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, createRecurringTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, deleteTimer, (uint32_t), (override));
+};
+
+class MockMessageQueueThread : public MessageQueueThread {
+ public:
+  void runOnQueue(std::function<void()>&& func) override {
+    callbackQueue_.push(std::move(func));
+  }
+
+  void runOnQueueSync(std::function<void()>&& /*unused*/) override {}
+  void quitSynchronous() override {}
+
+  void tick() {
+    while (!callbackQueue_.empty()) {
+      auto callback = std::move(callbackQueue_.front());
+      callbackQueue_.pop();
+      callback();
+    }
+  }
+
+  size_t size() const {
+    return callbackQueue_.size();
+  }
+
+ private:
+  std::queue<std::function<void()>> callbackQueue_;
+};
+
+} // namespace
+
+class RuntimeExecutorShutdownTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    auto runtime =
+        std::make_unique<JSIRuntimeHolder>(hermes::makeHermesRuntime());
+    messageQueueThread_ = std::make_shared<MockMessageQueueThread>();
+    auto mockRegistry = std::make_unique<MockTimerRegistry>();
+    auto timerManager = std::make_shared<TimerManager>(std::move(mockRegistry));
+    auto onJsError =
+        [](jsi::Runtime& /*runtime*/,
+           const JsErrorHandler::ProcessedError& /*error*/) noexcept {};
+
+    instance_ = std::make_unique<ReactInstance>(
+        std::move(runtime),
+        messageQueueThread_,
+        timerManager,
+        std::move(onJsError));
+
+    // ReactInstance construction defers registering the RuntimeScheduler as the
+    // Hermes IEventLoopControl onto the runtime executor, which enqueues a
+    // callback on messageQueueThread_. Drain it so each shutdown scenario
+    // starts from an empty queue.
+    messageQueueThread_->tick();
+  }
+
+  std::shared_ptr<MockMessageQueueThread> messageQueueThread_;
+  std::unique_ptr<ReactInstance> instance_;
+};
+
+// Calling a held RuntimeExecutor after ReactInstance has been destroyed
+// must silently drop the callback. Use a shared_ptr captured into the
+// callback to also prove the callback itself is destroyed (not retained
+// somewhere indefinitely).
+TEST_F(
+    RuntimeExecutorShutdownTest,
+    heldExecutorCallAfterShutdownDropsCallback) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  instance_.reset();
+
+  auto tracker = std::make_shared<int>(0);
+  std::weak_ptr<int> weakTracker = tracker;
+  executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) {
+    FAIL() << "Callback should never run after shutdown";
+  });
+
+  EXPECT_EQ(messageQueueThread_->size(), 0u);
+  EXPECT_TRUE(weakTracker.expired())
+      << "Rejected callback (and its captures) should be destroyed";
+  messageQueueThread_->tick();
+}
+
+// Repeated post-shutdown invocations must remain memory-safe. This guards
+// against future refactors that swap the weak_ptr capture for a raw pointer
+// or shared_ptr.
+TEST_F(RuntimeExecutorShutdownTest, heldExecutorCallAfterShutdownDoesNotCrash) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  instance_.reset();
+
+  for (int i = 0; i < 100; ++i) {
+    executor([](jsi::Runtime& /*runtime*/) {
+      FAIL() << "Callback should never run after shutdown";
+    });
+  }
+  messageQueueThread_->tick();
+}
+
+// Work scheduled through the buffered executor sits in the internal buffer
+// until flush() (which only happens via loadScript). If the ReactInstance
+// is destroyed before flush, the buffered work must be dropped — never
+// surfaced on the JS queue and never retained past instance destruction.
+// A shared_ptr captured into the callback, watched via weak_ptr from
+// outside, proves the buffered queue actually releases its contents.
+TEST_F(
+    RuntimeExecutorShutdownTest,
+    pendingCallbackShutdownBeforeTickDropsCallback) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  auto tracker = std::make_shared<int>(0);
+  std::weak_ptr<int> weakTracker = tracker;
+  executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) {
+    FAIL() << "Buffered callback should never run after shutdown";
+  });
+
+  EXPECT_EQ(messageQueueThread_->size(), 0u);
+  EXPECT_FALSE(weakTracker.expired())
+      << "Callback should still be alive in BufferedRuntimeExecutor's queue";
+
+  instance_.reset();
+
+  EXPECT_TRUE(weakTracker.expired())
+      << "Buffered callback should be destroyed when ReactInstance is";
+  messageQueueThread_->tick();
+}
+
+} // namespace facebook::react

package/ReactCommon/react/timing/React-timing.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/utils/React-utils.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/utils/Telemetry.h

@@ -81,19 +81,6 @@ DestinationTimePointT clockCast(SourceTimePointT timePoint)
       timePoint - sourseClockNow + destinationClockNow);
 }
 
-/*
- * Returns a number of seconds that passed from the UNIX Epoch starting time
- * point to a given time point.
- * Also known as POSIX time or UNIX Timestamp.
- */
-static inline double telemetryTimePointToSecondsSinceEpoch(TelemetryTimePoint timePoint)
-{
-  auto systemClockTimePoint = clockCast<std::chrono::system_clock::time_point, TelemetryTimePoint>(timePoint);
-  return (double)std::chrono::duration_cast<std::chrono::microseconds>(systemClockTimePoint.time_since_epoch())
-             .count() /
-      1000000.0;
-}
-
 /*
  * Returns a number of milliseconds that represents the given duration object.
  */

package/ReactCommon/react/utils/tests/Base64Tests.cpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+#include <react/utils/Base64.h>
+#include <string>
+
+namespace facebook::react {
+
+TEST(Base64Tests, encodesAsciiString) {
+  EXPECT_EQ(base64Encode("hello"), "aGVsbG8=");
+}
+
+TEST(Base64Tests, encodesEmptyString) {
+  EXPECT_EQ(base64Encode(""), "");
+}
+
+// Padding depends on input length modulo 3.
+TEST(Base64Tests, encodesWithCorrectPadding) {
+  EXPECT_EQ(base64Encode("a"), "YQ==");
+  EXPECT_EQ(base64Encode("ab"), "YWI=");
+  EXPECT_EQ(base64Encode("abc"), "YWJj");
+}
+
+// Binary safety: bytes that are invalid UTF-8 / contain NULs must round-trip.
+// This is the case that matters for binary ('base64'/arraybuffer) response
+// bodies in the NetworkingModule -- sending such bytes verbatim corrupts them.
+TEST(Base64Tests, encodesBinaryBytes) {
+  EXPECT_EQ(base64Encode(std::string("\x00\xff", 2)), "AP8=");
+}
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/React-perflogger.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/reactperflogger/reactperflogger/ReactPerfettoLogger.cpp

@@ -20,7 +20,6 @@ namespace {
 #if defined(WITH_PERFETTO)
 const HighResTimeStamp PROGRAM_INIT_TIME = HighResTimeStamp::now();
 const std::string PERFETTO_DEFAULT_TRACK_NAME = "# Web Performance";
-const std::string PERFETTO_TRACK_NAME_PREFIX = "# Web Performance: ";
 
 std::string toPerfettoTrackName(
     const std::optional<std::string_view>& trackName,

package/ReactCommon/runtimeexecutor/React-runtimeexecutor.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/runtimeexecutor/platform/ios/ReactCommon/RuntimeExecutorSyncUIThreadUtils.mm

@@ -9,9 +9,7 @@
 
 #import <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
 #import <react/debug/react_native_assert.h>
-#import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/utils/OnScopeExit.h>
-#import <algorithm>
 #import <functional>
 #import <future>
 #import <mutex>
@@ -111,8 +109,8 @@ void runUITask(UITask &uiTask)
 }
 
 /**
- * This method is resilient to multiple javascript threads.
- * This can happen when multiple react instances interleave.
+ * Coordinator-style implementation that is resilient to multiple javascript
+ * threads. This can happen when multiple react instances interleave.
  *
  * The extension from 1 js thread to n: All js threads race to
  * get a ticket to post a ui task. The first one to get the ticket
@@ -122,10 +120,13 @@ void runUITask(UITask &uiTask)
  *
  * For simplicity, we will just use this algorithm for all bg threads.
  * Not just the js thread.
+ *
+ * Requires the caller to be on the main thread, because the wait loop pumps
+ * UI tasks that are dispatched to the main queue.
  */
-void saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
+void coordinatedExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
-    std::function<void(jsi::Runtime &runtime)> &&runtimeWork)
+    std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
   react_native_assert([[NSThread currentThread] isMainThread] && !g_isRunningUITask);
 
@@ -159,52 +160,34 @@ void saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
   runtimeWork(*runtime);
 }
 
-/*
+/**
  * Schedules `runtimeWork` to be executed on the same thread using the
- * `RuntimeExecutor`, and blocks on its completion.
- *
- * Example:
- * - [UI thread] Schedule `runtimeCaptureBlock` on js thread
- * - [UI thread] Wait for runtime capture: await(runtime)
- * - [JS thread] Capture runtime for ui thread: resolve(runtime, &rt);
- * - [JS thread] Wait until runtimeWork done: await(runtimeWorkDone)
- * - [UI thread] Call runtimeWork: runtimeWork(*runtimePrt);
- * - [UI thread] Signal runtimeWork done: resolve(runtimeWorkDone)
- * - [UI thread] Wait until runtime capture block finished:
- *               await(runtimeCaptureBlockDone);
- * - [JS thread] Signal runtime capture block is finished:
- *               resolve(runtimeCaptureBlockDone);
+ * `RuntimeExecutor`, and blocks on its completion. Used when the caller is
+ * not on the main thread (the coordinator implementation requires main).
  */
-void legacyExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
+void simpleExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
     std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
   std::promise<jsi::Runtime *> runtime;
-  std::promise<void> runtimeCaptureBlockDone;
   std::promise<void> runtimeWorkDone;
 
   auto callingThread = std::this_thread::get_id();
 
-  auto runtimeCaptureBlock = [&](jsi::Runtime &rt) {
+  runtimeExecutor([&](jsi::Runtime &rt) {
     runtime.set_value(&rt);
 
-    auto runtimeThread = std::this_thread::get_id();
-    if (callingThread != runtimeThread) {
-      // Block `runtimeThread` on execution of `runtimeWork` on `callingThread`.
+    if (callingThread != std::this_thread::get_id()) {
+      // Block the runtime thread on execution of `runtimeWork` on the calling thread.
       runtimeWorkDone.get_future().wait();
     }
-
-    // TODO(T225331233): This is likely unnecessary. Remove it.
-    runtimeCaptureBlockDone.set_value();
-  };
-  runtimeExecutor(std::move(runtimeCaptureBlock));
+  });
 
   jsi::Runtime *runtimePtr = runtime.get_future().get();
-  runtimeWork(*runtimePtr);
-  runtimeWorkDone.set_value();
 
-  // TODO(T225331233): This is likely unnecessary. Remove it.
-  runtimeCaptureBlockDone.get_future().wait();
+  OnScopeExit onScopeExit([&]() { runtimeWorkDone.set_value(); });
+  // Calls into runtime scheduler, which takes care of error handling
+  runtimeWork(*runtimePtr);
 }
 
 } // namespace
@@ -213,10 +196,10 @@ void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
     std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
-  if (ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS()) {
-    saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
+  if ([[NSThread currentThread] isMainThread] && !g_isRunningUITask) {
+    coordinatedExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
   } else {
-    legacyExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
+    simpleExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
   }
 }
 

package/ReactCommon/yoga/Yoga.podspec

@@ -6,7 +6,7 @@
 package = JSON.parse(File.read(File.expand_path('../../package.json', __dir__)))
 version = package['version']
 
-source = { :git => ENV['INSTALL_YOGA_FROM_LOCATION'] || 'https://github.com/react/react-native.git' }
+source = { :git => ENV['INSTALL_YOGA_FROM_LOCATION'] || '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")
@@ -61,6 +61,6 @@ Pod::Spec.new do |spec|
   # Fabric must be able to access private headers (which should not be included in the umbrella header)
   all_header_files = 'yoga/**/*.h'
   all_header_files = File.join('ReactCommon/yoga', all_header_files) if ENV['INSTALL_YOGA_WITHOUT_PATH_OPTION']
-  spec.private_header_files = Dir.glob(all_header_files) - Dir.glob(public_header_files)
+  spec.private_header_files = Dir.glob(all_header_files).sort - Dir.glob(public_header_files).sort
   spec.preserve_paths = [all_header_files]
 end

package/ReactCommon/yoga/yoga/YGEnums.cpp

@@ -117,6 +117,8 @@ const char* YGErrataToString(const YGErrata value) {
       return "absolute-position-without-insets-excludes-padding";
     case YGErrataAbsolutePercentAgainstInnerSize:
       return "absolute-percent-against-inner-size";
+    case YGErrataMinSizeUndefinedInsteadOfAuto:
+      return "min-size-undefined-instead-of-auto";
     case YGErrataAll:
       return "all";
     case YGErrataClassic:

package/ReactCommon/yoga/yoga/YGEnums.h

@@ -67,6 +67,7 @@ YG_ENUM_DECL(
     YGErrataStretchFlexBasis = 1,
     YGErrataAbsolutePositionWithoutInsetsExcludesPadding = 2,
     YGErrataAbsolutePercentAgainstInnerSize = 4,
+    YGErrataMinSizeUndefinedInsteadOfAuto = 8,
     YGErrataAll = 2147483647,
     YGErrataClassic = 2147483646)
 YG_DEFINE_ENUM_FLAG_OPERATORS(YGErrata)