@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/react/renderer/mounting/tests/DifferentiatorUnflattenTest.cpp

@@ -27,9 +27,14 @@ namespace {
 
 class TestFlagsWithUnflattenFix : public ReactNativeFeatureFlagsDefaults {
  public:
+  explicit TestFlagsWithUnflattenFix(bool enabled) : enabled_(enabled) {}
+
   bool fixDifferentiatorParentTagForUnflattenCase() override {
-    return true;
+    return enabled_;
   }
+
+ private:
+  bool enabled_;
 };
 
 } // namespace
@@ -107,7 +112,7 @@ class DifferentiatorUnflattenTest : public ::testing::Test {
     rootShadowNode_ =
         std::static_pointer_cast<RootShadowNode>(rootShadowNode_->cloneTree(
             node->getFamily(), [&](const ShadowNode& oldShadowNode) {
-              auto viewProps = std::make_shared<ViewShadowNodeProps>();
+              auto viewProps = std::make_shared<ViewProps>();
               callback(*viewProps);
               return oldShadowNode.clone(
                   ShadowNodeFragment{.props = viewProps});
@@ -164,6 +169,9 @@ class DifferentiatorUnflattenTest : public ::testing::Test {
 TEST_F(
     DifferentiatorUnflattenTest,
     withoutFix_updateMutationHasWrongParentTag) {
+  ReactNativeFeatureFlags::dangerouslyForceOverride(
+      std::make_unique<TestFlagsWithUnflattenFix>(false));
+
   applyUnflattenSetup_();
 
   auto mutations = calculateMutations_();
@@ -186,7 +194,7 @@ TEST_F(
 // as parentTag, and StubViewTree::mutate() succeeds without assertion failure.
 TEST_F(DifferentiatorUnflattenTest, withFix_updateMutationHasCorrectParentTag) {
   ReactNativeFeatureFlags::dangerouslyForceOverride(
-      std::make_unique<TestFlagsWithUnflattenFix>());
+      std::make_unique<TestFlagsWithUnflattenFix>(true));
 
   applyUnflattenSetup_();
 

package/ReactCommon/react/renderer/mounting/tests/OrderIndexTest.cpp

@@ -82,7 +82,7 @@ class OrderIndexTest : public ::testing::Test {
     rootShadowNode_ =
         std::static_pointer_cast<RootShadowNode>(rootShadowNode_->cloneTree(
             node->getFamily(), [&](const ShadowNode& oldShadowNode) {
-              auto viewProps = std::make_shared<ViewShadowNodeProps>();
+              auto viewProps = std::make_shared<ViewProps>();
               callback(*viewProps);
               return oldShadowNode.clone(
                   ShadowNodeFragment{.props = viewProps});

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -19,8 +19,6 @@
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 
-#include <react/featureflags/ReactNativeFeatureFlags.h>
-#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 #include <react/renderer/mounting/stubs/stubs.h>
 #include <react/test_utils/Entropy.h>
 #include <react/test_utils/shadowTreeGeneration.h>
@@ -351,35 +349,9 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
 
 using namespace facebook::react;
 
-namespace {
+class ShadowTreeLifecycleTest : public ::testing::Test {};
 
-class LISFeatureFlagsOverride
-    : public facebook::react::ReactNativeFeatureFlagsDefaults {
- public:
-  bool useLISAlgorithmInDifferentiator() override {
-    return true;
-  }
-};
-
-} // namespace
-
-// Parametrized lifecycle tests: each test runs with both the greedy
-// algorithm (false) and the LIS algorithm (true).
-class ShadowTreeLifecycleTest : public ::testing::TestWithParam<bool> {
- protected:
-  void SetUp() override {
-    if (GetParam()) {
-      facebook::react::ReactNativeFeatureFlags::override(
-          std::make_unique<LISFeatureFlagsOverride>());
-    }
-  }
-
-  void TearDown() override {
-    facebook::react::ReactNativeFeatureFlags::dangerouslyReset();
-  }
-};
-
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
@@ -389,7 +361,7 @@ TEST_P(
       /* stages */ 32);
 }
 
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener2) {
   testShadowNodeTreeLifeCycle(
@@ -399,7 +371,7 @@ TEST_P(
       /* stages */ 32);
 }
 
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     stableSmallerTreeMoreIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
@@ -409,7 +381,7 @@ TEST_P(
       /* stages */ 32);
 }
 
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     unstableSmallerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -419,7 +391,7 @@ TEST_P(
       /* stages */ 32);
 }
 
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     unstableBiggerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -429,7 +401,7 @@ TEST_P(
       /* stages */ 32);
 }
 
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -440,7 +412,7 @@ TEST_P(
 }
 
 // failing test case found 4-25-2021
-TEST_P(
+TEST_F(
     ShadowTreeLifecycleTest,
     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
@@ -451,7 +423,7 @@ TEST_P(
 }
 
 // You may uncomment this - locally only! - to generate failing seeds.
-// TEST_P(
+// TEST_F(
 //     ShadowTreeLifecycleTest,
 //     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflatteningManyRandom)
 //     {
@@ -467,16 +439,13 @@ TEST_P(
 //   }
 // }
 
-// Demonstrates that the LIS algorithm produces fewer mutations than the
-// greedy algorithm for a simple child reorder: [A,B,C,D,E] → [B,C,D,E,A].
-// The greedy two-pointer walk encounters A vs B mismatch and generates
-// excessive REMOVE+INSERT pairs. The LIS algorithm identifies that B,C,D,E
-// are already in increasing order and only moves A.
-TEST_P(ShadowTreeLifecycleTest, moveFirstChildToLast) {
+// Tests greedy algorithm behavior for a simple child reorder:
+// [A,B,C,D,E] → [B,C,D,E,A].
+TEST_F(ShadowTreeLifecycleTest, moveFirstChildToLast) {
   auto builder = simpleComponentBuilder();
 
   auto makeProps = [](const std::string& id) {
-    auto props = std::make_shared<ViewShadowNodeProps>();
+    auto props = std::make_shared<ViewProps>();
     props->nativeId = id;
     return props;
   };
@@ -520,214 +489,10 @@ TEST_P(ShadowTreeLifecycleTest, moveFirstChildToLast) {
         m.type == ShadowViewMutation::Insert;
   };
 
-  if (ReactNativeFeatureFlags::useLISAlgorithmInDifferentiator()) {
-    // LIS: 1 REMOVE + 1 INSERT = 2 move ops.
-    EXPECT_EQ(std::count_if(mutations.begin(), mutations.end(), isMoveOp), 2);
-  } else {
-    // Greedy: 4 REMOVE + 4 INSERT = 8 move ops.
-    EXPECT_EQ(std::count_if(mutations.begin(), mutations.end(), isMoveOp), 8);
-  }
-
-  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
-  viewTree.mutate(mutations);
-  EXPECT_EQ(viewTree, expected);
-}
-
-// Exercises the LIS path where concreteChanged=true AND flattening
-// consumption occur simultaneously. Z(tag=7) is reordered to break head/tail
-// matching, forcing A, W, and C into the LIS path. W(tag=3) loses testId
-// (concrete→non-concrete, concreteChanged=true) while remaining in the LIS.
-// updateMatchedPairSubtrees triggers the flattener which promotes B(tag=6).
-// The if(!concreteChanged) block that normally checks consumption is bypassed,
-// so this test verifies the combination still produces correct mutations.
-TEST_P(ShadowTreeLifecycleTest, concreteChangedWithFlattening) {
-  auto builder = simpleComponentBuilder();
-
-  auto concreteProps = [](const std::string& id) {
-    auto props = std::make_shared<ViewShadowNodeProps>();
-    props->testId = id;
-    return props;
-  };
-
-  // clang-format off
-  // Old: Root -> [Z, A, W(concrete, child B), C]
-  // Old flattened: [Z(7), A(2), W(3), C(4)]
-  auto rootElement =
-      Element<RootShadowNode>()
-        .tag(1)
-        .children({
-          Element<ViewShadowNode>().tag(7).props(concreteProps("Z")),
-          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
-          Element<ViewShadowNode>().tag(3).props(concreteProps("W"))
-            .children({
-              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
-            }),
-          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
-        });
-  // clang-format on
-
-  auto rootNode = builder.build(rootElement);
-  auto children = rootNode->getChildren();
-  // children: [Z(7), A(2), W(3), C(4)]
-
-  // W loses testId → non-concrete (flattened). B(tag=6) promoted.
-  auto flatW = children[2]->clone(
-      ShadowNodeFragment{.props = std::make_shared<ViewShadowNodeProps>()});
-
-  // New: Root -> [A, W(flattened), C, Z] — Z moved to end.
-  // New flattened: [A(2), W(3,non-concrete), B(6), C(4), Z(7)]
-  // Z's move breaks head matching; A, W, C enter LIS path.
-  // Among old remaining [Z,A,W,C] mapped to new positions,
-  // LIS includes A,W,C (increasing order), W has concreteChanged=true.
-  auto newChildren =
-      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
-  newChildren->push_back(children[1]); // A
-  newChildren->push_back(flatW); // W (flattened)
-  newChildren->push_back(children[3]); // C
-  newChildren->push_back(children[0]); // Z (moved to end)
-
-  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
-      rootNode->ShadowNode::clone(
-          ShadowNodeFragment{
-              .props = ShadowNodeFragment::propsPlaceholder(),
-              .children = newChildren}));
+  // Greedy: 4 REMOVE + 4 INSERT = 8 move ops.
+  EXPECT_EQ(std::count_if(mutations.begin(), mutations.end(), isMoveOp), 8);
 
-  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
-  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
   auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
   viewTree.mutate(mutations);
   EXPECT_EQ(viewTree, expected);
 }
-
-// Reverse: W(tag=3) gains testId (non-concrete→concrete, concreteChanged=true)
-// while in the LIS path. B(tag=6) was promoted by flattening and now gets
-// absorbed back into W via unflattening. Z reorder breaks head matching.
-TEST_P(ShadowTreeLifecycleTest, concreteChangedWithUnflatteningInLIS) {
-  auto builder = simpleComponentBuilder();
-
-  auto concreteProps = [](const std::string& id) {
-    auto props = std::make_shared<ViewShadowNodeProps>();
-    props->testId = id;
-    return props;
-  };
-
-  // clang-format off
-  // Old: Root -> [Z, A, W(NON-concrete, child B(concrete)), C]
-  // Old flattened: [Z(7), A(2), W(3,non-concrete), B(6), C(4)]
-  auto rootElement =
-      Element<RootShadowNode>()
-        .tag(1)
-        .children({
-          Element<ViewShadowNode>().tag(7).props(concreteProps("Z")),
-          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
-          Element<ViewShadowNode>().tag(3)
-            .children({
-              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
-            }),
-          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
-        });
-  // clang-format on
-
-  auto rootNode = builder.build(rootElement);
-  auto children = rootNode->getChildren();
-
-  // W gains testId → concrete (unflattened). B absorbed back into W.
-  auto concreteW =
-      children[2]->clone(ShadowNodeFragment{.props = concreteProps("W")});
-
-  // New: Root -> [A, W(concrete), C, Z] — Z moved to end.
-  // New flattened: [A(2), W(3), C(4), Z(7)]
-  auto newChildren =
-      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
-  newChildren->push_back(children[1]); // A
-  newChildren->push_back(concreteW); // W (concrete)
-  newChildren->push_back(children[3]); // C
-  newChildren->push_back(children[0]); // Z (moved to end)
-
-  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
-      rootNode->ShadowNode::clone(
-          ShadowNodeFragment{
-              .props = ShadowNodeFragment::propsPlaceholder(),
-              .children = newChildren}));
-
-  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
-  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
-  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
-  viewTree.mutate(mutations);
-  EXPECT_EQ(viewTree, expected);
-}
-
-// Tests that the LIS algorithm produces correct mutations when child
-// reordering coincides with a view's flattening transition. When W(tag=3)
-// becomes flattened (loses testId), its child B(tag=6) is promoted to the
-// parent level in the flattened view. The LIS pre-computation maps old
-// children to new positions, but the flattener may consume entries from
-// newRemainingPairs during flatten/unflatten processing. This test verifies
-// the runtime newRemainingPairs check correctly handles this interaction.
-TEST_P(ShadowTreeLifecycleTest, reorderWithFlatteningTransition) {
-  auto builder = simpleComponentBuilder();
-
-  auto concreteProps = [](const std::string& id) {
-    auto props = std::make_shared<ViewShadowNodeProps>();
-    props->testId = id;
-    return props;
-  };
-
-  // clang-format off
-  // Old tree: Root -> [A, W(concrete with testId, child B), C, D]
-  auto rootElement =
-      Element<RootShadowNode>()
-        .tag(1)
-        .children({
-          Element<ViewShadowNode>().tag(2).props(concreteProps("A")),
-          Element<ViewShadowNode>().tag(3).props(concreteProps("W"))
-            .children({
-              Element<ViewShadowNode>().tag(6).props(concreteProps("B")),
-            }),
-          Element<ViewShadowNode>().tag(4).props(concreteProps("C")),
-          Element<ViewShadowNode>().tag(5).props(concreteProps("D")),
-        });
-  // clang-format on
-
-  auto rootNode = builder.build(rootElement);
-  auto children = rootNode->getChildren();
-  // children: [A(2), W(3), C(4), D(5)]
-
-  // Clone W without testId to make it non-concrete (flattened).
-  // B(tag=6) will be promoted to the parent level.
-  auto flatW = children[1]->clone(
-      ShadowNodeFragment{.props = std::make_shared<ViewShadowNodeProps>()});
-
-  // New tree: Root -> [C, D, A, W(flattened)]
-  // Reorder [A,W,C,D] -> [C,D,A,W(flattened)]
-  auto reorderedChildren =
-      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
-  reorderedChildren->push_back(children[2]); // C
-  reorderedChildren->push_back(children[3]); // D
-  reorderedChildren->push_back(children[0]); // A
-  reorderedChildren->push_back(flatW); // W (flattened)
-
-  auto newRootNode = std::static_pointer_cast<const RootShadowNode>(
-      rootNode->ShadowNode::clone(
-          ShadowNodeFragment{
-              .props = ShadowNodeFragment::propsPlaceholder(),
-              .children = reorderedChildren}));
-
-  auto expected = buildStubViewTreeWithoutUsingDifferentiator(*newRootNode);
-  auto mutations = calculateShadowViewMutations(*rootNode, *newRootNode);
-  auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*rootNode);
-  viewTree.mutate(mutations);
-  EXPECT_EQ(viewTree, expected);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    Greedy,
-    ShadowTreeLifecycleTest,
-    ::testing::Values(false),
-    [](const auto&) { return "Greedy"; });
-
-INSTANTIATE_TEST_SUITE_P(
-    LIS,
-    ShadowTreeLifecycleTest,
-    ::testing::Values(true),
-    [](const auto&) { return "LIS"; });

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeReactBranchingTest.cpp

@@ -0,0 +1,141 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/element/ComponentBuilder.h>
+#include <react/renderer/element/Element.h>
+#include <react/renderer/element/testUtils.h>
+#include <react/renderer/mounting/MountingCoordinator.h>
+#include <react/renderer/mounting/ShadowTree.h>
+#include <react/renderer/mounting/ShadowTreeDelegate.h>
+
+using namespace facebook::react;
+
+namespace {
+
+class BranchingEnabledFlags : public ReactNativeFeatureFlagsDefaults {
+ public:
+  bool enableFabricCommitBranching() override {
+    return true;
+  }
+};
+
+class DummyShadowTreeDelegate : public ShadowTreeDelegate {
+ public:
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      const ShadowTree& /*shadowTree*/,
+      const RootShadowNode::Shared& /*oldRootShadowNode*/,
+      const RootShadowNode::Unshared& newRootShadowNode,
+      const ShadowTree::CommitOptions& /*commitOptions*/) const override {
+    return newRootShadowNode;
+  }
+
+  void shadowTreeDidFinishTransaction(
+      std::shared_ptr<const MountingCoordinator> /*mountingCoordinator*/,
+      bool /*mountSynchronously*/) const override {}
+
+  void shadowTreeDidFinishReactCommit(
+      const ShadowTree& /*shadowTree*/) const override {}
+
+  void shadowTreeDidPromoteReactRevision(
+      const ShadowTree& /*shadowTree*/) const override {}
+};
+
+} // namespace
+
+class ShadowTreeReactBranchingTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    // Must override before any component construction reads a flag.
+    ReactNativeFeatureFlags::dangerouslyReset();
+    ReactNativeFeatureFlags::override(
+        std::make_unique<BranchingEnabledFlags>());
+  }
+
+  void TearDown() override {
+    ReactNativeFeatureFlags::dangerouslyReset();
+  }
+};
+
+// Two React revisions committed before a merge share a revision number.
+// Merging the first must not clear the second: the old number-based comparison
+// cleared it (dropping a pending update); the fix compares root node identity.
+TEST_F(ShadowTreeReactBranchingTest, mergeDoesNotDropNewerReactRevision) {
+  // clang-format off
+  auto element =
+      Element<RootShadowNode>()
+        .children({
+          Element<ViewShadowNode>()
+        });
+  // clang-format on
+
+  ContextContainer contextContainer{};
+  auto builder = simpleComponentBuilder();
+  auto initialRootShadowNode = builder.build(element);
+  auto shadowTreeDelegate = DummyShadowTreeDelegate{};
+
+  ShadowTree shadowTree{
+      SurfaceId{11},
+      LayoutConstraints{},
+      LayoutContext{},
+      shadowTreeDelegate,
+      contextContainer};
+
+  // Initial (non-React) commit establishes `currentRevision_`.
+  shadowTree.commit(
+      [&](const RootShadowNode& /*oldRootShadowNode*/) {
+        return std::static_pointer_cast<RootShadowNode>(initialRootShadowNode);
+      },
+      {.enableStateReconciliation = false});
+
+  // First React revision (R1).
+  auto rootR1 = std::static_pointer_cast<RootShadowNode>(
+      initialRootShadowNode->ShadowNode::clone({}));
+  shadowTree.commit(
+      [&](const RootShadowNode& /*oldRootShadowNode*/) { return rootR1; },
+      {.enableStateReconciliation = false,
+       .mountSynchronously = false,
+       .source = ShadowTreeCommitSource::React});
+
+  auto revisionAfterR1 = shadowTree.getCurrentReactRevision();
+  ASSERT_TRUE(revisionAfterR1.has_value());
+
+  // Promote R1 (end-of-tick), but do not merge it yet.
+  shadowTree.promoteReactRevision();
+
+  // Second React revision (R2) lands before the merge. The main revision has
+  // not advanced, so R2 gets R1's revision number but is a distinct tree.
+  auto rootR2 = std::static_pointer_cast<RootShadowNode>(
+      initialRootShadowNode->ShadowNode::clone({}));
+  shadowTree.commit(
+      [&](const RootShadowNode& /*oldRootShadowNode*/) { return rootR2; },
+      {.enableStateReconciliation = false,
+       .mountSynchronously = false,
+       .source = ShadowTreeCommitSource::React});
+
+  auto revisionAfterR2 = shadowTree.getCurrentReactRevision();
+  ASSERT_TRUE(revisionAfterR2.has_value());
+
+  // Precondition for the bug: same number, different revisions.
+  EXPECT_EQ(revisionAfterR1->number, revisionAfterR2->number);
+  EXPECT_NE(revisionAfterR2->rootShadowNode, revisionAfterR1->rootShadowNode);
+
+  // Merging R1 must not clear R2.
+  shadowTree.mergeReactRevision();
+
+  auto revisionAfterMerge = shadowTree.getCurrentReactRevision();
+  ASSERT_TRUE(revisionAfterMerge.has_value())
+      << "Newer React revision (R2) was incorrectly dropped while merging R1";
+  EXPECT_EQ(
+      revisionAfterMerge->rootShadowNode, revisionAfterR2->rootShadowNode);
+}

package/ReactCommon/react/renderer/mounting/tests/StackingContextTest.cpp

@@ -162,7 +162,7 @@ class StackingContextTest : public ::testing::Test {
     rootShadowNode_ =
         std::static_pointer_cast<RootShadowNode>(rootShadowNode_->cloneTree(
             node->getFamily(), [&](const ShadowNode& oldShadowNode) {
-              auto viewProps = std::make_shared<ViewShadowNodeProps>();
+              auto viewProps = std::make_shared<ViewProps>();
               callback(*viewProps);
               return oldShadowNode.clone(
                   ShadowNodeFragment{.props = viewProps});

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

@@ -15,6 +15,7 @@ target_include_directories(react_renderer_runtimescheduler PUBLIC ${REACT_COMMON
 
 target_link_libraries(react_renderer_runtimescheduler
         callinvoker
+        jserrorhandler
         jsi
         react_debug
         react_performance_timeline

package/ReactCommon/react/renderer/runtimescheduler/React-runtimescheduler.podspec

@@ -47,6 +47,7 @@ Pod::Spec.new do |s|
   s.dependency "React-utils"
   s.dependency "React-featureflags"
   s.dependency "React-timing"
+  s.dependency "React-jserrorhandler"
   s.dependency "React-jsi"
   s.dependency "React-performancetimeline"
   s.dependency "React-rendererconsistency"

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

@@ -6,12 +6,16 @@
  */
 
 #include "RuntimeScheduler.h"
-#include "RuntimeScheduler_Legacy.h"
 #include "RuntimeScheduler_Modern.h"
+#ifndef RCT_REMOVE_LEGACY_ARCH
+#include "RuntimeScheduler_Legacy.h"
+#endif
 
-#include <cxxreact/ErrorUtils.h>
 #include <cxxreact/TraceSection.h>
+#include <jserrorhandler/ErrorUtils.h>
+#ifndef RCT_REMOVE_LEGACY_ARCH
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#endif
 #include <utility>
 
 namespace facebook::react {
@@ -23,13 +27,17 @@ std::unique_ptr<RuntimeSchedulerBase> getRuntimeSchedulerImplementation(
     RuntimeExecutor runtimeExecutor,
     std::function<HighResTimeStamp()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError) {
+#ifndef RCT_REMOVE_LEGACY_ARCH
   if (ReactNativeFeatureFlags::enableBridgelessArchitecture()) {
+#endif
     return std::make_unique<RuntimeScheduler_Modern>(
         std::move(runtimeExecutor), std::move(now), std::move(onTaskError));
+#ifndef RCT_REMOVE_LEGACY_ARCH
   } else {
     return std::make_unique<RuntimeScheduler_Legacy>(
         std::move(runtimeExecutor), std::move(now), std::move(onTaskError));
   }
+#endif
 }
 
 } // namespace
@@ -53,6 +61,18 @@ void RuntimeScheduler::scheduleWork(RawCallback&& callback) noexcept {
   return runtimeSchedulerImpl_->scheduleWork(std::move(callback));
 }
 
+void RuntimeScheduler::scheduleTask(const std::function<void()>& task) {
+  return runtimeSchedulerImpl_->scheduleTask(task);
+}
+
+uint64_t RuntimeScheduler::registerTaskQueueSource() {
+  return runtimeSchedulerImpl_->registerTaskQueueSource();
+}
+
+void RuntimeScheduler::unregisterTaskQueueSource(uint64_t sourceId) {
+  return runtimeSchedulerImpl_->unregisterTaskQueueSource(sourceId);
+}
+
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
     SchedulerPriority priority,
     jsi::Function&& callback) noexcept {

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

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <ReactCommon/RuntimeExecutor.h>
+#include <jsi/hermes-interfaces.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/runtimescheduler/SchedulerPriorityUtils.h>
@@ -27,9 +28,12 @@ extern const char RuntimeSchedulerKey[];
 
 // This is a temporary abstract class for RuntimeScheduler forks to implement
 // (and use them interchangeably).
-class RuntimeSchedulerBase {
+class RuntimeSchedulerBase : public facebook::hermes::IEventLoopControl {
  public:
   virtual ~RuntimeSchedulerBase() = default;
+
+  using facebook::hermes::IEventLoopControl::scheduleTask;
+
   virtual void scheduleWork(RawCallback &&callback) noexcept = 0;
   virtual void executeNowOnTheSameThread(RawCallback &&callback) = 0;
   virtual std::shared_ptr<Task> scheduleTask(SchedulerPriority priority, jsi::Function &&callback) noexcept = 0;
@@ -55,7 +59,7 @@ class RuntimeSchedulerBase {
 
 // This is a proxy for RuntimeScheduler implementation, which will be selected
 // at runtime based on a feature flag.
-class RuntimeScheduler final : RuntimeSchedulerBase {
+class RuntimeScheduler final : public RuntimeSchedulerBase {
  public:
   explicit RuntimeScheduler(
       RuntimeExecutor runtimeExecutor,
@@ -76,6 +80,13 @@ class RuntimeScheduler final : RuntimeSchedulerBase {
 
   void scheduleWork(RawCallback &&callback) noexcept override;
 
+  /// IEventLoopControl implementation, forwarded to the underlying fork.
+  void scheduleTask(const std::function<void()> &task) override;
+
+  uint64_t registerTaskQueueSource() override;
+
+  void unregisterTaskQueueSource(uint64_t sourceId) override;
+
   /*
    * Grants access to the runtime synchronously on the caller's thread.
    *