react-native-tvos 0.75.2-0rc1 → 0.76.0-0rc0

package/ReactCommon/jsinspector-modern/tests/InspectorMocks.h

@@ -127,6 +127,12 @@ class MockHostTargetDelegate : public HostTargetDelegate {
       onSetPausedInDebuggerMessage,
       (const OverlaySetPausedInDebuggerMessageRequest& request),
       (override));
+  MOCK_METHOD(
+      void,
+      loadNetworkResource,
+      (const LoadNetworkResourceRequest& params,
+       ScopedExecutor<NetworkRequestListener> executor),
+      (override));
 };
 
 class MockInstanceTargetDelegate : public InstanceTargetDelegate {};

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

@@ -199,34 +199,51 @@ TEST_F(InspectorPackagerConnectionTest, TestGetPages) {
       "event": "getPages"
     })");
 
-  auto pageId = getInspectorInstance().addPage(
-      "mock-title",
+  auto pageId1 = getInspectorInstance().addPage(
+      "mock-title-1",
+      "mock-vm",
+      localConnections_
+          .lazily_make_unique<std::unique_ptr<IRemoteConnection>>(),
+      {.nativePageReloads = true});
+
+  auto pageId2 = getInspectorInstance().addPage(
+      "mock-title-2",
       "mock-vm",
       localConnections_
           .lazily_make_unique<std::unique_ptr<IRemoteConnection>>(),
       {.nativePageReloads = true});
 
-  // getPages now reports the page we registered.
+  // getPages now reports the page we registered, in the order added
   EXPECT_CALL(
       *webSockets_[0],
       send(JsonParsed(AllOf(
           AtJsonPtr("/event", Eq("getPages")),
           AtJsonPtr(
               "/payload",
-              ElementsAreArray({AllOf(
-                  AtJsonPtr("/app", Eq("my-app")),
-                  AtJsonPtr("/title", Eq("mock-title [C++ connection]")),
-                  AtJsonPtr("/id", Eq(std::to_string(pageId))),
-                  AtJsonPtr("/capabilities/nativePageReloads", Eq(true)),
-                  AtJsonPtr(
-                      "/capabilities/nativeSourceCodeFetching",
-                      Eq(false)))}))))))
+              ElementsAreArray(
+                  {AllOf(
+                       AtJsonPtr("/app", Eq("my-app")),
+                       AtJsonPtr("/title", Eq("mock-title-1 [C++ connection]")),
+                       AtJsonPtr("/id", Eq(std::to_string(pageId1))),
+                       AtJsonPtr("/capabilities/nativePageReloads", Eq(true)),
+                       AtJsonPtr(
+                           "/capabilities/nativeSourceCodeFetching",
+                           Eq(false))),
+                   AllOf(
+                       AtJsonPtr("/app", Eq("my-app")),
+                       AtJsonPtr("/title", Eq("mock-title-2 [C++ connection]")),
+                       AtJsonPtr("/id", Eq(std::to_string(pageId2))),
+                       AtJsonPtr("/capabilities/nativePageReloads", Eq(true)),
+                       AtJsonPtr(
+                           "/capabilities/nativeSourceCodeFetching",
+                           Eq(false)))}))))))
       .RetiresOnSaturation();
   webSockets_[0]->getDelegate().didReceiveMessage(R"({
       "event": "getPages"
     })");
 
-  getInspectorInstance().removePage(pageId);
+  getInspectorInstance().removePage(pageId1);
+  getInspectorInstance().removePage(pageId2);
 
   // getPages is back to reporting no pages.
   EXPECT_CALL(

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

@@ -530,6 +530,44 @@ TYPED_TEST(JsiIntegrationHermesTest, EvaluateExpressionInExecutionContext) {
       std::to_string(executionContextId)));
 }
 
+TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterEval) {
+  this->connect();
+
+  InSequence s;
+
+  this->expectMessageFromPage(JsonEq(R"({
+                                         "id": 1,
+                                         "result": {}
+                                       })"));
+  this->toPage_->sendMessage(R"({
+                                 "id": 1,
+                                 "method": "Debugger.enable"
+                               })");
+
+  auto scriptInfo = this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Debugger.scriptParsed"),
+      AtJsonPtr("/params/url", "breakpointTest.js"))));
+  this->eval(R"( // line 0
+    globalThis.foo = function() { // line 1
+      Date.now(); // line 2
+    };
+    //# sourceURL=breakpointTest.js
+  )");
+  ASSERT_TRUE(scriptInfo->has_value());
+
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/id", 2),
+      AtJsonPtr("/result/locations/0/lineNumber", 2),
+      AtJsonPtr(
+          "/result/locations/0/scriptId",
+          scriptInfo->value()["params"]["scriptId"]))));
+  this->toPage_->sendMessage(R"({
+                                 "id": 2,
+                                 "method": "Debugger.setBreakpointByUrl",
+                                 "params": {"lineNumber": 2, "url": "breakpointTest.js"}
+                               })");
+}
+
 TYPED_TEST(JsiIntegrationHermesTest, ResolveBreakpointAfterReload) {
   this->connect();
 

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

@@ -51,7 +51,8 @@ void ReactInstanceIntegrationTest::SetUp() {
 
   auto jsRuntimeFactory = std::make_unique<react::HermesInstance>();
   std::unique_ptr<react::JSRuntime> runtime_ =
-      jsRuntimeFactory->createJSRuntime(nullptr, nullptr, messageQueueThread);
+      jsRuntimeFactory->createJSRuntime(
+          nullptr, nullptr, messageQueueThread, false);
   jsi::Runtime* jsiRuntime = &runtime_->getRuntime();
 
   // Error handler:

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

@@ -0,0 +1,214 @@
+/*
+ * 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 <folly/executors/QueuedImmediateExecutor.h>
+
+#include "JsiIntegrationTest.h"
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+class RuntimeTargetDebuggerSessionObserverTest
+    : public JsiIntegrationPortableTestBase<
+          JsiIntegrationTestHermesEngineAdapter,
+          folly::QueuedImmediateExecutor> {
+ public:
+  void enableRuntimeDomain() {
+    InSequence s;
+
+    auto executionContextInfo = expectMessageFromPage(JsonParsed(
+        AllOf(AtJsonPtr("/method", "Runtime.executionContextCreated"))));
+    expectMessageFromPage(JsonEq(R"({
+                                        "id": 1,
+                                        "result": {}
+                                    })"));
+    toPage_->sendMessage(R"({
+                                "id": 1,
+                                "method": "Runtime.enable"
+                            })");
+  }
+
+  void enableLogDomain() {
+    InSequence s;
+
+    EXPECT_CALL(
+        fromPage(),
+        onMessage(JsonParsed(AllOf(
+            AtJsonPtr("/method", "Log.entryAdded"),
+            AtJsonPtr("/params/entry", Not(IsEmpty()))))))
+        .Times(AtLeast(1));
+    expectMessageFromPage(JsonEq(R"({
+                                        "id": 1,
+                                        "result": {}
+                                    })"));
+    toPage_->sendMessage(R"({
+                                "id": 1,
+                                "method": "Log.enable"
+                            })");
+  }
+
+  void disableRuntimeDomain() {
+    InSequence s;
+    expectMessageFromPage(JsonEq(R"({
+                                        "id": 1,
+                                        "result": {}
+                                    })"));
+    toPage_->sendMessage(R"({
+                                "id": 1,
+                                "method": "Runtime.disable"
+                            })");
+  }
+
+  void disableLogDomain() {
+    InSequence s;
+    expectMessageFromPage(JsonEq(R"({
+                                        "id": 1,
+                                        "result": {}
+                                    })"));
+    toPage_->sendMessage(R"({
+                                "id": 1,
+                                "method": "Log.disable"
+                            })");
+  }
+};
+
+TEST_F(
+    RuntimeTargetDebuggerSessionObserverTest,
+    InstallsGlobalObserverObjectByDefault) {
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_THAT(
+      eval("JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__ != null)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+}
+
+TEST_F(
+    RuntimeTargetDebuggerSessionObserverTest,
+    WillNotEmitStatusUpdateUnlessBothRuntimeAndLogDomainsAreEnabled) {
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+
+  connect();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+
+  enableRuntimeDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+
+  enableLogDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+}
+
+TEST_F(
+    RuntimeTargetDebuggerSessionObserverTest,
+    UpdatesTheStatusOnceOneRuntimeDomainIsDisabled) {
+  auto& runtime = engineAdapter_->getRuntime();
+  connect();
+  enableLogDomain();
+  enableRuntimeDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+
+  disableRuntimeDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+}
+
+TEST_F(
+    RuntimeTargetDebuggerSessionObserverTest,
+    UpdatesTheStatusOnceOneLogDomainIsDisabled) {
+  auto& runtime = engineAdapter_->getRuntime();
+  connect();
+  enableLogDomain();
+  enableRuntimeDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+
+  disableLogDomain();
+
+  EXPECT_THAT(
+      eval(
+          "JSON.stringify(globalThis.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+}
+
+TEST_F(
+    RuntimeTargetDebuggerSessionObserverTest,
+    NotifiesSubscribersWhichWereSubscribedBeforeSessionInitialization) {
+  auto& runtime = engineAdapter_->getRuntime();
+
+  eval(
+      "globalThis.__DEBUGGER_SESSION_OBSERVER__.subscribers.add(updatedStatus => (globalThis.__LOREM_IPSUM__ = updatedStatus))");
+
+  EXPECT_THAT(
+      eval("JSON.stringify(globalThis.__LOREM_IPSUM__ === undefined)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+
+  connect();
+  enableLogDomain();
+  enableRuntimeDomain();
+
+  EXPECT_THAT(
+      eval("JSON.stringify(globalThis.__LOREM_IPSUM__)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(true)"));
+
+  disableLogDomain();
+
+  EXPECT_THAT(
+      eval("JSON.stringify(globalThis.__LOREM_IPSUM__)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(R"(false)"));
+}
+
+} // namespace facebook::react::jsinspector_modern

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

@@ -0,0 +1,58 @@
+/*
+ * 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 <jsinspector-modern/Utf8.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+TEST(Utf8Test, TruncateToValidUtf8) {
+  auto buffer = std::vector<char>();
+  std::vector<std::pair<std::string, size_t>> expectedStringsUpToSizes;
+  // Construct a buffer with a concatenation of all code points, and a vector
+  // or "expectedStringsUpToSizes", pairs of valid UTF8 prefix strings and sizes
+  // "n" such that the string would be the expected truncation of the first "n"
+  // bytes of the buffer.
+  for (const std::string& codePoint : {
+           "a", // 1 byte
+           "é", // 2 bytes
+           "✓", // 3 bytes
+           "😀" // 4 bytes
+       }) {
+    auto partial = std::string(buffer.data(), buffer.size());
+    buffer.insert(buffer.end(), codePoint.begin(), codePoint.end());
+    expectedStringsUpToSizes.push_back(std::pair(partial, buffer.size()));
+  }
+  // The constructed buffer is 10 bytes long, comprised of 4 code points of
+  // varied size. Range over naive slices of length 0-9 ensuring that the
+  // truncated result matches the valid UTF8 substring of length <= n.
+  size_t n = 0;
+  for (const auto& expectedStringUpToSize : expectedStringsUpToSizes) {
+    auto nextSize = expectedStringUpToSize.second;
+    auto expectedString = expectedStringUpToSize.first;
+    for (; n < nextSize; ++n) {
+      // Take the first n bytes of the whole buffer, which may be slicing
+      // through the middle of a code point.
+      std::vector<char> slice(buffer.begin(), buffer.begin() + n);
+      truncateToValidUTF8(slice);
+      // Expect the final code point fragment has been discarded and that the
+      // contents are equal to expectedString, which is valid UTF8.
+      EXPECT_EQ(std::string(slice.begin(), slice.end()), expectedString);
+    }
+  }
+  // Finally verify that truncating the whole buffer, which is already valid
+  // UTF8, is a no-op.
+  auto wholeString = std::string(buffer.begin(), buffer.end());
+  truncateToValidUTF8(buffer);
+  EXPECT_EQ(std::string(buffer.begin(), buffer.end()), wholeString);
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/logger/CMakeLists.txt

@@ -9,7 +9,7 @@ set(CMAKE_VERBOSE_MAKEFILE on)
 add_compile_options(-fexceptions)
 
 file(GLOB logger_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(logger STATIC ${logger_SRC})
+add_library(logger OBJECT ${logger_SRC})
 
 target_include_directories(logger PUBLIC .)
 

package/ReactCommon/react/bridging/Bool.h

@@ -13,7 +13,7 @@ namespace facebook::react {
 
 template <>
 struct Bridging<bool> {
-  static bool fromJs(jsi::Runtime& rt, const jsi::Value& value) {
+  static bool fromJs(jsi::Runtime&, const jsi::Value& value) {
     return value.asBool();
   }
 

package/ReactCommon/react/bridging/CMakeLists.txt

@@ -16,7 +16,7 @@ add_compile_options(
 
 file(GLOB react_bridging_SRC CONFIGURE_DEPENDS *.cpp)
 
-add_library(react_bridging STATIC ${react_bridging_SRC})
+add_library(react_bridging OBJECT ${react_bridging_SRC})
 
 target_include_directories(react_bridging PUBLIC ${REACT_COMMON_DIR})
 

package/ReactCommon/react/config/CMakeLists.txt

@@ -15,6 +15,6 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_config_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_config STATIC ${react_config_SRC})
+add_library(react_config OBJECT ${react_config_SRC})
 
 target_include_directories(react_config PUBLIC ${REACT_COMMON_DIR})

package/ReactCommon/react/config/ReactNativeConfig.cpp

@@ -10,9 +10,6 @@
 namespace facebook::react {
 
 bool EmptyReactNativeConfig::getBool(const std::string& param) const {
-  if (param == "react_fabric:enabled_layout_animations_ios") {
-    return true;
-  }
   if (param == "react_fabric:enabled_automatic_interop_android") {
     return true;
   }

package/ReactCommon/react/debug/CMakeLists.txt

@@ -16,7 +16,7 @@ add_compile_options(
 
 
 file(GLOB react_debug_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_debug SHARED ${react_debug_SRC})
+add_library(react_debug OBJECT ${react_debug_SRC})
 
 target_include_directories(react_debug PUBLIC ${REACT_COMMON_DIR})
 

package/ReactCommon/react/featureflags/CMakeLists.txt

@@ -15,6 +15,6 @@ add_compile_options(
         -DLOG_TAG=\"ReactNative\")
 
 file(GLOB react_featureflags_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_featureflags SHARED ${react_featureflags_SRC})
+add_library(react_featureflags OBJECT ${react_featureflags_SRC})
 
 target_include_directories(react_featureflags PUBLIC ${REACT_COMMON_DIR})

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<<ec12fd62d1dc2109e52a95094d7ad167>>
+ * @generated SignedSource<<6139aa47aac3e5682a453a416bc10236>>
  */
 
 /**
@@ -25,10 +25,6 @@ bool ReactNativeFeatureFlags::commonTestFlag() {
   return getAccessor().commonTestFlag();
 }
 
-bool ReactNativeFeatureFlags::allowCollapsableChildren() {
-  return getAccessor().allowCollapsableChildren();
-}
-
 bool ReactNativeFeatureFlags::allowRecursiveCommitsWithSynchronousMountOnAndroid() {
   return getAccessor().allowRecursiveCommitsWithSynchronousMountOnAndroid();
 }
@@ -37,26 +33,74 @@ bool ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop() {
   return getAccessor().batchRenderingUpdatesInEventLoop();
 }
 
+bool ReactNativeFeatureFlags::completeReactInstanceCreationOnBgThreadOnAndroid() {
+  return getAccessor().completeReactInstanceCreationOnBgThreadOnAndroid();
+}
+
 bool ReactNativeFeatureFlags::destroyFabricSurfacesInReactInstanceManager() {
   return getAccessor().destroyFabricSurfacesInReactInstanceManager();
 }
 
-bool ReactNativeFeatureFlags::enableBackgroundExecutor() {
-  return getAccessor().enableBackgroundExecutor();
+bool ReactNativeFeatureFlags::enableAlignItemsBaselineOnFabricIOS() {
+  return getAccessor().enableAlignItemsBaselineOnFabricIOS();
+}
+
+bool ReactNativeFeatureFlags::enableAndroidMixBlendModeProp() {
+  return getAccessor().enableAndroidMixBlendModeProp();
+}
+
+bool ReactNativeFeatureFlags::enableBackgroundStyleApplicator() {
+  return getAccessor().enableBackgroundStyleApplicator();
 }
 
 bool ReactNativeFeatureFlags::enableCleanTextInputYogaNode() {
   return getAccessor().enableCleanTextInputYogaNode();
 }
 
+bool ReactNativeFeatureFlags::enableEagerRootViewAttachment() {
+  return getAccessor().enableEagerRootViewAttachment();
+}
+
+bool ReactNativeFeatureFlags::enableEventEmitterRetentionDuringGesturesOnAndroid() {
+  return getAccessor().enableEventEmitterRetentionDuringGesturesOnAndroid();
+}
+
+bool ReactNativeFeatureFlags::enableFabricLogs() {
+  return getAccessor().enableFabricLogs();
+}
+
+bool ReactNativeFeatureFlags::enableFabricRendererExclusively() {
+  return getAccessor().enableFabricRendererExclusively();
+}
+
 bool ReactNativeFeatureFlags::enableGranularShadowTreeStateReconciliation() {
   return getAccessor().enableGranularShadowTreeStateReconciliation();
 }
 
+bool ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox() {
+  return getAccessor().enableIOSViewClipToPaddingBox();
+}
+
+bool ReactNativeFeatureFlags::enableLayoutAnimationsOnIOS() {
+  return getAccessor().enableLayoutAnimationsOnIOS();
+}
+
+bool ReactNativeFeatureFlags::enableLongTaskAPI() {
+  return getAccessor().enableLongTaskAPI();
+}
+
 bool ReactNativeFeatureFlags::enableMicrotasks() {
   return getAccessor().enableMicrotasks();
 }
 
+bool ReactNativeFeatureFlags::enablePropsUpdateReconciliationAndroid() {
+  return getAccessor().enablePropsUpdateReconciliationAndroid();
+}
+
+bool ReactNativeFeatureFlags::enableReportEventPaintTime() {
+  return getAccessor().enableReportEventPaintTime();
+}
+
 bool ReactNativeFeatureFlags::enableSynchronousStateUpdates() {
   return getAccessor().enableSynchronousStateUpdates();
 }
@@ -65,8 +109,32 @@ bool ReactNativeFeatureFlags::enableUIConsistency() {
   return getAccessor().enableUIConsistency();
 }
 
-bool ReactNativeFeatureFlags::fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak() {
-  return getAccessor().fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak();
+bool ReactNativeFeatureFlags::enableViewRecycling() {
+  return getAccessor().enableViewRecycling();
+}
+
+bool ReactNativeFeatureFlags::excludeYogaFromRawProps() {
+  return getAccessor().excludeYogaFromRawProps();
+}
+
+bool ReactNativeFeatureFlags::fetchImagesInViewPreallocation() {
+  return getAccessor().fetchImagesInViewPreallocation();
+}
+
+bool ReactNativeFeatureFlags::fixIncorrectScrollViewStateUpdateOnAndroid() {
+  return getAccessor().fixIncorrectScrollViewStateUpdateOnAndroid();
+}
+
+bool ReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact() {
+  return getAccessor().fixMappingOfEventPrioritiesBetweenFabricAndReact();
+}
+
+bool ReactNativeFeatureFlags::fixMissedFabricStateUpdatesOnAndroid() {
+  return getAccessor().fixMissedFabricStateUpdatesOnAndroid();
+}
+
+bool ReactNativeFeatureFlags::fixMountingCoordinatorReportedPendingTransactionsOnAndroid() {
+  return getAccessor().fixMountingCoordinatorReportedPendingTransactionsOnAndroid();
 }
 
 bool ReactNativeFeatureFlags::forceBatchingMountItemsOnAndroid() {
@@ -81,18 +149,30 @@ bool ReactNativeFeatureFlags::fuseboxEnabledRelease() {
   return getAccessor().fuseboxEnabledRelease();
 }
 
+bool ReactNativeFeatureFlags::initEagerTurboModulesOnNativeModulesQueueAndroid() {
+  return getAccessor().initEagerTurboModulesOnNativeModulesQueueAndroid();
+}
+
 bool ReactNativeFeatureFlags::lazyAnimationCallbacks() {
   return getAccessor().lazyAnimationCallbacks();
 }
 
-bool ReactNativeFeatureFlags::preventDoubleTextMeasure() {
-  return getAccessor().preventDoubleTextMeasure();
+bool ReactNativeFeatureFlags::loadVectorDrawablesOnImages() {
+  return getAccessor().loadVectorDrawablesOnImages();
 }
 
 bool ReactNativeFeatureFlags::setAndroidLayoutDirection() {
   return getAccessor().setAndroidLayoutDirection();
 }
 
+bool ReactNativeFeatureFlags::traceTurboModulePromiseRejectionsOnAndroid() {
+  return getAccessor().traceTurboModulePromiseRejectionsOnAndroid();
+}
+
+bool ReactNativeFeatureFlags::useFabricInterop() {
+  return getAccessor().useFabricInterop();
+}
+
 bool ReactNativeFeatureFlags::useImmediateExecutorInAndroidBridgeless() {
   return getAccessor().useImmediateExecutorInAndroidBridgeless();
 }
@@ -105,6 +185,18 @@ bool ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode() {
   return getAccessor().useNativeViewConfigsInBridgelessMode();
 }
 
+bool ReactNativeFeatureFlags::useNewReactImageViewBackgroundDrawing() {
+  return getAccessor().useNewReactImageViewBackgroundDrawing();
+}
+
+bool ReactNativeFeatureFlags::useOptimisedViewPreallocationOnAndroid() {
+  return getAccessor().useOptimisedViewPreallocationOnAndroid();
+}
+
+bool ReactNativeFeatureFlags::useOptimizedEventBatchingOnAndroid() {
+  return getAccessor().useOptimizedEventBatchingOnAndroid();
+}
+
 bool ReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdate() {
   return getAccessor().useRuntimeShadowNodeReferenceUpdate();
 }
@@ -117,6 +209,10 @@ bool ReactNativeFeatureFlags::useStateAlignmentMechanism() {
   return getAccessor().useStateAlignmentMechanism();
 }
 
+bool ReactNativeFeatureFlags::useTurboModuleInterop() {
+  return getAccessor().useTurboModuleInterop();
+}
+
 void ReactNativeFeatureFlags::override(
     std::unique_ptr<ReactNativeFeatureFlagsProvider> provider) {
   getAccessor().override(std::move(provider));