react-native 0.84.0-nightly-20251106-de5141a3d → 0.84.0-nightly-20251108-7486a2bc5

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsAccessor.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<b72070ee07df0d084009668488efb889>>
+ * @generated SignedSource<<4e1bcac109eecdaf11c62ce8c367b20d>>
  */
 
 /**
@@ -38,10 +38,12 @@ class ReactNativeFeatureFlagsAccessor {
   bool cxxNativeAnimatedRemoveJsSync();
   bool disableEarlyViewCommandExecution();
   bool disableFabricCommitInCXXAnimated();
+  bool disableImageViewPreallocationAndroid();
   bool disableMountItemReorderingAndroid();
   bool disableOldAndroidAttachmentMetricsWorkarounds();
   bool disableSubviewClippingAndroid();
   bool disableTextLayoutManagerCacheAndroid();
+  bool disableViewPreallocationAndroid();
   bool enableAccessibilityOrder();
   bool enableAccumulatedUpdatesInRawPropsAndroid();
   bool enableAndroidLinearText();
@@ -125,7 +127,7 @@ class ReactNativeFeatureFlagsAccessor {
   std::unique_ptr<ReactNativeFeatureFlagsProvider> currentProvider_;
   bool wasOverridden_;
 
-  std::array<std::atomic<const char*>, 82> accessedFeatureFlags_;
+  std::array<std::atomic<const char*>, 84> accessedFeatureFlags_;
 
   std::atomic<std::optional<bool>> commonTestFlag_;
   std::atomic<std::optional<bool>> cdpInteractionMetricsEnabled_;
@@ -133,10 +135,12 @@ class ReactNativeFeatureFlagsAccessor {
   std::atomic<std::optional<bool>> cxxNativeAnimatedRemoveJsSync_;
   std::atomic<std::optional<bool>> disableEarlyViewCommandExecution_;
   std::atomic<std::optional<bool>> disableFabricCommitInCXXAnimated_;
+  std::atomic<std::optional<bool>> disableImageViewPreallocationAndroid_;
   std::atomic<std::optional<bool>> disableMountItemReorderingAndroid_;
   std::atomic<std::optional<bool>> disableOldAndroidAttachmentMetricsWorkarounds_;
   std::atomic<std::optional<bool>> disableSubviewClippingAndroid_;
   std::atomic<std::optional<bool>> disableTextLayoutManagerCacheAndroid_;
+  std::atomic<std::optional<bool>> disableViewPreallocationAndroid_;
   std::atomic<std::optional<bool>> enableAccessibilityOrder_;
   std::atomic<std::optional<bool>> enableAccumulatedUpdatesInRawPropsAndroid_;
   std::atomic<std::optional<bool>> enableAndroidLinearText_;

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<85c260dcb8eb9209a53207c3c54183f0>>
+ * @generated SignedSource<<cce007ecab09ff43ec931cb259542ed9>>
  */
 
 /**
@@ -51,6 +51,10 @@ class ReactNativeFeatureFlagsDefaults : public ReactNativeFeatureFlagsProvider {
     return false;
   }
 
+  bool disableImageViewPreallocationAndroid() override {
+    return false;
+  }
+
   bool disableMountItemReorderingAndroid() override {
     return false;
   }
@@ -67,6 +71,10 @@ class ReactNativeFeatureFlagsDefaults : public ReactNativeFeatureFlagsProvider {
     return false;
   }
 
+  bool disableViewPreallocationAndroid() override {
+    return false;
+  }
+
   bool enableAccessibilityOrder() override {
     return false;
   }

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<0224a638fbec556a62c58f5d84c4c662>>
+ * @generated SignedSource<<c1ffba92f08189da8b2a2726cd490afc>>
  */
 
 /**
@@ -99,6 +99,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::disableFabricCommitInCXXAnimated();
   }
 
+  bool disableImageViewPreallocationAndroid() override {
+    auto value = values_["disableImageViewPreallocationAndroid"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::disableImageViewPreallocationAndroid();
+  }
+
   bool disableMountItemReorderingAndroid() override {
     auto value = values_["disableMountItemReorderingAndroid"];
     if (!value.isNull()) {
@@ -135,6 +144,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::disableTextLayoutManagerCacheAndroid();
   }
 
+  bool disableViewPreallocationAndroid() override {
+    auto value = values_["disableViewPreallocationAndroid"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::disableViewPreallocationAndroid();
+  }
+
   bool enableAccessibilityOrder() override {
     auto value = values_["enableAccessibilityOrder"];
     if (!value.isNull()) {

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<a50e4901fa5524066608b64929744dd8>>
+ * @generated SignedSource<<724a7046fefc47616249d6fac8367615>>
  */
 
 /**
@@ -31,10 +31,12 @@ class ReactNativeFeatureFlagsProvider {
   virtual bool cxxNativeAnimatedRemoveJsSync() = 0;
   virtual bool disableEarlyViewCommandExecution() = 0;
   virtual bool disableFabricCommitInCXXAnimated() = 0;
+  virtual bool disableImageViewPreallocationAndroid() = 0;
   virtual bool disableMountItemReorderingAndroid() = 0;
   virtual bool disableOldAndroidAttachmentMetricsWorkarounds() = 0;
   virtual bool disableSubviewClippingAndroid() = 0;
   virtual bool disableTextLayoutManagerCacheAndroid() = 0;
+  virtual bool disableViewPreallocationAndroid() = 0;
   virtual bool enableAccessibilityOrder() = 0;
   virtual bool enableAccumulatedUpdatesInRawPropsAndroid() = 0;
   virtual bool enableAndroidLinearText() = 0;

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm

@@ -30,7 +30,6 @@
 #import <ReactCommon/CxxTurboModuleUtils.h>
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
 #import <ReactCommon/TurboModulePerfLogger.h>
-#import <react/featureflags/ReactNativeFeatureFlags.h>
 
 using namespace facebook;
 using namespace facebook::react;

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<bd66756451b25d73717a5907e6789a77>>
+ * @generated SignedSource<<19cc3c19f4e6115556fa29320ab47ff2>>
  */
 
 /**
@@ -74,6 +74,11 @@ bool NativeReactNativeFeatureFlags::disableFabricCommitInCXXAnimated(
   return ReactNativeFeatureFlags::disableFabricCommitInCXXAnimated();
 }
 
+bool NativeReactNativeFeatureFlags::disableImageViewPreallocationAndroid(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::disableImageViewPreallocationAndroid();
+}
+
 bool NativeReactNativeFeatureFlags::disableMountItemReorderingAndroid(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::disableMountItemReorderingAndroid();
@@ -94,6 +99,11 @@ bool NativeReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid(
   return ReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid();
 }
 
+bool NativeReactNativeFeatureFlags::disableViewPreallocationAndroid(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::disableViewPreallocationAndroid();
+}
+
 bool NativeReactNativeFeatureFlags::enableAccessibilityOrder(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableAccessibilityOrder();

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<0d898a94decb43e191a343676c8afb91>>
+ * @generated SignedSource<<65a06880aea8299c68e57e5b48a2fed8>>
  */
 
 /**
@@ -48,6 +48,8 @@ class NativeReactNativeFeatureFlags
 
   bool disableFabricCommitInCXXAnimated(jsi::Runtime& runtime);
 
+  bool disableImageViewPreallocationAndroid(jsi::Runtime& runtime);
+
   bool disableMountItemReorderingAndroid(jsi::Runtime& runtime);
 
   bool disableOldAndroidAttachmentMetricsWorkarounds(jsi::Runtime& runtime);
@@ -56,6 +58,8 @@ class NativeReactNativeFeatureFlags
 
   bool disableTextLayoutManagerCacheAndroid(jsi::Runtime& runtime);
 
+  bool disableViewPreallocationAndroid(jsi::Runtime& runtime);
+
   bool enableAccessibilityOrder(jsi::Runtime& runtime);
 
   bool enableAccumulatedUpdatesInRawPropsAndroid(jsi::Runtime& runtime);

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.mm

@@ -24,10 +24,7 @@ using namespace facebook::react;
 }
 
 // Backward-compatible export
-+ (NSString *)moduleName
-{
-  return @"SampleTurboModule";
-}
+RCT_EXPORT_MODULE()
 
 // Backward-compatible queue configuration
 + (BOOL)requiresMainQueueSetup

package/ReactCommon/react/performance/timeline/CMakeLists.txt

@@ -16,6 +16,7 @@ target_compile_options(react_performance_timeline PRIVATE -Wpedantic)
 
 target_include_directories(react_performance_timeline PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_performance_timeline
+        jsinspector
         jsinspector_tracing
         reactperflogger
         react_featureflags

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.cpp

@@ -7,6 +7,7 @@
 
 #include "PerformanceEntryReporter.h"
 
+#include <jsinspector-modern/ConsoleTaskOrchestrator.h>
 #include <jsinspector-modern/tracing/PerformanceTracer.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/timing/primitives.h>
@@ -381,8 +382,15 @@ void PerformanceEntryReporter::traceMeasure(
     }
 
     if (performanceTracer.isTracing()) {
+      auto taskContext =
+          jsinspector_modern::ConsoleTaskOrchestrator::getInstance().top();
+
       performanceTracer.reportMeasure(
-          entry.name, entry.startTime, entry.duration, std::move(detail));
+          entry.name,
+          entry.startTime,
+          entry.duration,
+          std::move(detail),
+          taskContext ? taskContext->getSerializedStackTrace() : nullptr);
     }
   }
 }

package/ReactCommon/react/performance/timeline/React-performancetimeline.podspec

@@ -41,6 +41,7 @@ Pod::Spec.new do |s|
   resolve_use_frameworks(s, header_mappings_dir: "../../..", module_name: "React_performancetimeline")
 
   s.dependency "React-featureflags"
+  add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
   s.dependency "React-timing"
   s.dependency "React-perflogger"

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -519,6 +519,17 @@ NativeAnimatedNodesManager::ensureEventEmitterListener() noexcept {
 }
 
 void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
+  // This method can be called from either the UI thread or JavaScript thread.
+  // It ensures `startOnRenderCallback_` is called exactly once using atomic
+  // operations. We use std::atomic_bool rather than std::mutex to avoid
+  // potential deadlocks that could occur if we called external code while
+  // holding a mutex.
+  auto isRenderCallbackStarted = isRenderCallbackStarted_.exchange(true);
+  if (isRenderCallbackStarted) {
+    // onRender callback is already started.
+    return;
+  }
+
   if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
 #ifdef RN_USE_ANIMATION_BACKEND
     if (auto animationBackend = animationBackend_.lock()) {
@@ -531,16 +542,6 @@ void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
 
     return;
   }
-  // This method can be called from either the UI thread or JavaScript thread.
-  // It ensures `startOnRenderCallback_` is called exactly once using atomic
-  // operations. We use std::atomic_bool rather than std::mutex to avoid
-  // potential deadlocks that could occur if we called external code while
-  // holding a mutex.
-  auto isRenderCallbackStarted = isRenderCallbackStarted_.exchange(true);
-  if (isRenderCallbackStarted) {
-    // onRender callback is already started.
-    return;
-  }
 
   if (startOnRenderCallback_) {
     startOnRenderCallback_([this]() { onRender(); }, isAsync);
@@ -549,25 +550,28 @@ void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
 
 void NativeAnimatedNodesManager::stopRenderCallbackIfNeeded(
     bool isAsync) noexcept {
-  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-    if (auto animationBackend = animationBackend_.lock()) {
-      animationBackend->stop(isAsync);
-    }
-    return;
-  }
   // When multiple threads reach this point, only one thread should call
   // stopOnRenderCallback_. This synchronization is primarily needed during
   // destruction of NativeAnimatedNodesManager. In normal operation,
   // stopRenderCallbackIfNeeded is always called from the UI thread.
   auto isRenderCallbackStarted = isRenderCallbackStarted_.exchange(false);
 
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    if (isRenderCallbackStarted) {
+      if (auto animationBackend = animationBackend_.lock()) {
+        animationBackend->stop(isAsync);
+      }
+    }
+    return;
+  }
+
   if (isRenderCallbackStarted) {
     if (stopOnRenderCallback_) {
       stopOnRenderCallback_(isAsync);
-    }
 
-    if (frameRateListenerCallback_) {
-      frameRateListenerCallback_(false);
+      if (frameRateListenerCallback_) {
+        frameRateListenerCallback_(false);
+      }
     }
   }
 }
@@ -988,6 +992,7 @@ AnimationMutations NativeAnimatedNodesManager::pullAnimationMutations() {
             AnimationMutation{tag, nullptr, propsBuilder.get()});
         containsChange = true;
       }
+      updateViewPropsDirect_.clear();
     }
 
     if (!containsChange) {

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManagerProvider.cpp

@@ -80,19 +80,28 @@ NativeAnimatedNodesManagerProvider::getOrCreate(
           std::move(directManipulationCallback),
           std::move(fabricCommitCallback),
           uiManager);
-#endif
 
       nativeAnimatedNodesManager_ =
           std::make_shared<NativeAnimatedNodesManager>(animationBackend_);
 
+      nativeAnimatedDelegate_ =
+          std::make_shared<UIManagerNativeAnimatedDelegateBackendImpl>(
+              animationBackend_);
+
       uiManager->unstable_setAnimationBackend(animationBackend_);
+#endif
     } else {
       nativeAnimatedNodesManager_ =
           std::make_shared<NativeAnimatedNodesManager>(
               std::move(directManipulationCallback),
               std::move(fabricCommitCallback),
               std::move(startOnRenderCallback_),
-              std::move(stopOnRenderCallback_));
+              std::move(stopOnRenderCallback_),
+              std::move(frameRateListenerCallback_));
+
+      nativeAnimatedDelegate_ =
+          std::make_shared<UIManagerNativeAnimatedDelegateImpl>(
+              nativeAnimatedNodesManager_);
     }
 
     addEventEmitterListener(
@@ -117,10 +126,6 @@ NativeAnimatedNodesManagerProvider::getOrCreate(
               return false;
             }));
 
-    nativeAnimatedDelegate_ =
-        std::make_shared<UIManagerNativeAnimatedDelegateImpl>(
-            nativeAnimatedNodesManager_);
-
     uiManager->setNativeAnimatedDelegate(nativeAnimatedDelegate_);
 
     // TODO: remove force casting.

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -10,6 +10,18 @@
 
 namespace facebook::react {
 
+UIManagerNativeAnimatedDelegateBackendImpl::
+    UIManagerNativeAnimatedDelegateBackendImpl(
+        std::weak_ptr<UIManagerAnimationBackend> animationBackend)
+    : animationBackend_(std::move(animationBackend)) {}
+
+void UIManagerNativeAnimatedDelegateBackendImpl::runAnimationFrame() {
+  if (auto animationBackendStrong = animationBackend_.lock()) {
+    animationBackendStrong->onAnimationFrame(
+        std::chrono::steady_clock::now().time_since_epoch().count() / 1000);
+  }
+}
+
 static inline Props::Shared cloneProps(
     AnimatedProps& animatedProps,
     const ShadowNode& shadowNode) {
@@ -87,19 +99,23 @@ AnimationBackend::AnimationBackend(
 
 void AnimationBackend::onAnimationFrame(double timestamp) {
   std::unordered_map<Tag, AnimatedProps> updates;
-  std::unordered_set<const ShadowNodeFamily*> families;
+  std::unordered_map<SurfaceId, std::unordered_set<const ShadowNodeFamily*>>
+      surfaceToFamilies;
   bool hasAnyLayoutUpdates = false;
   for (auto& callback : callbacks) {
     auto muatations = callback(static_cast<float>(timestamp));
     for (auto& mutation : muatations) {
       hasAnyLayoutUpdates |= mutationHasLayoutUpdates(mutation);
-      families.insert(mutation.family);
+      const auto family = mutation.family;
+      if (family != nullptr) {
+        surfaceToFamilies[family->getSurfaceId()].insert(family);
+      }
       updates[mutation.tag] = std::move(mutation.props);
     }
   }
 
   if (hasAnyLayoutUpdates) {
-    commitUpdatesWithFamilies(families, updates);
+    commitUpdates(surfaceToFamilies, updates);
   } else {
     synchronouslyUpdateProps(updates);
   }
@@ -108,41 +124,60 @@ void AnimationBackend::onAnimationFrame(double timestamp) {
 void AnimationBackend::start(const Callback& callback, bool isAsync) {
   callbacks.push_back(callback);
   // TODO: startOnRenderCallback_ should provide the timestamp from the platform
-  startOnRenderCallback_(
-      [this]() {
-        onAnimationFrame(
-            std::chrono::steady_clock::now().time_since_epoch().count() / 1000);
-      },
-      isAsync);
+  if (startOnRenderCallback_) {
+    startOnRenderCallback_(
+        [this]() {
+          onAnimationFrame(
+              std::chrono::steady_clock::now().time_since_epoch().count() /
+              1000);
+        },
+        isAsync);
+  }
 }
 void AnimationBackend::stop(bool isAsync) {
-  stopOnRenderCallback_(isAsync);
+  if (stopOnRenderCallback_) {
+    stopOnRenderCallback_(isAsync);
+  }
   callbacks.clear();
 }
 
-void AnimationBackend::commitUpdatesWithFamilies(
-    const std::unordered_set<const ShadowNodeFamily*>& families,
+void AnimationBackend::commitUpdates(
+    const std::unordered_map<
+        SurfaceId,
+        std::unordered_set<const ShadowNodeFamily*>>& surfaceToFamilies,
     std::unordered_map<Tag, AnimatedProps>& updates) {
-  uiManager_->getShadowTreeRegistry().enumerate(
-      [families, &updates](const ShadowTree& shadowTree, bool& /*stop*/) {
-        shadowTree.commit(
-            [families, &updates](const RootShadowNode& oldRootShadowNode) {
-              return std::static_pointer_cast<RootShadowNode>(
-                  oldRootShadowNode.cloneMultiple(
-                      families,
-                      [families, &updates](
-                          const ShadowNode& shadowNode,
-                          const ShadowNodeFragment& fragment) {
-                        auto& animatedProps = updates.at(shadowNode.getTag());
-                        auto newProps = cloneProps(animatedProps, shadowNode);
-                        return shadowNode.clone(
-                            {newProps,
-                             fragment.children,
-                             shadowNode.getState()});
-                      }));
-            },
-            {.mountSynchronously = true});
-      });
+  for (const auto& surfaceEntry : surfaceToFamilies) {
+    const auto& surfaceId = surfaceEntry.first;
+    const auto& surfaceFamilies = surfaceEntry.second;
+    uiManager_->getShadowTreeRegistry().visit(
+        surfaceId, [&surfaceFamilies, &updates](const ShadowTree& shadowTree) {
+          shadowTree.commit(
+              [&surfaceFamilies,
+               &updates](const RootShadowNode& oldRootShadowNode) {
+                return std::static_pointer_cast<RootShadowNode>(
+                    oldRootShadowNode.cloneMultiple(
+                        surfaceFamilies,
+                        [&surfaceFamilies, &updates](
+                            const ShadowNode& shadowNode,
+                            const ShadowNodeFragment& fragment) {
+                          auto newProps =
+                              ShadowNodeFragment::propsPlaceholder();
+                          if (surfaceFamilies.contains(
+                                  &shadowNode.getFamily())) {
+                            auto& animatedProps =
+                                updates.at(shadowNode.getTag());
+                            newProps = cloneProps(animatedProps, shadowNode);
+                          }
+                          return shadowNode.clone(
+                              {.props = newProps,
+                               .children = fragment.children,
+                               .state = shadowNode.getState(),
+                               .runtimeShadowNodeReference = false});
+                        }));
+              },
+              {.mountSynchronously = true});
+        });
+  }
 }
 
 void AnimationBackend::synchronouslyUpdateProps(

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.h

@@ -18,6 +18,18 @@
 
 namespace facebook::react {
 
+class AnimationBackend;
+
+class UIManagerNativeAnimatedDelegateBackendImpl : public UIManagerNativeAnimatedDelegate {
+ public:
+  explicit UIManagerNativeAnimatedDelegateBackendImpl(std::weak_ptr<UIManagerAnimationBackend> animationBackend);
+
+  void runAnimationFrame() override;
+
+ private:
+  std::weak_ptr<UIManagerAnimationBackend> animationBackend_;
+};
+
 struct AnimationMutation {
   Tag tag;
   const ShadowNodeFamily *family;
@@ -47,8 +59,8 @@ class AnimationBackend : public UIManagerAnimationBackend {
       DirectManipulationCallback &&directManipulationCallback,
       FabricCommitCallback &&fabricCommitCallback,
       UIManager *uiManager);
-  void commitUpdatesWithFamilies(
-      const std::unordered_set<const ShadowNodeFamily *> &families,
+  void commitUpdates(
+      const std::unordered_map<SurfaceId, std::unordered_set<const ShadowNodeFamily *>> &surfaceToFamilies,
       std::unordered_map<Tag, AnimatedProps> &updates);
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
 

package/ReactCommon/react/renderer/core/EventDispatcher.cpp

@@ -6,7 +6,7 @@
  */
 
 #include "EventDispatcher.h"
-#include <cxxreact/JSExecutor.h>
+
 #include <react/renderer/core/StateUpdate.h>
 
 #include "EventQueue.h"

package/ReactCommon/react/renderer/core/EventQueueProcessor.cpp

@@ -5,13 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <cxxreact/JSExecutor.h>
+#include "EventQueueProcessor.h"
+
 #include <logger/react_native_log.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+
 #include "EventEmitter.h"
 #include "EventLogger.h"
-#include "EventQueue.h"
-#include "ShadowNodeFamily.h"
 
 namespace facebook::react {
 

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -18,10 +18,10 @@
 #include <jsi/hermes.h>
 #include <jsi/instrumentation.h>
 #include <jsinspector-modern/HostTarget.h>
-#include <jsireact/JSIExecutor.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
+#include <react/runtime/JSRuntimeBindings.h>
 #include <react/timing/primitives.h>
 #include <react/utils/jsi-utils.h>
 #include <iostream>
@@ -48,6 +48,12 @@ std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
   return scheduler;
 }
 
+std::string getSyntheticBundlePath(uint32_t bundleId) {
+  std::array<char, 32> buffer{};
+  std::snprintf(buffer.data(), buffer.size(), "seg-%u.js", bundleId);
+  return buffer.data();
+}
+
 } // namespace
 
 ReactInstance::ReactInstance(
@@ -365,12 +371,8 @@ void ReactInstance::registerSegment(
     }
     LOG(WARNING) << "Starting to evaluate segment " << segmentId
                  << " in ReactInstance::registerSegment";
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     runtime.evaluateJavaScript(
-        std::move(script),
-        JSExecutor::getSyntheticBundlePath(segmentId, segmentPath));
-#pragma clang diagnostic pop
+        std::move(script), getSyntheticBundlePath(segmentId));
     LOG(WARNING) << "Finished evaluating segment " << segmentId
                  << " in ReactInstance::registerSegment";
     if (hasLogger) {

package/ReactCommon/react/runtime/ReactInstance.h

@@ -13,7 +13,6 @@
 #include <jserrorhandler/JsErrorHandler.h>
 #include <jsi/jsi.h>
 #include <jsinspector-modern/ReactCdp.h>
-#include <jsireact/JSIExecutor.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/runtime/BufferedRuntimeExecutor.h>
 #include <react/runtime/JSRuntimeFactory.h>