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

package/ReactCommon/jsinspector-modern/tests/TracingTest.cpp

@@ -66,7 +66,6 @@ TEST_F(TracingTest, RecordsFrameTimings) {
       1, // id
       11, // threadId
       now,
-      now + HighResDuration::fromNanoseconds(10),
       now + HighResDuration::fromNanoseconds(50));
 
   page_->recordFrameTimings(frameTimingSequence);
@@ -86,12 +85,10 @@ TEST_F(TracingTest, EmitsRecordedFrameTimingSequences) {
           1, // id
           11, // threadId
           now,
-          now + HighResDuration::fromNanoseconds(10),
           now + HighResDuration::fromNanoseconds(50)));
 
   auto allTraceEvents = endTracingAndCollectEvents();
   EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "BeginFrame")));
-  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "Commit")));
   EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "DrawFrame")));
 }
 
@@ -105,7 +102,6 @@ TEST_F(TracingTest, EmitsScreenshotEventWhenScreenshotValuePassed) {
           1, // id
           11, // threadId
           now,
-          now + HighResDuration::fromNanoseconds(10),
           now + HighResDuration::fromNanoseconds(50),
           "base64EncodedScreenshotData"));
 
@@ -113,4 +109,227 @@ TEST_F(TracingTest, EmitsScreenshotEventWhenScreenshotValuePassed) {
   EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "Screenshot")));
 }
 
+TEST_F(
+    TracingTest,
+    SecondSessionTracingStartIsRejectedWhileFirstSessionIsTracing) {
+  auto secondary = connectSecondary();
+  InSequence s;
+
+  // Session 1 starts tracing successfully
+  startTracing();
+
+  // Session 2 tries to start tracing - should get error
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/id", 2),
+          AtJsonPtr("/error/message", "Tracing has already been started")))));
+  secondary.toPage().sendMessage(R"({"id": 2, "method": "Tracing.start"})");
+
+  // Session 1 ends tracing normally
+  endTracingAndCollectEvents();
+
+  // Now Session 2 can start tracing
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 3, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 3, "method": "Tracing.start"})");
+
+  // Clean up - end secondary's tracing
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 4, "result": {}})")));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
+      .Times(AtLeast(1));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.tracingComplete"))));
+  secondary.toPage().sendMessage(R"({"id": 4, "method": "Tracing.end"})");
+}
+
+TEST_F(TracingTest, CDPTracingPreemptsBackgroundTracing) {
+  InSequence s;
+
+  // Start background tracing directly
+  page_->startTracing(tracing::Mode::Background, {});
+
+  // CDP Tracing.start should preempt background (succeed, not fail)
+  startTracing();
+
+  // End tracing normally
+  endTracingAndCollectEvents();
+}
+
+TEST_F(TracingTest, BackgroundTracingIsRejectedWhileCDPTracingIsRunning) {
+  InSequence s;
+
+  // Start CDP tracing
+  startTracing();
+
+  // Background tracing should be rejected
+  bool started = page_->startTracing(tracing::Mode::Background, {});
+  EXPECT_FALSE(started);
+
+  // End CDP tracing
+  endTracingAndCollectEvents();
+
+  // Now background tracing should succeed
+  started = page_->startTracing(tracing::Mode::Background, {});
+  EXPECT_TRUE(started);
+
+  // Clean up
+  page_->stopTracing();
+}
+
+TEST_F(TracingTest, EmitsToAllSessionsWithReactNativeApplicationDomainEnabled) {
+  auto secondaryFusebox = this->connectSecondary();
+  auto secondaryNonFusebox = this->connectSecondary();
+
+  // Enable ReactNativeApplication domain on primary and secondaryFusebox
+  // sessions (but NOT on secondaryNonFusebox)
+  {
+    InSequence s;
+    EXPECT_CALL(
+        this->fromPage(),
+        onMessage(JsonParsed(
+            AtJsonPtr("/method", "ReactNativeApplication.metadataUpdated"))));
+    EXPECT_CALL(
+        this->fromPage(), onMessage(JsonEq(R"({"id": 1, "result": {}})")));
+  }
+  this->toPage_->sendMessage(
+      R"({"id": 1, "method": "ReactNativeApplication.enable"})");
+
+  {
+    InSequence s;
+    EXPECT_CALL(
+        secondaryFusebox.fromPage(),
+        onMessage(JsonParsed(
+            AtJsonPtr("/method", "ReactNativeApplication.metadataUpdated"))));
+    EXPECT_CALL(
+        secondaryFusebox.fromPage(),
+        onMessage(JsonEq(R"({"id": 1, "result": {}})")));
+  }
+  secondaryFusebox.toPage().sendMessage(
+      R"({"id": 1, "method": "ReactNativeApplication.enable"})");
+
+  // Start background tracing
+  this->page_->startTracing(
+      tracing::Mode::Background, {tracing::Category::Timeline});
+
+  // Record some frame timings
+  auto now = HighResTimeStamp::now();
+  this->page_->recordFrameTimings(
+      tracing::FrameTimingSequence(
+          1, // id
+          11, // threadId
+          now,
+          now + HighResDuration::fromNanoseconds(50)));
+
+  // Primary and secondaryFusebox sessions should receive the trace.
+  // Events within each session are ordered, but order between sessions is
+  // arbitrary.
+  Sequence primarySeq;
+  Sequence secondarySeq;
+
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(
+          AtJsonPtr("/method", "ReactNativeApplication.traceRequested"))))
+      .InSequence(primarySeq);
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
+      .Times(AtLeast(1))
+      .InSequence(primarySeq);
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.tracingComplete"))))
+      .InSequence(primarySeq);
+
+  EXPECT_CALL(
+      secondaryFusebox.fromPage(),
+      onMessage(JsonParsed(
+          AtJsonPtr("/method", "ReactNativeApplication.traceRequested"))))
+      .InSequence(secondarySeq);
+  EXPECT_CALL(
+      secondaryFusebox.fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
+      .Times(AtLeast(1))
+      .InSequence(secondarySeq);
+  EXPECT_CALL(
+      secondaryFusebox.fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.tracingComplete"))))
+      .InSequence(secondarySeq);
+
+  // secondaryNonFusebox should NOT receive anything (it did not enable the
+  // domain)
+  EXPECT_CALL(secondaryNonFusebox.fromPage(), onMessage(_)).Times(0);
+
+  // Stop tracing and emit to all eligible sessions
+  EXPECT_TRUE(this->page_->stopAndMaybeEmitBackgroundTrace());
+}
+
+TEST_F(TracingTest, StashedTraceIsEmittedOnlyToFirstEligibleSession) {
+  // Start background tracing with no sessions having ReactNativeApplication
+  // enabled
+  this->page_->startTracing(
+      tracing::Mode::Background, {tracing::Category::Timeline});
+
+  // Record some frame timings
+  auto now = HighResTimeStamp::now();
+  this->page_->recordFrameTimings(
+      tracing::FrameTimingSequence(
+          1, // id
+          11, // threadId
+          now,
+          now + HighResDuration::fromNanoseconds(50)));
+
+  // Stop tracing - no eligible sessions exist, so the trace is stashed
+  EXPECT_FALSE(this->page_->stopAndMaybeEmitBackgroundTrace());
+
+  // Now the primary session enables ReactNativeApplication - it should receive
+  // the stashed trace. Events within a session are ordered.
+  Sequence primarySeq;
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(
+          AtJsonPtr("/method", "ReactNativeApplication.metadataUpdated"))))
+      .InSequence(primarySeq);
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(
+          AtJsonPtr("/method", "ReactNativeApplication.traceRequested"))))
+      .InSequence(primarySeq);
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
+      .Times(AtLeast(1))
+      .InSequence(primarySeq);
+  EXPECT_CALL(
+      this->fromPage(),
+      onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.tracingComplete"))))
+      .InSequence(primarySeq);
+  EXPECT_CALL(this->fromPage(), onMessage(JsonEq(R"({"id": 1, "result": {}})")))
+      .InSequence(primarySeq);
+  this->toPage_->sendMessage(
+      R"({"id": 1, "method": "ReactNativeApplication.enable"})");
+
+  // Connect a secondary session and enable ReactNativeApplication - it should
+  // NOT receive the already-emitted stashed trace
+  auto secondary = this->connectSecondary();
+  Sequence secondarySeq;
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(
+          AtJsonPtr("/method", "ReactNativeApplication.metadataUpdated"))))
+      .InSequence(secondarySeq);
+  // No traceRequested, dataCollected, or tracingComplete expected for
+  // secondary
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 1, "result": {}})")))
+      .InSequence(secondarySeq);
+  secondary.toPage().sendMessage(
+      R"({"id": 1, "method": "ReactNativeApplication.enable"})");
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/WeakListTest.cpp

@@ -70,7 +70,7 @@ TEST(WeakListTest, ForEach) {
   EXPECT_THAT(visited, ElementsAre(1, 3));
 }
 
-TEST(WeakListTest, ElementsAreAliveDuringCallback) {
+TEST(WeakListTest, ElementsAreAliveDuringForEachCallback) {
   WeakList<int> list;
   auto p1 = std::make_shared<int>(1);
   // A separate weak_ptr to observe the lifetime of `p1`.
@@ -88,4 +88,34 @@ TEST(WeakListTest, ElementsAreAliveDuringCallback) {
   EXPECT_THAT(visited, ElementsAre(1));
 }
 
+TEST(WeakListTest, AnyOf) {
+  WeakList<int> list;
+  auto p1 = std::make_shared<int>(1);
+  auto p2 = std::make_shared<int>(2);
+  auto p3 = std::make_shared<int>(3);
+  list.insert(p1);
+  list.insert(p2);
+  list.insert(p3);
+
+  EXPECT_TRUE(list.anyOf([](const int& value) { return value == 2; }));
+  EXPECT_FALSE(list.anyOf([](const int& value) { return value == 4; }));
+}
+
+TEST(WeakListTest, ElementsAreAliveDuringAnyOfCallback) {
+  WeakList<int> list;
+  auto p1 = std::make_shared<int>(42);
+  // A separate weak_ptr to observe the lifetime of `p1`.
+  std::weak_ptr wp1 = p1;
+  list.insert(p1);
+
+  bool result = list.anyOf([&](const int& value) {
+    p1.reset();
+    EXPECT_FALSE(wp1.expired());
+    return value == 42;
+  });
+
+  EXPECT_TRUE(result);
+  EXPECT_TRUE(wp1.expired());
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/engines/JsiIntegrationTestHermesEngineAdapter.cpp

@@ -17,7 +17,7 @@ JsiIntegrationTestHermesEngineAdapter::JsiIntegrationTestHermesEngineAdapter(
                   ::hermes::vm::CompilationMode::ForceLazyCompilation)
               .build())},
       jsExecutor_{jsExecutor},
-      runtimeTargetDelegate_{runtime_} {
+      runtimeTargetDelegate_{runtime_, *runtime_} {
   // NOTE: In React Native, registerForProfiling is called by
   // HermesInstance::unstable_initializeOnJsThread, called from
   // ReactInstance::initializeRuntime. Ideally, we should figure out how to

package/ReactCommon/jsinspector-modern/tracing/FrameTimingSequence.h

@@ -24,15 +24,13 @@ struct FrameTimingSequence {
   FrameTimingSequence(
       FrameSequenceId id,
       ThreadId threadId,
-      HighResTimeStamp beginDrawingTimestamp,
-      HighResTimeStamp commitTimestamp,
-      HighResTimeStamp endDrawingTimestamp,
+      HighResTimeStamp beginTimestamp,
+      HighResTimeStamp endTimestamp,
       std::optional<std::string> screenshot = std::nullopt)
       : id(id),
         threadId(threadId),
-        beginDrawingTimestamp(beginDrawingTimestamp),
-        commitTimestamp(commitTimestamp),
-        endDrawingTimestamp(endDrawingTimestamp),
+        beginTimestamp(beginTimestamp),
+        endTimestamp(endTimestamp),
         screenshot(std::move(screenshot))
   {
   }
@@ -47,9 +45,8 @@ struct FrameTimingSequence {
    */
   ThreadId threadId;
 
-  HighResTimeStamp beginDrawingTimestamp;
-  HighResTimeStamp commitTimestamp;
-  HighResTimeStamp endDrawingTimestamp;
+  HighResTimeStamp beginTimestamp;
+  HighResTimeStamp endTimestamp;
 
   /**
    * Optional screenshot data (base64 encoded) captured during the frame.

package/ReactCommon/jsinspector-modern/tracing/HostTracingProfileSerializer.cpp

@@ -106,19 +106,17 @@ constexpr int FALLBACK_LAYER_TREE_ID = 1;
       chunk = generateNewChunk(chunkSize);
     }
 
-    auto [beginDrawingEvent, commitEvent, endDrawingEvent] =
+    auto [beginDrawingEvent, endDrawingEvent] =
         TraceEventGenerator::createFrameTimingsEvents(
             frameTimingSequence.id,
             FALLBACK_LAYER_TREE_ID,
-            frameTimingSequence.beginDrawingTimestamp,
-            frameTimingSequence.commitTimestamp,
-            frameTimingSequence.endDrawingTimestamp,
+            frameTimingSequence.beginTimestamp,
+            frameTimingSequence.endTimestamp,
             processId,
             frameTimingSequence.threadId);
 
     chunk.push_back(
         TraceEventSerializer::serialize(std::move(beginDrawingEvent)));
-    chunk.push_back(TraceEventSerializer::serialize(std::move(commitEvent)));
     chunk.push_back(
         TraceEventSerializer::serialize(std::move(endDrawingEvent)));
 
@@ -127,7 +125,7 @@ constexpr int FALLBACK_LAYER_TREE_ID = 1;
           frameTimingSequence.id,
           FALLBACK_LAYER_TREE_ID,
           std::move(frameTimingSequence.screenshot.value()),
-          frameTimingSequence.endDrawingTimestamp,
+          frameTimingSequence.endTimestamp,
           processId,
           frameTimingSequence.threadId);
 

package/ReactCommon/jsinspector-modern/tracing/TraceEventGenerator.cpp

@@ -32,13 +32,12 @@ namespace facebook::react::jsinspector_modern::tracing {
   };
 }
 
-/* static */ std::tuple<TraceEvent, TraceEvent, TraceEvent>
+/* static */ std::pair<TraceEvent, TraceEvent>
 TraceEventGenerator::createFrameTimingsEvents(
     uint64_t sequenceId,
     int layerTreeId,
-    HighResTimeStamp beginDrawingTimestamp,
-    HighResTimeStamp commitTimestamp,
-    HighResTimeStamp endDrawingTimestamp,
+    HighResTimeStamp beginTimestamp,
+    HighResTimeStamp endTimestamp,
     ProcessId processId,
     ThreadId threadId) {
   folly::dynamic args = folly::dynamic::object("frameSeqId", sequenceId)(
@@ -48,17 +47,7 @@ TraceEventGenerator::createFrameTimingsEvents(
       .name = "BeginFrame",
       .cat = {Category::Frame},
       .ph = 'I',
-      .ts = beginDrawingTimestamp,
-      .pid = processId,
-      .s = 't',
-      .tid = threadId,
-      .args = args,
-  };
-  auto commitEvent = TraceEvent{
-      .name = "Commit",
-      .cat = {Category::Frame},
-      .ph = 'I',
-      .ts = commitTimestamp,
+      .ts = beginTimestamp,
       .pid = processId,
       .s = 't',
       .tid = threadId,
@@ -68,14 +57,14 @@ TraceEventGenerator::createFrameTimingsEvents(
       .name = "DrawFrame",
       .cat = {Category::Frame},
       .ph = 'I',
-      .ts = endDrawingTimestamp,
+      .ts = endTimestamp,
       .pid = processId,
       .s = 't',
       .tid = threadId,
       .args = args,
   };
 
-  return {std::move(beginEvent), std::move(commitEvent), std::move(drawEvent)};
+  return {std::move(beginEvent), std::move(drawEvent)};
 }
 
 /* static */ TraceEvent TraceEventGenerator::createScreenshotEvent(

package/ReactCommon/jsinspector-modern/tracing/TraceEventGenerator.h

@@ -12,7 +12,7 @@
 #include <jsinspector-modern/tracing/FrameTimingSequence.h>
 #include <react/timing/primitives.h>
 
-#include <tuple>
+#include <utility>
 
 namespace facebook::react::jsinspector_modern::tracing {
 
@@ -35,12 +35,11 @@ class TraceEventGenerator {
   /**
    * Creates canonical "BeginFrame", "Commit", "DrawFrame" trace events.
    */
-  static std::tuple<TraceEvent, TraceEvent, TraceEvent> createFrameTimingsEvents(
+  static std::pair<TraceEvent, TraceEvent> createFrameTimingsEvents(
       FrameSequenceId sequenceId,
       int layerTreeId,
-      HighResTimeStamp beginDrawingTimestamp,
-      HighResTimeStamp commitTimestamp,
-      HighResTimeStamp endDrawingTimestamp,
+      HighResTimeStamp beginTimestamp,
+      HighResTimeStamp endTimestamp,
       ProcessId processId,
       ThreadId threadId);
 

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.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<<3d71ee2b906dcc1313428185cbe853f8>>
+ * @generated SignedSource<<08a361f2ffac6a0496adac1d4c3e4726>>
  */
 
 /**
@@ -38,6 +38,10 @@ bool ReactNativeFeatureFlags::cxxNativeAnimatedEnabled() {
   return getAccessor().cxxNativeAnimatedEnabled();
 }
 
+bool ReactNativeFeatureFlags::defaultTextToOverflowHidden() {
+  return getAccessor().defaultTextToOverflowHidden();
+}
+
 bool ReactNativeFeatureFlags::disableEarlyViewCommandExecution() {
   return getAccessor().disableEarlyViewCommandExecution();
 }
@@ -50,10 +54,6 @@ bool ReactNativeFeatureFlags::disableMountItemReorderingAndroid() {
   return getAccessor().disableMountItemReorderingAndroid();
 }
 
-bool ReactNativeFeatureFlags::disableOldAndroidAttachmentMetricsWorkarounds() {
-  return getAccessor().disableOldAndroidAttachmentMetricsWorkarounds();
-}
-
 bool ReactNativeFeatureFlags::disableSubviewClippingAndroid() {
   return getAccessor().disableSubviewClippingAndroid();
 }
@@ -118,6 +118,10 @@ bool ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid() {
   return getAccessor().enableExclusivePropsUpdateAndroid();
 }
 
+bool ReactNativeFeatureFlags::enableFabricCommitBranching() {
+  return getAccessor().enableFabricCommitBranching();
+}
+
 bool ReactNativeFeatureFlags::enableFabricLogs() {
   return getAccessor().enableFabricLogs();
 }
@@ -238,16 +242,8 @@ bool ReactNativeFeatureFlags::enableVirtualViewDebugFeatures() {
   return getAccessor().enableVirtualViewDebugFeatures();
 }
 
-bool ReactNativeFeatureFlags::enableVirtualViewRenderState() {
-  return getAccessor().enableVirtualViewRenderState();
-}
-
-bool ReactNativeFeatureFlags::enableVirtualViewWindowFocusDetection() {
-  return getAccessor().enableVirtualViewWindowFocusDetection();
-}
-
-bool ReactNativeFeatureFlags::enableWebPerformanceAPIsByDefault() {
-  return getAccessor().enableWebPerformanceAPIsByDefault();
+bool ReactNativeFeatureFlags::fixFindShadowNodeByTagRaceCondition() {
+  return getAccessor().fixFindShadowNodeByTagRaceCondition();
 }
 
 bool ReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact() {
@@ -298,22 +294,6 @@ bool ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover() {
   return getAccessor().shouldPressibilityUseW3CPointerEventsForHover();
 }
 
-bool ReactNativeFeatureFlags::shouldResetClickableWhenRecyclingView() {
-  return getAccessor().shouldResetClickableWhenRecyclingView();
-}
-
-bool ReactNativeFeatureFlags::shouldResetOnClickListenerWhenRecyclingView() {
-  return getAccessor().shouldResetOnClickListenerWhenRecyclingView();
-}
-
-bool ReactNativeFeatureFlags::shouldSetEnabledBasedOnAccessibilityState() {
-  return getAccessor().shouldSetEnabledBasedOnAccessibilityState();
-}
-
-bool ReactNativeFeatureFlags::shouldSetIsClickableByDefault() {
-  return getAccessor().shouldSetIsClickableByDefault();
-}
-
 bool ReactNativeFeatureFlags::shouldTriggerResponderTransferOnScrollAndroid() {
   return getAccessor().shouldTriggerResponderTransferOnScrollAndroid();
 }
@@ -322,6 +302,10 @@ bool ReactNativeFeatureFlags::skipActivityIdentityAssertionOnHostPause() {
   return getAccessor().skipActivityIdentityAssertionOnHostPause();
 }
 
+bool ReactNativeFeatureFlags::syncAndroidClipToPaddingWithOverflow() {
+  return getAccessor().syncAndroidClipToPaddingWithOverflow();
+}
+
 bool ReactNativeFeatureFlags::traceTurboModulePromiseRejectionsOnAndroid() {
   return getAccessor().traceTurboModulePromiseRejectionsOnAndroid();
 }
@@ -330,6 +314,10 @@ bool ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit() {
   return getAccessor().updateRuntimeShadowNodeReferencesOnCommit();
 }
 
+bool ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommitThread() {
+  return getAccessor().updateRuntimeShadowNodeReferencesOnCommitThread();
+}
+
 bool ReactNativeFeatureFlags::useAlwaysAvailableJSErrorHandling() {
   return getAccessor().useAlwaysAvailableJSErrorHandling();
 }
@@ -342,12 +330,8 @@ bool ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode() {
   return getAccessor().useNativeViewConfigsInBridgelessMode();
 }
 
-bool ReactNativeFeatureFlags::useRawPropsJsiValue() {
-  return getAccessor().useRawPropsJsiValue();
-}
-
-bool ReactNativeFeatureFlags::useShadowNodeStateOnClone() {
-  return getAccessor().useShadowNodeStateOnClone();
+bool ReactNativeFeatureFlags::useNestedScrollViewAndroid() {
+  return getAccessor().useNestedScrollViewAndroid();
 }
 
 bool ReactNativeFeatureFlags::useSharedAnimatedBackend() {
@@ -366,12 +350,16 @@ bool ReactNativeFeatureFlags::useTurboModules() {
   return getAccessor().useTurboModules();
 }
 
+bool ReactNativeFeatureFlags::useUnorderedMapInDifferentiator() {
+  return getAccessor().useUnorderedMapInDifferentiator();
+}
+
 double ReactNativeFeatureFlags::viewCullingOutsetRatio() {
   return getAccessor().viewCullingOutsetRatio();
 }
 
-double ReactNativeFeatureFlags::virtualViewHysteresisRatio() {
-  return getAccessor().virtualViewHysteresisRatio();
+bool ReactNativeFeatureFlags::viewTransitionEnabled() {
+  return getAccessor().viewTransitionEnabled();
 }
 
 double ReactNativeFeatureFlags::virtualViewPrerenderRatio() {