react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/uimanager/consistency/tests/LazyShadowTreeRevisionConsistencyManagerTest.cpp

@@ -27,6 +27,12 @@ class FakeShadowTreeDelegate : public ShadowTreeDelegate {
   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 {}
 };
 
 class LazyShadowTreeRevisionConsistencyManagerTest : public ::testing::Test {
@@ -141,7 +147,7 @@ TEST_F(
 
   EXPECT_EQ(consistencyManager_.getCurrentRevision(0), nullptr);
 
-  consistencyManager_.updateCurrentRevision(0, newRootShadowNode);
+  consistencyManager_.updateCurrentRevision(0);
 
   EXPECT_NE(consistencyManager_.getCurrentRevision(0), nullptr);
   EXPECT_EQ(
@@ -176,7 +182,7 @@ TEST_F(
 
   EXPECT_EQ(consistencyManager_.getCurrentRevision(0), nullptr);
 
-  consistencyManager_.updateCurrentRevision(0, newRootShadowNode);
+  consistencyManager_.updateCurrentRevision(0);
 
   EXPECT_EQ(
       consistencyManager_.getCurrentRevision(0).get(), newRootShadowNode.get());
@@ -192,7 +198,7 @@ TEST_F(
             {});
       });
 
-  consistencyManager_.updateCurrentRevision(0, newRootShadowNode2);
+  consistencyManager_.updateCurrentRevision(0);
 
   EXPECT_EQ(
       consistencyManager_.getCurrentRevision(0).get(),
@@ -265,7 +271,7 @@ TEST_F(
   EXPECT_EQ(
       consistencyManager_.getCurrentRevision(0).get(), newRootShadowNode.get());
 
-  consistencyManager_.updateCurrentRevision(0, newRootShadowNode2);
+  consistencyManager_.updateCurrentRevision(0);
 
   // Updated
   EXPECT_EQ(
@@ -344,7 +350,9 @@ TEST_F(LazyShadowTreeRevisionConsistencyManagerTest, testUpdateToUnmounted) {
   EXPECT_EQ(
       consistencyManager_.getCurrentRevision(0).get(), newRootShadowNode.get());
 
-  consistencyManager_.updateCurrentRevision(0, nullptr);
+  shadowTreeRegistry_.remove(0);
+
+  consistencyManager_.updateCurrentRevision(0);
 
   // Updated
   EXPECT_EQ(consistencyManager_.getCurrentRevision(0).get(), nullptr);

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

@@ -19,14 +19,17 @@ namespace facebook::react {
 using BackgroundExecutor = std::function<void(std::function<void()> &&callback)>;
 
 struct ShadowNodeListWrapper : public jsi::NativeState {
-  ShadowNodeListWrapper(ShadowNode::UnsharedListOfShared shadowNodeList) : shadowNodeList(std::move(shadowNodeList)) {}
+  ShadowNodeListWrapper(std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> shadowNodeList)
+      : shadowNodeList(std::move(shadowNodeList))
+  {
+  }
 
   // The below method needs to be implemented out-of-line in order for the class
   // to have at least one "key function" (see
   // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vague-vtable)
   ~ShadowNodeListWrapper() override;
 
-  ShadowNode::UnsharedListOfShared shadowNodeList;
+  std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> shadowNodeList;
 };
 
 inline static jsi::Value valueFromShadowNode(
@@ -48,7 +51,9 @@ inline static jsi::Value valueFromShadowNode(
 
 // TODO: once we no longer need to mutate the return value (appendChildToSet)
 // make this a SharedListOfShared
-inline static ShadowNode::UnsharedListOfShared shadowNodeListFromValue(jsi::Runtime &runtime, const jsi::Value &value)
+inline static std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> shadowNodeListFromValue(
+    jsi::Runtime &runtime,
+    const jsi::Value &value)
 {
   // TODO: cleanup when passChildrenWhenCloningPersistedNodes is rolled out
   jsi::Object object = value.asObject(runtime);
@@ -75,7 +80,9 @@ inline static ShadowNode::UnsharedListOfShared shadowNodeListFromValue(jsi::Runt
   }
 }
 
-inline static jsi::Value valueFromShadowNodeList(jsi::Runtime &runtime, ShadowNode::UnsharedListOfShared shadowNodeList)
+inline static jsi::Value valueFromShadowNodeList(
+    jsi::Runtime &runtime,
+    std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> shadowNodeList)
 {
   auto wrapper = std::make_shared<ShadowNodeListWrapper>(std::move(shadowNodeList));
   // Use the wrapper for NativeState too, otherwise we can't implement
@@ -85,8 +92,8 @@ inline static jsi::Value valueFromShadowNodeList(jsi::Runtime &runtime, ShadowNo
   return obj;
 }
 
-inline static ShadowNode::UnsharedListOfShared shadowNodeListFromWeakList(
-    const ShadowNode::UnsharedListOfWeak &weakShadowNodeList)
+inline static std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> shadowNodeListFromWeakList(
+    const std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>> &weakShadowNodeList)
 {
   auto result = std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
   for (const auto &weakShadowNode : *weakShadowNodeList) {
@@ -99,7 +106,9 @@ inline static ShadowNode::UnsharedListOfShared shadowNodeListFromWeakList(
   return result;
 }
 
-inline static ShadowNode::UnsharedListOfWeak weakShadowNodeListFromValue(jsi::Runtime &runtime, const jsi::Value &value)
+inline static std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>> weakShadowNodeListFromValue(
+    jsi::Runtime &runtime,
+    const jsi::Value &value)
 {
   auto shadowNodeList = shadowNodeListFromValue(runtime, value);
   auto weakShadowNodeList = std::make_shared<std::vector<std::weak_ptr<const ShadowNode>>>();

package/ReactCommon/react/renderer/uimanager/tests/FindShadowNodeByTagTest.cpp

@@ -0,0 +1,287 @@
+/*
+ * 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 <atomic>
+#include <thread>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <jsi/jsi.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+#include <react/renderer/element/Element.h>
+#include <react/renderer/element/testUtils.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+namespace facebook::react {
+
+class FindShadowNodeByTagTestFeatureFlags
+    : public ReactNativeFeatureFlagsDefaults {
+ public:
+  bool fixFindShadowNodeByTagRaceCondition() override {
+    return true;
+  }
+};
+
+class FindShadowNodeByTagTest : public ::testing::Test {
+ public:
+  FindShadowNodeByTagTest() {
+    ReactNativeFeatureFlags::override(
+        std::make_unique<FindShadowNodeByTagTestFeatureFlags>());
+
+    contextContainer_ = std::make_shared<ContextContainer>();
+
+    ComponentDescriptorProviderRegistry componentDescriptorProviderRegistry{};
+    auto eventDispatcher = EventDispatcher::Shared{};
+    auto componentDescriptorRegistry =
+        componentDescriptorProviderRegistry.createComponentDescriptorRegistry(
+            ComponentDescriptorParameters{
+                .eventDispatcher = eventDispatcher,
+                .contextContainer = contextContainer_,
+                .flavor = nullptr});
+
+    componentDescriptorProviderRegistry.add(
+        concreteComponentDescriptorProvider<RootComponentDescriptor>());
+    componentDescriptorProviderRegistry.add(
+        concreteComponentDescriptorProvider<ViewComponentDescriptor>());
+
+    builder_ = std::make_unique<ComponentBuilder>(componentDescriptorRegistry);
+
+    RuntimeExecutor runtimeExecutor =
+        [](std::function<void(
+               facebook::jsi::Runtime & runtime)>&& /*callback*/) {};
+    uiManager_ =
+        std::make_unique<UIManager>(runtimeExecutor, contextContainer_);
+    uiManager_->setComponentDescriptorRegistry(componentDescriptorRegistry);
+
+    buildAndCommitTree();
+  }
+
+  void TearDown() override {
+    if (!surfaceStopped_) {
+      uiManager_->stopSurface(surfaceId_);
+    }
+    ReactNativeFeatureFlags::dangerouslyReset();
+  }
+
+ protected:
+  std::shared_ptr<RootShadowNode> buildTree() {
+    std::shared_ptr<RootShadowNode> rootNode;
+
+    // clang-format off
+    auto element =
+        Element<RootShadowNode>()
+          .tag(1)
+          .surfaceId(surfaceId_)
+          .reference(rootNode)
+          .props([] {
+            auto sharedProps = std::make_shared<RootProps>();
+            auto& props = *sharedProps;
+            props.layoutConstraints = LayoutConstraints{
+                .minimumSize = {.width = 0, .height = 0},
+                .maximumSize = {.width = 500, .height = 500}};
+            auto& yogaStyle = props.yogaStyle;
+            yogaStyle.setDimension(
+                yoga::Dimension::Width,
+                yoga::StyleSizeLength::points(500));
+            yogaStyle.setDimension(
+                yoga::Dimension::Height,
+                yoga::StyleSizeLength::points(500));
+            return sharedProps;
+          })
+          .children({
+            Element<ViewShadowNode>()
+              .tag(viewTag_)
+              .surfaceId(surfaceId_)
+              .props([] {
+                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
+                auto& yogaStyle = sharedProps->yogaStyle;
+                yogaStyle.setDimension(
+                    yoga::Dimension::Width,
+                    yoga::StyleSizeLength::points(100));
+                yogaStyle.setDimension(
+                    yoga::Dimension::Height,
+                    yoga::StyleSizeLength::points(100));
+                return sharedProps;
+              })
+          })
+          .finalize([](RootShadowNode& shadowNode) {
+            shadowNode.layoutIfNeeded();
+            shadowNode.sealRecursive();
+          });
+    // clang-format on
+
+    builder_->build(element);
+    return rootNode;
+  }
+
+  void buildAndCommitTree() {
+    auto rootNode = buildTree();
+
+    auto layoutConstraints = LayoutConstraints{};
+    auto layoutContext = LayoutContext{};
+    auto shadowTree = std::make_unique<ShadowTree>(
+        surfaceId_,
+        layoutConstraints,
+        layoutContext,
+        *uiManager_,
+        *contextContainer_);
+
+    shadowTreePtr_ = shadowTree.get();
+
+    shadowTree->commit(
+        [&rootNode](const RootShadowNode& /*oldRootShadowNode*/) {
+          return std::static_pointer_cast<RootShadowNode>(rootNode);
+        },
+        {true});
+
+    uiManager_->startSurface(
+        std::move(shadowTree),
+        "test",
+        folly::dynamic::object,
+        DisplayMode::Visible);
+  }
+
+  SurfaceId surfaceId_{0};
+  Tag viewTag_{42};
+  bool surfaceStopped_{false};
+  std::shared_ptr<ContextContainer> contextContainer_;
+  std::unique_ptr<ComponentBuilder> builder_;
+  std::unique_ptr<UIManager> uiManager_;
+  ShadowTree* shadowTreePtr_{nullptr};
+};
+
+TEST_F(FindShadowNodeByTagTest, FindExistingNode) {
+  auto found = uiManager_->findShadowNodeByTag_DEPRECATED(viewTag_);
+  ASSERT_NE(found, nullptr);
+  EXPECT_EQ(found->getTag(), viewTag_);
+}
+
+TEST_F(FindShadowNodeByTagTest, FindNonExistentNode) {
+  auto found = uiManager_->findShadowNodeByTag_DEPRECATED(9999);
+  EXPECT_EQ(found, nullptr);
+}
+
+TEST_F(
+    FindShadowNodeByTagTest,
+    RawPointerFromTryCommitDanglesAfterSurfaceStop) {
+  // Observe root lifetime via weak_ptr
+  std::weak_ptr<const RootShadowNode> weakRoot;
+  {
+    auto rev = shadowTreePtr_->getCurrentRevision();
+    weakRoot = rev.rootShadowNode;
+  }
+  ASSERT_FALSE(weakRoot.expired());
+
+  // Simulate the old (buggy) pattern: capture raw pointer via tryCommit.
+  // This is exactly what findShadowNodeByTag_DEPRECATED used to do.
+  const RootShadowNode* rawPtr = nullptr;
+  shadowTreePtr_->tryCommit(
+      [&](const RootShadowNode& oldRoot) {
+        rawPtr = &oldRoot;
+        return nullptr; // cancel commit
+      },
+      {});
+  ASSERT_NE(rawPtr, nullptr);
+  ASSERT_EQ(rawPtr, weakRoot.lock().get());
+
+  // Stop the surface — releases all internal references (ShadowTree's
+  // currentRevision_ and MountingCoordinator's baseRevision_)
+  {
+    auto tree = uiManager_->stopSurface(surfaceId_);
+    surfaceStopped_ = true;
+    // tree goes out of scope here, destroying ShadowTree + MountingCoordinator
+  }
+
+  // Old root is now destroyed. rawPtr is dangling.
+  EXPECT_TRUE(weakRoot.expired())
+      << "Old root should be destroyed after surface stop, "
+         "proving that the raw pointer captured from tryCommit is dangling";
+}
+
+TEST_F(FindShadowNodeByTagTest, SharedPtrFromRevisionSurvivesSurfaceStop) {
+  // The fixed pattern: getCurrentRevision() returns a shared_ptr copy
+  auto revision = shadowTreePtr_->getCurrentRevision();
+  std::weak_ptr<const RootShadowNode> weakRoot = revision.rootShadowNode;
+  ASSERT_FALSE(weakRoot.expired());
+
+  // Stop the surface — releases all internal references
+  {
+    auto tree = uiManager_->stopSurface(surfaceId_);
+    surfaceStopped_ = true;
+  }
+
+  // Old root is STILL alive — revision's shared_ptr keeps it alive
+  EXPECT_FALSE(weakRoot.expired())
+      << "Revision's shared_ptr should keep the root alive";
+
+  // Safely traverse the old tree even after the surface was stopped
+  const auto& children = revision.rootShadowNode->getChildren();
+  ASSERT_FALSE(children.empty());
+  EXPECT_EQ(children.front()->getTag(), viewTag_);
+}
+
+TEST_F(FindShadowNodeByTagTest, ConcurrentFindAndCommitStress) {
+  // Stress test: multiple threads finding nodes while others rapidly commit
+  // new same-family tree clones. With the old tryCommit + raw pointer pattern,
+  // a committer can destroy the root between the time the finder captures the
+  // raw pointer and dereferences it, causing a use-after-free detectable by
+  // ASAN/TSAN.
+  constexpr int kNumFinderThreads = 4;
+  constexpr int kNumCommitterThreads = 2;
+  constexpr auto kDuration = std::chrono::seconds(2);
+
+  std::atomic<bool> stop{false};
+  std::atomic<int32_t> findCount{0};
+  std::atomic<int32_t> commitCount{0};
+
+  std::vector<std::thread> threads;
+  threads.reserve(kNumFinderThreads);
+
+  // Finder threads: repeatedly search for the node by tag
+  for (int i = 0; i < kNumFinderThreads; i++) {
+    threads.emplace_back([&]() {
+      while (!stop.load(std::memory_order_relaxed)) {
+        auto found = uiManager_->findShadowNodeByTag_DEPRECATED(viewTag_);
+        if (found) {
+          EXPECT_EQ(found->getTag(), viewTag_);
+          findCount.fetch_add(1, std::memory_order_relaxed);
+        }
+      }
+    });
+  }
+
+  // Committer threads: rapidly replace the tree with same-family clones.
+  // Using ShadowNode::clone() is much faster than buildTree() (no layout/
+  // allocation overhead), maximizing commit throughput and the probability
+  // of hitting the race window.
+  for (int i = 0; i < kNumCommitterThreads; i++) {
+    threads.emplace_back([&]() {
+      while (!stop.load(std::memory_order_relaxed)) {
+        shadowTreePtr_->commit(
+            [](const RootShadowNode& oldRoot) {
+              return std::static_pointer_cast<RootShadowNode>(
+                  oldRoot.ShadowNode::clone(ShadowNodeFragment{}));
+            },
+            {});
+        commitCount.fetch_add(1, std::memory_order_relaxed);
+      }
+    });
+  }
+
+  std::this_thread::sleep_for(kDuration);
+  stop.store(true, std::memory_order_relaxed);
+  for (auto& t : threads) {
+    t.join();
+  }
+
+  EXPECT_GT(findCount.load(), 0);
+  EXPECT_GT(commitCount.load(), 0);
+}
+
+} // namespace facebook::react

package/ReactCommon/react/runtime/TimerManager.cpp

@@ -134,7 +134,15 @@ TimerHandle TimerManager::createRecurringTimer(
 
 void TimerManager::deleteTimer(jsi::Runtime& runtime, TimerHandle timerHandle) {
   if (timerHandle < 0) {
-    throw jsi::JSError(runtime, "clearTimeout called with an invalid handle");
+    /**
+     * Do nothing for negative values to match web spec.
+     *
+     * cancelAnimationFrame:
+     * https://www.w3.org/TR/animation-timing/#Window-interface-extensions
+     * clearTimeout:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Window/clearTimeout#notes
+     */
+    return;
   }
 
   platformTimerRegistry_->deleteTimer(timerHandle);
@@ -145,7 +153,13 @@ void TimerManager::deleteRecurringTimer(
     jsi::Runtime& runtime,
     TimerHandle timerHandle) {
   if (timerHandle < 0) {
-    throw jsi::JSError(runtime, "clearInterval called with an invalid handle");
+    /**
+     * Do nothing for negative values to match web spec.
+     *
+     * clearInterval:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Window/clearInterval
+     */
+    return;
   }
 
   platformTimerRegistry_->deleteTimer(timerHandle);

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

@@ -98,8 +98,10 @@ class DecoratedRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
 
 class HermesJSRuntime : public JSRuntime {
  public:
-  HermesJSRuntime(std::unique_ptr<HermesRuntime> runtime)
-      : runtime_(std::move(runtime)) {}
+  HermesJSRuntime(
+      std::shared_ptr<jsi::Runtime> runtime,
+      HermesRuntime& hermesRuntime)
+      : runtime_(std::move(runtime)), hermesRuntime_(hermesRuntime) {}
 
   jsi::Runtime& getRuntime() noexcept override {
     return *runtime_;
@@ -108,17 +110,18 @@ class HermesJSRuntime : public JSRuntime {
   jsinspector_modern::RuntimeTargetDelegate& getRuntimeTargetDelegate()
       override {
     if (!targetDelegate_) {
-      targetDelegate_.emplace(runtime_);
+      targetDelegate_.emplace(runtime_, hermesRuntime_);
     }
     return *targetDelegate_;
   }
 
   void unstable_initializeOnJsThread() override {
-    runtime_->registerForProfiling();
+    hermesRuntime_.registerForProfiling();
   }
 
  private:
-  std::shared_ptr<HermesRuntime> runtime_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+  HermesRuntime& hermesRuntime_;
   std::optional<jsinspector_modern::HermesRuntimeTargetDelegate>
       targetDelegate_;
 };
@@ -173,7 +176,9 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
   (void)msgQueueThread;
 #endif
 
-  return std::make_unique<HermesJSRuntime>(std::move(hermesRuntime));
+  HermesRuntime& hermesRuntimeRef = *hermesRuntime;
+  return std::make_unique<HermesJSRuntime>(
+      std::move(hermesRuntime), hermesRuntimeRef);
 }
 
 } // namespace facebook::react

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

@@ -162,6 +162,17 @@ static ShimRCTInstance *shimmedRCTInstance;
 }
 
 - (void)testDidInitializeRuntime
+{
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
+
+  id<RCTInstanceDelegate> instanceDelegate = (id<RCTInstanceDelegate>)_subject;
+  [instanceDelegate instance:[OCMArg any] didInitializeRuntime:*rt];
+
+  OCMVerify(OCMTimes(1), [_mockHostDelegate host:_subject didInitializeRuntime:*rt]);
+}
+
+- (void)testDidInitializeRuntime_DEPRECATED
 {
   id<RCTHostRuntimeDelegate> mockRuntimeDelegate = OCMProtocolMock(@protocol(RCTHostRuntimeDelegate));
   _subject.runtimeDelegate = mockRuntimeDelegate;

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

@@ -49,11 +49,24 @@ typedef NSURL *_Nullable (^RCTHostBundleURLProvider)(void);
                exceptionId:(NSUInteger)exceptionId
                    isFatal:(BOOL)isFatal
                  extraData:(NSDictionary<NSString *, id> *)extraData __attribute__((deprecated));
+
+/**
+ Delegate method invoked after the host has finished initializing the JavaScript runtime. At this stage,
+ bindings for Turbo Modules and the NativeComponentRegistry are already installed,
+ but the JavaScript bundle has not yet been executed. This method is called on the JavaScript thread;
+ accessing the runtime from any other thread is prohibited and will result in crashes.
+ */
+- (void)host:(RCTHost *)host didInitializeRuntime:(facebook::jsi::Runtime &)runtime;
+
 @end
 
-@protocol RCTHostRuntimeDelegate <NSObject>
+// `RCTHostRuntimeDelegate` has been merged into `RCTHostDelegate` in 0.84
+[[deprecated("Use 'RCTHostDelegate' instead")]]
+@protocol RCTHostRuntimeDelegate<NSObject>
 
-- (void)host:(RCTHost *)host didInitializeRuntime:(facebook::jsi::Runtime &)runtime;
+- (void)host:(RCTHost *)host
+    didInitializeRuntime:(facebook::jsi::Runtime &)runtime
+    [[deprecated("Use an equivalent method from 'RCTHostDelegate' instead")]];
 
 @end
 
@@ -84,7 +97,8 @@ typedef std::shared_ptr<facebook::react::JSRuntimeFactory> (^RCTHostJSEngineProv
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-@property (nonatomic, weak, nullable) id<RCTHostRuntimeDelegate> runtimeDelegate;
+@property (nonatomic, weak, nullable) id<RCTHostRuntimeDelegate> runtimeDelegate
+    [[deprecated("Use 'RCTHostDelegate' instead")]];
 
 @property (nonatomic, readonly) RCTSurfacePresenter *surfacePresenter;
 

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

@@ -255,7 +255,7 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
           }
           return strongSelf->_inspectorTarget->connect(std::move(remote));
         },
-        {.nativePageReloads = true, .prefersFuseboxFrontend = true});
+        {.nativePageReloads = true});
   }
   if (_instance) {
     RCTLogWarn(
@@ -371,7 +371,14 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
 
 - (void)instance:(RCTInstance *)instance didInitializeRuntime:(facebook::jsi::Runtime &)runtime
 {
+  if ([_hostDelegate respondsToSelector:@selector(host:didInitializeRuntime:)]) {
+    [_hostDelegate host:self didInitializeRuntime:runtime];
+  }
+  // Runtime delegate is deprecated as of 0.84
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
   [self.runtimeDelegate host:self didInitializeRuntime:runtime];
+#pragma clang diagnostic pop
 }
 
 - (void)loadBundleAtURL:(NSURL *)sourceURL

package/ReactCommon/react/test_utils/shadowTreeGeneration.h

@@ -89,9 +89,10 @@ static ShadowTreeEdge findRandomShadowNode(
   return findShadowNodeWithIndex(rootShadowNode, entropy.random<int>(1 /* Excluding a root node */, count - 1));
 }
 
-static ShadowNode::ListOfShared cloneSharedShadowNodeList(const ShadowNode::ListOfShared &list)
+static std::vector<std::shared_ptr<const ShadowNode>> cloneSharedShadowNodeList(
+    const std::vector<std::shared_ptr<const ShadowNode>> &list)
 {
-  auto result = ShadowNode::ListOfShared{};
+  auto result = std::vector<std::shared_ptr<const ShadowNode>>{};
   result.reserve(list.size());
   for (const auto &shadowNode : list) {
     result.push_back(shadowNode->clone({}));
@@ -105,7 +106,8 @@ static inline std::shared_ptr<ShadowNode> messWithChildren(const Entropy &entrop
   children = cloneSharedShadowNodeList(children);
   entropy.shuffle(children);
   return shadowNode.clone(
-      {ShadowNodeFragment::propsPlaceholder(), std::make_shared<const ShadowNode::ListOfShared>(children)});
+      {ShadowNodeFragment::propsPlaceholder(),
+       std::make_shared<const std::vector<std::shared_ptr<const ShadowNode>>>(children)});
 }
 
 static inline std::shared_ptr<ShadowNode> messWithLayoutableOnlyFlag(
@@ -280,7 +282,7 @@ static inline std::shared_ptr<const ShadowNode> generateShadowNodeTree(
   auto items = std::vector<int>(size);
   std::fill(items.begin(), items.end(), 1);
   auto chunks = entropy.distribute(items, deviation);
-  auto children = ShadowNode::ListOfShared{};
+  auto children = std::vector<std::shared_ptr<const ShadowNode>>{};
 
   for (const auto &chunk : chunks) {
     children.push_back(generateShadowNodeTree(entropy, componentDescriptor, chunk.size()));
@@ -289,7 +291,8 @@ static inline std::shared_ptr<const ShadowNode> generateShadowNodeTree(
   auto family = componentDescriptor.createFamily({generateReactTag(), SurfaceId(1), nullptr});
   return componentDescriptor.createShadowNode(
       ShadowNodeFragment{
-          generateDefaultProps(componentDescriptor), std::make_shared<const ShadowNode::ListOfShared>(children)},
+          generateDefaultProps(componentDescriptor),
+          std::make_shared<const std::vector<std::shared_ptr<const ShadowNode>>>(children)},
       family);
 }
 

package/ReactCommon/react/utils/ContextContainer.h

@@ -25,8 +25,6 @@ namespace facebook::react {
  */
 class ContextContainer final {
  public:
-  using Shared [[deprecated("Use std::shared_ptr<const ContextContainer> instead.")]] =
-      std::shared_ptr<const ContextContainer>;
   /*
    * Registers an instance of the particular type `T` in the container
    * using the provided `key`. Only one instance can be registered per key.

package/ReactCommon/yoga/yoga/YGNode.cpp

@@ -177,6 +177,13 @@ void YGNodeRemoveChild(
     if (owner == childOwner) {
       excludedChild->setLayout({}); // layout is no longer valid
       excludedChild->setOwner(nullptr);
+      // Mark dirty to invalidate cache, but suppress the dirtied callback
+      // since the node is being detached from the tree and should not
+      // propagate dirty signals through external callback mechanisms.
+      auto dirtiedFunc = excludedChild->getDirtiedFunc();
+      excludedChild->setDirtiedFunc(nullptr);
+      excludedChild->setDirty(true);
+      excludedChild->setDirtiedFunc(dirtiedFunc);
     }
     owner->markDirtyAndPropagate();
   }
@@ -198,6 +205,13 @@ void YGNodeRemoveAllChildren(const YGNodeRef ownerRef) {
       yoga::Node* oldChild = owner->getChild(i);
       oldChild->setLayout({}); // layout is no longer valid
       oldChild->setOwner(nullptr);
+      // Mark dirty to invalidate cache, but suppress the dirtied callback
+      // since the node is being detached from the tree and should not
+      // propagate dirty signals through external callback mechanisms.
+      auto dirtiedFunc = oldChild->getDirtiedFunc();
+      oldChild->setDirtiedFunc(nullptr);
+      oldChild->setDirty(true);
+      oldChild->setDirtiedFunc(dirtiedFunc);
     }
     owner->clearChildren();
     owner->markDirtyAndPropagate();

package/ReactCommon/yoga/yoga/YGValue.h

@@ -77,10 +77,6 @@ inline bool operator==(const YGValue& lhs, const YGValue& rhs) {
   }
 }
 
-inline bool operator!=(const YGValue& lhs, const YGValue& rhs) {
-  return !(lhs == rhs);
-}
-
 inline YGValue operator-(const YGValue& value) {
   return {-value.value, value.unit};
 }