react-native-tvos 0.81.4-0 → 0.82.0-0

package/ReactCommon/jsinspector-modern/tracing/tests/RuntimeSamplingProfileTraceEventSerializerTest.cpp

@@ -18,9 +18,9 @@ class RuntimeSamplingProfileTraceEventSerializerTest : public ::testing::Test {
  protected:
   std::vector<folly::dynamic> notificationEvents_;
 
-  std::function<void(const folly::dynamic& traceEventsChunk)>
+  std::function<void(folly::dynamic&& traceEventsChunk)>
   createNotificationCallback() {
-    return [this](const folly::dynamic& traceEventsChunk) {
+    return [this](folly::dynamic&& traceEventsChunk) {
       notificationEvents_.push_back(traceEventsChunk);
     };
   }
@@ -49,32 +49,36 @@ class RuntimeSamplingProfileTraceEventSerializerTest : public ::testing::Test {
 
   RuntimeSamplingProfile::Sample createSample(
       uint64_t timestamp,
-      uint64_t threadId,
+      ThreadId threadId,
       std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack) {
     return {timestamp, threadId, std::move(callStack)};
   }
 
   RuntimeSamplingProfile createEmptyProfile() {
-    return {"TestRuntime", {}, {}};
+    return {"TestRuntime", 1, {}, {}};
   }
 
   RuntimeSamplingProfile createProfileWithSamples(
       std::vector<RuntimeSamplingProfile::Sample> samples) {
-    return {"TestRuntime", std::move(samples), {}};
+    return {"TestRuntime", 1, std::move(samples), {}};
   }
 };
 
 TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, EmptyProfile) {
   // Setup
   auto notificationCallback = createNotificationCallback();
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(), notificationCallback, 10);
+  IdGenerator profileIdGenerator;
 
   auto profile = createEmptyProfile();
   auto tracingStartTime = HighResTimeStamp::now();
 
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      10);
 
   // Nothing should be reported if the profile is empty.
   EXPECT_TRUE(notificationEvents_.empty());
@@ -85,8 +89,7 @@ TEST_F(
     SameCallFramesAreMerged) {
   // Setup
   auto notificationCallback = createNotificationCallback();
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(), notificationCallback, 10);
+  IdGenerator profileIdGenerator;
 
   // [     foo     ]
   // [     bar     ]
@@ -108,7 +111,7 @@ TEST_F(
       createJSCallFrame("foo", 1, "test.js", 10, 5),
   };
 
-  uint64_t threadId = 1;
+  ThreadId threadId = 1;
   uint64_t timestamp1 = 1000000;
   uint64_t timestamp2 = 2000000;
   uint64_t timestamp3 = 3000000;
@@ -122,7 +125,12 @@ TEST_F(
   auto tracingStartTime = HighResTimeStamp::now();
 
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      10);
 
   // Verify
   ASSERT_EQ(notificationEvents_.size(), 2);
@@ -135,13 +143,12 @@ TEST_F(
 TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, EmptySample) {
   // Setup
   auto notificationCallback = createNotificationCallback();
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(), notificationCallback, 10);
+  IdGenerator profileIdGenerator;
 
   // Create an empty sample (no call stack)
   std::vector<RuntimeSamplingProfile::SampleCallStackFrame> emptyCallStack;
 
-  uint64_t threadId = 1;
+  ThreadId threadId = 1;
   uint64_t timestamp = 1000000;
 
   auto samples = std::vector<RuntimeSamplingProfile::Sample>{};
@@ -150,12 +157,13 @@ TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, EmptySample) {
 
   auto tracingStartTime = HighResTimeStamp::now();
 
-  // Mock the performance tracer methods
-  folly::dynamic profileEvent = folly::dynamic::object;
-  folly::dynamic chunkEvent = folly::dynamic::object;
-
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      10);
 
   // Verify
   // [["Profile"], ["ProfileChunk"]]
@@ -171,16 +179,15 @@ TEST_F(
     SamplesFromDifferentThreads) {
   // Setup
   auto notificationCallback = createNotificationCallback();
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(), notificationCallback, 10);
+  IdGenerator profileIdGenerator;
 
   // Create samples with different thread IDs
   std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
       createJSCallFrame("foo", 1, "test.js", 10, 5)};
 
   uint64_t timestamp = 1000000;
-  uint64_t threadId1 = 1;
-  uint64_t threadId2 = 2;
+  ThreadId threadId1 = 1;
+  ThreadId threadId2 = 2;
 
   auto samples = std::vector<RuntimeSamplingProfile::Sample>{};
   samples.emplace_back(createSample(timestamp, threadId1, callStack));
@@ -192,13 +199,25 @@ TEST_F(
   auto tracingStartTime = HighResTimeStamp::now();
 
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
-
-  // [["Profile"], ["ProfileChunk", "ProfileChunk", "ProfileChunk]]
-  // Samples from different thread should never be grouped together in the same
-  // chunk.
-  ASSERT_EQ(notificationEvents_.size(), 2);
-  ASSERT_EQ(notificationEvents_[1].size(), 3);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      10);
+
+  /**
+   * [
+   *  ["Profile"],
+   *  ["Profile"],
+   *  ["ProfileChunk" for threadId1, "ProfileChunk" for threadId2]
+   * ]
+   *
+   * Samples from different thread should never be grouped together in the same
+   * chunk.
+   **/
+  ASSERT_EQ(notificationEvents_.size(), 3);
+  ASSERT_EQ(notificationEvents_[2].size(), 2);
 }
 
 TEST_F(
@@ -206,20 +225,16 @@ TEST_F(
     TraceEventChunkSizeLimit) {
   // Setup
   auto notificationCallback = createNotificationCallback();
+  IdGenerator profileIdGenerator;
   uint16_t traceEventChunkSize = 2;
   uint16_t profileChunkSize = 2;
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(),
-      notificationCallback,
-      traceEventChunkSize,
-      profileChunkSize);
 
   // Create multiple samples
   std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
       createJSCallFrame("foo", 1, "test.js", 10, 5)};
 
   uint64_t timestamp = 1000000;
-  uint64_t threadId = 1;
+  ThreadId threadId = 1;
 
   std::vector<RuntimeSamplingProfile::Sample> samples;
   samples.reserve(5);
@@ -231,7 +246,13 @@ TEST_F(
   auto tracingStartTime = HighResTimeStamp::now();
 
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      traceEventChunkSize,
+      profileChunkSize);
 
   // [["Profile"], ["ProfileChunk", "ProfileChunk"], ["ProfileChunk"]]
   ASSERT_EQ(notificationEvents_.size(), 3);
@@ -245,22 +266,18 @@ TEST_F(
 TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, ProfileChunkSizeLimit) {
   // Setup
   auto notificationCallback = createNotificationCallback();
+  IdGenerator profileIdGenerator;
   // Set a small profile chunk size to test profile chunking
   uint16_t traceEventChunkSize = 10;
   uint16_t profileChunkSize = 2;
   double samplesCount = 5;
-  RuntimeSamplingProfileTraceEventSerializer serializer(
-      PerformanceTracer::getInstance(),
-      notificationCallback,
-      traceEventChunkSize,
-      profileChunkSize);
 
   // Create multiple samples
   std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
       createJSCallFrame("foo", 1, "test.js", 10, 5)};
 
   uint64_t timestamp = 1000000;
-  uint64_t threadId = 1;
+  ThreadId threadId = 1;
 
   std::vector<RuntimeSamplingProfile::Sample> samples;
   samples.reserve(samplesCount);
@@ -272,7 +289,13 @@ TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, ProfileChunkSizeLimit) {
   auto tracingStartTime = HighResTimeStamp::now();
 
   // Execute
-  serializer.serializeAndNotify(profile, tracingStartTime);
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      traceEventChunkSize,
+      profileChunkSize);
 
   // [["Profile"], ["ProfileChunk", "ProfileChunk", "ProfileChunk"]]
   ASSERT_EQ(notificationEvents_.size(), 2);
@@ -287,4 +310,51 @@ TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, ProfileChunkSizeLimit) {
   }
 }
 
+TEST_F(RuntimeSamplingProfileTraceEventSerializerTest, UniqueNodesThreshold) {
+  // Setup
+  auto notificationCallback = createNotificationCallback();
+  IdGenerator profileIdGenerator;
+  uint16_t traceEventChunkSize = 10;
+  uint16_t profileChunkSize = 10;
+  uint16_t maxUniqueNodesPerChunk = 3;
+
+  // Create samples with different function names to generate unique nodes
+  ThreadId threadId = 1;
+  uint64_t timestamp = 1000000;
+
+  std::vector<RuntimeSamplingProfile::Sample> samples;
+
+  // In total we would have 8 unique nodes, 5 of which are created here.
+  // Other 3 are (root), (program), (idle).
+  for (int i = 0; i < 5; i++) {
+    std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack = {
+        createJSCallFrame(
+            "function" + std::to_string(i), 1, "test.js", 10 + i, 5)};
+    samples.push_back(createSample(timestamp + i * 1000, threadId, callStack));
+  }
+
+  auto profile = createProfileWithSamples(std::move(samples));
+  auto tracingStartTime = HighResTimeStamp::now();
+
+  // Execute
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(profile),
+      profileIdGenerator,
+      tracingStartTime,
+      notificationCallback,
+      traceEventChunkSize,
+      profileChunkSize,
+      maxUniqueNodesPerChunk);
+
+  // [["Profile"], ["ProfileChunk", "ProfileChunk", "ProfileChunk"]]
+  ASSERT_EQ(notificationEvents_.size(), 2);
+  EXPECT_EQ(notificationEvents_[1].size(), 3);
+
+  // Verify that each chunk respects the unique nodes limit
+  for (auto& profileChunk : notificationEvents_[1]) {
+    auto& nodes = profileChunk["args"]["data"]["cpuProfile"]["nodes"];
+    EXPECT_LE(nodes.size(), maxUniqueNodesPerChunk);
+  }
+}
+
 } // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsitooling/React-jsitooling.podspec

@@ -37,6 +37,7 @@ Pod::Spec.new do |s|
 
   s.dependency "React-cxxreact", version
   s.dependency "React-jsi", version
+  add_dependency(s, "React-debug")
   add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   add_dependency(s, "React-jsinspectorcdp", :framework_name => 'jsinspector_moderncdp')

package/ReactCommon/jsitooling/react/runtime/JSRuntimeFactoryCAPI.cpp

@@ -9,7 +9,7 @@
 #include "JSRuntimeFactory.h"
 
 void js_runtime_factory_destroy(JSRuntimeFactoryRef factory) {
-  if (factory) {
+  if (factory != nullptr) {
     delete static_cast<facebook::react::JSRuntimeFactory*>(factory);
   }
 }

package/ReactCommon/logger/react_native_log.h

@@ -14,20 +14,20 @@ enum ReactNativeLogLevel {
   ReactNativeLogLevelFatal = 4
 };
 
-typedef void (*reactnativelogfunctype)(ReactNativeLogLevel, const char*);
+using reactnativelogfunctype = void (*)(ReactNativeLogLevel, const char*);
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 void set_react_native_logfunc(reactnativelogfunctype newlogfunc);
 
-void react_native_log_info(const char* text);
-void react_native_log_warn(const char* text);
-void react_native_log_error(const char* text);
-void react_native_log_fatal(const char* text);
+void react_native_log_info(const char* message);
+void react_native_log_warn(const char* message);
+void react_native_log_error(const char* message);
+void react_native_log_fatal(const char* message);
 
-void _react_native_log(ReactNativeLogLevel level, const char* text);
-void _react_native_log_default(ReactNativeLogLevel level, const char* text);
+void _react_native_log(ReactNativeLogLevel level, const char* message);
+void _react_native_log_default(ReactNativeLogLevel level, const char* message);
 #ifdef __cplusplus
 }
 #endif // __cpusplus

package/ReactCommon/react/bridging/Class.h

@@ -27,6 +27,11 @@ JSReturnT callFromJs(
       sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
   static_assert(
       (supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
+  if constexpr (std::is_void_v<JSReturnT>) {
+    static_assert(
+        std::is_void_v<ReturnT>,
+        "Method must return void when JSReturnT is void");
+  }
 
   if constexpr (std::is_void_v<JSReturnT>) {
     (instance->*method)(

package/ReactCommon/react/bridging/tests/BridgingTest.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <ReactCommon/TestCallInvoker.h>
 #include <gtest/gtest.h>
 #include <hermes/hermes.h>
 #include <react/bridging/Bridging.h>
@@ -15,34 +16,24 @@
 
 namespace facebook::react {
 
-class TestCallInvoker : public CallInvoker {
+class BridgingTest : public ::testing::Test {
  public:
-  void invokeAsync(CallFunc&& fn) noexcept override {
-    queue_.push_back(std::move(fn));
-  }
-
-  void invokeSync(CallFunc&&) override {
-    FAIL() << "JSCallInvoker does not support invokeSync()";
-  }
-
- private:
-  friend class BridgingTest;
+  BridgingTest(BridgingTest& other) = delete;
+  BridgingTest& operator=(BridgingTest& other) = delete;
+  BridgingTest(BridgingTest&& other) = delete;
+  BridgingTest& operator=(BridgingTest&& other) = delete;
 
-  std::list<CallFunc> queue_;
-};
-
-class BridgingTest : public ::testing::Test {
  protected:
   BridgingTest()
-      : invoker(std::make_shared<TestCallInvoker>()),
-        runtime(hermes::makeHermesRuntime(
+      : runtime(hermes::makeHermesRuntime(
             ::hermes::vm::RuntimeConfig::Builder()
                 // Make promises work with Hermes microtasks.
                 .withMicrotaskQueue(true)
                 .build())),
-        rt(*runtime) {}
+        rt(*runtime),
+        invoker(std::make_shared<TestCallInvoker>(*runtime)) {}
 
-  ~BridgingTest() {
+  ~BridgingTest() override {
     LongLivedObjectCollection::get(rt).clear();
   }
 
@@ -62,16 +53,12 @@ class BridgingTest : public ::testing::Test {
   }
 
   void flushQueue() {
-    while (!invoker->queue_.empty()) {
-      invoker->queue_.front()(*runtime);
-      invoker->queue_.pop_front();
-      rt.drainMicrotasks(); // Run microtasks every cycle.
-    }
+    invoker->flushQueue();
   }
 
-  std::shared_ptr<TestCallInvoker> invoker;
-  std::unique_ptr<jsi::Runtime> runtime;
+  std::shared_ptr<jsi::Runtime> runtime;
   jsi::Runtime& rt;
+  std::shared_ptr<TestCallInvoker> invoker;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/bridging/tests/ClassTest.cpp

@@ -7,33 +7,38 @@
 
 #include "BridgingTest.h"
 
+#include <utility>
+
 namespace facebook::react {
 
 using namespace std::literals;
 
 struct TestClass {
-  TestClass(std::shared_ptr<CallInvoker> invoker) : invoker_(invoker) {}
+  explicit TestClass(std::shared_ptr<CallInvoker> invoker)
+      : invoker_(std::move(invoker)) {}
 
-  double add(jsi::Runtime&, int a, float b) {
+  double add(jsi::Runtime& /*unused*/, int a, float b) {
     return a + b;
   }
 
-  jsi::Object getObject(jsi::Runtime&, jsi::Object obj) {
+  jsi::Object getObject(jsi::Runtime& /*unused*/, jsi::Object obj) {
     return obj;
   }
 
   AsyncPromise<std::string> getPromise(jsi::Runtime& rt, std::string result) {
     auto promise = AsyncPromise<std::string>(rt, invoker_);
-    promise.resolve(result);
+    promise.resolve(std::move(result));
     return promise;
   }
 
-  std::string
-  callFunc(jsi::Runtime&, SyncCallback<std::string(int)> func, int num) {
+  std::string callFunc(
+      jsi::Runtime& /*unused*/,
+      SyncCallback<std::string(int)> func,
+      int num) {
     return func(num);
   }
 
-  void callAsync(jsi::Runtime&, AsyncCallback<> callback) {
+  void callAsync(jsi::Runtime& /*unused*/, const AsyncCallback<>& callback) {
     callback();
   }
 
@@ -69,7 +74,8 @@ TEST_F(BridgingTest, callFromJsTest) {
   then.callWithThis(
       rt,
       promise,
-      bridging::toJs(rt, [&](std::string res) { result = res; }, invoker));
+      bridging::toJs(
+          rt, [&](std::string res) { result = std::move(res); }, invoker));
 
   flushQueue();
   EXPECT_EQ("hi"s, result);

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<<2cabd888b74b84201ff027457efc6007>>
+ * @generated SignedSource<<ce235bb558df2f110e0446e68cf6bc6a>>
  */
 
 /**
@@ -30,8 +30,8 @@ bool ReactNativeFeatureFlags::commonTestFlag() {
   return getAccessor().commonTestFlag();
 }
 
-bool ReactNativeFeatureFlags::animatedShouldSignalBatch() {
-  return getAccessor().animatedShouldSignalBatch();
+bool ReactNativeFeatureFlags::cdpInteractionMetricsEnabled() {
+  return getAccessor().cdpInteractionMetricsEnabled();
 }
 
 bool ReactNativeFeatureFlags::cxxNativeAnimatedEnabled() {
@@ -42,14 +42,18 @@ bool ReactNativeFeatureFlags::cxxNativeAnimatedRemoveJsSync() {
   return getAccessor().cxxNativeAnimatedRemoveJsSync();
 }
 
-bool ReactNativeFeatureFlags::disableMainQueueSyncDispatchIOS() {
-  return getAccessor().disableMainQueueSyncDispatchIOS();
+bool ReactNativeFeatureFlags::disableFabricCommitInCXXAnimated() {
+  return getAccessor().disableFabricCommitInCXXAnimated();
 }
 
 bool ReactNativeFeatureFlags::disableMountItemReorderingAndroid() {
   return getAccessor().disableMountItemReorderingAndroid();
 }
 
+bool ReactNativeFeatureFlags::disableOldAndroidAttachmentMetricsWorkarounds() {
+  return getAccessor().disableOldAndroidAttachmentMetricsWorkarounds();
+}
+
 bool ReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid() {
   return getAccessor().disableTextLayoutManagerCacheAndroid();
 }
@@ -86,6 +90,10 @@ bool ReactNativeFeatureFlags::enableDoubleMeasurementFixAndroid() {
   return getAccessor().enableDoubleMeasurementFixAndroid();
 }
 
+bool ReactNativeFeatureFlags::enableEagerMainQueueModulesOnIOS() {
+  return getAccessor().enableEagerMainQueueModulesOnIOS();
+}
+
 bool ReactNativeFeatureFlags::enableEagerRootViewAttachment() {
   return getAccessor().enableEagerRootViewAttachment();
 }
@@ -98,10 +106,6 @@ bool ReactNativeFeatureFlags::enableFabricRenderer() {
   return getAccessor().enableFabricRenderer();
 }
 
-bool ReactNativeFeatureFlags::enableFixForParentTagDuringReparenting() {
-  return getAccessor().enableFixForParentTagDuringReparenting();
-}
-
 bool ReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout() {
   return getAccessor().enableFontScaleChangesUpdatingLayout();
 }
@@ -114,6 +118,14 @@ bool ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox() {
   return getAccessor().enableIOSViewClipToPaddingBox();
 }
 
+bool ReactNativeFeatureFlags::enableImagePrefetchingAndroid() {
+  return getAccessor().enableImagePrefetchingAndroid();
+}
+
+bool ReactNativeFeatureFlags::enableImmediateUpdateModeForContentOffsetChanges() {
+  return getAccessor().enableImmediateUpdateModeForContentOffsetChanges();
+}
+
 bool ReactNativeFeatureFlags::enableInteropViewManagerClassLookUpOptimizationIOS() {
   return getAccessor().enableInteropViewManagerClassLookUpOptimizationIOS();
 }
@@ -130,10 +142,6 @@ bool ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS() {
   return getAccessor().enableMainQueueCoordinatorOnIOS();
 }
 
-bool ReactNativeFeatureFlags::enableMainQueueModulesOnIOS() {
-  return getAccessor().enableMainQueueModulesOnIOS();
-}
-
 bool ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS() {
   return getAccessor().enableModuleArgumentNSNullConversionIOS();
 }
@@ -162,10 +170,6 @@ bool ReactNativeFeatureFlags::enableResourceTimingAPI() {
   return getAccessor().enableResourceTimingAPI();
 }
 
-bool ReactNativeFeatureFlags::enableSynchronousStateUpdates() {
-  return getAccessor().enableSynchronousStateUpdates();
-}
-
 bool ReactNativeFeatureFlags::enableViewCulling() {
   return getAccessor().enableViewCulling();
 }
@@ -174,6 +178,10 @@ bool ReactNativeFeatureFlags::enableViewRecycling() {
   return getAccessor().enableViewRecycling();
 }
 
+bool ReactNativeFeatureFlags::enableViewRecyclingForScrollView() {
+  return getAccessor().enableViewRecyclingForScrollView();
+}
+
 bool ReactNativeFeatureFlags::enableViewRecyclingForText() {
   return getAccessor().enableViewRecyclingForText();
 }
@@ -194,6 +202,10 @@ bool ReactNativeFeatureFlags::enableVirtualViewWindowFocusDetection() {
   return getAccessor().enableVirtualViewWindowFocusDetection();
 }
 
+bool ReactNativeFeatureFlags::enableWebPerformanceAPIsByDefault() {
+  return getAccessor().enableWebPerformanceAPIsByDefault();
+}
+
 bool ReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact() {
   return getAccessor().fixMappingOfEventPrioritiesBetweenFabricAndReact();
 }
@@ -210,6 +222,10 @@ bool ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS() {
   return getAccessor().hideOffscreenVirtualViewsOnIOS();
 }
 
+bool ReactNativeFeatureFlags::perfMonitorV2Enabled() {
+  return getAccessor().perfMonitorV2Enabled();
+}
+
 double ReactNativeFeatureFlags::preparedTextCacheSize() {
   return getAccessor().preparedTextCacheSize();
 }
@@ -218,6 +234,22 @@ bool ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion() {
   return getAccessor().preventShadowTreeCommitExhaustion();
 }
 
+bool ReactNativeFeatureFlags::releaseImageDataWhenConsumed() {
+  return getAccessor().releaseImageDataWhenConsumed();
+}
+
+bool ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover() {
+  return getAccessor().shouldPressibilityUseW3CPointerEventsForHover();
+}
+
+bool ReactNativeFeatureFlags::skipActivityIdentityAssertionOnHostPause() {
+  return getAccessor().skipActivityIdentityAssertionOnHostPause();
+}
+
+bool ReactNativeFeatureFlags::sweepActiveTouchOnChildNativeGesturesAndroid() {
+  return getAccessor().sweepActiveTouchOnChildNativeGesturesAndroid();
+}
+
 bool ReactNativeFeatureFlags::traceTurboModulePromiseRejectionsOnAndroid() {
   return getAccessor().traceTurboModulePromiseRejectionsOnAndroid();
 }
@@ -266,6 +298,10 @@ bool ReactNativeFeatureFlags::useTurboModules() {
   return getAccessor().useTurboModules();
 }
 
+double ReactNativeFeatureFlags::virtualViewHysteresisRatio() {
+  return getAccessor().virtualViewHysteresisRatio();
+}
+
 double ReactNativeFeatureFlags::virtualViewPrerenderRatio() {
   return getAccessor().virtualViewPrerenderRatio();
 }