react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactCommon/jsi/jsi/CMakeLists.txt

@@ -21,9 +21,6 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC")
   # when they go out of scope due to exceptions.
   list(APPEND jsi_compile_flags "/EHsc")
 endif()
-if (HERMES_ENABLE_BITCODE)
-  list(APPEND jsi_compile_flags "-fembed-bitcode")
-endif ()
 target_compile_options(jsi PRIVATE ${jsi_compile_flags})
 
 install(DIRECTORY "${PROJECT_SOURCE_DIR}/API/jsi/" DESTINATION include

package/ReactCommon/jsi/jsi/JSIDynamic.cpp

@@ -153,7 +153,7 @@ void dynamicFromValueShallow(
 folly::dynamic dynamicFromValue(
     Runtime& runtime,
     const Value& valueInput,
-    std::function<bool(const std::string&)> filterObjectKeys) {
+    const std::function<bool(const std::string&)>& filterObjectKeys) {
   std::vector<FromValue> stack;
   folly::dynamic ret;
 

package/ReactCommon/jsi/jsi/JSIDynamic.h

@@ -20,7 +20,7 @@ facebook::jsi::Value valueFromDynamic(
 folly::dynamic dynamicFromValue(
     facebook::jsi::Runtime& runtime,
     const facebook::jsi::Value& value,
-    std::function<bool(const std::string&)> filterObjectKeys = nullptr);
+    const std::function<bool(const std::string&)>& filterObjectKeys = nullptr);
 
 } // namespace jsi
 } // namespace facebook

package/ReactCommon/jsi/jsi/decorator.h

@@ -232,6 +232,26 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_.utf16(sym);
   }
 
+  void getStringData(
+      const jsi::String& str,
+      void* ctx,
+      void (
+          *cb)(void* ctx, bool ascii, const void* data, size_t num)) override {
+    plain_.getStringData(str, ctx, cb);
+  }
+
+  void getPropNameIdData(
+      const jsi::PropNameID& sym,
+      void* ctx,
+      void (
+          *cb)(void* ctx, bool ascii, const void* data, size_t num)) override {
+    plain_.getPropNameIdData(sym, ctx, cb);
+  }
+
+  Object createObjectWithPrototype(const Value& prototype) override {
+    return plain_.createObjectWithPrototype(prototype);
+  }
+
   Object createObject() override {
     return plain_.createObject();
   };
@@ -266,6 +286,14 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     plain_.setExternalMemoryPressure(obj, amt);
   }
 
+  void setPrototypeOf(const Object& object, const Value& prototype) override {
+    plain_.setPrototypeOf(object, prototype);
+  }
+
+  Value getPrototypeOf(const Object& object) override {
+    return plain_.getPrototypeOf(object);
+  }
+
   Value getProperty(const Object& o, const PropNameID& name) override {
     return plain_.getProperty(o, name);
   };
@@ -690,11 +718,34 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::utf16(sym);
   }
 
+  void getStringData(
+      const jsi::String& str,
+      void* ctx,
+      void (
+          *cb)(void* ctx, bool ascii, const void* data, size_t num)) override {
+    Around around{with_};
+    RD::getStringData(str, ctx, cb);
+  }
+
+  void getPropNameIdData(
+      const jsi::PropNameID& sym,
+      void* ctx,
+      void (
+          *cb)(void* ctx, bool ascii, const void* data, size_t num)) override {
+    Around around{with_};
+    RD::getPropNameIdData(sym, ctx, cb);
+  }
+
   Value createValueFromJsonUtf8(const uint8_t* json, size_t length) override {
     Around around{with_};
     return RD::createValueFromJsonUtf8(json, length);
   };
 
+  Object createObjectWithPrototype(const Value& prototype) override {
+    Around around{with_};
+    return RD::createObjectWithPrototype(prototype);
+  }
+
   Object createObject() override {
     Around around{with_};
     return RD::createObject();
@@ -726,6 +777,16 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     RD::setNativeState(o, state);
   };
 
+  void setPrototypeOf(const Object& object, const Value& prototype) override {
+    Around around{with_};
+    RD::setPrototypeOf(object, prototype);
+  }
+
+  Value getPrototypeOf(const Object& object) override {
+    Around around{with_};
+    return RD::getPrototypeOf(object);
+  }
+
   Value getProperty(const Object& o, const PropNameID& name) override {
     Around around{with_};
     return RD::getProperty(o, name);

package/ReactCommon/jsi/jsi/jsi-inl.h

@@ -84,6 +84,10 @@ inline const Runtime::PointerValue* Runtime::getPointerValue(
   return value.data_.pointer.ptr_;
 }
 
+Value Object::getPrototype(Runtime& runtime) const {
+  return runtime.getPrototypeOf(*this);
+}
+
 inline Value Object::getProperty(Runtime& runtime, const char* name) const {
   return getProperty(runtime, String::createFromAscii(runtime, name));
 }

package/ReactCommon/jsi/jsi/jsi.cpp

@@ -258,6 +258,43 @@ std::u16string Runtime::utf16(const String& str) {
   return convertUTF8ToUTF16(utf8Str);
 }
 
+void Runtime::getStringData(
+    const jsi::String& str,
+    void* ctx,
+    void (*cb)(void* ctx, bool ascii, const void* data, size_t num)) {
+  auto utf16Str = utf16(str);
+  cb(ctx, false, utf16Str.data(), utf16Str.size());
+}
+
+void Runtime::getPropNameIdData(
+    const jsi::PropNameID& sym,
+    void* ctx,
+    void (*cb)(void* ctx, bool ascii, const void* data, size_t num)) {
+  auto utf16Str = utf16(sym);
+  cb(ctx, false, utf16Str.data(), utf16Str.size());
+}
+
+void Runtime::setPrototypeOf(const Object& object, const Value& prototype) {
+  auto setPrototypeOfFn = global()
+                              .getPropertyAsObject(*this, "Object")
+                              .getPropertyAsFunction(*this, "setPrototypeOf");
+  setPrototypeOfFn.call(*this, object, prototype).asObject(*this);
+}
+
+Value Runtime::getPrototypeOf(const Object& object) {
+  auto setPrototypeOfFn = global()
+                              .getPropertyAsObject(*this, "Object")
+                              .getPropertyAsFunction(*this, "getPrototypeOf");
+  return setPrototypeOfFn.call(*this, object);
+}
+
+Object Runtime::createObjectWithPrototype(const Value& prototype) {
+  auto createFn = global()
+                      .getPropertyAsObject(*this, "Object")
+                      .getPropertyAsFunction(*this, "create");
+  return createFn.call(*this, prototype).asObject(*this);
+}
+
 Pointer& Pointer::operator=(Pointer&& other) noexcept {
   if (ptr_) {
     ptr_->invalidate();

package/ReactCommon/jsi/jsi/jsi.h

@@ -333,12 +333,18 @@ class JSI_EXPORT Runtime {
   virtual std::shared_ptr<HostObject> getHostObject(const jsi::Object&) = 0;
   virtual HostFunctionType& getHostFunction(const jsi::Function&) = 0;
 
+  // Creates a new Object with the custom prototype
+  virtual Object createObjectWithPrototype(const Value& prototype);
+
   virtual bool hasNativeState(const jsi::Object&) = 0;
   virtual std::shared_ptr<NativeState> getNativeState(const jsi::Object&) = 0;
   virtual void setNativeState(
       const jsi::Object&,
       std::shared_ptr<NativeState> state) = 0;
 
+  virtual void setPrototypeOf(const Object& object, const Value& prototype);
+  virtual Value getPrototypeOf(const Object& object);
+
   virtual Value getProperty(const Object&, const PropNameID& name) = 0;
   virtual Value getProperty(const Object&, const String& name) = 0;
   virtual bool hasProperty(const Object&, const PropNameID& name) = 0;
@@ -402,6 +408,34 @@ class JSI_EXPORT Runtime {
   virtual std::u16string utf16(const String& str);
   virtual std::u16string utf16(const PropNameID& sym);
 
+  /// Invokes the provided callback \p cb with the String content in \p str.
+  /// The callback must take in three arguments: bool ascii, const void* data,
+  /// and size_t num, respectively. \p ascii indicates whether the \p data
+  /// passed to the callback should be interpreted as a pointer to a sequence of
+  /// \p num ASCII characters or UTF16 characters. Depending on the internal
+  /// representation of the string, the function may invoke the callback
+  /// multiple times, with a different format on each invocation. The callback
+  /// must not access runtime functionality, as any operation on the runtime may
+  /// invalidate the data pointers.
+  virtual void getStringData(
+      const jsi::String& str,
+      void* ctx,
+      void (*cb)(void* ctx, bool ascii, const void* data, size_t num));
+
+  /// Invokes the provided callback \p cb with the PropNameID content in \p sym.
+  /// The callback must take in three arguments: bool ascii, const void* data,
+  /// and size_t num, respectively. \p ascii indicates whether the \p data
+  /// passed to the callback should be interpreted as a pointer to a sequence of
+  /// \p num ASCII characters or UTF16 characters. Depending on the internal
+  /// representation of the string, the function may invoke the callback
+  /// multiple times, with a different format on each invocation. The callback
+  /// must not access runtime functionality, as any operation on the runtime may
+  /// invalidate the data pointers.
+  virtual void getPropNameIdData(
+      const jsi::PropNameID& sym,
+      void* ctx,
+      void (*cb)(void* ctx, bool ascii, const void* data, size_t num));
+
   // These exist so derived classes can access the private parts of
   // Value, Symbol, String, and Object, which are all friends of Runtime.
   template <typename T>
@@ -509,6 +543,22 @@ class JSI_EXPORT PropNameID : public Pointer {
     return runtime.utf16(*this);
   }
 
+  /// Invokes the user provided callback to process the content in PropNameId.
+  /// The callback must take in three arguments: bool ascii, const void* data,
+  /// and size_t num, respectively. \p ascii indicates whether the \p data
+  /// passed to the callback should be interpreted as a pointer to a sequence of
+  /// \p num ASCII characters or UTF16 characters. The function may invoke the
+  /// callback multiple times, with a different format on each invocation. The
+  /// callback must not access runtime functionality, as any operation on the
+  /// runtime may invalidate the data pointers.
+  template <typename CB>
+  void getPropNameIdData(Runtime& runtime, CB& cb) const {
+    runtime.getPropNameIdData(
+        *this, &cb, [](void* ctx, bool ascii, const void* data, size_t num) {
+          (*((CB*)ctx))(ascii, data, num);
+        });
+  }
+
   static bool compare(
       Runtime& runtime,
       const jsi::PropNameID& a,
@@ -664,6 +714,22 @@ class JSI_EXPORT String : public Pointer {
     return runtime.utf16(*this);
   }
 
+  /// Invokes the user provided callback to process content in String. The
+  /// callback must take in three arguments: bool ascii, const void* data, and
+  /// size_t num, respectively. \p ascii indicates whether the \p data passed to
+  /// the callback should be interpreted as a pointer to a sequence of \p num
+  /// ASCII characters or UTF16 characters. The function may invoke the callback
+  /// multiple times, with a different format on each invocation. The callback
+  /// must not access runtime functionality, as any operation on the runtime may
+  /// invalidate the data pointers.
+  template <typename CB>
+  void getStringData(Runtime& runtime, CB& cb) const {
+    runtime.getStringData(
+        *this, &cb, [](void* ctx, bool ascii, const void* data, size_t num) {
+          (*((CB*)ctx))(ascii, data, num);
+        });
+  }
+
   friend class Runtime;
   friend class Value;
 };
@@ -688,6 +754,11 @@ class JSI_EXPORT Object : public Pointer {
     return runtime.createObject(ho);
   }
 
+  /// Creates a new Object with the custom prototype
+  static Object create(Runtime& runtime, const Value& prototype) {
+    return runtime.createObjectWithPrototype(prototype);
+  }
+
   /// \return whether this and \c obj are the same JSObject or not.
   static bool strictEquals(Runtime& runtime, const Object& a, const Object& b) {
     return runtime.strictEquals(a, b);
@@ -698,6 +769,16 @@ class JSI_EXPORT Object : public Pointer {
     return rt.instanceOf(*this, ctor);
   }
 
+  /// Sets \p prototype as the prototype of the object. The prototype must be
+  /// either an Object or null. If the prototype was not set successfully, this
+  /// method will throw.
+  void setPrototype(Runtime& runtime, const Value& prototype) const {
+    return runtime.setPrototypeOf(*this, prototype);
+  }
+
+  /// \return the prototype of the object
+  inline Value getPrototype(Runtime& runtime) const;
+
   /// \return the property of the object with the given ascii name.
   /// If the name isn't a property on the object, returns the
   /// undefined value.

package/ReactCommon/jsi/jsi/test/testlib.cpp

@@ -1635,6 +1635,94 @@ TEST_P(JSITest, UTF16Test) {
   EXPECT_EQ(str.utf16(rd), u"\uFFFD\u007A");
 }
 
+TEST_P(JSITest, GetStringDataTest) {
+  // This Runtime Decorator is used to test the default getStringData
+  // implementation for VMs that do not provide their own implementation
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    void getStringData(
+        const String& str,
+        void* ctx,
+        void (*cb)(void* ctx, bool ascii, const void* data, size_t num))
+        override {
+      Runtime::getStringData(str, ctx, cb);
+    }
+  };
+
+  RD rd = RD(rt);
+  String str = String::createFromUtf8(rd, "hello👋");
+
+  std::u16string buf;
+  auto cb = [&buf](bool ascii, const void* data, size_t num) {
+    assert(!ascii && "Default implementation is always utf16");
+    buf.append((const char16_t*)data, num);
+  };
+
+  str.getStringData(rd, cb);
+  EXPECT_EQ(buf, str.utf16(rd));
+}
+
+TEST_P(JSITest, ObjectSetPrototype) {
+  // This Runtime Decorator is used to test the default implementation of
+  // Object.setPrototypeOf
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    explicit RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    void setPrototypeOf(const Object& object, const Value& prototype) override {
+      return Runtime::setPrototypeOf(object, prototype);
+    }
+
+    Value getPrototypeOf(const Object& object) override {
+      return Runtime::getPrototypeOf(object);
+    }
+  };
+
+  RD rd = RD(rt);
+  Object child(rd);
+
+  // Tests null value as prototype
+  child.setPrototype(rd, Value::null());
+  EXPECT_TRUE(child.getPrototype(rd).isNull());
+
+  Object prototypeObj(rd);
+  prototypeObj.setProperty(rd, "someProperty", 123);
+  Value prototype(rd, prototypeObj);
+
+  child.setPrototype(rd, prototype);
+  EXPECT_EQ(child.getProperty(rd, "someProperty").getNumber(), 123);
+
+  auto getPrototypeRes = child.getPrototype(rd).asObject(rd);
+  EXPECT_EQ(getPrototypeRes.getProperty(rd, "someProperty").getNumber(), 123);
+}
+
+TEST_P(JSITest, ObjectCreateWithPrototype) {
+  // This Runtime Decorator is used to test the default implementation of
+  // Object.create(prototype)
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    Object createObjectWithPrototype(const Value& prototype) override {
+      return Runtime::createObjectWithPrototype(prototype);
+    }
+  };
+
+  RD rd = RD(rt);
+  Object prototypeObj(rd);
+  prototypeObj.setProperty(rd, "someProperty", 123);
+  Value prototype(rd, prototypeObj);
+
+  Object child = Object::create(rd, prototype);
+  EXPECT_EQ(child.getProperty(rd, "someProperty").getNumber(), 123);
+
+  // Tests null value as prototype
+  child = Object::create(rd, Value::null());
+  EXPECT_TRUE(child.getPrototype(rd).isNull());
+}
+
 INSTANTIATE_TEST_CASE_P(
     Runtimes,
     JSITest,

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -11,7 +11,7 @@
 #include <cxxreact/JSBigString.h>
 #include <cxxreact/ModuleRegistry.h>
 #include <cxxreact/ReactMarker.h>
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <folly/Conv.h>
 #include <folly/json.h>
 #include <glog/logging.h>
@@ -80,7 +80,7 @@ JSIExecutor::JSIExecutor(
 }
 
 void JSIExecutor::initializeRuntime() {
-  SystraceSection s("JSIExecutor::initializeRuntime");
+  TraceSection s("JSIExecutor::initializeRuntime");
 
   bindNativePerformanceNow(*runtime_);
 
@@ -152,7 +152,7 @@ void JSIExecutor::initializeRuntime() {
 void JSIExecutor::loadBundle(
     std::unique_ptr<const JSBigString> script,
     std::string sourceURL) {
-  SystraceSection s("JSIExecutor::loadBundle");
+  TraceSection s("JSIExecutor::loadBundle");
   bool hasLogger = false;
   {
     std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
@@ -218,7 +218,7 @@ void JSIExecutor::callFunction(
     const std::string& moduleId,
     const std::string& methodId,
     const folly::dynamic& arguments) {
-  SystraceSection s(
+  TraceSection s(
       "JSIExecutor::callFunction", "moduleId", moduleId, "methodId", methodId);
   if (!callFunctionReturnFlushedQueue_) {
     bindBridge();
@@ -255,7 +255,7 @@ void JSIExecutor::callFunction(
 void JSIExecutor::invokeCallback(
     const double callbackId,
     const folly::dynamic& arguments) {
-  SystraceSection s("JSIExecutor::invokeCallback", "callbackId", callbackId);
+  TraceSection s("JSIExecutor::invokeCallback", "callbackId", callbackId);
   if (!invokeCallbackAndReturnFlushedQueue_) {
     bindBridge();
   }
@@ -274,7 +274,7 @@ void JSIExecutor::invokeCallback(
 void JSIExecutor::setGlobalVariable(
     std::string propName,
     std::unique_ptr<const JSBigString> jsonValue) {
-  SystraceSection s("JSIExecutor::setGlobalVariable", "propName", propName);
+  TraceSection s("JSIExecutor::setGlobalVariable", "propName", propName);
   runtime_->global().setProperty(
       *runtime_,
       propName.c_str(),
@@ -366,7 +366,7 @@ void JSIExecutor::handleMemoryPressure(int pressureLevel) {
 
 void JSIExecutor::bindBridge() {
   std::call_once(bindFlag_, [this] {
-    SystraceSection s("JSIExecutor::bindBridge (once)");
+    TraceSection s("JSIExecutor::bindBridge (once)");
     Value batchedBridgeValue =
         runtime_->global().getProperty(*runtime_, "__fbBatchedBridge");
     if (batchedBridgeValue.isUndefined() || !batchedBridgeValue.isObject()) {
@@ -385,7 +385,7 @@ void JSIExecutor::bindBridge() {
 }
 
 void JSIExecutor::callNativeModules(const Value& queue, bool isEndOfBatch) {
-  SystraceSection s("JSIExecutor::callNativeModules");
+  TraceSection s("JSIExecutor::callNativeModules");
   // If this fails, you need to pass a fully functional delegate with a
   // module registry to the factory/ctor.
   CHECK(delegate_) << "Attempting to use native modules without a delegate";
@@ -401,7 +401,7 @@ void JSIExecutor::callNativeModules(const Value& queue, bool isEndOfBatch) {
 }
 
 void JSIExecutor::flush() {
-  SystraceSection s("JSIExecutor::flush");
+  TraceSection s("JSIExecutor::flush");
   if (flushedQueue_) {
     Value ret = flushedQueue_->call(*runtime_);
     callNativeModules(ret, true);

package/ReactCommon/jsinspector-modern/CMakeLists.txt

@@ -25,7 +25,7 @@ target_include_directories(jsinspector PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(jsinspector
         folly_runtime
         glog
+        jsinspector_tracing
         react_featureflags
         runtimeexecutor
-        reactperflogger
 )

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -125,21 +125,17 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
 
     shouldSendOKResponse = true;
     isFinishedHandlingRequest = true;
-  } else if (req.method == "FuseboxClient.setClientMetadata") {
+  } else if (req.method == "ReactNativeApplication.enable") {
+    sessionState_.isReactNativeApplicationDomainEnabled = true;
     fuseboxClientType_ = FuseboxClientType::Fusebox;
 
     if (sessionState_.isLogDomainEnabled) {
       sendFuseboxNotice();
     }
 
-    shouldSendOKResponse = true;
-    isFinishedHandlingRequest = true;
-  } else if (req.method == "ReactNativeApplication.enable") {
-    sessionState_.isReactNativeApplicationDomainEnabled = true;
-
     frontendChannel_(cdp::jsonNotification(
         "ReactNativeApplication.metadataUpdated",
-        hostMetadataToDynamic(hostMetadata_)));
+        createHostMetadataPayload(hostMetadata_)));
 
     shouldSendOKResponse = true;
     isFinishedHandlingRequest = true;

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -13,6 +13,8 @@
 #include "InstanceTarget.h"
 #include "SessionState.h"
 
+#include <jsinspector-modern/InspectorFlags.h>
+
 #include <folly/dynamic.h>
 #include <folly/json.h>
 
@@ -232,7 +234,22 @@ bool HostTargetController::decrementPauseOverlayCounter() {
   return true;
 }
 
-folly::dynamic hostMetadataToDynamic(const HostTargetMetadata& metadata) {
+namespace {
+
+struct StaticHostTargetMetadata {
+  std::optional<bool> isProfilingBuild;
+};
+
+StaticHostTargetMetadata getStaticHostMetadata() {
+  auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
+
+  return {.isProfilingBuild = inspectorFlags.getIsProfilingBuild()};
+}
+
+} // namespace
+
+folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata) {
+  auto staticMetadata = getStaticHostMetadata();
   folly::dynamic result = folly::dynamic::object;
 
   if (metadata.appDisplayName) {
@@ -253,6 +270,10 @@ folly::dynamic hostMetadataToDynamic(const HostTargetMetadata& metadata) {
   if (metadata.reactNativeVersion) {
     result["reactNativeVersion"] = metadata.reactNativeVersion.value();
   }
+  if (staticMetadata.isProfilingBuild) {
+    result["unstable_isProfilingBuild"] =
+        staticMetadata.isProfilingBuild.value();
+  }
 
   return result;
 }

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -271,6 +271,6 @@ class JSINSPECTOR_EXPORT HostTarget
   friend class HostTargetController;
 };
 
-folly::dynamic hostMetadataToDynamic(const HostTargetMetadata& metadata);
+folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata);
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -18,13 +18,25 @@ InspectorFlags& InspectorFlags::getInstance() {
 }
 
 bool InspectorFlags::getFuseboxEnabled() const {
+  if (fuseboxDisabledForTest_) {
+    return false;
+  }
+
   return loadFlagsAndAssertUnchanged().fuseboxEnabled;
 }
 
+bool InspectorFlags::getIsProfilingBuild() const {
+  return loadFlagsAndAssertUnchanged().isProfilingBuild;
+}
+
 void InspectorFlags::dangerouslyResetFlags() {
   *this = InspectorFlags{};
 }
 
+void InspectorFlags::dangerouslyDisableFuseboxForTest() {
+  fuseboxDisabledForTest_ = true;
+}
+
 #if defined(REACT_NATIVE_FORCE_ENABLE_FUSEBOX) && \
     defined(REACT_NATIVE_FORCE_DISABLE_FUSEBOX)
 #error \
@@ -39,15 +51,18 @@ const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
           true,
 #elif defined(REACT_NATIVE_FORCE_DISABLE_FUSEBOX)
           false,
-#elif defined(HERMES_ENABLE_DEBUGGER) && \
-    defined(REACT_NATIVE_ENABLE_FUSEBOX_DEBUG)
-          true,
 #elif defined(HERMES_ENABLE_DEBUGGER)
-          ReactNativeFeatureFlags::fuseboxEnabledDebug(),
+          true,
 #elif defined(REACT_NATIVE_ENABLE_FUSEBOX_RELEASE)
           true,
 #else
           ReactNativeFeatureFlags::fuseboxEnabledRelease(),
+#endif
+      .isProfilingBuild =
+#if defined(REACT_NATIVE_ENABLE_FUSEBOX_RELEASE)
+          true,
+#else
+          false,
 #endif
   };
 

package/ReactCommon/jsinspector-modern/InspectorFlags.h

@@ -24,6 +24,18 @@ class InspectorFlags {
    */
   bool getFuseboxEnabled() const;
 
+  /**
+   * Flag determining if this is a profiling build
+   * (react_native.enable_fusebox_release).
+   */
+  bool getIsProfilingBuild() const;
+
+  /**
+   * Forcibly disable the main `getFuseboxEnabled()` flag. This should ONLY be
+   * used by `ReactInstanceIntegrationTest`.
+   */
+  void dangerouslyDisableFuseboxForTest();
+
   /**
    * Reset flags to their upstream values. The caller must ensure any resources
    * that have read previous flag values have been cleaned up.
@@ -33,6 +45,7 @@ class InspectorFlags {
  private:
   struct Values {
     bool fuseboxEnabled;
+    bool isProfilingBuild;
     bool operator==(const Values&) const = default;
   };
 
@@ -43,6 +56,7 @@ class InspectorFlags {
 
   mutable std::optional<Values> cachedValues_;
   mutable bool inconsistentFlagsStateLogged_{false};
+  bool fuseboxDisabledForTest_{false};
 
   const Values& loadFlagsAndAssertUnchanged() const;
 };