react-native-tvos 0.87.1-0 → 0.88.0-0rc2

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <ReactCommon/SchedulerPriority.h>
 #include <react/debug/react_native_assert.h>
 #include <react/timing/primitives.h>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <ReactCommon/SchedulerPriority.h>
 #include <jsi/jsi.h>
 #include <react/timing/primitives.h>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/Task.h>
 

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

@@ -13,10 +13,14 @@
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/utils/OnScopeExit.h>
+#include <algorithm>
 #include <chrono>
+#include <functional>
 #include <memory>
 #include <semaphore>
 #include <thread>
+#include <unordered_set>
 #include <variant>
 
 #include "StubClock.h"
@@ -30,24 +34,15 @@ using namespace std::chrono_literals;
 class RuntimeSchedulerTestFeatureFlags
     : public ReactNativeFeatureFlagsDefaults {
  public:
-  explicit RuntimeSchedulerTestFeatureFlags(
-      bool enableEventLoop,
-      bool enableRuntimeSchedulerQueueClearingOnError = false)
-      : enableEventLoop_(enableEventLoop),
-        enableRuntimeSchedulerQueueClearingOnError_(
-            enableRuntimeSchedulerQueueClearingOnError) {}
+  explicit RuntimeSchedulerTestFeatureFlags(bool enableEventLoop)
+      : enableEventLoop_(enableEventLoop) {}
 
   bool enableBridgelessArchitecture() override {
     return enableEventLoop_;
   }
 
-  bool enableRuntimeSchedulerQueueClearingOnError() override {
-    return enableRuntimeSchedulerQueueClearingOnError_;
-  }
-
  private:
   bool enableEventLoop_;
-  bool enableRuntimeSchedulerQueueClearingOnError_;
 };
 
 class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
@@ -93,12 +88,10 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
     ReactNativeFeatureFlags::dangerouslyReset();
   }
 
-  void setUpFeatureFlags(
-      bool enableRuntimeSchedulerQueueClearingOnError = false) {
+  void setUpFeatureFlags() {
     ReactNativeFeatureFlags::dangerouslyReset();
     ReactNativeFeatureFlags::override(
-        std::make_unique<RuntimeSchedulerTestFeatureFlags>(
-            GetParam(), enableRuntimeSchedulerQueueClearingOnError));
+        std::make_unique<RuntimeSchedulerTestFeatureFlags>(GetParam()));
   }
 
   jsi::Function createHostFunctionFromLambda(
@@ -921,8 +914,6 @@ TEST_P(RuntimeSchedulerTest, clearsQueuesOnError) {
     return;
   }
 
-  setUpFeatureFlags(/*enableRuntimeSchedulerQueueClearingOnError=*/true);
-
   bool didRunThrowingTask = false;
   bool didRunQueuedTask = false;
   bool didRunRenderingUpdate = false;
@@ -1454,12 +1445,436 @@ TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
       entry);
 }
 
+/*
+ * Stub delegates for the "update the rendering" step, used by the resize
+ * observer tests below.
+ *
+ * Records every delivery of resize observations, together with the runtime it
+ * was given, so tests can assert *which* runtime reached the delegate (resize
+ * observations are broadcast to JS synchronously, so it has to be the runtime
+ * the task ran with) and whether deliveries ever nest.
+ */
+class StubResizeObserverDelegate
+    : public RuntimeSchedulerResizeObserverDelegate {
+ public:
+  void runResizeObservations(jsi::Runtime& runtime) override {
+    callCount++;
+    lastRuntime = &runtime;
+
+    concurrentInvocationCount++;
+    maxConcurrentInvocationCount =
+        std::max(maxConcurrentInvocationCount, concurrentInvocationCount);
+    // Decrement even if the hook throws, so `maxConcurrentInvocationCount`
+    // stays meaningful in the error tests.
+    OnScopeExit onExit([this]() { concurrentInvocationCount--; });
+
+    if (onRunResizeObservations != nullptr) {
+      onRunResizeObservations(runtime);
+    }
+  }
+
+  uint callCount{0};
+  jsi::Runtime* lastRuntime{nullptr};
+  uint concurrentInvocationCount{0};
+  uint maxConcurrentInvocationCount{0};
+  std::function<void(jsi::Runtime&)> onRunResizeObservations{nullptr};
+};
+
+class StubEventTimingDelegate : public RuntimeSchedulerEventTimingDelegate {
+ public:
+  void dispatchPendingEventTimingEntries(
+      HighResTimeStamp /*taskEndTime*/,
+      const std::unordered_set<SurfaceId>&
+      /*surfaceIdsWithPendingRenderingUpdates*/) override {
+    callCount++;
+    if (onDispatchPendingEventTimingEntries != nullptr) {
+      onDispatchPendingEventTimingEntries();
+    }
+  }
+
+  uint callCount{0};
+  std::function<void()> onDispatchPendingEventTimingEntries{nullptr};
+};
+
+class StubIntersectionObserverDelegate
+    : public RuntimeSchedulerIntersectionObserverDelegate {
+ public:
+  void updateIntersectionObservations(
+      const std::unordered_set<SurfaceId>&
+      /*surfaceIdsWithPendingRenderingUpdates*/) override {
+    callCount++;
+    if (onUpdateIntersectionObservations != nullptr) {
+      onUpdateIntersectionObservations();
+    }
+  }
+
+  uint callCount{0};
+  std::function<void()> onUpdateIntersectionObservations{nullptr};
+};
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsReceiveTheRuntimeOfTheTask) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  jsi::Runtime* runtimeFromTask = nullptr;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [&](jsi::Runtime& runtime) {
+        runtimeFromTask = &runtime;
+        // Resize observations are part of the "update the rendering" step,
+        // which runs after the task.
+        EXPECT_EQ(resizeObserverDelegate.callCount, 0);
+      });
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 0);
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  EXPECT_EQ(runtimeFromTask, static_cast<jsi::Runtime*>(runtime_.get()));
+  // The crux of synchronous delivery: the delegate gets the very same runtime
+  // instance the task ran with, so it can call into JS right away.
+  EXPECT_EQ(resizeObserverDelegate.lastRuntime, runtimeFromTask);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsRunSynchronouslyWithinTheTick) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  bool didRunTask = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority,
+      [&](jsi::Runtime& /*runtime*/) { didRunTask = true; });
+
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  // Already delivered when the tick returns.
+  EXPECT_TRUE(didRunTask);
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  // And not deferred to a task on the JS queue: nothing is left to run.
+  EXPECT_EQ(stubQueue_->size(), 0);
+
+  stubQueue_->flush();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+}
+
+TEST_P(RuntimeSchedulerTest, updateRenderingStepRunsDelegatesInOrder) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  uint nextOperationPosition = 1;
+
+  uint taskPosition = 0;
+  uint eventTimingPosition = 0;
+  uint resizeObservationsPosition = 0;
+  uint intersectionObservationsPosition = 0;
+  uint updateRenderingPosition = 0;
+
+  StubEventTimingDelegate eventTimingDelegate;
+  eventTimingDelegate.onDispatchPendingEventTimingEntries = [&]() {
+    eventTimingPosition = nextOperationPosition;
+    nextOperationPosition++;
+  };
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  resizeObserverDelegate.onRunResizeObservations =
+      [&](jsi::Runtime& /*runtime*/) {
+        resizeObservationsPosition = nextOperationPosition;
+        nextOperationPosition++;
+      };
+
+  StubIntersectionObserverDelegate intersectionObserverDelegate;
+  intersectionObserverDelegate.onUpdateIntersectionObservations = [&]() {
+    intersectionObservationsPosition = nextOperationPosition;
+    nextOperationPosition++;
+  };
+
+  runtimeScheduler_->setEventTimingDelegate(&eventTimingDelegate);
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+  runtimeScheduler_->setIntersectionObserverDelegate(
+      &intersectionObserverDelegate);
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [&](jsi::Runtime& /*runtime*/) {
+        taskPosition = nextOperationPosition;
+        nextOperationPosition++;
+
+        runtimeScheduler_->scheduleRenderingUpdate(0, [&]() {
+          updateRenderingPosition = nextOperationPosition;
+          nextOperationPosition++;
+        });
+      });
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(taskPosition, 1);
+  EXPECT_EQ(eventTimingPosition, 2);
+  EXPECT_EQ(resizeObservationsPosition, 3);
+  EXPECT_EQ(intersectionObservationsPosition, 4);
+  EXPECT_EQ(updateRenderingPosition, 5);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsRunWithoutRenderingUpdates) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  // No task below schedules a rendering update for any surface. Resize
+  // observations still run on every tick, which is what makes the initial
+  // delivery in `ResizeObserverManager::observe` prompt.
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [](jsi::Runtime& /*runtime*/) {});
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [](jsi::Runtime& /*runtime*/) {});
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 2);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsStopAfterDelegateIsUnset) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  bool didRunFirstTask = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority,
+      [&](jsi::Runtime& /*runtime*/) { didRunFirstTask = true; });
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunFirstTask);
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+
+  // This is what happens when the last observer disconnects (or the surface
+  // tears down): the scheduler is left without a delegate.
+  runtimeScheduler_->setResizeObserverDelegate(nullptr);
+
+  bool didRunSecondTask = false;
+  bool didRunRenderingUpdate = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [&](jsi::Runtime& /*runtime*/) {
+        didRunSecondTask = true;
+        runtimeScheduler_->scheduleRenderingUpdate(
+            0, [&]() { didRunRenderingUpdate = true; });
+      });
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunSecondTask);
+  // The rest of the "update the rendering" step is unaffected.
+  EXPECT_TRUE(didRunRenderingUpdate);
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsCanUnsetTheDelegateFromWithin) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  StubIntersectionObserverDelegate intersectionObserverDelegate;
+
+  // A resize callback can disconnect the last observer, which clears the
+  // delegate from inside the delivery itself.
+  resizeObserverDelegate.onRunResizeObservations =
+      [&](jsi::Runtime& /*runtime*/) {
+        runtimeScheduler_->setResizeObserverDelegate(nullptr);
+      };
+
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+  runtimeScheduler_->setIntersectionObserverDelegate(
+      &intersectionObserverDelegate);
+
+  bool didRunRenderingUpdate = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [&](jsi::Runtime& /*runtime*/) {
+        runtimeScheduler_->scheduleRenderingUpdate(
+            0, [&]() { didRunRenderingUpdate = true; });
+      });
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  // The rest of the step still runs after the delegate went away.
+  EXPECT_EQ(intersectionObserverDelegate.callCount, 1);
+  EXPECT_TRUE(didRunRenderingUpdate);
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [](jsi::Runtime& /*runtime*/) {});
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  EXPECT_EQ(intersectionObserverDelegate.callCount, 2);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObservationsSchedulingWorkDoesNotReenter) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  uint nextOperationPosition = 1;
+
+  uint firstResizeObservationsPosition = 0;
+  uint renderingUpdateFromObservationsPosition = 0;
+  uint taskFromObservationsPosition = 0;
+  uint secondResizeObservationsPosition = 0;
+
+  // Simulates a JS resize callback that commits and schedules more work.
+  resizeObserverDelegate.onRunResizeObservations =
+      [&](jsi::Runtime& /*runtime*/) {
+        EXPECT_EQ(resizeObserverDelegate.concurrentInvocationCount, 1);
+
+        if (resizeObserverDelegate.callCount > 1) {
+          secondResizeObservationsPosition = nextOperationPosition;
+          nextOperationPosition++;
+          return;
+        }
+
+        firstResizeObservationsPosition = nextOperationPosition;
+        nextOperationPosition++;
+
+        runtimeScheduler_->scheduleRenderingUpdate(0, [&]() {
+          renderingUpdateFromObservationsPosition = nextOperationPosition;
+          nextOperationPosition++;
+        });
+
+        runtimeScheduler_->scheduleTask(
+            SchedulerPriority::NormalPriority, [&](jsi::Runtime& /*runtime*/) {
+              taskFromObservationsPosition = nextOperationPosition;
+              nextOperationPosition++;
+            });
+      };
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [](jsi::Runtime& /*runtime*/) {});
+
+  stubQueue_->tick();
+
+  // The task scheduled from the observations runs as another tick of the event
+  // loop that is already running, so it neither hangs nor needs another trip
+  // through the JS queue.
+  EXPECT_EQ(resizeObserverDelegate.callCount, 2);
+  EXPECT_EQ(resizeObserverDelegate.maxConcurrentInvocationCount, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+
+  EXPECT_EQ(firstResizeObservationsPosition, 1);
+  // A rendering update scheduled from the observations is flushed by the same
+  // "update the rendering" step, because it runs before the pending updates.
+  EXPECT_EQ(renderingUpdateFromObservationsPosition, 2);
+  // The task, on the other hand, is a new tick: it runs after the current
+  // "update the rendering" step is done, and gets its own observations
+  // afterwards. Not nested in the first one.
+  EXPECT_EQ(taskFromObservationsPosition, 3);
+  EXPECT_EQ(secondResizeObservationsPosition, 4);
+}
+
+TEST_P(RuntimeSchedulerTest, errorInResizeObservationsDoesNotStopUpdate) {
+  // Only for event loop
+  if (!GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  resizeObserverDelegate.onRunResizeObservations = [](jsi::Runtime& runtime) {
+    throw jsi::JSError(runtime, "Test error");
+  };
+
+  StubIntersectionObserverDelegate intersectionObserverDelegate;
+
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+  runtimeScheduler_->setIntersectionObserverDelegate(
+      &intersectionObserverDelegate);
+
+  bool didRunRenderingUpdate = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, [&](jsi::Runtime& /*runtime*/) {
+        runtimeScheduler_->scheduleRenderingUpdate(
+            0, [&]() { didRunRenderingUpdate = true; });
+      });
+
+  stubQueue_->tick();
+
+  // Delivering observations to JS synchronously happens outside the error
+  // boundary of the task, so the step handles the error itself and carries on.
+  // In particular the error must not be routed through `handleTaskError`:
+  // that clears the pending rendering updates this same step is about to
+  // drain, and `didRunRenderingUpdate` below would be false.
+  EXPECT_EQ(stubErrorUtils_->getReportFatalCallCount(), 1);
+  EXPECT_EQ(resizeObserverDelegate.callCount, 1);
+  EXPECT_EQ(intersectionObserverDelegate.callCount, 1);
+  EXPECT_TRUE(didRunRenderingUpdate);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+TEST_P(RuntimeSchedulerTest, resizeObserverDelegateIsIgnoredInLegacyScheduler) {
+  // Only for the legacy scheduler, which has no "update the rendering" step.
+  if (GetParam()) {
+    return;
+  }
+
+  StubResizeObserverDelegate resizeObserverDelegate;
+  runtimeScheduler_->setResizeObserverDelegate(&resizeObserverDelegate);
+
+  bool didRunTask = false;
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority,
+      [&](jsi::Runtime& /*runtime*/) { didRunTask = true; });
+
+  stubQueue_->tick();
+
+  EXPECT_TRUE(didRunTask);
+  EXPECT_EQ(resizeObserverDelegate.callCount, 0);
+  EXPECT_EQ(stubQueue_->size(), 0);
+}
+
+#ifdef RCT_REMOVE_LEGACY_ARCH
 INSTANTIATE_TEST_SUITE_P(
     UseModernRuntimeScheduler,
     RuntimeSchedulerTest,
-#ifdef RCT_REMOVE_LEGACY_ARCH
     testing::Values(true));
 #else
+INSTANTIATE_TEST_SUITE_P(
+    UseModernRuntimeScheduler,
+    RuntimeSchedulerTest,
     testing::Values(false, true));
 #endif
 

package/ReactCommon/react/renderer/scheduler/CMakeLists.txt

@@ -17,6 +17,7 @@ target_link_libraries(react_renderer_scheduler
         folly_runtime
         glog
         jsi
+        react_cxxstableapi
         react_debug
         react_featureflags
         react_performance_cdpmetrics

package/ReactCommon/react/renderer/scheduler/InspectorData.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <vector>
 
 namespace facebook::react {

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

@@ -20,6 +20,7 @@
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/renderer/uimanager/LayoutEventEmitter.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <mutex>
@@ -30,8 +31,7 @@ Scheduler::Scheduler(
     const SchedulerToolbox& schedulerToolbox,
     UIManagerAnimationDelegate* animationDelegate,
     SchedulerDelegate* delegate)
-    : delegateInvalidated_(std::make_shared<std::atomic<bool>>(false)),
-      runtimeExecutor_(schedulerToolbox.runtimeExecutor),
+    : runtimeExecutor_(schedulerToolbox.runtimeExecutor),
       contextContainer_(schedulerToolbox.contextContainer) {
   // Creating a container for future `EventDispatcher` instance.
   eventDispatcher_ = std::make_shared<std::optional<const EventDispatcher>>();
@@ -58,16 +58,6 @@ Scheduler::Scheduler(
   auto uiManager =
       std::make_shared<UIManager>(runtimeExecutor_, contextContainer_);
 
-  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-    auto animationBackend = std::make_shared<AnimationBackend>(
-        schedulerToolbox.animationChoreographer, uiManager);
-
-    schedulerToolbox.animationChoreographer->setAnimationBackend(
-        animationBackend);
-
-    uiManager->unstable_setAnimationBackend(animationBackend);
-  }
-
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -130,6 +120,19 @@ Scheduler::Scheduler(
   uiManager->setDelegate(this);
   uiManager->setComponentDescriptorRegistry(componentDescriptorRegistry_);
 
+  // Must come after `setDelegate`: the backend's constructor registers a
+  // surface-start callback, and `UIManager` silently drops those while it has
+  // no delegate.
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    auto animationBackend = std::make_shared<AnimationBackend>(
+        schedulerToolbox.animationChoreographer, uiManager);
+
+    schedulerToolbox.animationChoreographer->setAnimationBackend(
+        animationBackend);
+
+    uiManager->unstable_setAnimationBackend(animationBackend);
+  }
+
   auto bindingsExecutor =
       schedulerToolbox.bridgelessBindingsExecutor.has_value()
       ? schedulerToolbox.bridgelessBindingsExecutor.value()
@@ -148,6 +151,11 @@ Scheduler::Scheduler(
 
   delegate_ = delegate;
   commitHooks_ = schedulerToolbox.commitHooks;
+
+  // Layout events (`onLayout`) are emitted as a standalone consumer of the
+  // `shadowTreeDidCommit` commit hook.
+  commitHooks_.push_back(std::make_shared<LayoutEventEmitter>());
+
   uiManager_ = uiManager;
 
   for (auto& commitHook : commitHooks_) {
@@ -173,15 +181,6 @@ Scheduler::~Scheduler() {
   LOG(WARNING) << "Scheduler::~Scheduler() was called (address: " << this
                << ").";
 
-  // Invalidate any lambdas already queued via scheduleRenderingUpdate that
-  // captured a raw delegate_ pointer; without this they'd dereference a
-  // dangling SchedulerDelegate after Scheduler teardown. (No replacement
-  // token is allocated here — Scheduler is going away.)
-  // Gated to allow controlled rollout / rollback.
-  if (ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation()) {
-    *delegateInvalidated_ = true;
-  }
-
   auto weakRuntimeScheduler =
       contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
           RuntimeSchedulerKey);
@@ -271,21 +270,6 @@ Scheduler::findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
 #pragma mark - Delegate
 
 void Scheduler::setDelegate(SchedulerDelegate* delegate) {
-  // Gated to allow controlled rollout / rollback.
-  if (ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation() &&
-      delegate_ != delegate) {
-    // Mark the *current* token invalid: any rendering-update lambda already
-    // queued holds a shared_ptr to this atomic and will observe `true` on
-    // its next read, so it no-ops instead of calling into the previous
-    // delegate (which the caller is about to drop).
-    *delegateInvalidated_ = true;
-    // Then install a *fresh* token (a new atomic) so lambdas captured
-    // against the new delegate use their own non-invalidated flag.
-    // Reusing the previous atomic and flipping it back to `false` would
-    // re-arm the in-flight lambdas — exactly the use-after-free we're
-    // trying to prevent — because they share the same shared_ptr.
-    delegateInvalidated_ = std::make_shared<std::atomic<bool>>(false);
-  }
   delegate_ = delegate;
 }
 
@@ -317,21 +301,10 @@ void Scheduler::uiManagerDidFinishTransaction(
     if (!mountSynchronously) {
       auto surfaceId = mountingCoordinator->getSurfaceId();
 
-      // Capture the gating flag at queue time: the lambda's decision to
-      // honor the invalidation guard is fixed when we enqueue, not when it
-      // later runs. Avoids per-invocation feature-flag reads and keeps the
-      // contract for an in-flight lambda stable across flag flips.
-      auto guardEnabled =
-          ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation();
       runtimeScheduler_->scheduleRenderingUpdate(
           surfaceId,
           [delegate = delegate_,
-           invalidated = delegateInvalidated_,
-           guardEnabled,
            mountingCoordinator = std::move(mountingCoordinator)]() {
-            if (guardEnabled && *invalidated) {
-              return;
-            }
             delegate->schedulerShouldRenderTransactions(mountingCoordinator);
           });
     } else {
@@ -354,20 +327,12 @@ void Scheduler::uiManagerDidDispatchCommand(
       "Scheduler::uiManagerDispatchCommand", "commandName", commandName);
   if (delegate_ != nullptr) {
     auto shadowView = ShadowView(*shadowNode);
-    // See comment in uiManagerDidFinishTransaction above for gating shape.
-    auto guardEnabled =
-        ReactNativeFeatureFlags::enableSchedulerDelegateInvalidation();
     runtimeScheduler_->scheduleRenderingUpdate(
         shadowNode->getSurfaceId(),
         [delegate = delegate_,
-         invalidated = delegateInvalidated_,
-         guardEnabled,
          shadowView = std::move(shadowView),
          commandName,
          args]() {
-          if (guardEnabled && *invalidated) {
-            return;
-          }
           delegate->schedulerDidDispatchCommand(shadowView, commandName, args);
         });
   }