react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -43,44 +43,50 @@ ReactInstance::ReactInstance(
                                          std::weak_ptr(timerManager_),
                                      weakJsThread =
                                          std::weak_ptr(jsMessageQueueThread_),
-                                     weakJsErrorHander = std::weak_ptr(
-                                         jsErrorHandler_)](auto callback) {
-    auto jsErrorHandler = weakJsErrorHander.lock();
-    if (weakRuntime.expired() || !jsErrorHandler) {
+                                     jsErrorHandler =
+                                         jsErrorHandler_](auto callback) {
+    if (weakRuntime.expired()) {
       return;
     }
 
-    if (jsErrorHandler->hasHandledFatalError()) {
+    /**
+     * If a fatal error was caught while executing the main bundle, assume the
+     * js runtime is invalid. And stop executing any more js.
+     */
+    if (!jsErrorHandler->isRuntimeReady() &&
+        jsErrorHandler->hasHandledFatalError()) {
       LOG(INFO)
-          << "RuntimeExecutor: Detected fatal js error. Dropping work on non-js thread."
+          << "RuntimeExecutor: Detected fatal error. Dropping work on non-js thread."
           << std::endl;
       return;
     }
 
     if (auto jsThread = weakJsThread.lock()) {
-      jsThread->runOnQueue(
-          [weakRuntime, weakTimerManager, callback = std::move(callback)]() {
-            auto runtime = weakRuntime.lock();
-            if (!runtime) {
-              return;
-            }
+      jsThread->runOnQueue([jsErrorHandler,
+                            weakRuntime,
+                            weakTimerManager,
+                            callback = std::move(callback)]() {
+        auto runtime = weakRuntime.lock();
+        if (!runtime) {
+          return;
+        }
 
-            jsi::Runtime& jsiRuntime = runtime->getRuntime();
-            SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
-            try {
-              callback(jsiRuntime);
+        jsi::Runtime& jsiRuntime = runtime->getRuntime();
+        SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
+        try {
+          callback(jsiRuntime);
 
-              // If we have first-class support for microtasks,
-              // they would've been called as part of the previous callback.
-              if (!ReactNativeFeatureFlags::enableMicrotasks()) {
-                if (auto timerManager = weakTimerManager.lock()) {
-                  timerManager->callReactNativeMicrotasks(jsiRuntime);
-                }
-              }
-            } catch (jsi::JSError& originalError) {
-              handleJSError(jsiRuntime, originalError, true);
+          // If we have first-class support for microtasks,
+          // they would've been called as part of the previous callback.
+          if (!ReactNativeFeatureFlags::enableMicrotasks()) {
+            if (auto timerManager = weakTimerManager.lock()) {
+              timerManager->callReactNativeMicrotasks(jsiRuntime);
             }
-          });
+          }
+        } catch (jsi::JSError& originalError) {
+          jsErrorHandler->handleFatalError(jsiRuntime, originalError);
+        }
+      });
     }
   };
 
@@ -118,7 +124,17 @@ ReactInstance::ReactInstance(
         };
   }
 
-  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(runtimeExecutor);
+  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(
+      runtimeExecutor,
+      RuntimeSchedulerClock::now,
+      [jsErrorHandler = jsErrorHandler_](
+          jsi::Runtime& runtime, jsi::JSError& error) {
+        jsErrorHandler->handleFatalError(runtime, error);
+      });
+  runtimeScheduler_->setPerformanceEntryReporter(
+      // FIXME: Move creation of PerformanceEntryReporter to here and guarantee
+      // that its lifetime is the same as the runtime.
+      PerformanceEntryReporter::getInstance().get());
 
   bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
@@ -148,8 +164,8 @@ RuntimeExecutor ReactInstance::getUnbufferedRuntimeExecutor() noexcept {
 
 // This BufferedRuntimeExecutor ensures that the main JS bundle finished
 // execution before any JS queued into it from C++ are executed. Use
-// getBufferedRuntimeExecutor() instead if you do not need the main JS bundle to
-// have finished. e.g. setting global variables into JS runtime.
+// getUnbufferedRuntimeExecutor() instead if you do not need the main JS bundle
+// to have finished. e.g. setting global variables into JS runtime.
 RuntimeExecutor ReactInstance::getBufferedRuntimeExecutor() noexcept {
   return [weakBufferedRuntimeExecutor_ =
               std::weak_ptr<BufferedRuntimeExecutor>(bufferedRuntimeExecutor_)](
@@ -199,28 +215,34 @@ void ReactInstance::loadScript(
        buffer = std::move(buffer),
        weakBufferedRuntimeExecuter = std::weak_ptr<BufferedRuntimeExecutor>(
            bufferedRuntimeExecutor_)](jsi::Runtime& runtime) {
-        try {
-          SystraceSection s("ReactInstance::loadScript");
-          bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
-          if (hasLogger) {
-            ReactMarker::logTaggedMarkerBridgeless(
-                ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
-          }
+        SystraceSection s("ReactInstance::loadScript");
+        bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
+        if (hasLogger) {
+          ReactMarker::logTaggedMarkerBridgeless(
+              ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+        }
 
-          runtime.evaluateJavaScript(buffer, sourceURL);
-          if (hasLogger) {
-            ReactMarker::logTaggedMarkerBridgeless(
-                ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
-            ReactMarker::logMarkerBridgeless(
-                ReactMarker::INIT_REACT_RUNTIME_STOP);
-            ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
-          }
-          if (auto strongBufferedRuntimeExecuter =
-                  weakBufferedRuntimeExecuter.lock()) {
-            strongBufferedRuntimeExecuter->flush();
-          }
-        } catch (jsi::JSError& error) {
-          jsErrorHandler_->handleFatalError(error);
+        runtime.evaluateJavaScript(buffer, sourceURL);
+
+        /**
+         * TODO(T183610671): We need a safe/reliable way to enable the js
+         * pipeline from javascript. Remove this after we figure that out, or
+         * after we just remove the js pipeline.
+         */
+        if (!jsErrorHandler_->hasHandledFatalError()) {
+          jsErrorHandler_->setRuntimeReady();
+        }
+
+        if (hasLogger) {
+          ReactMarker::logTaggedMarkerBridgeless(
+              ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
+          ReactMarker::logMarkerBridgeless(
+              ReactMarker::INIT_REACT_RUNTIME_STOP);
+          ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
+        }
+        if (auto strongBufferedRuntimeExecuter =
+                weakBufferedRuntimeExecuter.lock()) {
+          strongBufferedRuntimeExecuter->flush();
         }
       });
 }
@@ -332,6 +354,11 @@ void defineReactInstanceFlags(
   }
 }
 
+bool isTruthy(jsi::Runtime& runtime, const jsi::Value& value) {
+  auto Boolean = runtime.global().getPropertyAsFunction(runtime, "Boolean");
+  return Boolean.call(runtime, value).getBool();
+}
+
 } // namespace
 
 void ReactInstance::initializeRuntime(
@@ -346,8 +373,48 @@ void ReactInstance::initializeRuntime(
     RuntimeSchedulerBinding::createAndInstallIfNeeded(
         runtime, runtimeScheduler_);
 
+    runtime_->unstable_initializeOnJsThread();
+
     defineReactInstanceFlags(runtime, options);
 
+    // TODO(T196834299): We should really use a C++ turbomodule for this
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$handleException",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "handleException"),
+            2,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& runtime,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* args,
+                size_t count) {
+              if (count < 2) {
+                throw jsi::JSError(
+                    runtime,
+                    "handleException requires 2 arguments: error, isFatal");
+              }
+
+              auto isFatal = isTruthy(runtime, args[1]);
+              if (jsErrorHandler->isRuntimeReady()) {
+                if (isFatal) {
+                  jsErrorHandler->notifyOfFatalError();
+                }
+
+                return jsi::Value(false);
+              }
+
+              if (isFatal) {
+                auto jsError =
+                    jsi::JSError(runtime, jsi::Value(runtime, args[0]));
+                jsErrorHandler->handleFatalError(runtime, jsError);
+                return jsi::Value(true);
+              }
+
+              return jsi::Value(false);
+            }));
+
     defineReadOnlyGlobal(
         runtime,
         "RN$registerCallableModule",

package/ReactCommon/react/runtime/TimerManager.cpp

@@ -8,10 +8,51 @@
 #include "TimerManager.h"
 
 #include <cxxreact/SystraceSection.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+
+#include <cmath>
 #include <utility>
 
 namespace facebook::react {
 
+namespace {
+
+double coerceNumberTimeout(jsi::Runtime& rt, const jsi::Value& timeout) {
+  double delay = 0.0;
+
+  // fast-path
+  if (timeout.isNumber()) {
+    delay = timeout.getNumber();
+  } else {
+    // perform number coercion for timeout to be web spec compliant
+    auto numberCtor = rt.global().getPropertyAsObject(rt, "Number");
+    auto delayNumberObject =
+        numberCtor.getFunction(rt).callAsConstructor(rt, timeout).getObject(rt);
+    auto delayNumericValue =
+        delayNumberObject.getPropertyAsFunction(rt, "valueOf")
+            .callWithThis(rt, delayNumberObject);
+    delay = delayNumericValue.isNumber() ? delayNumericValue.getNumber() : 0;
+  }
+
+  return std::isnan(delay) ? 0.0 : std::max(0.0, delay);
+}
+
+inline const char* getTimerSourceName(TimerSource source) {
+  switch (source) {
+    case TimerSource::Unknown:
+      return "unknown";
+    case TimerSource::SetTimeout:
+      return "setTimeout";
+    case TimerSource::SetInterval:
+      return "setInterval";
+    case TimerSource::RequestAnimationFrame:
+      return "requestAnimationFrame";
+  }
+  return "unknown";
+}
+
+} // namespace
+
 TimerManager::TimerManager(
     std::unique_ptr<PlatformTimerRegistry> platformTimerRegistry) noexcept
     : platformTimerRegistry_(std::move(platformTimerRegistry)) {}
@@ -59,14 +100,28 @@ void TimerManager::callReactNativeMicrotasks(jsi::Runtime& runtime) {
 TimerHandle TimerManager::createTimer(
     jsi::Function&& callback,
     std::vector<jsi::Value>&& args,
-    double delay) {
+    double delay,
+    TimerSource source) {
   // Get the id for the callback.
   TimerHandle timerID = timerIndex_++;
+
+  SystraceSection s(
+      "TimerManager::createTimer",
+      "id",
+      timerID,
+      "type",
+      getTimerSourceName(source),
+      "delay",
+      delay);
+
   timers_.emplace(
       std::piecewise_construct,
       std::forward_as_tuple(timerID),
       std::forward_as_tuple(
-          std::move(callback), std::move(args), /* repeat */ false));
+          std::move(callback),
+          std::move(args),
+          /* repeat */ false,
+          source));
 
   platformTimerRegistry_->createTimer(timerID, delay);
 
@@ -76,14 +131,25 @@ TimerHandle TimerManager::createTimer(
 TimerHandle TimerManager::createRecurringTimer(
     jsi::Function&& callback,
     std::vector<jsi::Value>&& args,
-    double delay) {
+    double delay,
+    TimerSource source) {
   // Get the id for the callback.
   TimerHandle timerID = timerIndex_++;
+
+  SystraceSection s(
+      "TimerManager::createRecurringTimer",
+      "id",
+      timerID,
+      "type",
+      getTimerSourceName(source),
+      "delay",
+      delay);
+
   timers_.emplace(
       std::piecewise_construct,
       std::forward_as_tuple(timerID),
       std::forward_as_tuple(
-          std::move(callback), std::move(args), /* repeat */ true));
+          std::move(callback), std::move(args), /* repeat */ true, source));
 
   platformTimerRegistry_->createRecurringTimer(timerID, delay);
 
@@ -130,11 +196,20 @@ void TimerManager::deleteRecurringTimer(
 
 void TimerManager::callTimer(TimerHandle timerHandle) {
   runtimeExecutor_([this, timerHandle](jsi::Runtime& runtime) {
-    SystraceSection s("TimerManager::callTimer");
     auto it = timers_.find(timerHandle);
     if (it != timers_.end()) {
-      bool repeats = it->second.repeat;
-      it->second.invoke(runtime);
+      auto& timerCallback = it->second;
+      bool repeats = timerCallback.repeat;
+
+      {
+        SystraceSection s(
+            "TimerManager::callTimer",
+            "id",
+            timerHandle,
+            "type",
+            getTimerSourceName(timerCallback.source));
+        timerCallback.invoke(runtime);
+      }
 
       if (!repeats) {
         // Invoking a timer has the potential to delete it. Do not re-use the
@@ -148,60 +223,63 @@ void TimerManager::callTimer(TimerHandle timerHandle) {
 void TimerManager::attachGlobals(jsi::Runtime& runtime) {
   // Install host functions for timers.
   // TODO (T45786383): Add missing timer functions from JSTimers
-  // TODO (T96212789): Remove when JSVM microtask queue is used everywhere in
-  // bridgeless mode. This is being overwritten in JS in that case.
-  runtime.global().setProperty(
-      runtime,
-      "setImmediate",
-      jsi::Function::createFromHostFunction(
-          runtime,
-          jsi::PropNameID::forAscii(runtime, "setImmediate"),
-          2, // Function, ...args
-          [this](
-              jsi::Runtime& rt,
-              const jsi::Value& thisVal,
-              const jsi::Value* args,
-              size_t count) {
-            if (count == 0) {
-              throw jsi::JSError(
-                  rt,
-                  "setImmediate must be called with at least one argument (a function to call)");
-            }
-
-            if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
-              throw jsi::JSError(
-                  rt, "The first argument to setImmediate must be a function.");
-            }
-            auto callback = args[0].getObject(rt).getFunction(rt);
-
-            // Package up the remaining argument values into one place.
-            std::vector<jsi::Value> moreArgs;
-            for (size_t extraArgNum = 1; extraArgNum < count; extraArgNum++) {
-              moreArgs.emplace_back(rt, args[extraArgNum]);
-            }
-
-            return createReactNativeMicrotask(
-                std::move(callback), std::move(moreArgs));
-          }));
 
-  runtime.global().setProperty(
-      runtime,
-      "clearImmediate",
-      jsi::Function::createFromHostFunction(
-          runtime,
-          jsi::PropNameID::forAscii(runtime, "clearImmediate"),
-          1, // handle
-          [this](
-              jsi::Runtime& rt,
-              const jsi::Value& thisVal,
-              const jsi::Value* args,
-              size_t count) {
-            if (count > 0 && args[0].isNumber()) {
-              auto handle = (TimerHandle)args[0].asNumber();
-              deleteReactNativeMicrotask(rt, handle);
-            }
-            return jsi::Value::undefined();
-          }));
+  // Ensure that we don't define `setImmediate` and `clearImmediate` if
+  // microtasks are enabled (as we polyfill them using `queueMicrotask` then).
+  if (!ReactNativeFeatureFlags::enableMicrotasks()) {
+    runtime.global().setProperty(
+        runtime,
+        "setImmediate",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "setImmediate"),
+            2, // Function, ...args
+            [this](
+                jsi::Runtime& rt,
+                const jsi::Value& thisVal,
+                const jsi::Value* args,
+                size_t count) {
+              if (count == 0) {
+                throw jsi::JSError(
+                    rt,
+                    "setImmediate must be called with at least one argument (a function to call)");
+              }
+
+              if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
+                // Do not throw any error to match web spec
+                return timerIndex_++;
+              }
+              auto callback = args[0].getObject(rt).getFunction(rt);
+
+              // Package up the remaining argument values into one place.
+              std::vector<jsi::Value> moreArgs;
+              for (size_t extraArgNum = 1; extraArgNum < count; extraArgNum++) {
+                moreArgs.emplace_back(rt, args[extraArgNum]);
+              }
+
+              return createReactNativeMicrotask(
+                  std::move(callback), std::move(moreArgs));
+            }));
+
+    runtime.global().setProperty(
+        runtime,
+        "clearImmediate",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "clearImmediate"),
+            1, // handle
+            [this](
+                jsi::Runtime& rt,
+                const jsi::Value& thisVal,
+                const jsi::Value* args,
+                size_t count) {
+              if (count > 0 && args[0].isNumber()) {
+                auto handle = (TimerHandle)args[0].asNumber();
+                deleteReactNativeMicrotask(rt, handle);
+              }
+              return jsi::Value::undefined();
+            }));
+  }
 
   runtime.global().setProperty(
       runtime,
@@ -222,18 +300,12 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
             }
 
             if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
-              throw jsi::JSError(
-                  rt, "The first argument to setTimeout must be a function.");
+              // Do not throw any error to match web spec
+              return timerIndex_++;
             }
-            auto callback = args[0].getObject(rt).getFunction(rt);
 
-            if (count > 1 && !args[1].isNumber() && !args[1].isUndefined()) {
-              throw jsi::JSError(
-                  rt,
-                  "The second argument to setTimeout must be a number or undefined.");
-            }
-            auto delay =
-                count > 1 && args[1].isNumber() ? args[1].getNumber() : 0;
+            auto callback = args[0].getObject(rt).getFunction(rt);
+            auto delay = count > 1 ? coerceNumberTimeout(rt, args[1]) : 0.0;
 
             // Package up the remaining argument values into one place.
             std::vector<jsi::Value> moreArgs;
@@ -241,7 +313,11 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               moreArgs.emplace_back(rt, args[extraArgNum]);
             }
 
-            return createTimer(std::move(callback), std::move(moreArgs), delay);
+            return createTimer(
+                std::move(callback),
+                std::move(moreArgs),
+                delay,
+                TimerSource::SetTimeout);
           }));
 
   runtime.global().setProperty(
@@ -286,8 +362,9 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
                   rt, "The first argument to setInterval must be a function.");
             }
             auto callback = args[0].getObject(rt).getFunction(rt);
-            auto delay =
-                count > 1 && args[1].isNumber() ? args[1].getNumber() : 0;
+            auto delay = count > 1
+                ? coerceNumberTimeout(rt, jsi::Value{rt, args[1]})
+                : 0.0;
 
             // Package up the remaining argument values into one place.
             std::vector<jsi::Value> moreArgs;
@@ -296,7 +373,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
             }
 
             return createRecurringTimer(
-                std::move(callback), std::move(moreArgs), delay);
+                std::move(callback),
+                std::move(moreArgs),
+                delay,
+                TimerSource::SetInterval);
           }));
 
   runtime.global().setProperty(
@@ -365,7 +445,8 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
             return createTimer(
                 std::move(callback),
                 std::vector<jsi::Value>(),
-                /* delay */ 0);
+                /* delay */ 0,
+                TimerSource::RequestAnimationFrame);
           }));
 
   runtime.global().setProperty(

package/ReactCommon/react/runtime/TimerManager.h

@@ -18,6 +18,13 @@ namespace facebook::react {
 
 using TimerHandle = int;
 
+enum class TimerSource {
+  Unknown,
+  SetTimeout,
+  SetInterval,
+  RequestAnimationFrame
+};
+
 /*
  * Wraps a jsi::Function to make it copyable so we can pass it into a lambda.
  */
@@ -25,10 +32,12 @@ struct TimerCallback {
   TimerCallback(
       jsi::Function callback,
       std::vector<jsi::Value> args,
-      bool repeat)
+      bool repeat,
+      TimerSource source = TimerSource::Unknown)
       : callback_(std::move(callback)),
         args_(std::move(args)),
-        repeat(repeat) {}
+        repeat(repeat),
+        source(source) {}
 
   void invoke(jsi::Runtime& runtime) {
     callback_.call(runtime, args_.data(), args_.size());
@@ -37,6 +46,7 @@ struct TimerCallback {
   jsi::Function callback_;
   const std::vector<jsi::Value> args_;
   bool repeat;
+  TimerSource source;
 };
 
 class TimerManager {
@@ -62,14 +72,16 @@ class TimerManager {
   TimerHandle createTimer(
       jsi::Function&& callback,
       std::vector<jsi::Value>&& args,
-      double delay);
+      double delay,
+      TimerSource source = TimerSource::Unknown);
 
   void deleteTimer(jsi::Runtime& runtime, TimerHandle handle);
 
   TimerHandle createRecurringTimer(
       jsi::Function&& callback,
       std::vector<jsi::Value>&& args,
-      double delay);
+      double delay,
+      TimerSource source = TimerSource::Unknown);
 
   void deleteRecurringTimer(jsi::Runtime& runtime, TimerHandle handle);
 

package/ReactCommon/react/runtime/hermes/CMakeLists.txt

@@ -11,20 +11,18 @@ add_compile_options(-std=c++20)
 file(GLOB_RECURSE bridgeless_hermes_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(
         bridgelesshermes
-        STATIC
+        OBJECT
         ${bridgeless_hermes_SRC}
 )
 target_include_directories(bridgelesshermes PUBLIC .)
 
 target_link_libraries(bridgelesshermes
-        jsireact
         hermes-engine::libhermes
+        hermes_executor_common
         hermes_inspector_modern
         jsi
-        hermes_executor_common
-        bridgeless
-        react_featureflags
         jsinspector
+        reactnative
 )
 
 if(${CMAKE_BUILD_TYPE} MATCHES Debug)

package/ReactCommon/react/runtime/hermes/HermesInstance.cpp

@@ -109,6 +109,10 @@ class HermesJSRuntime : public JSRuntime {
     return *targetDelegate_;
   }
 
+  void unstable_initializeOnJsThread() override {
+    runtime_->registerForProfiling();
+  }
+
  private:
   std::shared_ptr<HermesRuntime> runtime_;
   std::optional<jsinspector_modern::HermesRuntimeTargetDelegate>
@@ -117,32 +121,37 @@ class HermesJSRuntime : public JSRuntime {
 
 std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
     std::shared_ptr<const ReactNativeConfig> reactNativeConfig,
-    std::shared_ptr<::hermes::vm::CrashManager> cm,
-    std::shared_ptr<MessageQueueThread> msgQueueThread) noexcept {
+    std::shared_ptr<::hermes::vm::CrashManager> crashManager,
+    std::shared_ptr<MessageQueueThread> msgQueueThread,
+    bool allocInOldGenBeforeTTI) noexcept {
   assert(msgQueueThread != nullptr);
+
+  auto gcConfig = ::hermes::vm::GCConfig::Builder()
+                      // Default to 3GB
+                      .withMaxHeapSize(3072 << 20)
+                      .withName("RNBridgeless");
+
+  if (allocInOldGenBeforeTTI) {
+    // For the next two arguments: avoid GC before TTI
+    // by initializing the runtime to allocate directly
+    // in the old generation, but revert to normal
+    // operation when we reach the (first) TTI point.
+    gcConfig.withAllocInYoung(false).withRevertToYGAtTTI(true);
+  }
+
   int64_t vmExperimentFlags = reactNativeConfig
       ? reactNativeConfig->getInt64("ios_hermes:vm_experiment_flags")
       : 0;
 
   ::hermes::vm::RuntimeConfig::Builder runtimeConfigBuilder =
       ::hermes::vm::RuntimeConfig::Builder()
-          .withGCConfig(::hermes::vm::GCConfig::Builder()
-                            // Default to 3GB
-                            .withMaxHeapSize(3072 << 20)
-                            .withName("RNBridgeless")
-                            // For the next two arguments: avoid GC before TTI
-                            // by initializing the runtime to allocate directly
-                            // in the old generation, but revert to normal
-                            // operation when we reach the (first) TTI point.
-                            .withAllocInYoung(false)
-                            .withRevertToYGAtTTI(true)
-                            .build())
+          .withGCConfig(gcConfig.build())
           .withEnableSampleProfiling(true)
           .withMicrotaskQueue(ReactNativeFeatureFlags::enableMicrotasks())
           .withVMExperimentFlags(vmExperimentFlags);
 
-  if (cm) {
-    runtimeConfigBuilder.withCrashMgr(cm);
+  if (crashManager) {
+    runtimeConfigBuilder.withCrashMgr(crashManager);
   }
 
   std::unique_ptr<HermesRuntime> hermesRuntime =