react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -11,7 +11,6 @@
 #include <mutex>
 
 #include <ReactCommon/RuntimeExecutor.h>
-#include <react/config/ReactNativeConfig.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
@@ -85,7 +84,7 @@ class Scheduler final : public UIManagerDelegate {
 #pragma mark - UIManagerDelegate
 
   void uiManagerDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) override;
   void uiManagerDidCreateShadowNode(const ShadowNode& shadowNode) override;
   void uiManagerDidDispatchCommand(
@@ -120,7 +119,6 @@ class Scheduler final : public UIManagerDelegate {
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   RuntimeExecutor runtimeExecutor_;
   std::shared_ptr<UIManager> uiManager_;
-  std::shared_ptr<const ReactNativeConfig> reactNativeConfig_;
 
   std::vector<std::shared_ptr<UIManagerCommitHook>> commitHooks_;
 
@@ -141,6 +139,8 @@ class Scheduler final : public UIManagerDelegate {
    * Must not be nullptr.
    */
   ContextContainer::Shared contextContainer_;
+
+  RuntimeScheduler* runtimeScheduler_{nullptr};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -26,7 +26,8 @@ class SchedulerDelegate {
    * to construct a new one.
    */
   virtual void schedulerDidFinishTransaction(
-      const MountingCoordinator::Shared& mountingCoordinator) = 0;
+      const std::shared_ptr<const MountingCoordinator>&
+          mountingCoordinator) = 0;
 
   /*
    * Called when the runtime scheduler decides that one-or-more previously
@@ -37,7 +38,8 @@ class SchedulerDelegate {
    * correctly apply changes, due to changes in Props representation.
    */
   virtual void schedulerShouldRenderTransactions(
-      const MountingCoordinator::Shared& mountingCoordinator) = 0;
+      const std::shared_ptr<const MountingCoordinator>&
+          mountingCoordinator) = 0;
 
   /*
    * Called right after a new ShadowNode was created.

package/ReactCommon/react/renderer/scheduler/SchedulerToolbox.h

@@ -49,11 +49,10 @@ struct SchedulerToolbox final {
   RuntimeExecutor runtimeExecutor;
 
   /*
-   * Asynchronous & synchronous event beats.
    * Represent connections with the platform-specific run loops and general
    * purpose background queue.
    */
-  EventBeat::Factory asynchronousEventBeatFactory;
+  EventBeat::Factory eventBeatFactory;
 
   /*
    * A list of `UIManagerCommitHook`s that should be registered in `UIManager`.

package/ReactCommon/react/renderer/scheduler/SurfaceManager.cpp

@@ -64,9 +64,9 @@ Size SurfaceManager::measureSurface(
   return size;
 }
 
-MountingCoordinator::Shared SurfaceManager::findMountingCoordinator(
-    SurfaceId surfaceId) const noexcept {
-  auto mountingCoordinator = MountingCoordinator::Shared{};
+std::shared_ptr<const MountingCoordinator>
+SurfaceManager::findMountingCoordinator(SurfaceId surfaceId) const noexcept {
+  auto mountingCoordinator = std::shared_ptr<const MountingCoordinator>{};
 
   visit(surfaceId, [&](const SurfaceHandler& surfaceHandler) {
     mountingCoordinator = surfaceHandler.getMountingCoordinator();

package/ReactCommon/react/renderer/scheduler/SurfaceManager.h

@@ -49,7 +49,7 @@ class SurfaceManager final {
       const LayoutConstraints& layoutConstraints,
       const LayoutContext& layoutContext) const noexcept;
 
-  MountingCoordinator::Shared findMountingCoordinator(
+  std::shared_ptr<const MountingCoordinator> findMountingCoordinator(
       SurfaceId surfaceId) const noexcept;
 
  private:

package/ReactCommon/react/renderer/textlayoutmanager/TextMeasureCache.h

@@ -208,8 +208,7 @@ inline bool operator==(
   return areAttributedStringsEquivalentLayoutWise(
              lhs.attributedString, rhs.attributedString) &&
       lhs.paragraphAttributes == rhs.paragraphAttributes &&
-      lhs.layoutConstraints.maximumSize.width ==
-      rhs.layoutConstraints.maximumSize.width;
+      lhs.layoutConstraints == rhs.layoutConstraints;
 }
 
 inline bool operator!=(
@@ -243,7 +242,7 @@ struct hash<facebook::react::TextMeasureCacheKey> {
     return facebook::react::hash_combine(
         attributedStringHashLayoutWise(key.attributedString),
         key.paragraphAttributes,
-        key.layoutConstraints.maximumSize.width);
+        key.layoutConstraints);
   }
 };
 

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.mm

@@ -407,6 +407,7 @@ static NSMutableAttributedString *RCTNSAttributedStringFragmentWithAttributesFro
 {
   auto nsAttributedStringFragment = RCTNSAttributedStringFragmentFromFragment(fragment, placeholderImage);
 
+#if !TARGET_OS_MACCATALYST
   if (fragment.parentShadowView.componentHandle) {
     RCTWeakEventEmitterWrapper *eventEmitterWrapper = [RCTWeakEventEmitterWrapper new];
     eventEmitterWrapper.eventEmitter = fragment.parentShadowView.eventEmitter;
@@ -417,6 +418,7 @@ static NSMutableAttributedString *RCTNSAttributedStringFragmentWithAttributesFro
     [nsAttributedStringFragment addAttributes:additionalTextAttributes
                                         range:NSMakeRange(0, nsAttributedStringFragment.length)];
   }
+#endif
 
   return nsAttributedStringFragment;
 }

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm

@@ -347,8 +347,33 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
   [layoutManager ensureLayoutForTextContainer:textContainer];
 
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+  __block BOOL textDidWrap = NO;
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(
+                                   CGRect overallRect,
+                                   CGRect usedRect,
+                                   NSTextContainer *_Nonnull usedTextContainer,
+                                   NSRange lineGlyphRange,
+                                   BOOL *_Nonnull stop) {
+                                 NSRange range = [layoutManager characterRangeForGlyphRange:lineGlyphRange
+                                                                           actualGlyphRange:nil];
+                                 NSUInteger lastCharacterIndex = range.location + range.length - 1;
+                                 BOOL endsWithNewLine =
+                                     [textStorage.string characterAtIndex:lastCharacterIndex] == '\n';
+                                 if (!endsWithNewLine && textStorage.string.length > lastCharacterIndex + 1) {
+                                   textDidWrap = YES;
+                                   *stop = YES;
+                                 }
+                               }];
+
   CGSize size = [layoutManager usedRectForTextContainer:textContainer].size;
 
+  if (textDidWrap) {
+    size.width = textContainer.size.width;
+  }
+
   size = (CGSize){RCTCeilPixelValue(size.width), RCTCeilPixelValue(size.height)};
 
   __block auto attachments = TextMeasurement::Attachments{};

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -382,9 +382,6 @@ void UIManager::updateState(const StateUpdate& stateUpdate) const {
   auto& callback = stateUpdate.callback;
   auto& family = stateUpdate.family;
   auto& componentDescriptor = family->getComponentDescriptor();
-  auto clonedByNativeStateTraits = ShadowNodeTraits();
-  clonedByNativeStateTraits.set(
-      ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
 
   shadowTreeRegistry_.visit(
       family->getSurfaceId(), [&](const ShadowTree& shadowTree) {
@@ -393,8 +390,7 @@ void UIManager::updateState(const StateUpdate& stateUpdate) const {
               auto isValid = true;
 
               auto rootNode = oldRootShadowNode.cloneTree(
-                  *family,
-                  [&](const ShadowNode& oldShadowNode) {
+                  *family, [&](const ShadowNode& oldShadowNode) {
                     auto newData =
                         callback(oldShadowNode.getState()->getDataPointer());
 
@@ -410,10 +406,8 @@ void UIManager::updateState(const StateUpdate& stateUpdate) const {
                     return oldShadowNode.clone(
                         {.props = ShadowNodeFragment::propsPlaceholder(),
                          .children = ShadowNodeFragment::childrenPlaceholder(),
-                         .state = newState,
-                         .traits = clonedByNativeStateTraits});
-                  },
-                  clonedByNativeStateTraits);
+                         .state = newState});
+                  });
 
               return isValid
                   ? std::static_pointer_cast<RootShadowNode>(rootNode)
@@ -634,7 +628,7 @@ RootShadowNode::Unshared UIManager::shadowTreeWillCommit(
 }
 
 void UIManager::shadowTreeDidFinishTransaction(
-    MountingCoordinator::Shared mountingCoordinator,
+    std::shared_ptr<const MountingCoordinator> mountingCoordinator,
     bool mountSynchronously) const {
   SystraceSection s("UIManager::shadowTreeDidFinishTransaction");
 

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -119,7 +119,7 @@ class UIManager final : public ShadowTreeDelegate {
 #pragma mark - ShadowTreeDelegate
 
   void shadowTreeDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) const override;
 
   RootShadowNode::Unshared shadowTreeWillCommit(

package/ReactCommon/react/renderer/uimanager/UIManagerAnimationDelegate.h

@@ -31,7 +31,7 @@ class UIManagerAnimationDelegate {
   /**
    * Set ComponentDescriptor registry.
    *
-   * @param componentDescriptorRegistry
+   * @param componentDescriptorRegistry the registry of componentDescriptors
    */
   virtual void setComponentDescriptorRegistry(
       const SharedComponentDescriptorRegistry& componentDescriptorRegistry) = 0;

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.cpp

@@ -483,9 +483,7 @@ jsi::Value UIManagerBinding::get(
           uiManager->completeSurface(
               surfaceId,
               shadowNodeList,
-              {.enableStateReconciliation = true,
-               .mountSynchronously = false,
-               .shouldYield = nullptr});
+              {.enableStateReconciliation = true, .mountSynchronously = false});
 
           return jsi::Value::undefined();
         });

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -23,7 +23,7 @@ class UIManagerDelegate {
    * For this moment the tree is already laid out and sealed.
    */
   virtual void uiManagerDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) = 0;
 
   /*

package/ReactCommon/react/renderer/uimanager/consistency/tests/LazyShadowTreeRevisionConsistencyManagerTest.cpp

@@ -24,7 +24,7 @@ class FakeShadowTreeDelegate : public ShadowTreeDelegate {
   };
 
   void shadowTreeDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) const override {};
 };
 

package/ReactCommon/react/renderer/uimanager/tests/PointerEventsProcessorTest.cpp

@@ -87,8 +87,8 @@ class PointerEventsProcessorTest : public ::testing::Test {
             listenToAllPointerEvents(props);
             props.layoutConstraints = LayoutConstraints{{0,0}, {500, 500}};
             auto &yogaStyle = props.yogaStyle;
-            yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(400));
-            yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(400));
+            yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(400));
+            yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(400));
             yogaStyle.setDisplay(yoga::Display::Flex);
             yogaStyle.setFlexDirection(yoga::FlexDirection::Row);
             yogaStyle.setAlignItems(yoga::Align::Center);
@@ -109,8 +109,8 @@ class PointerEventsProcessorTest : public ::testing::Test {
                 yogaStyle.setFlexDirection(yoga::FlexDirection::Column);
                 yogaStyle.setAlignItems(yoga::Align::FlexEnd);
                 yogaStyle.setJustifyContent(yoga::Justify::Center);
-                yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(150));
-                yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(300));
+                yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(150));
+                yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(300));
                 return sharedProps;
               })
               .children({
@@ -123,8 +123,8 @@ class PointerEventsProcessorTest : public ::testing::Test {
                     auto &props = *sharedProps;
                     listenToAllPointerEvents(props);
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(100));
-                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(200));
+                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(100));
+                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(200));
                     return sharedProps;
                   })
               }),
@@ -141,8 +141,8 @@ class PointerEventsProcessorTest : public ::testing::Test {
                 yogaStyle.setFlexDirection(yoga::FlexDirection::Column);
                 yogaStyle.setAlignItems(yoga::Align::FlexStart);
                 yogaStyle.setJustifyContent(yoga::Justify::Center);
-                yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(150));
-                yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(300));
+                yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(150));
+                yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(300));
                 return sharedProps;
               })
               .children({
@@ -155,8 +155,8 @@ class PointerEventsProcessorTest : public ::testing::Test {
                     auto &props = *sharedProps;
                     listenToAllPointerEvents(props);
                     auto &yogaStyle = props.yogaStyle;
-                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::value::points(100));
-                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::value::points(200));
+                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(100));
+                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(200));
                     return sharedProps;
                   })
               })

package/ReactCommon/react/runtime/React-RuntimeCore.podspec

@@ -19,9 +19,10 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
+folly_dep_name = folly_config[:dep_name]
 
-folly_dep_name = 'RCT-Folly/Fabric'
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags] 
 
 Pod::Spec.new do |s|
   s.name                   = "React-RuntimeCore"
@@ -57,6 +58,8 @@ Pod::Spec.new do |s|
   s.dependency "React-runtimescheduler"
   s.dependency "React-utils"
   s.dependency "React-featureflags"
+  
+  add_dependency(s, "React-Fabric")
 
   if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
     s.dependency "hermes-engine"

package/ReactCommon/react/runtime/React-RuntimeHermes.podspec

@@ -19,8 +19,10 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-folly_dep_name = 'RCT-Folly/Fabric'
-boost_compiler_flags = '-Wno-documentation'
+folly_dep_name = folly_config[:dep_name]
+
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags] 
 
 Pod::Spec.new do |s|
   s.name                   = "React-RuntimeHermes"

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -19,6 +19,7 @@
 #include <jsinspector-modern/HostTarget.h>
 #include <jsireact/JSIExecutor.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 #include <react/utils/jsi-utils.h>
 #include <iostream>
@@ -27,6 +28,24 @@
 
 namespace facebook::react {
 
+namespace {
+
+std::shared_ptr<RuntimeScheduler> createRuntimeScheduler(
+    RuntimeExecutor runtimeExecutor,
+    RuntimeSchedulerTaskErrorHandler taskErrorHandler) {
+  std::shared_ptr<RuntimeScheduler> scheduler =
+      std::make_shared<RuntimeScheduler>(
+          runtimeExecutor, RuntimeSchedulerClock::now, taskErrorHandler);
+  scheduler->setPerformanceEntryReporter(
+      // FIXME: Move creation of PerformanceEntryReporter to here and
+      // guarantee that its lifetime is the same as the runtime.
+      PerformanceEntryReporter::getInstance().get());
+
+  return scheduler;
+}
+
+} // namespace
+
 ReactInstance::ReactInstance(
     std::unique_ptr<JSRuntime> runtime,
     std::shared_ptr<MessageQueueThread> jsMessageQueueThread,
@@ -74,17 +93,22 @@ ReactInstance::ReactInstance(
         jsi::Runtime& jsiRuntime = runtime->getRuntime();
         SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
         try {
+          ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(true);
           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 (ReactNativeFeatureFlags::disableEventLoopOnBridgeless()) {
             if (auto timerManager = weakTimerManager.lock()) {
               timerManager->callReactNativeMicrotasks(jsiRuntime);
             }
           }
         } catch (jsi::JSError& originalError) {
-          jsErrorHandler->handleFatalError(jsiRuntime, originalError);
+          jsErrorHandler->handleError(jsiRuntime, originalError, true);
+        } catch (std::exception& ex) {
+          jsi::JSError error(
+              jsiRuntime, std::string("Non-js exception: ") + ex.what());
+          jsErrorHandler->handleError(jsiRuntime, error, true);
         }
       });
     }
@@ -93,13 +117,34 @@ ReactInstance::ReactInstance(
   if (parentInspectorTarget_) {
     auto executor = parentInspectorTarget_->executorFromThis();
 
-    auto runtimeExecutorThatWaitsForInspectorSetup =
+    auto bufferedRuntimeExecutorThatWaitsForInspectorSetup =
         std::make_shared<BufferedRuntimeExecutor>(runtimeExecutor);
+    auto runtimeExecutorThatExecutesAfterInspectorSetup =
+        [bufferedRuntimeExecutorThatWaitsForInspectorSetup](
+            std::function<void(jsi::Runtime & runtime)>&& callback) {
+          bufferedRuntimeExecutorThatWaitsForInspectorSetup->execute(
+              std::move(callback));
+        };
+
+    runtimeScheduler_ = createRuntimeScheduler(
+        runtimeExecutorThatExecutesAfterInspectorSetup,
+        [jsErrorHandler = jsErrorHandler_](
+            jsi::Runtime& runtime, jsi::JSError& error) {
+          jsErrorHandler->handleError(runtime, error, true);
+        });
+
+    auto runtimeExecutorThatGoesThroughRuntimeScheduler =
+        [runtimeScheduler = runtimeScheduler_.get()](
+            std::function<void(jsi::Runtime & runtime)>&& callback) {
+          runtimeScheduler->scheduleWork(std::move(callback));
+        };
 
     // This code can execute from any thread, so we need to make sure we set up
     // the inspector logic in the right one. The callback executes immediately
     // if we are already in the right thread.
-    executor([this, runtimeExecutor, runtimeExecutorThatWaitsForInspectorSetup](
+    executor([this,
+              runtimeExecutorThatGoesThroughRuntimeScheduler,
+              bufferedRuntimeExecutorThatWaitsForInspectorSetup](
                  jsinspector_modern::HostTarget& hostTarget) {
       // Callbacks scheduled through the page target executor are generally
       // not guaranteed to run (e.g.: if the page target is destroyed)
@@ -110,32 +155,19 @@ ReactInstance::ReactInstance(
       //   creation task to finish before starting the destruction.
       inspectorTarget_ = &hostTarget.registerInstance(*this);
       runtimeInspectorTarget_ = &inspectorTarget_->registerRuntime(
-          runtime_->getRuntimeTargetDelegate(), runtimeExecutor);
-      runtimeExecutorThatWaitsForInspectorSetup->flush();
+          runtime_->getRuntimeTargetDelegate(),
+          runtimeExecutorThatGoesThroughRuntimeScheduler);
+      bufferedRuntimeExecutorThatWaitsForInspectorSetup->flush();
     });
-
-    // We decorate the runtime executor used everywhere else to wait for the
-    // inspector to finish its setup.
-    runtimeExecutor =
-        [runtimeExecutorThatWaitsForInspectorSetup](
-            std::function<void(jsi::Runtime & runtime)>&& callback) {
-          runtimeExecutorThatWaitsForInspectorSetup->execute(
-              std::move(callback));
-        };
+  } else {
+    runtimeScheduler_ = createRuntimeScheduler(
+        runtimeExecutor,
+        [jsErrorHandler = jsErrorHandler_](
+            jsi::Runtime& runtime, jsi::JSError& error) {
+          jsErrorHandler->handleError(runtime, error, true);
+        });
   }
 
-  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()](
           std::function<void(jsi::Runtime & runtime)>&& callback) {
@@ -259,6 +291,12 @@ void ReactInstance::callFunctionOnModule(
     const std::string& moduleName,
     const std::string& methodName,
     folly::dynamic&& args) {
+  if (bufferedRuntimeExecutor_ == nullptr) {
+    LOG(ERROR)
+        << "Calling callFunctionOnModule with null BufferedRuntimeExecutor";
+    return;
+  }
+
   bufferedRuntimeExecutor_->execute([this,
                                      moduleName = moduleName,
                                      methodName = methodName,
@@ -381,6 +419,73 @@ void ReactInstance::initializeRuntime(
 
     defineReactInstanceFlags(runtime, options);
 
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$useAlwaysAvailableJSErrorHandling",
+        jsi::Value(
+            ReactNativeFeatureFlags::useAlwaysAvailableJSErrorHandling()));
+
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$isRuntimeReady",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "isRuntimeReady"),
+            0,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& /*runtime*/,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* /*args*/,
+                size_t /*count*/) {
+              return jsErrorHandler->isRuntimeReady();
+            }));
+
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$hasHandledFatalException",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "hasHandledFatalException"),
+            0,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& /*runtime*/,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* /*args*/,
+                size_t /*count*/) {
+              return jsErrorHandler->hasHandledFatalError();
+            }));
+
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$notifyOfFatalException",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "notifyOfFatalException"),
+            0,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& /*runtime*/,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* /*args*/,
+                size_t /*count*/) {
+              jsErrorHandler->notifyOfFatalError();
+              return jsi::Value::undefined();
+            }));
+
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$inExceptionHandler",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "inExceptionHandler"),
+            0,
+            [jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& /*runtime*/,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* /*args*/,
+                size_t /*count*/) {
+              return jsErrorHandler->inErrorHandler();
+            }));
+
     // TODO(T196834299): We should really use a C++ turbomodule for this
     defineReadOnlyGlobal(
         runtime,
@@ -388,7 +493,7 @@ void ReactInstance::initializeRuntime(
         jsi::Function::createFromHostFunction(
             runtime,
             jsi::PropNameID::forAscii(runtime, "handleException"),
-            2,
+            3,
             [jsErrorHandler = jsErrorHandler_](
                 jsi::Runtime& runtime,
                 const jsi::Value& /*unused*/,
@@ -397,26 +502,71 @@ void ReactInstance::initializeRuntime(
               if (count < 2) {
                 throw jsi::JSError(
                     runtime,
-                    "handleException requires 2 arguments: error, isFatal");
+                    "handleException requires 3 arguments: error, isFatal, logToConsole (optional)");
               }
 
               auto isFatal = isTruthy(runtime, args[1]);
-              if (jsErrorHandler->isRuntimeReady()) {
-                if (isFatal) {
-                  jsErrorHandler->notifyOfFatalError();
+
+              if (!ReactNativeFeatureFlags::
+                      useAlwaysAvailableJSErrorHandling()) {
+                if (jsErrorHandler->isRuntimeReady()) {
+                  return jsi::Value(false);
                 }
+              }
+
+              auto jsError =
+                  jsi::JSError(runtime, jsi::Value(runtime, args[0]));
+
+              if (count == 2) {
+                jsErrorHandler->handleError(runtime, jsError, isFatal);
+              } else {
+                auto logToConsole = isTruthy(runtime, args[2]);
+                jsErrorHandler->handleError(
+                    runtime, jsError, isFatal, logToConsole);
+              }
+
+              return jsi::Value(true);
+            }));
 
-                return jsi::Value(false);
+    defineReadOnlyGlobal(
+        runtime,
+        "RN$registerExceptionListener",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "registerExceptionListener"),
+            1,
+            [errorListeners = std::vector<std::shared_ptr<jsi::Function>>(),
+             jsErrorHandler = jsErrorHandler_](
+                jsi::Runtime& runtime,
+                const jsi::Value& /*unused*/,
+                const jsi::Value* args,
+                size_t count) mutable {
+              if (count < 1) {
+                throw jsi::JSError(
+                    runtime,
+                    "registerExceptionListener: requires 1 argument: fn");
               }
 
-              if (isFatal) {
-                auto jsError =
-                    jsi::JSError(runtime, jsi::Value(runtime, args[0]));
-                jsErrorHandler->handleFatalError(runtime, jsError);
-                return jsi::Value(true);
+              if (!args[0].isObject() ||
+                  !args[0].getObject(runtime).isFunction(runtime)) {
+                throw jsi::JSError(
+                    runtime,
+                    "registerExceptionListener: The first argument must be a function");
               }
 
-              return jsi::Value(false);
+              auto errorListener = std::make_shared<jsi::Function>(
+                  args[0].getObject(runtime).getFunction(runtime));
+              errorListeners.emplace_back(errorListener);
+
+              jsErrorHandler->registerErrorListener(
+                  [weakErrorListener = std::weak_ptr<jsi::Function>(
+                       errorListener)](jsi::Runtime& runtime, jsi::Value data) {
+                    if (auto strongErrorListener = weakErrorListener.lock()) {
+                      strongErrorListener->call(runtime, data);
+                    }
+                  });
+
+              return jsi::Value::undefined();
             }));
 
     defineReadOnlyGlobal(