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

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

@@ -11,6 +11,7 @@
 
 #import <React/NSTextStorage+FontScaling.h>
 #import <React/RCTUtils.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/utils/ManagedObjectWrapper.h>
 #import <react/utils/SimpleThreadSafeCache.h>
 
@@ -82,6 +83,9 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
 #endif
 
   NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+
+  [self processTruncatedAttributedText:textStorage textContainer:textContainer layoutManager:layoutManager];
+
   [layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:frame.origin];
   [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:frame.origin];
 
@@ -122,6 +126,49 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   }
 }
 
+- (void)processTruncatedAttributedText:(NSTextStorage *)textStorage
+                         textContainer:(NSTextContainer *)textContainer
+                         layoutManager:(NSLayoutManager *)layoutManager
+{
+  if (textContainer.maximumNumberOfLines > 0) {
+    [layoutManager ensureLayoutForTextContainer:textContainer];
+    NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+    __block int line = 0;
+    [layoutManager
+        enumerateLineFragmentsForGlyphRange:glyphRange
+                                 usingBlock:^(
+                                     CGRect rect,
+                                     CGRect usedRect,
+                                     NSTextContainer *_Nonnull _,
+                                     NSRange lineGlyphRange,
+                                     BOOL *_Nonnull stop) {
+                                   if (line == textContainer.maximumNumberOfLines - 1) {
+                                     NSRange truncatedRange = [layoutManager
+                                         truncatedGlyphRangeInLineFragmentForGlyphAtIndex:lineGlyphRange.location];
+                                     if (truncatedRange.location != NSNotFound) {
+                                       NSRange characterRange =
+                                           [layoutManager characterRangeForGlyphRange:truncatedRange
+                                                                     actualGlyphRange:nil];
+                                       if (characterRange.location > 0 && characterRange.length > 0) {
+                                         // Remove color attributes for truncated range
+                                         for (NSAttributedStringKey key in
+                                              @[ NSForegroundColorAttributeName, NSBackgroundColorAttributeName ]) {
+                                           [textStorage removeAttribute:key range:characterRange];
+                                           id attribute = [textStorage attribute:key
+                                                                         atIndex:characterRange.location - 1
+                                                                  effectiveRange:nil];
+                                           if (attribute) {
+                                             [textStorage addAttribute:key value:attribute range:characterRange];
+                                           }
+                                         }
+                                       }
+                                     }
+                                   }
+                                   line++;
+                                 }];
+  }
+}
+
 - (LinesMeasurements)getLinesForAttributedString:(facebook::react::AttributedString)attributedString
                              paragraphAttributes:(facebook::react::ParagraphAttributes)paragraphAttributes
                                             size:(CGSize)size
@@ -155,14 +202,28 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                                             auto rect = facebook::react::Rect{
                                                 facebook::react::Point{usedRect.origin.x, usedRect.origin.y},
                                                 facebook::react::Size{usedRect.size.width, usedRect.size.height}};
-                                            auto line = LineMeasurement{
-                                                std::string([renderedString UTF8String]),
-                                                rect,
-                                                -font.descender,
-                                                font.capHeight,
-                                                font.ascender,
-                                                font.xHeight};
-                                            blockParagraphLines->push_back(line);
+
+                                            if (ReactNativeFeatureFlags::enableAlignItemsBaselineOnFabricIOS()) {
+                                              CGFloat baseline =
+                                                  [layoutManager locationForGlyphAtIndex:range.location].y;
+                                              auto line = LineMeasurement{
+                                                  std::string([renderedString UTF8String]),
+                                                  rect,
+                                                  overallRect.size.height - baseline,
+                                                  font.capHeight,
+                                                  baseline,
+                                                  font.xHeight};
+                                              blockParagraphLines->push_back(line);
+                                            } else {
+                                              auto line = LineMeasurement{
+                                                  std::string([renderedString UTF8String]),
+                                                  rect,
+                                                  -font.descender,
+                                                  font.capHeight,
+                                                  font.ascender,
+                                                  font.xHeight};
+                                              blockParagraphLines->push_back(line);
+                                            }
                                           }];
   return paragraphLines;
 }
@@ -185,6 +246,8 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
 
   NSTextStorage *textStorage = [[NSTextStorage alloc] initWithAttributedString:attributedString];
 
+  RCTApplyBaselineOffset(textStorage);
+
   [textStorage addLayoutManager:layoutManager];
 
   if (paragraphAttributes.adjustsFontSizeToFit) {
@@ -302,12 +365,19 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                 CGSize attachmentSize = attachment.bounds.size;
                 CGRect glyphRect = [layoutManager boundingRectForGlyphRange:range inTextContainer:textContainer];
 
-                UIFont *font = [textStorage attribute:NSFontAttributeName atIndex:range.location effectiveRange:nil];
+                CGRect frame;
+                if (ReactNativeFeatureFlags::enableAlignItemsBaselineOnFabricIOS()) {
+                  CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
 
-                CGRect frame = {
-                    {glyphRect.origin.x,
-                     glyphRect.origin.y + glyphRect.size.height - attachmentSize.height + font.descender},
-                    attachmentSize};
+                  frame = {{glyphRect.origin.x, glyphRect.origin.y + baseline - attachmentSize.height}, attachmentSize};
+                } else {
+                  UIFont *font = [textStorage attribute:NSFontAttributeName atIndex:range.location effectiveRange:nil];
+
+                  frame = {
+                      {glyphRect.origin.x,
+                       glyphRect.origin.y + glyphRect.size.height - attachmentSize.height + font.descender},
+                      attachmentSize};
+                }
 
                 auto rect = facebook::react::Rect{
                     facebook::react::Point{frame.origin.x, frame.origin.y},

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextPrimitivesConversions.h

@@ -63,6 +63,24 @@ inline static NSLineBreakStrategy RCTNSLineBreakStrategyFromLineBreakStrategy(
   }
 }
 
+inline static NSLineBreakMode RCTNSLineBreakModeFromLineBreakMode(facebook::react::LineBreakMode lineBreakMode)
+{
+  switch (lineBreakMode) {
+    case facebook::react::LineBreakMode::Word:
+      return NSLineBreakByWordWrapping;
+    case facebook::react::LineBreakMode::Char:
+      return NSLineBreakByCharWrapping;
+    case facebook::react::LineBreakMode::Clip:
+      return NSLineBreakByClipping;
+    case facebook::react::LineBreakMode::Head:
+      return NSLineBreakByTruncatingHead;
+    case facebook::react::LineBreakMode::Middle:
+      return NSLineBreakByTruncatingMiddle;
+    case facebook::react::LineBreakMode::Tail:
+      return NSLineBreakByTruncatingTail;
+  }
+}
+
 inline static RCTFontStyle RCTFontStyleFromFontStyle(facebook::react::FontStyle fontStyle)
 {
   switch (fontStyle) {

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/TextLayoutManager.h

@@ -31,19 +31,28 @@ class TextLayoutManager {
    * Measures `attributedString` using native text rendering infrastructure.
    */
   TextMeasurement measure(
-      AttributedStringBox attributedStringBox,
-      ParagraphAttributes paragraphAttributes,
+      const AttributedStringBox& attributedStringBox,
+      const ParagraphAttributes& paragraphAttributes,
       const TextLayoutContext& layoutContext,
-      LayoutConstraints layoutConstraints) const;
+      const LayoutConstraints& layoutConstraints) const;
 
   /*
    * Measures lines of `attributedString` using native text rendering
    * infrastructure.
    */
   LinesMeasurements measureLines(
-      AttributedString attributedString,
-      ParagraphAttributes paragraphAttributes,
-      Size size) const;
+      const AttributedStringBox& attributedStringBox,
+      const ParagraphAttributes& paragraphAttributes,
+      const Size& size) const;
+
+  /*
+   * Calculates baseline of `attributedString` using native text rendering
+   * infrastructure.
+   */
+  Float baseline(
+      const AttributedStringBox& attributedStringBox,
+      const ParagraphAttributes& paragraphAttributes,
+      const Size& size) const;
 
   /*
    * Returns an opaque pointer to platform-specific TextLayoutManager.
@@ -53,7 +62,8 @@ class TextLayoutManager {
 
  private:
   std::shared_ptr<void> self_;
-  TextMeasureCache measureCache_{};
+  TextMeasureCache textMeasureCache_{};
+  LineMeasureCache lineMeasureCache_{};
 };
 
 } // namespace facebook::react

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

@@ -25,10 +25,10 @@ std::shared_ptr<void> TextLayoutManager::getNativeTextLayoutManager() const
 }
 
 TextMeasurement TextLayoutManager::measure(
-    AttributedStringBox attributedStringBox,
-    ParagraphAttributes paragraphAttributes,
+    const AttributedStringBox &attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
     const TextLayoutContext &layoutContext,
-    LayoutConstraints layoutConstraints) const
+    const LayoutConstraints &layoutConstraints) const
 {
   RCTTextLayoutManager *textLayoutManager = (RCTTextLayoutManager *)unwrapManagedObject(self_);
 
@@ -38,7 +38,7 @@ TextMeasurement TextLayoutManager::measure(
     case AttributedStringBox::Mode::Value: {
       auto &attributedString = attributedStringBox.getValue();
 
-      measurement = measureCache_.get(
+      measurement = textMeasureCache_.get(
           {attributedString, paragraphAttributes, layoutConstraints}, [&](const TextMeasureCacheKey &key) {
             auto telemetry = TransactionTelemetry::threadLocalTelemetry();
             if (telemetry) {
@@ -85,14 +85,38 @@ TextMeasurement TextLayoutManager::measure(
 }
 
 LinesMeasurements TextLayoutManager::measureLines(
-    AttributedString attributedString,
-    ParagraphAttributes paragraphAttributes,
-    Size size) const
+    const AttributedStringBox &attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
+    const Size &size) const
 {
+  react_native_assert(attributedStringBox.getMode() == AttributedStringBox::Mode::Value);
+  const auto &attributedString = attributedStringBox.getValue();
+
   RCTTextLayoutManager *textLayoutManager = (RCTTextLayoutManager *)unwrapManagedObject(self_);
-  return [textLayoutManager getLinesForAttributedString:attributedString
-                                    paragraphAttributes:paragraphAttributes
-                                                   size:{size.width, size.height}];
+
+  auto measurement =
+      lineMeasureCache_.get({attributedString, paragraphAttributes, size}, [&](const LineMeasureCacheKey &key) {
+        auto measurement = [textLayoutManager getLinesForAttributedString:attributedString
+                                                      paragraphAttributes:paragraphAttributes
+                                                                     size:{size.width, size.height}];
+        return measurement;
+      });
+
+  return measurement;
+}
+
+Float TextLayoutManager::baseline(
+    const AttributedStringBox &attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
+    const Size &size) const
+{
+  auto lines = this->measureLines(attributedStringBox, paragraphAttributes, size);
+
+  if (!lines.empty()) {
+    return lines[0].ascender;
+  } else {
+    return 0;
+  }
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/CMakeLists.txt

@@ -16,7 +16,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_uimanager_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_uimanager STATIC ${react_render_uimanager_SRC})
+add_library(react_render_uimanager OBJECT ${react_render_uimanager_SRC})
 
 target_include_directories(react_render_uimanager PUBLIC ${REACT_COMMON_DIR})
 

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

@@ -36,19 +36,17 @@ std::unique_ptr<facebook::react::LeakChecker> constructLeakCheckerIfNeeded(
 
 namespace facebook::react {
 
-// Explicitly define destructors here, as they to exist in order to act as a
-// "key function" for the ShadowNodeWrapper class -- this allow for RTTI to work
-// properly across dynamic library boundaries (i.e. dynamic_cast that is used by
-// isHostObject method)
+// Explicitly define destructors here, as they have to exist in order to act as
+// a "key function" for the ShadowNodeWrapper class -- this allows for RTTI to
+// work properly across dynamic library boundaries (i.e. dynamic_cast that is
+// used by getNativeState method)
 ShadowNodeListWrapper::~ShadowNodeListWrapper() = default;
 
 UIManager::UIManager(
     const RuntimeExecutor& runtimeExecutor,
-    BackgroundExecutor backgroundExecutor,
     ContextContainer::Shared contextContainer)
     : runtimeExecutor_(runtimeExecutor),
       shadowTreeRegistry_(),
-      backgroundExecutor_(std::move(backgroundExecutor)),
       contextContainer_(std::move(contextContainer)),
       leakChecker_(constructLeakCheckerIfNeeded(runtimeExecutor)),
       lazyShadowTreeRevisionConsistencyManager_(
@@ -636,15 +634,15 @@ void UIManager::reportMount(SurfaceId surfaceId) const {
         shadowTree.getMountingCoordinator()->getBaseRevision().rootShadowNode;
   });
 
-  if (!rootShadowNode) {
-    return;
-  }
-
   {
     std::shared_lock lock(mountHookMutex_);
 
     for (auto* mountHook : mountHooks_) {
-      mountHook->shadowTreeDidMount(rootShadowNode, time);
+      if (rootShadowNode) {
+        mountHook->shadowTreeDidMount(rootShadowNode, time);
+      } else {
+        mountHook->shadowTreeDidUnmount(surfaceId, time);
+      }
     }
   }
 }

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

@@ -41,7 +41,6 @@ class UIManager final : public ShadowTreeDelegate {
  public:
   UIManager(
       const RuntimeExecutor& runtimeExecutor,
-      BackgroundExecutor backgroundExecutor,
       ContextContainer::Shared contextContainer);
 
   ~UIManager() override;
@@ -199,10 +198,6 @@ class UIManager final : public ShadowTreeDelegate {
 
   void reportMount(SurfaceId surfaceId) const;
 
-  bool hasBackgroundExecutor() const {
-    return backgroundExecutor_ != nullptr;
-  }
-
  private:
   friend class UIManagerBinding;
   friend class Scheduler;
@@ -227,7 +222,6 @@ class UIManager final : public ShadowTreeDelegate {
   UIManagerAnimationDelegate* animationDelegate_{nullptr};
   const RuntimeExecutor runtimeExecutor_{};
   ShadowTreeRegistry shadowTreeRegistry_{};
-  const BackgroundExecutor backgroundExecutor_{};
   ContextContainer::Shared contextContainer_;
 
   mutable std::shared_mutex commitHookMutex_;

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

@@ -256,36 +256,14 @@ jsi::Value UIManagerBinding::get(
                     stringFromValue(runtime, arguments[1]),
                     surfaceIdFromValue(runtime, arguments[2]),
                     RawProps(runtime, arguments[3]),
-                    std::move(instanceHandle)));
+                    std::move(instanceHandle)),
+                true);
           } catch (const std::logic_error& ex) {
             LOG(FATAL) << "logic_error in createNode: " << ex.what();
           }
         });
   }
 
-  // Semantic: Clones the node with *same* props and *same* children.
-  if (methodName == "cloneNode") {
-    auto paramCount = 1;
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        name,
-        paramCount,
-        [uiManager, methodName, paramCount](
-            jsi::Runtime& runtime,
-            const jsi::Value& /*thisValue*/,
-            const jsi::Value* arguments,
-            size_t count) -> jsi::Value {
-          validateArgumentCount(runtime, methodName, paramCount, count);
-
-          return valueFromShadowNode(
-              runtime,
-              uiManager->cloneNode(
-                  *shadowNodeFromValue(runtime, arguments[0]),
-                  nullptr,
-                  RawProps()));
-        });
-  }
-
   if (methodName == "setIsJSResponder") {
     auto paramCount = 3;
     return jsi::Function::createFromHostFunction(
@@ -369,7 +347,8 @@ jsi::Value UIManagerBinding::get(
                   *shadowNodeFromValue(runtime, arguments[0]),
                   count > 1 ? shadowNodeListFromValue(runtime, arguments[1])
                             : ShadowNode::emptySharedShadowNodeSharedList(),
-                  RawProps()));
+                  RawProps()),
+              true);
         });
   }
 
@@ -392,7 +371,8 @@ jsi::Value UIManagerBinding::get(
               uiManager->cloneNode(
                   *shadowNodeFromValue(runtime, arguments[0]),
                   nullptr,
-                  RawProps(runtime, arguments[1])));
+                  RawProps(runtime, arguments[1])),
+              true);
         });
   }
 
@@ -420,7 +400,8 @@ jsi::Value UIManagerBinding::get(
                   hasChildrenArg
                       ? shadowNodeListFromValue(runtime, arguments[1])
                       : ShadowNode::emptySharedShadowNodeSharedList(),
-                  RawProps(runtime, arguments[hasChildrenArg ? 2 : 1])));
+                  RawProps(runtime, arguments[hasChildrenArg ? 2 : 1])),
+              true);
         });
   }
 
@@ -483,14 +464,11 @@ jsi::Value UIManagerBinding::get(
 
   if (methodName == "completeRoot") {
     auto paramCount = 2;
-    std::weak_ptr<UIManager> weakUIManager = uiManager_;
-    // Enhanced version of the method that uses `backgroundExecutor` and
-    // captures a shared pointer to `UIManager`.
     return jsi::Function::createFromHostFunction(
         runtime,
         name,
         paramCount,
-        [weakUIManager, uiManager, methodName, paramCount](
+        [uiManager, methodName, paramCount](
             jsi::Runtime& runtime,
             const jsi::Value& /*thisValue*/,
             const jsi::Value* arguments,
@@ -501,47 +479,13 @@ jsi::Value UIManagerBinding::get(
               RuntimeSchedulerBinding::getBinding(runtime);
           auto surfaceId = surfaceIdFromValue(runtime, arguments[0]);
 
-          if (uiManager->backgroundExecutor_) {
-            auto weakShadowNodeList =
-                weakShadowNodeListFromValue(runtime, arguments[1]);
-            static std::atomic_uint_fast8_t completeRootEventCounter{0};
-            static std::atomic_uint_fast32_t mostRecentSurfaceId{0};
-            completeRootEventCounter += 1;
-            mostRecentSurfaceId = surfaceId;
-            uiManager->backgroundExecutor_(
-                [weakUIManager,
-                 weakShadowNodeList,
-                 surfaceId,
-                 eventCount = completeRootEventCounter.load()] {
-                  auto shouldYield = [=]() -> bool {
-                    // If `completeRootEventCounter` was incremented, another
-                    // `completeSurface` call has been scheduled and current
-                    // `completeSurface` should yield to it.
-                    return completeRootEventCounter > eventCount &&
-                        mostRecentSurfaceId == surfaceId;
-                  };
-                  auto shadowNodeList =
-                      shadowNodeListFromWeakList(weakShadowNodeList);
-                  auto strongUIManager = weakUIManager.lock();
-                  if (shadowNodeList && strongUIManager) {
-                    strongUIManager->completeSurface(
-                        surfaceId,
-                        shadowNodeList,
-                        {.enableStateReconciliation = true,
-                         .mountSynchronously = false,
-                         .shouldYield = shouldYield});
-                  }
-                });
-          } else {
-            auto shadowNodeList =
-                shadowNodeListFromValue(runtime, arguments[1]);
-            uiManager->completeSurface(
-                surfaceId,
-                shadowNodeList,
-                {.enableStateReconciliation = true,
-                 .mountSynchronously = false,
-                 .shouldYield = nullptr});
-          }
+          auto shadowNodeList = shadowNodeListFromValue(runtime, arguments[1]);
+          uiManager->completeSurface(
+              surfaceId,
+              shadowNodeList,
+              {.enableStateReconciliation = true,
+               .mountSynchronously = false,
+               .shouldYield = nullptr});
 
           return jsi::Value::undefined();
         });

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

@@ -28,6 +28,12 @@ class UIManagerMountHook {
       const RootShadowNode::Shared& rootShadowNode,
       double mountTime) noexcept = 0;
 
+  virtual void shadowTreeDidUnmount(
+      SurfaceId /*surfaceId*/,
+      double /*unmountTime*/) noexcept {
+    // Default no-op implementation for backwards compatibility.
+  }
+
   virtual ~UIManagerMountHook() noexcept = default;
 };
 

package/ReactCommon/react/renderer/uimanager/consistency/CMakeLists.txt

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_uimanager_consistency_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_uimanager_consistency SHARED ${react_render_uimanager_consistency_SRC})
+add_library(react_render_uimanager_consistency OBJECT ${react_render_uimanager_consistency_SRC})
 
 target_include_directories(react_render_uimanager_consistency PUBLIC ${REACT_COMMON_DIR})
 

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

@@ -44,12 +44,17 @@ inline static ShadowNode::Shared shadowNodeFromValue(
 
 inline static jsi::Value valueFromShadowNode(
     jsi::Runtime& runtime,
-    ShadowNode::Shared shadowNode) {
+    ShadowNode::Shared shadowNode,
+    bool assignRuntimeShadowNodeReference = false) {
   // Wrap the shadow node so that we can update JS references from native
   auto wrappedShadowNode =
       std::make_shared<ShadowNodeWrapper>(std::move(shadowNode));
-  wrappedShadowNode->shadowNode->setRuntimeShadowNodeReference(
-      &*wrappedShadowNode);
+
+  if (assignRuntimeShadowNodeReference) {
+    wrappedShadowNode->shadowNode->setRuntimeShadowNodeReference(
+        wrappedShadowNode);
+  }
+
   jsi::Object obj(runtime);
   obj.setNativeState(runtime, std::move(wrappedShadowNode));
   return obj;

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

@@ -58,10 +58,7 @@ class PointerEventsProcessorTest : public ::testing::Test {
     // tests)
     RuntimeExecutor runtimeExecutor =
         [](std::function<void(facebook::jsi::Runtime & runtime)>&& callback) {};
-    BackgroundExecutor backgroundExecutor =
-        [](std::function<void()>&& callback) {};
-    uiManager_ = std::make_unique<UIManager>(
-        runtimeExecutor, backgroundExecutor, contextContainer);
+    uiManager_ = std::make_unique<UIManager>(runtimeExecutor, contextContainer);
     uiManager_->setComponentDescriptorRegistry(componentDescriptorRegistry);
 
     // Create a hierarchy of nodes

package/ReactCommon/react/runtime/BufferedRuntimeExecutor.h

@@ -41,7 +41,7 @@ class BufferedRuntimeExecutor {
   void unsafeFlush();
 
   RuntimeExecutor runtimeExecutor_;
-  bool isBufferingEnabled_;
+  std::atomic<bool> isBufferingEnabled_;
   std::mutex lock_;
   std::atomic<uint64_t> lastIndex_;
   std::priority_queue<BufferedWork> queue_;

package/ReactCommon/react/runtime/CMakeLists.txt

@@ -9,7 +9,7 @@ set(CMAKE_VERBOSE_MAKEFILE on)
 file(GLOB bridgeless_SRC "*.cpp")
 
 add_library(bridgeless
-        STATIC
+        OBJECT
         ${bridgeless_SRC}
 )
 target_compile_options(
@@ -21,11 +21,6 @@ target_compile_options(
 )
 target_include_directories(bridgeless PUBLIC .)
 
-find_library(LIBHERMES NAMES hermes-engine::libhermes)
-if (LIBHERMES)
-    target_link_libraries(bridgeless hermes-engine::libhermes)
-endif ()
-
 target_link_libraries(
         bridgeless
         jserrorhandler
@@ -38,5 +33,6 @@ target_link_libraries(
         react_utils
         jsinspector
         react_featureflags
+        react_performance_timeline
         react_utils
 )

package/ReactCommon/react/runtime/JSRuntimeFactory.h

@@ -30,6 +30,14 @@ class JSRuntime {
    */
   virtual jsinspector_modern::RuntimeTargetDelegate& getRuntimeTargetDelegate();
 
+  /**
+   * Run initialize work that must happen on the runtime's JS thread. Used for
+   * initializing TLS and registering profiling.
+   *
+   * TODO T194671568 Move the runtime constructor to the JsThread
+   */
+  virtual void unstable_initializeOnJsThread() {}
+
  private:
   /**
    * Initialized by \c getRuntimeTargetDelegate if not overridden, and then

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

@@ -53,6 +53,7 @@ Pod::Spec.new do |s|
   s.dependency "glog"
   s.dependency "React-jsi"
   s.dependency "React-jserrorhandler"
+  s.dependency "React-performancetimeline"
   s.dependency "React-runtimescheduler"
   s.dependency "React-utils"
   s.dependency "React-featureflags"