react-native 0.85.2 → 0.85.3

package/ReactCommon/react/debug/redbox/RedBoxErrorParser.h

@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <optional>
+#include <string>
+
+namespace facebook::react::unstable_redbox {
+
+struct CodeFrame {
+  std::string content;
+  std::string fileName;
+  int row = 0;
+  int column = 0;
+};
+
+struct ParsedError {
+  std::string title;
+  std::string message;
+  std::optional<CodeFrame> codeFrame;
+  bool isCompileError = false;
+  bool isRetryable = true;
+};
+
+/**
+ * Parse a raw error message into structured components.
+ * C++ port of parseLogBoxException from parseLogBoxLog.js.
+ */
+ParsedError parseErrorMessage(
+    const std::string &message,
+    const std::string &name = "",
+    const std::string &componentStack = "",
+    bool isFatal = true);
+
+} // namespace facebook::react::unstable_redbox

package/ReactCommon/react/debug/redbox/tests/AnsiParserTest.cpp

@@ -0,0 +1,97 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <react/debug/redbox/AnsiParser.h>
+
+using namespace facebook::react::unstable_redbox;
+
+TEST(AnsiParserTest, ParsesPlainText) {
+  auto spans = parseAnsi("hello world");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "hello world");
+  EXPECT_FALSE(spans[0].foregroundColor.has_value());
+  EXPECT_FALSE(spans[0].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ParsesRedForeground) {
+  auto spans = parseAnsi("\x1b[31mred text\x1b[0m normal");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "red text");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 187);
+  EXPECT_EQ(spans[0].foregroundColor->g, 86);
+  EXPECT_EQ(spans[0].foregroundColor->b, 83);
+
+  EXPECT_EQ(spans[1].text, " normal");
+  EXPECT_FALSE(spans[1].foregroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ParsesMultipleColors) {
+  auto spans = parseAnsi("\x1b[32mgreen\x1b[34mblue\x1b[0m");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "green");
+  EXPECT_EQ(spans[0].foregroundColor->r, 144);
+  EXPECT_EQ(spans[1].text, "blue");
+  EXPECT_EQ(spans[1].foregroundColor->r, 125);
+}
+
+TEST(AnsiParserTest, ParsesBrightColors) {
+  auto spans = parseAnsi("\x1b[93myellow\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "yellow");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 234);
+}
+
+TEST(AnsiParserTest, ParsesBackgroundColor) {
+  auto spans = parseAnsi("\x1b[41mred bg\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "red bg");
+  EXPECT_FALSE(spans[0].foregroundColor.has_value());
+  ASSERT_TRUE(spans[0].backgroundColor.has_value());
+  EXPECT_EQ(spans[0].backgroundColor->r, 187);
+  EXPECT_EQ(spans[0].backgroundColor->g, 86);
+  EXPECT_EQ(spans[0].backgroundColor->b, 83);
+}
+
+TEST(AnsiParserTest, ResetClearsBackground) {
+  auto spans = parseAnsi("\x1b[31;42mcolored\x1b[49mfg only\x1b[0m");
+  ASSERT_EQ(spans.size(), 2);
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  ASSERT_TRUE(spans[0].backgroundColor.has_value());
+  ASSERT_TRUE(spans[1].foregroundColor.has_value());
+  EXPECT_FALSE(spans[1].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ResetShorthandClearsColors) {
+  auto spans = parseAnsi("\x1b[31mred\x1b[mplain");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "red");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[1].text, "plain");
+  EXPECT_FALSE(spans[1].foregroundColor.has_value());
+  EXPECT_FALSE(spans[1].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, StripsAnsi) {
+  auto result = stripAnsi("\x1b[31mred\x1b[0m and \x1b[32mgreen\x1b[0m");
+  EXPECT_EQ(result, "red and green");
+}
+
+TEST(AnsiParserTest, HandlesEmptyString) {
+  auto spans = parseAnsi("");
+  EXPECT_TRUE(spans.empty());
+}
+
+TEST(AnsiParserTest, HandlesSemicolonSeparatedCodes) {
+  auto spans = parseAnsi("\x1b[1;31mtext\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "text");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 187);
+}

package/ReactCommon/react/debug/redbox/tests/JscSafeUrlTest.cpp

@@ -0,0 +1,173 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <react/debug/redbox/JscSafeUrl.h>
+
+using namespace facebook::react::unstable_redbox;
+
+// --- toNormalUrl ---
+
+// Rewrites urls treating //& in paths as ?
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInAbsolutePath) {
+  EXPECT_EQ(
+      toNormalUrl("/path1/path2//&foo=bar?bar=baz#frag?"),
+      "/path1/path2?foo=bar&bar=baz#frag?");
+  // Idempotent
+  EXPECT_EQ(
+      toNormalUrl("/path1/path2?foo=bar&bar=baz#frag?"),
+      "/path1/path2?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInRelativePathWithEncoding) {
+  EXPECT_EQ(
+      toNormalUrl("relative/path/with%3B%26/encoded//&foo=bar?bar=baz#frag?"),
+      "relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?");
+  EXPECT_EQ(
+      toNormalUrl("relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?"),
+      "relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInFullUrl) {
+  EXPECT_EQ(
+      toNormalUrl(
+          "https://user:password@mydomain.com:8080/path1/path2//&foo=bar?bar=baz#frag?"),
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?");
+  EXPECT_EQ(
+      toNormalUrl(
+          "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?"),
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerWithoutFragment) {
+  EXPECT_EQ(
+      toNormalUrl("http://127.0.0.1/path1/path2//&foo=bar&bar=baz"),
+      "http://127.0.0.1/path1/path2?foo=bar&bar=baz");
+  EXPECT_EQ(
+      toNormalUrl("http://127.0.0.1/path1/path2?foo=bar&bar=baz"),
+      "http://127.0.0.1/path1/path2?foo=bar&bar=baz");
+}
+
+// Returns other strings exactly as given
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForQueryWithMarkerAfter) {
+  auto url = "http://user:password/@mydomain.com/foo?bar=zoo?baz=quux//&";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForSimpleQuery) {
+  auto url = "/foo?bar=zoo?baz=quux";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForOpaqueUri) {
+  auto url = "proto:arbitrary_bad_url";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForStar) {
+  EXPECT_EQ(toNormalUrl("*"), "*");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForRelativePath) {
+  auto url = "relative/path";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+// --- toJscSafeUrl ---
+
+// Replaces the first ? with a JSC-friendly delimiter, url-encodes subsequent
+// ?, and is idempotent
+TEST(JscSafeUrlTest, ToJscSafeUrl_FullUrlWithEncodedQuestionMark) {
+  auto input =
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=question?#frag?";
+  auto output =
+      "https://user:password@mydomain.com:8080/path1/path2//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_SimpleUrl) {
+  auto input = "http://127.0.0.1/path1/path2?foo=bar";
+  auto output = "http://127.0.0.1/path1/path2//&foo=bar";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForStar) {
+  EXPECT_EQ(toJscSafeUrl("*"), "*");
+  EXPECT_EQ(toJscSafeUrl("*"), "*");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForAbsolutePath) {
+  EXPECT_EQ(toJscSafeUrl("/absolute/path"), "/absolute/path");
+  EXPECT_EQ(toJscSafeUrl("/absolute/path"), "/absolute/path");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForRelativePath) {
+  EXPECT_EQ(toJscSafeUrl("relative/path"), "relative/path");
+  EXPECT_EQ(toJscSafeUrl("relative/path"), "relative/path");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_EmptyQueryDropped) {
+  EXPECT_EQ(toJscSafeUrl("/?"), "/");
+  EXPECT_EQ(toJscSafeUrl("/"), "/");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForUrlWithoutQuery) {
+  auto url = "http://127.0.0.1/path1/path";
+  EXPECT_EQ(toJscSafeUrl(url), url);
+  EXPECT_EQ(toJscSafeUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_AbsolutePathWithEncodedQuestionMark) {
+  auto input = "/path1/path2?foo=bar&bar=question?#frag?";
+  auto output = "/path1/path2//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_RelativePathWithEncodedQuestionMark) {
+  auto input = "relative/path?foo=bar&bar=question?#frag?";
+  auto output = "relative/path//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_AlreadySafeWithExtraQuery) {
+  auto input = "/path1/path2//&foo=bar&bar=question%3F?extra=query#frag?";
+  auto output = "/path1/path2//&foo=bar&bar=question%3F&extra=query#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+// Throws on a URL with an empty path and a query string
+TEST(JscSafeUrlTest, ToJscSafeUrl_ThrowsForEmptyPathWithQuery) {
+  EXPECT_THROW(toJscSafeUrl("http://127.0.0.1?foo=bar"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("http://127.0.0.1?q#hash"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("?foo=bar"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("?foo=/bar#hash"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("/?bar=baz/"), std::invalid_argument);
+}
+
+// --- isJscSafeUrl ---
+
+TEST(JscSafeUrlTest, IsJscSafeUrl_TrueForSafeUrls) {
+  EXPECT_TRUE(isJscSafeUrl("http://example.com//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("http://example.com/with/path//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("relative/path///&foo=bar//&#frag=//&"));
+  EXPECT_TRUE(isJscSafeUrl("/absolute/path//&foo=bar//&#frag=//&"));
+}
+
+TEST(JscSafeUrlTest, IsJscSafeUrl_FalseForNormalUrls) {
+  EXPECT_FALSE(isJscSafeUrl("http://example.com?foo=bar//&#frag=//"));
+  EXPECT_FALSE(
+      isJscSafeUrl("http://example.com/with/path/?foo=bar//&#frag=//"));
+  EXPECT_FALSE(isJscSafeUrl("?foo=bar//&#frag=//&"));
+  EXPECT_FALSE(isJscSafeUrl("relative/path/?foo=bar//#frag=//"));
+  EXPECT_FALSE(isJscSafeUrl("/absolute/path/?foo=bar//&#frag=//"));
+}

package/ReactCommon/react/debug/redbox/tests/RedBoxErrorParserTest.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <react/debug/redbox/RedBoxErrorParser.h>
+
+using namespace facebook::react::unstable_redbox;
+
+TEST(RedBoxErrorParserTest, ParsesBabelTransformError) {
+  auto result = parseErrorMessage(
+      "SyntaxError: /path/to/file.js: Unexpected token (10:5)\n\n"
+      "> 10 |   const x = {\n"
+      "     |              ^");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "Unexpected token");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->fileName, "/path/to/file.js");
+  EXPECT_EQ(result.codeFrame->row, 10);
+  EXPECT_EQ(result.codeFrame->column, 5);
+  EXPECT_TRUE(result.isCompileError);
+  EXPECT_TRUE(result.isRetryable);
+}
+
+TEST(RedBoxErrorParserTest, ParsesMetroError) {
+  auto result = parseErrorMessage(
+      "InternalError Metro has encountered an error: "
+      "BundleError: Unable to resolve module (1:0)\n\n"
+      "code frame here");
+
+  EXPECT_EQ(result.title, "BundleError");
+  EXPECT_EQ(result.message, "Unable to resolve module");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->row, 1);
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesBundleLoadError_SyntaxError) {
+  auto result = parseErrorMessage(
+      "SyntaxError in /app/index.js: Unexpected token (3:10)\ncode frame");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "Unexpected token");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->fileName, "/app/index.js");
+  EXPECT_EQ(result.codeFrame->row, 3);
+  EXPECT_EQ(result.codeFrame->column, 10);
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesBundleLoadError_UnableToResolve) {
+  auto result = parseErrorMessage(
+      "UnableToResolveError in /app/index.js: Cannot find module (1:0)");
+
+  EXPECT_EQ(result.title, "Module Not Found");
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesGenericTransformError) {
+  auto result = parseErrorMessage("TransformError some error message");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "TransformError some error message");
+  EXPECT_FALSE(result.codeFrame.has_value());
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, DefaultsToUncaughtError) {
+  auto result = parseErrorMessage("TypeError: undefined is not a function");
+
+  EXPECT_EQ(result.title, "Uncaught Error");
+  EXPECT_EQ(result.message, "TypeError: undefined is not a function");
+  EXPECT_FALSE(result.codeFrame.has_value());
+  EXPECT_FALSE(result.isCompileError);
+  EXPECT_TRUE(result.isRetryable);
+}
+
+TEST(RedBoxErrorParserTest, UsesNameForTitle) {
+  auto result = parseErrorMessage("something broke", "CustomError");
+
+  EXPECT_EQ(result.title, "CustomError");
+}
+
+TEST(RedBoxErrorParserTest, UsesRenderErrorForComponentStack) {
+  auto result =
+      parseErrorMessage("something broke", "", "in MyComponent\nin App");
+
+  EXPECT_EQ(result.title, "Render Error");
+}
+
+TEST(RedBoxErrorParserTest, NonFatalDefaultsToError) {
+  auto result = parseErrorMessage("warning message", "", "", false);
+
+  EXPECT_EQ(result.title, "Error");
+}
+
+TEST(RedBoxErrorParserTest, HandlesEmptyMessage) {
+  auto result = parseErrorMessage("");
+
+  EXPECT_EQ(result.title, "Uncaught Error");
+  EXPECT_EQ(result.message, "");
+  EXPECT_FALSE(result.codeFrame.has_value());
+}

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<<08a361f2ffac6a0496adac1d4c3e4726>>
+ * @generated SignedSource<<983f38f2d2fdc1cbef07f6a4b1891342>>
  */
 
 /**
@@ -190,6 +190,10 @@ bool ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS() {
   return getAccessor().enableModuleArgumentNSNullConversionIOS();
 }
 
+bool ReactNativeFeatureFlags::enableMutationObserverByDefault() {
+  return getAccessor().enableMutationObserverByDefault();
+}
+
 bool ReactNativeFeatureFlags::enableNativeCSSParsing() {
   return getAccessor().enableNativeCSSParsing();
 }
@@ -262,10 +266,18 @@ bool ReactNativeFeatureFlags::fuseboxEnabledRelease() {
   return getAccessor().fuseboxEnabledRelease();
 }
 
+bool ReactNativeFeatureFlags::fuseboxFrameRecordingEnabled() {
+  return getAccessor().fuseboxFrameRecordingEnabled();
+}
+
 bool ReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled() {
   return getAccessor().fuseboxNetworkInspectionEnabled();
 }
 
+bool ReactNativeFeatureFlags::fuseboxScreenshotCaptureEnabled() {
+  return getAccessor().fuseboxScreenshotCaptureEnabled();
+}
+
 bool ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS() {
   return getAccessor().hideOffscreenVirtualViewsOnIOS();
 }
@@ -290,6 +302,14 @@ bool ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion() {
   return getAccessor().preventShadowTreeCommitExhaustion();
 }
 
+bool ReactNativeFeatureFlags::redBoxV2Android() {
+  return getAccessor().redBoxV2Android();
+}
+
+bool ReactNativeFeatureFlags::redBoxV2IOS() {
+  return getAccessor().redBoxV2IOS();
+}
+
 bool ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover() {
   return getAccessor().shouldPressibilityUseW3CPointerEventsForHover();
 }

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.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<<0bbe4d41581432dfad7adbc2db133d00>>
+ * @generated SignedSource<<57b1294863f5899a0892cc8501773edf>>
  */
 
 /**
@@ -244,6 +244,11 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool enableModuleArgumentNSNullConversionIOS();
 
+  /**
+   * Enables the MutationObserver Web API in React Native.
+   */
+  RN_EXPORT static bool enableMutationObserverByDefault();
+
   /**
    * Parse CSS strings using the Fabric CSS parser instead of ViewConfig processing
    */
@@ -334,11 +339,21 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool fuseboxEnabledRelease();
 
+  /**
+   * Enable frame timings and screenshots support in the React Native DevTools CDP backend. This flag is global and should not be changed across React Host lifetimes.
+   */
+  RN_EXPORT static bool fuseboxFrameRecordingEnabled();
+
   /**
    * Enable network inspection support in the React Native DevTools CDP backend. Requires `enableBridgelessArchitecture`. This flag is global and should not be changed across React Host lifetimes.
    */
   RN_EXPORT static bool fuseboxNetworkInspectionEnabled();
 
+  /**
+   * Enable Page.captureScreenshot CDP method support in the React Native DevTools CDP backend. This flag is global and should not be changed across React Host lifetimes.
+   */
+  RN_EXPORT static bool fuseboxScreenshotCaptureEnabled();
+
   /**
    * Hides offscreen VirtualViews on iOS by setting hidden = YES to avoid extra cost of views
    */
@@ -369,6 +384,16 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool preventShadowTreeCommitExhaustion();
 
+  /**
+   * Use the redesigned RedBox error overlay on Android, styled to match the LogBox visual language.
+   */
+  RN_EXPORT static bool redBoxV2Android();
+
+  /**
+   * Use the redesigned RedBox error overlay on iOS, styled to match the LogBox visual language.
+   */
+  RN_EXPORT static bool redBoxV2IOS();
+
   /**
    * Function used to enable / disable Pressibility from using W3C Pointer Events for its hover callbacks
    */