react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactCommon/react/renderer/observers/mutation/MutationObserver.h

@@ -27,6 +27,18 @@ class MutationObserver {
  public:
   MutationObserver(MutationObserverId intersectionObserverId);
 
+  // delete copy constructor
+  MutationObserver(const MutationObserver&) = delete;
+
+  // delete copy assignment
+  MutationObserver& operator=(const MutationObserver&) = delete;
+
+  // allow move constructor
+  MutationObserver(MutationObserver&&) = default;
+
+  // allow move assignment
+  MutationObserver& operator=(MutationObserver&&) = default;
+
   void observe(ShadowNode::Shared targetShadowNode, bool observeSubtree);
   void unobserve(const ShadowNode& targetShadowNode);
 
@@ -53,12 +65,11 @@ class MutationObserver {
       SetOfShadowNodePointers& processedNodes) const;
 
   void recordMutationsInSubtrees(
-      ShadowNode::Shared targetShadowNode,
-      const ShadowNode& oldNode,
-      const ShadowNode& newNode,
+      const ShadowNode::Shared& oldNode,
+      const ShadowNode::Shared& newNode,
       bool observeSubtree,
       std::vector<MutationRecord>& recordedMutations,
-      SetOfShadowNodePointers processedNodes) const;
+      SetOfShadowNodePointers& processedNodes) const;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/observers/mutation/MutationObserverManager.cpp

@@ -29,9 +29,9 @@ void MutationObserverManager::observe(
   if (observerIt == observers.end()) {
     auto observer = MutationObserver{mutationObserverId};
     observer.observe(shadowNode, observeSubtree);
-    observers.insert({mutationObserverId, std::move(observer)});
+    observers.emplace(mutationObserverId, std::move(observer));
   } else {
-    auto observer = observerIt->second;
+    auto& observer = observerIt->second;
     observer.observe(shadowNode, observeSubtree);
   }
 }

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -22,7 +22,8 @@ std::unique_ptr<RuntimeSchedulerBase> getRuntimeSchedulerImplementation(
     RuntimeExecutor runtimeExecutor,
     std::function<RuntimeSchedulerTimePoint()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError) {
-  if (ReactNativeFeatureFlags::useModernRuntimeScheduler()) {
+  if (ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
+      !ReactNativeFeatureFlags::disableEventLoopOnBridgeless()) {
     return std::make_unique<RuntimeScheduler_Modern>(
         std::move(runtimeExecutor), std::move(now), std::move(onTaskError));
   } else {

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.cpp

@@ -170,6 +170,9 @@ void RuntimeScheduler_Legacy::callExpiredTasks(jsi::Runtime& runtime) {
     }
   } catch (jsi::JSError& error) {
     onTaskError_(runtime, error);
+  } catch (std::exception& ex) {
+    jsi::JSError error(runtime, std::string("Non-js exception: ") + ex.what());
+    onTaskError_(runtime, error);
   }
 
   currentPriority_ = previousPriority;
@@ -233,6 +236,9 @@ void RuntimeScheduler_Legacy::startWorkLoop(jsi::Runtime& runtime) {
     }
   } catch (jsi::JSError& error) {
     onTaskError_(runtime, error);
+  } catch (std::exception& ex) {
+    jsi::JSError error(runtime, std::string("Non-js exception: ") + ex.what());
+    onTaskError_(runtime, error);
   }
 
   currentPriority_ = previousPriority;

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -155,27 +155,26 @@ void RuntimeScheduler_Modern::executeNowOnTheSameThread(
   auto expirationTime = currentTime + timeoutForSchedulerPriority(priority);
   Task task{priority, std::move(callback), expirationTime};
 
-  if (runtimePtr == nullptr) {
-    syncTaskRequests_++;
-    executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-        runtimeExecutor_,
-        [this, currentTime, &task](jsi::Runtime& runtime) mutable {
-          SystraceSection s2(
-              "RuntimeScheduler::executeNowOnTheSameThread callback");
-
-          syncTaskRequests_--;
-          runtimePtr = &runtime;
-          runEventLoopTick(runtime, task, currentTime);
-          runtimePtr = nullptr;
-        });
-
-  } else {
+  if (runtimePtr != nullptr) {
     // Protecting against re-entry into `executeNowOnTheSameThread` from within
     // `executeNowOnTheSameThread`. Without accounting for re-rentry, a deadlock
     // will occur when trying to gain access to the runtime.
-    return runEventLoopTick(*runtimePtr, task, currentTime);
+    return executeTask(*runtimePtr, task, true);
   }
 
+  syncTaskRequests_++;
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+      runtimeExecutor_,
+      [this, currentTime, &task](jsi::Runtime& runtime) mutable {
+        SystraceSection s2(
+            "RuntimeScheduler::executeNowOnTheSameThread callback");
+
+        syncTaskRequests_--;
+        runtimePtr = &runtime;
+        runEventLoopTick(runtime, task, currentTime);
+        runtimePtr = nullptr;
+      });
+
   bool shouldScheduleEventLoop = false;
 
   {
@@ -196,13 +195,7 @@ void RuntimeScheduler_Modern::executeNowOnTheSameThread(
 }
 
 void RuntimeScheduler_Modern::callExpiredTasks(jsi::Runtime& runtime) {
-  // If we have first-class support for microtasks, this a no-op.
-  if (ReactNativeFeatureFlags::enableMicrotasks()) {
-    return;
-  }
-
-  SystraceSection s("RuntimeScheduler::callExpiredTasks");
-  runEventLoop(runtime, true);
+  // No-op in the event loop implementation.
 }
 
 void RuntimeScheduler_Modern::scheduleRenderingUpdate(
@@ -210,14 +203,8 @@ void RuntimeScheduler_Modern::scheduleRenderingUpdate(
     RuntimeSchedulerRenderingUpdate&& renderingUpdate) {
   SystraceSection s("RuntimeScheduler::scheduleRenderingUpdate");
 
-  if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
-    surfaceIdsWithPendingRenderingUpdates_.insert(surfaceId);
-    pendingRenderingUpdates_.push(renderingUpdate);
-  } else {
-    if (renderingUpdate != nullptr) {
-      renderingUpdate();
-    }
-  }
+  surfaceIdsWithPendingRenderingUpdates_.insert(surfaceId);
+  pendingRenderingUpdates_.push(renderingUpdate);
 }
 
 void RuntimeScheduler_Modern::setShadowTreeRevisionConsistencyManager(
@@ -253,7 +240,7 @@ void RuntimeScheduler_Modern::scheduleTask(std::shared_ptr<Task> task) {
       shouldScheduleEventLoop = true;
     }
 
-    taskQueue_.push(task);
+    taskQueue_.push(std::move(task));
   }
 
   if (shouldScheduleEventLoop) {
@@ -273,17 +260,18 @@ void RuntimeScheduler_Modern::runEventLoop(
 
   auto previousPriority = currentPriority_;
 
-  while (syncTaskRequests_ == 0) {
-    auto currentTime = now_();
-    auto topPriorityTask = selectTask(currentTime, onlyExpired);
-
-    if (!topPriorityTask) {
-      // No pending work to do.
-      // Events will restart the loop when necessary.
-      break;
-    }
-
+  auto currentTime = now_();
+  // `selectTask` must be called unconditionaly to ensure that
+  // `isEventLoopScheduled_` is set to false and the event loop resume
+  // correctly if a synchronous task is scheduled.
+  // Unit test normalTaskYieldsToSynchronousAccessAndResumes covers this
+  // scenario.
+  auto topPriorityTask = selectTask(currentTime, onlyExpired);
+  while (topPriorityTask && syncTaskRequests_ == 0) {
     runEventLoopTick(runtime, *topPriorityTask, currentTime);
+
+    currentTime = now_();
+    topPriorityTask = selectTask(currentTime, onlyExpired);
   }
 
   currentPriority_ = previousPriority;
@@ -337,10 +325,8 @@ void RuntimeScheduler_Modern::runEventLoopTick(
   auto didUserCallbackTimeout = task.expirationTime <= taskStartTime;
   executeTask(runtime, task, didUserCallbackTimeout);
 
-  if (ReactNativeFeatureFlags::enableMicrotasks()) {
-    // "Perform a microtask checkpoint" step.
-    performMicrotaskCheckpoint(runtime);
-  }
+  // "Perform a microtask checkpoint" step.
+  performMicrotaskCheckpoint(runtime);
 
   if (ReactNativeFeatureFlags::enableLongTaskAPI()) {
     auto taskEndTime = now_();
@@ -348,10 +334,8 @@ void RuntimeScheduler_Modern::runEventLoopTick(
     reportLongTasks(task, taskStartTime, taskEndTime);
   }
 
-  if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
-    // "Update the rendering" step.
-    updateRendering();
-  }
+  // "Update the rendering" step.
+  updateRendering();
 
   currentTask_ = nullptr;
 }
@@ -402,6 +386,9 @@ void RuntimeScheduler_Modern::executeTask(
     }
   } catch (jsi::JSError& error) {
     onTaskError_(runtime, error);
+  } catch (std::exception& ex) {
+    jsi::JSError error(runtime, std::string("Non-js exception: ") + ex.what());
+    onTaskError_(runtime, error);
   }
 }
 
@@ -436,6 +423,10 @@ void RuntimeScheduler_Modern::performMicrotaskCheckpoint(
       }
     } catch (jsi::JSError& error) {
       onTaskError_(runtime, error);
+    } catch (std::exception& ex) {
+      jsi::JSError error(
+          runtime, std::string("Non-js exception: ") + ex.what());
+      onTaskError_(runtime, error);
     }
     retries++;
   }
@@ -459,7 +450,7 @@ void RuntimeScheduler_Modern::reportLongTasks(
   if (checkedDurationMs >= LONG_TASK_DURATION_THRESHOLD_MS) {
     auto durationMs = chronoToDOMHighResTimeStamp(endTime - startTime);
     auto startTimeMs = chronoToDOMHighResTimeStamp(startTime);
-    reporter->logLongTaskEntry(startTimeMs, durationMs);
+    reporter->reportLongTask(startTimeMs, durationMs);
   }
 }
 

package/ReactCommon/react/renderer/runtimescheduler/primitives.h

@@ -9,7 +9,6 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/Task.h>
-#include <react/utils/CoreFeatures.h>
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -28,19 +28,11 @@ static bool forcedBatchRenderingUpdatesInEventLoop = false;
 class RuntimeSchedulerTestFeatureFlags
     : public ReactNativeFeatureFlagsDefaults {
  public:
-  RuntimeSchedulerTestFeatureFlags(bool useModernRuntimeScheduler)
-      : useModernRuntimeScheduler_(useModernRuntimeScheduler) {}
+  explicit RuntimeSchedulerTestFeatureFlags(bool enableEventLoop)
+      : enableEventLoop_(enableEventLoop) {}
 
-  bool useModernRuntimeScheduler() override {
-    return useModernRuntimeScheduler_;
-  }
-
-  bool enableMicrotasks() override {
-    return useModernRuntimeScheduler_;
-  }
-
-  bool batchRenderingUpdatesInEventLoop() override {
-    return forcedBatchRenderingUpdatesInEventLoop;
+  bool enableBridgelessArchitecture() override {
+    return enableEventLoop_;
   }
 
   bool enableLongTaskAPI() override {
@@ -48,7 +40,7 @@ class RuntimeSchedulerTestFeatureFlags
   }
 
  private:
-  bool useModernRuntimeScheduler_;
+  bool enableEventLoop_;
 };
 
 class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
@@ -82,19 +74,17 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
       return stubClock_->getNow();
     };
 
-    performanceEntryReporter_ = PerformanceEntryReporter::getInstance().get();
-
-    performanceEntryReporter_->startReporting(PerformanceEntryType::LONGTASK);
+    performanceEntryReporter_ = std::make_unique<PerformanceEntryReporter>();
 
     runtimeScheduler_ =
         std::make_unique<RuntimeScheduler>(runtimeExecutor, stubNow);
 
-    runtimeScheduler_->setPerformanceEntryReporter(performanceEntryReporter_);
+    runtimeScheduler_->setPerformanceEntryReporter(
+        performanceEntryReporter_.get());
   }
 
   void TearDown() override {
     ReactNativeFeatureFlags::dangerouslyReset();
-    performanceEntryReporter_->popPendingEntries();
   }
 
   jsi::Function createHostFunctionFromLambda(
@@ -121,7 +111,7 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
   std::unique_ptr<StubQueue> stubQueue_;
   std::unique_ptr<RuntimeScheduler> runtimeScheduler_;
   std::shared_ptr<StubErrorUtils> stubErrorUtils_;
-  PerformanceEntryReporter* performanceEntryReporter_{};
+  std::unique_ptr<PerformanceEntryReporter> performanceEntryReporter_{};
 };
 
 TEST_P(RuntimeSchedulerTest, now) {
@@ -164,21 +154,10 @@ TEST_P(RuntimeSchedulerTest, scheduleSingleTask) {
   EXPECT_EQ(stubQueue_->size(), 0);
 }
 
-TEST_P(RuntimeSchedulerTest, scheduleNonBatchedRenderingUpdate) {
-  forcedBatchRenderingUpdatesInEventLoop = false;
-
-  bool didRunRenderingUpdate = false;
-
-  runtimeScheduler_->scheduleRenderingUpdate(
-      0, [&]() { didRunRenderingUpdate = true; });
-
-  EXPECT_TRUE(didRunRenderingUpdate);
-}
-
 TEST_P(
     RuntimeSchedulerTest,
     scheduleSingleTaskWithMicrotasksAndBatchedRenderingUpdate) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -618,7 +597,7 @@ TEST_P(RuntimeSchedulerTest, immediateTaskDoesntYieldToPlatformEvent) {
 }
 
 TEST_P(RuntimeSchedulerTest, scheduleTaskWithYielding) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -642,7 +621,7 @@ TEST_P(RuntimeSchedulerTest, scheduleTaskWithYielding) {
 }
 
 TEST_P(RuntimeSchedulerTest, normalTaskYieldsToSynchronousAccess) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -705,21 +684,70 @@ TEST_P(RuntimeSchedulerTest, normalTaskYieldsToSynchronousAccess) {
   t1.join();
 
   EXPECT_EQ(syncTaskExecutionCount, 1);
-  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
-  // The previous task is still in the queue (although it was executed
-  // already).
+  EXPECT_EQ(normalTaskExecutionCount, 1); // It hasn't executed again
+  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_P(RuntimeSchedulerTest, normalTaskYieldsToSynchronousAccessAndResumes) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  uint syncTaskExecutionCount = 0;
+  uint normalTaskExecutionCount = 0;
+
+  std::binary_semaphore signalTaskToSync{0};
+
+  // Scheduling normal priority task.
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority,
+      [&normalTaskExecutionCount](jsi::Runtime& /*unused*/) {
+        normalTaskExecutionCount++;
+      });
+
+  // Only the normal task has been scheduled at this point.
   EXPECT_EQ(stubQueue_->size(), 1);
 
-  // Just empty the queue
+  // Scheduling sync task.
+  std::thread t1([this, &syncTaskExecutionCount, &signalTaskToSync]() {
+    signalTaskToSync.release();
+    runtimeScheduler_->executeNowOnTheSameThread(
+        [&syncTaskExecutionCount](jsi::Runtime& /*runtime*/) {
+          syncTaskExecutionCount++;
+        });
+  });
+
+  signalTaskToSync.acquire();
+
+  // Normal priority task immediatelly yield in favour of the sync task.
+  stubQueue_->tick();
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+  EXPECT_EQ(normalTaskExecutionCount, 0);
+  EXPECT_EQ(syncTaskExecutionCount, 0);
+
+  // Execute sync task.
+  stubQueue_->tick();
+  t1.join();
+
+  // After executing sync task, event loop resumes normal operation and normal
+  // priority task is scheduled.
+  EXPECT_EQ(stubQueue_->size(), 1);
+  EXPECT_EQ(syncTaskExecutionCount, 1);
+  EXPECT_EQ(normalTaskExecutionCount, 0);
+
+  // Execute follow up normal priority task.
   stubQueue_->tick();
 
-  EXPECT_EQ(normalTaskExecutionCount, 1); // It hasn't executed again
-  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
   EXPECT_EQ(stubQueue_->size(), 0);
+  EXPECT_EQ(syncTaskExecutionCount, 1);
+  EXPECT_EQ(normalTaskExecutionCount, 1);
 }
 
 TEST_P(RuntimeSchedulerTest, immediateTaskYieldsToSynchronousAccess) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -782,14 +810,6 @@ TEST_P(RuntimeSchedulerTest, immediateTaskYieldsToSynchronousAccess) {
   t1.join();
 
   EXPECT_EQ(syncTaskExecutionCount, 1);
-  EXPECT_TRUE(runtimeScheduler_->getShouldYield());
-  // The previous task is still in the queue (although it was executed
-  // already), so the sync task scheduled the work loop to process it.
-  EXPECT_EQ(stubQueue_->size(), 1);
-
-  // Just empty the queue
-  stubQueue_->tick();
-
   EXPECT_EQ(normalTaskExecutionCount, 1); // It hasn't executed again
   EXPECT_FALSE(runtimeScheduler_->getShouldYield());
   EXPECT_EQ(stubQueue_->size(), 0);
@@ -1051,7 +1071,7 @@ TEST_P(RuntimeSchedulerTest, legacyTwoThreadsRequestAccessToTheRuntime) {
 }
 
 TEST_P(RuntimeSchedulerTest, modernTwoThreadsRequestAccessToTheRuntime) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -1134,7 +1154,7 @@ TEST_P(RuntimeSchedulerTest, modernTwoThreadsRequestAccessToTheRuntime) {
 }
 
 TEST_P(RuntimeSchedulerTest, errorInTaskShouldNotStopMicrotasks) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -1180,7 +1200,7 @@ TEST_P(RuntimeSchedulerTest, errorInTaskShouldNotStopMicrotasks) {
 }
 
 TEST_P(RuntimeSchedulerTest, reportsLongTasks) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -1203,8 +1223,8 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasks) {
 
   EXPECT_EQ(didRunTask1, 1);
   EXPECT_EQ(stubQueue_->size(), 0);
-  auto pendingEntries = performanceEntryReporter_->popPendingEntries();
-  EXPECT_EQ(pendingEntries.entries.size(), 0);
+  auto pendingEntries = performanceEntryReporter_->getEntries();
+  EXPECT_EQ(pendingEntries.size(), 0);
 
   bool didRunTask2 = false;
   stubClock_->setTimePoint(100ms);
@@ -1224,16 +1244,15 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasks) {
 
   EXPECT_EQ(didRunTask2, 1);
   EXPECT_EQ(stubQueue_->size(), 0);
-  pendingEntries = performanceEntryReporter_->popPendingEntries();
-  EXPECT_EQ(pendingEntries.entries.size(), 1);
-  EXPECT_EQ(
-      pendingEntries.entries[0].entryType, PerformanceEntryType::LONGTASK);
-  EXPECT_EQ(pendingEntries.entries[0].startTime, 100);
-  EXPECT_EQ(pendingEntries.entries[0].duration, 50);
+  pendingEntries = performanceEntryReporter_->getEntries();
+  EXPECT_EQ(pendingEntries.size(), 1);
+  EXPECT_EQ(pendingEntries[0].entryType, PerformanceEntryType::LONGTASK);
+  EXPECT_EQ(pendingEntries[0].startTime, 100);
+  EXPECT_EQ(pendingEntries[0].duration, 50);
 }
 
 TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
-  // Only for modern runtime scheduler
+  // Only for event loop
   if (!GetParam()) {
     return;
   }
@@ -1270,8 +1289,8 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
 
   EXPECT_EQ(didRunTask1, 1);
   EXPECT_EQ(stubQueue_->size(), 0);
-  auto pendingEntries = performanceEntryReporter_->popPendingEntries();
-  EXPECT_EQ(pendingEntries.entries.size(), 0);
+  auto pendingEntries = performanceEntryReporter_->getEntries();
+  EXPECT_EQ(pendingEntries.size(), 0);
 
   bool didRunTask2 = false;
   stubClock_->setTimePoint(100ms);
@@ -1305,12 +1324,11 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
 
   EXPECT_EQ(didRunTask2, 1);
   EXPECT_EQ(stubQueue_->size(), 0);
-  pendingEntries = performanceEntryReporter_->popPendingEntries();
-  EXPECT_EQ(pendingEntries.entries.size(), 1);
-  EXPECT_EQ(
-      pendingEntries.entries[0].entryType, PerformanceEntryType::LONGTASK);
-  EXPECT_EQ(pendingEntries.entries[0].startTime, 100);
-  EXPECT_EQ(pendingEntries.entries[0].duration, 120);
+  pendingEntries = performanceEntryReporter_->getEntries();
+  EXPECT_EQ(pendingEntries.size(), 1);
+  EXPECT_EQ(pendingEntries[0].entryType, PerformanceEntryType::LONGTASK);
+  EXPECT_EQ(pendingEntries[0].startTime, 100);
+  EXPECT_EQ(pendingEntries[0].duration, 120);
 }
 
 INSTANTIATE_TEST_SUITE_P(

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -22,11 +22,6 @@
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 
-#ifdef RN_SHADOW_TREE_INTROSPECTION
-#include <react/renderer/mounting/stubs.h>
-#include <iostream>
-#endif
-
 namespace facebook::react {
 
 Scheduler::Scheduler(
@@ -36,10 +31,6 @@ Scheduler::Scheduler(
   runtimeExecutor_ = schedulerToolbox.runtimeExecutor;
   contextContainer_ = schedulerToolbox.contextContainer;
 
-  reactNativeConfig_ =
-      contextContainer_->at<std::shared_ptr<const ReactNativeConfig>>(
-          "ReactNativeConfig");
-
   // Creating a container for future `EventDispatcher` instance.
   eventDispatcher_ = std::make_shared<std::optional<const EventDispatcher>>();
 
@@ -59,21 +50,22 @@ Scheduler::Scheduler(
   auto weakRuntimeScheduler =
       contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
           "RuntimeScheduler");
-  auto runtimeScheduler = weakRuntimeScheduler.has_value()
-      ? weakRuntimeScheduler.value().lock()
-      : nullptr;
+  react_native_assert(
+      weakRuntimeScheduler.has_value() &&
+      "Unexpected state: RuntimeScheduler was not provided.");
 
-  if (runtimeScheduler && ReactNativeFeatureFlags::enableUIConsistency()) {
-    runtimeScheduler->setShadowTreeRevisionConsistencyManager(
+  runtimeScheduler_ = weakRuntimeScheduler.value().lock().get();
+
+  if (ReactNativeFeatureFlags::enableUIConsistency()) {
+    runtimeScheduler_->setShadowTreeRevisionConsistencyManager(
         uiManager->getShadowTreeRevisionConsistencyManager());
   }
 
-  if (runtimeScheduler &&
-      ReactNativeFeatureFlags::enableReportEventPaintTime()) {
-    runtimeScheduler->setEventTimingDelegate(eventPerformanceLogger_.get());
+  if (ReactNativeFeatureFlags::enableReportEventPaintTime()) {
+    runtimeScheduler_->setEventTimingDelegate(eventPerformanceLogger_.get());
   }
 
-  auto eventPipe = [uiManager, runtimeScheduler = runtimeScheduler.get()](
+  auto eventPipe = [uiManager](
                        jsi::Runtime& runtime,
                        const EventTarget* eventTarget,
                        const std::string& type,
@@ -87,25 +79,23 @@ Scheduler::Scheduler(
         runtime);
   };
 
-  auto eventPipeConclusion =
-      [runtimeScheduler = runtimeScheduler.get()](jsi::Runtime& runtime) {
-        if (runtimeScheduler != nullptr) {
-          runtimeScheduler->callExpiredTasks(runtime);
-        }
-      };
+  auto eventPipeConclusion = [runtimeScheduler =
+                                  runtimeScheduler_](jsi::Runtime& runtime) {
+    runtimeScheduler->callExpiredTasks(runtime);
+  };
 
   auto statePipe = [uiManager](const StateUpdate& stateUpdate) {
     uiManager->updateState(stateUpdate);
   };
 
+  auto eventBeat = schedulerToolbox.eventBeatFactory(std::move(eventOwnerBox));
+
   // Creating an `EventDispatcher` instance inside the already allocated
   // container (inside the optional).
   eventDispatcher_->emplace(
       EventQueueProcessor(
           eventPipe, eventPipeConclusion, statePipe, eventPerformanceLogger_),
-      schedulerToolbox.asynchronousEventBeatFactory,
-      eventOwnerBox,
-      *runtimeScheduler,
+      std::move(eventBeat),
       statePipe,
       eventPerformanceLogger_);
 
@@ -288,7 +278,7 @@ void Scheduler::animationTick() const {
 #pragma mark - UIManagerDelegate
 
 void Scheduler::uiManagerDidFinishTransaction(
-    MountingCoordinator::Shared mountingCoordinator,
+    std::shared_ptr<const MountingCoordinator> mountingCoordinator,
     bool mountSynchronously) {
   SystraceSection s("Scheduler::uiManagerDidFinishTransaction");
 
@@ -297,16 +287,10 @@ void Scheduler::uiManagerDidFinishTransaction(
     // observe each transaction to be able to mount correctly.
     delegate_->schedulerDidFinishTransaction(mountingCoordinator);
 
-    auto weakRuntimeScheduler =
-        contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
-            "RuntimeScheduler");
-    auto runtimeScheduler = weakRuntimeScheduler.has_value()
-        ? weakRuntimeScheduler.value().lock()
-        : nullptr;
-    if (runtimeScheduler && !mountSynchronously) {
+    if (!mountSynchronously) {
       auto surfaceId = mountingCoordinator->getSurfaceId();
 
-      runtimeScheduler->scheduleRenderingUpdate(
+      runtimeScheduler_->scheduleRenderingUpdate(
           surfaceId,
           [delegate = delegate_,
            mountingCoordinator = std::move(mountingCoordinator)]() {
@@ -332,7 +316,19 @@ void Scheduler::uiManagerDidDispatchCommand(
 
   if (delegate_ != nullptr) {
     auto shadowView = ShadowView(*shadowNode);
-    delegate_->schedulerDidDispatchCommand(shadowView, commandName, args);
+    if (ReactNativeFeatureFlags::enableFixForViewCommandRace()) {
+      runtimeScheduler_->scheduleRenderingUpdate(
+          shadowNode->getSurfaceId(),
+          [delegate = delegate_,
+           shadowView = std::move(shadowView),
+           commandName,
+           args]() {
+            delegate->schedulerDidDispatchCommand(
+                shadowView, commandName, args);
+          });
+    } else {
+      delegate_->schedulerDidDispatchCommand(shadowView, commandName, args);
+    }
   }
 }