react-native-tvos 0.85.3-0 → 0.86.0-0

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/NativeDrawable.h

@@ -10,6 +10,7 @@
 #include <glog/logging.h>
 #include <react/debug/react_native_expect.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/graphics/Float.h>
 #include <unordered_map>
 
@@ -22,14 +23,16 @@ struct NativeDrawable {
   };
 
   struct Ripple {
-    std::optional<int32_t> color{};
+    std::optional<SharedColor> color{};
+    std::optional<std::vector<std::string>> colorResourcePaths{};
     std::optional<Float> rippleRadius{};
     bool borderless{false};
+    std::optional<Float> alpha{};
 
     bool operator==(const Ripple &rhs) const
     {
-      return std::tie(this->color, this->borderless, this->rippleRadius) ==
-          std::tie(rhs.color, rhs.borderless, rhs.rippleRadius);
+      return std::tie(this->color, this->colorResourcePaths, this->borderless, this->rippleRadius, this->alpha) ==
+          std::tie(rhs.color, rhs.colorResourcePaths, rhs.borderless, rhs.rippleRadius, rhs.alpha);
     }
   };
 
@@ -59,8 +62,7 @@ struct NativeDrawable {
   ~NativeDrawable() = default;
 };
 
-static inline void
-fromRawValue(const PropsParserContext & /*context*/, const RawValue &rawValue, NativeDrawable &result)
+static inline void fromRawValue(const PropsParserContext &context, const RawValue &rawValue, NativeDrawable &result)
 {
   auto map = (std::unordered_map<std::string, RawValue>)rawValue;
 
@@ -73,24 +75,53 @@ fromRawValue(const PropsParserContext & /*context*/, const RawValue &rawValue, N
     react_native_expect(attrIterator != map.end() && attrIterator->second.hasType<std::string>());
 
     result = NativeDrawable{
-        (std::string)attrIterator->second,
-        {},
-        NativeDrawable::Kind::ThemeAttr,
+        .themeAttr = (std::string)attrIterator->second,
+        .ripple = {},
+        .kind = NativeDrawable::Kind::ThemeAttr,
     };
   } else if (type == "RippleAndroid") {
     auto color = map.find("color");
     auto borderless = map.find("borderless");
     auto rippleRadius = map.find("rippleRadius");
+    auto alpha = map.find("alpha");
+
+    std::optional<SharedColor> parsedColor{};
+    std::optional<std::vector<std::string>> parsedColorResourcePaths{};
+    if (color != map.end()) {
+      if (color->second.hasType<std::unordered_map<std::string, std::vector<std::string>>>()) {
+        auto colorMap = (std::unordered_map<std::string, std::vector<std::string>>)color->second;
+        auto pathsIt = colorMap.find("resource_paths");
+        if (pathsIt != colorMap.end()) {
+          parsedColorResourcePaths = pathsIt->second;
+        }
+      } else {
+        SharedColor resolved;
+        fromRawValue(context, color->second, resolved);
+        if (resolved) {
+          parsedColor = resolved;
+        }
+      }
+    }
+
+    std::optional<Float> parsedAlpha{};
+    if (alpha != map.end() && alpha->second.hasType<Float>()) {
+      parsedAlpha = (Float)alpha->second;
+    }
 
     result = NativeDrawable{
-        std::string{},
-        NativeDrawable::Ripple{
-            color != map.end() && color->second.hasType<int32_t>() ? (int32_t)color->second : std::optional<int32_t>{},
-            rippleRadius != map.end() && rippleRadius->second.hasType<Float>() ? (Float)rippleRadius->second
-                                                                               : std::optional<Float>{},
-            borderless != map.end() && borderless->second.hasType<bool>() ? (bool)borderless->second : false,
-        },
-        NativeDrawable::Kind::Ripple,
+        .themeAttr = std::string{},
+        .ripple =
+            NativeDrawable::Ripple{
+                .color = parsedColor,
+                .colorResourcePaths = parsedColorResourcePaths,
+                .rippleRadius = rippleRadius != map.end() && rippleRadius->second.hasType<Float>()
+                    ? (Float)rippleRadius->second
+                    : std::optional<Float>{},
+                .borderless =
+                    borderless != map.end() && borderless->second.hasType<bool>() ? (bool)borderless->second : false,
+                .alpha = parsedAlpha,
+            },
+        .kind = NativeDrawable::Kind::Ripple,
     };
   } else {
     LOG(ERROR) << "Unknown native drawable type: " << type;

package/ReactCommon/react/renderer/components/view/platform/cxx/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -12,12 +12,12 @@
 
 namespace facebook::react::HostPlatformViewTraitsInitializer {
 
-inline bool formsStackingContext(const ViewProps &props)
+inline bool formsStackingContext(const ViewProps & /*props*/)
 {
   return false;
 }
 
-inline bool formsView(const ViewProps &props)
+inline bool formsView(const ViewProps & /*props*/)
 {
   return false;
 }

package/ReactCommon/react/renderer/{graphics/DoubleConversions.h → components/view/platform/tvos/react/renderer/components/view/HostPlatformTouch.h}

@@ -7,10 +7,8 @@
 
 #pragma once
 
-#include <string>
+#include <react/renderer/components/view/BaseTouch.h>
 
 namespace facebook::react {
-
-std::string toString(double doubleValue, char suffix);
-
+using HostPlatformTouch = BaseTouch;
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/tvos/react/renderer/components/view/HostPlatformViewEventEmitter.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/components/view/BaseViewEventEmitter.h>
+
+namespace facebook::react {
+using HostPlatformViewEventEmitter = BaseViewEventEmitter;
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/tvos/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "HostPlatformViewProps.h"
+
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+HostPlatformViewProps::HostPlatformViewProps(
+    const PropsParserContext& context,
+    const HostPlatformViewProps& sourceProps,
+    const RawProps& rawProps)
+    : BaseViewProps(context, sourceProps, rawProps),
+      focusable(convertRawProp(
+          context,
+          rawProps,
+          "focusable",
+          sourceProps.focusable,
+          false)) {}
+
+void HostPlatformViewProps::setProp(
+    const PropsParserContext& context,
+    RawPropsPropNameHash hash,
+    const char* propName,
+    const RawValue& value) {
+  BaseViewProps::setProp(context, hash, propName, value);
+
+  static auto defaults = HostPlatformViewProps{};
+
+  switch (hash) { RAW_SET_PROP_SWITCH_CASE_BASIC(focusable); }
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/tvos/react/renderer/components/view/HostPlatformViewProps.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/components/view/BaseViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+
+namespace facebook::react {
+
+class HostPlatformViewProps : public BaseViewProps {
+ public:
+  HostPlatformViewProps() = default;
+  HostPlatformViewProps(
+      const PropsParserContext &context,
+      const HostPlatformViewProps &sourceProps,
+      const RawProps &rawProps);
+
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, const RawValue &value);
+
+  bool focusable{false};
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/tvos/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+
+namespace facebook::react::HostPlatformViewTraitsInitializer {
+
+inline bool formsStackingContext(const ViewProps &props)
+{
+  return false;
+}
+
+inline bool formsView(const ViewProps &props)
+{
+  return false;
+}
+
+inline bool isKeyboardFocusable(const ViewProps & /*props*/)
+{
+  return false;
+}
+
+} // namespace facebook::react::HostPlatformViewTraitsInitializer

package/ReactCommon/react/renderer/components/view/propsConversions.h

@@ -356,8 +356,14 @@ convertRawProp(const PropsParserContext &context, const RawProps &rawProps, cons
       yoga::Dimension::Height,
       convertRawProp(context, rawProps, "maxHeight", sourceValue.maxDimension(yoga::Dimension::Height), {}));
 
-  yogaStyle.setAspectRatio(
-      convertRawProp(context, rawProps, "aspectRatio", sourceValue.aspectRatio(), yogaStyle.aspectRatio()));
+  {
+    const auto *rawValue = rawProps.at("aspectRatio", nullptr, nullptr);
+    if (rawValue != nullptr) {
+      yogaStyle.setAspectRatio(rawValue->hasValue() ? convertAspectRatio(context, *rawValue) : yogaStyle.aspectRatio());
+    } else {
+      yogaStyle.setAspectRatio(sourceValue.aspectRatio());
+    }
+  }
 
   yogaStyle.setBoxSizing(
       convertRawProp(context, rawProps, "boxSizing", sourceValue.boxSizing(), yogaStyle.boxSizing()));

package/ReactCommon/react/renderer/components/view/tests/ConversionsTest.cpp

@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 
+#include <react/renderer/attributedstring/conversions.h>
 #include <react/renderer/components/view/BoxShadowPropsConversions.h>
 #include <react/renderer/components/view/FilterPropsConversions.h>
 #include <react/renderer/components/view/conversions.h>
@@ -454,4 +455,89 @@ TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string_with_z) {
   EXPECT_EQ(result.z, 15.0f);
 }
 
+TEST(ConversionsTest, unprocessed_font_variant_string_single) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString("small-caps", result);
+
+  EXPECT_EQ((int)result, (int)FontVariant::SmallCaps);
+}
+
+TEST(ConversionsTest, unprocessed_font_variant_string_multiple) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString(
+      "small-caps oldstyle-nums tabular-nums", result);
+
+  EXPECT_EQ(
+      (int)result,
+      (int)FontVariant::SmallCaps | (int)FontVariant::OldstyleNums |
+          (int)FontVariant::TabularNums);
+}
+
+TEST(ConversionsTest, unprocessed_font_variant_string_invalid) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString("not-a-variant", result);
+
+  EXPECT_EQ((int)result, (int)FontVariant::Default);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_float) {
+  RawValue value{folly::dynamic(1.5)};
+  auto result =
+      convertAspectRatio(PropsParserContext{-1, ContextContainer{}}, value);
+
+  EXPECT_FALSE(result.isUndefined());
+  EXPECT_EQ(result.unwrap(), 1.5f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_ratio_string) {
+  // CSSRatio parses "16/9" as {numerator: 16, denominator: 9}
+  auto ratio = parseCSSProperty<CSSRatio>("16/9");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  auto r = std::get<CSSRatio>(ratio);
+  EXPECT_FALSE(r.isDegenerate());
+  EXPECT_NEAR(r.numerator / r.denominator, 16.0f / 9.0f, 0.001f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_number_string) {
+  // CSSRatio parses "1.5" as {numerator: 1.5, denominator: 1.0}
+  auto ratio = parseCSSProperty<CSSRatio>("1.5");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  auto r = std::get<CSSRatio>(ratio);
+  EXPECT_FALSE(r.isDegenerate());
+  EXPECT_EQ(r.numerator / r.denominator, 1.5f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_degenerate) {
+  auto ratio = parseCSSProperty<CSSRatio>("0/0");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  EXPECT_TRUE(std::get<CSSRatio>(ratio).isDegenerate());
+}
+
+TEST(ConversionsTest, float_optional_from_rawvalue_float) {
+  RawValue value{folly::dynamic(1.5)};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_FALSE(result.isUndefined());
+  EXPECT_EQ(result.unwrap(), 1.5f);
+}
+
+TEST(ConversionsTest, float_optional_undefined_for_non_float) {
+  RawValue value{folly::dynamic(nullptr)};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_TRUE(result.isUndefined());
+}
+
+TEST(ConversionsTest, float_optional_undefined_for_string) {
+  // fromRawValue for FloatOptional does not parse strings —
+  // that is handled by convertAspectRatio specifically.
+  RawValue value{folly::dynamic("16/9")};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_TRUE(result.isUndefined());
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp

@@ -19,6 +19,7 @@
 
 #include <react/renderer/element/Element.h>
 #include <react/renderer/element/testUtils.h>
+#include <yoga/numeric/FloatOptional.h>
 
 namespace facebook::react {
 
@@ -229,4 +230,37 @@ TEST_F(YogaDirtyFlagTest, updatingStateForScrollViewMistNotDirtyYogaNode) {
       static_cast<RootShadowNode&>(*newRootShadowNode).layoutIfNeeded());
 }
 
+TEST_F(YogaDirtyFlagTest, clonedPropsPreserveAspectRatio) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  /*
+   * Cloning props with empty RawProps must preserve aspectRatio set on the
+   * source props.
+   */
+  auto newRootShadowNode = rootShadowNode_->cloneTree(
+      innerShadowNode_->getFamily(), [&](const ShadowNode& oldShadowNode) {
+        // First clone: set aspectRatio to 1.5
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
+        viewProps->yogaStyle.setAspectRatio(yoga::FloatOptional(1.5f));
+        auto nodeWithAspectRatio =
+            oldShadowNode.clone(ShadowNodeFragment{.props = viewProps});
+
+        // Second clone: clone props with empty RawProps (simulating a prop
+        // update that does not touch aspectRatio)
+        auto& componentDescriptor =
+            nodeWithAspectRatio->getComponentDescriptor();
+        auto clonedProps = componentDescriptor.cloneProps(
+            parserContext, nodeWithAspectRatio->getProps(), RawProps());
+
+        auto& clonedViewProps =
+            static_cast<const ViewShadowNodeProps&>(*clonedProps);
+        EXPECT_TRUE(clonedViewProps.yogaStyle.aspectRatio().isDefined());
+        EXPECT_EQ(clonedViewProps.yogaStyle.aspectRatio().unwrap(), 1.5f);
+
+        return nodeWithAspectRatio->clone(
+            ShadowNodeFragment{.props = clonedProps});
+      });
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/EventEmitter.cpp

@@ -63,6 +63,18 @@ void EventEmitter::dispatchEvent(
       category);
 }
 
+void EventEmitter::dispatchEvent(
+    std::string type,
+    folly::dynamic&& payload,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchEvent(
+      std::move(type),
+      DynamicEventPayload::create(std::move(payload)),
+      category,
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchUniqueEvent(
     std::string type,
     folly::dynamic&& payload) const {
@@ -70,6 +82,16 @@ void EventEmitter::dispatchUniqueEvent(
       std::move(type), DynamicEventPayload::create(std::move(payload)));
 }
 
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    folly::dynamic&& payload,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchUniqueEvent(
+      std::move(type),
+      DynamicEventPayload::create(std::move(payload)),
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchEvent(
     std::string type,
     const ValueFactory& payloadFactory,
@@ -80,10 +102,31 @@ void EventEmitter::dispatchEvent(
       category);
 }
 
+void EventEmitter::dispatchEvent(
+    std::string type,
+    const ValueFactory& payloadFactory,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchEvent(
+      std::move(type),
+      std::make_shared<ValueFactoryEventPayload>(payloadFactory),
+      category,
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchEvent(
     std::string type,
     SharedEventPayload payload,
     RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type), std::move(payload), category, HighResTimeStamp::now());
+}
+
+void EventEmitter::dispatchEvent(
+    std::string type,
+    SharedEventPayload payload,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
   TraceSection s("EventEmitter::dispatchEvent", "type", type);
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -96,7 +139,9 @@ void EventEmitter::dispatchEvent(
       std::move(payload),
       eventTarget_,
       shadowNodeFamily_,
-      category));
+      category,
+      false,
+      eventTimestamp));
 }
 
 void EventEmitter::dispatchUniqueEvent(
@@ -107,9 +152,27 @@ void EventEmitter::dispatchUniqueEvent(
       std::make_shared<ValueFactoryEventPayload>(payloadFactory));
 }
 
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    const ValueFactory& payloadFactory,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchUniqueEvent(
+      std::move(type),
+      std::make_shared<ValueFactoryEventPayload>(payloadFactory),
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchUniqueEvent(
     std::string type,
     SharedEventPayload payload) const {
+  dispatchUniqueEvent(
+      std::move(type), std::move(payload), HighResTimeStamp::now());
+}
+
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    SharedEventPayload payload,
+    HighResTimeStamp eventTimestamp) const {
   TraceSection s("EventEmitter::dispatchUniqueEvent");
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -122,7 +185,9 @@ void EventEmitter::dispatchUniqueEvent(
       std::move(payload),
       eventTarget_,
       shadowNodeFamily_,
-      RawEvent::Category::Continuous));
+      RawEvent::Category::Continuous,
+      true,
+      eventTimestamp));
 }
 
 void EventEmitter::setEnabled(bool enabled) {

package/ReactCommon/react/renderer/core/EventEmitter.h

@@ -16,6 +16,7 @@
 #include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/ValueFactoryEventPayload.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -86,6 +87,12 @@ class EventEmitter {
       const ValueFactory &payloadFactory = EventEmitter::defaultPayloadFactory(),
       RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
+  void dispatchEvent(
+      std::string type,
+      const ValueFactory &payloadFactory,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
   void dispatchEvent(
       std::string type,
       folly::dynamic &&payload,
@@ -96,13 +103,31 @@ class EventEmitter {
       SharedEventPayload payload,
       RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
+  void dispatchEvent(
+      std::string type,
+      folly::dynamic &&payload,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
+  void dispatchEvent(
+      std::string type,
+      SharedEventPayload payload,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
   void dispatchUniqueEvent(std::string type, folly::dynamic &&payload) const;
 
   void dispatchUniqueEvent(std::string type, const ValueFactory &payloadFactory = EventEmitter::defaultPayloadFactory())
       const;
 
+  void dispatchUniqueEvent(std::string type, const ValueFactory &payloadFactory, HighResTimeStamp eventTimestamp) const;
+
   void dispatchUniqueEvent(std::string type, SharedEventPayload payload) const;
 
+  void dispatchUniqueEvent(std::string type, folly::dynamic &&payload, HighResTimeStamp eventTimestamp) const;
+
+  void dispatchUniqueEvent(std::string type, SharedEventPayload payload, HighResTimeStamp eventTimestamp) const;
+
  private:
   friend class UIManagerBinding;
 

package/ReactCommon/react/renderer/core/EventPipe.h

@@ -15,6 +15,7 @@
 #include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/ReactEventPriority.h>
 #include <react/renderer/core/ValueFactory.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -23,7 +24,8 @@ using EventPipe = std::function<void(
     EventTarget *eventTarget,
     const std::string &type,
     ReactEventPriority priority,
-    const EventPayload &payload)>;
+    const EventPayload &payload,
+    HighResTimeStamp eventTimestamp)>;
 
 using EventPipeConclusion = std::function<void(jsi::Runtime &runtime)>;
 

package/ReactCommon/react/renderer/core/EventQueueProcessor.cpp

@@ -7,6 +7,7 @@
 
 #include "EventQueueProcessor.h"
 
+#include <folly/ScopeGuard.h>
 #include <logger/react_native_log.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 
@@ -38,6 +39,20 @@ void EventQueueProcessor::flushEvents(
     }
   }
 
+  // RAII guard for the matching release() pass. If event dispatch throws (a JS
+  // exception from eventPipe_, or eventPipeConclusion_), the previous code
+  // skipped the release loop entirely, leaking JSI strong references. The
+  // guard destructor runs on every exit path. No DispatchMutex needed for
+  // release: we hold a strong pointer to each EventTarget via `events`, and
+  // release() only touches runtime-thread-confined state.
+  SCOPE_EXIT {
+    for (const auto& event : events) {
+      if (event.eventTarget) {
+        event.eventTarget->release(runtime);
+      }
+    }
+  };
+
   for (const auto& event : events) {
     auto reactPriority = ReactEventPriority::Default;
 
@@ -96,7 +111,8 @@ void EventQueueProcessor::flushEvents(
         event.eventTarget.get(),
         event.type,
         reactPriority,
-        *event.eventPayload);
+        *event.eventPayload,
+        event.eventStartTimeStamp);
 
     if (eventLogger != nullptr) {
       eventLogger->onEventProcessingEnd(event.loggingTag);
@@ -110,15 +126,7 @@ void EventQueueProcessor::flushEvents(
   // We only run the "Conclusion" once per event group when batched.
   eventPipeConclusion_(runtime);
 
-  // No need to lock `EventEmitter::DispatchMutex()` here.
-  // The mutex protects from a situation when the `instanceHandle` can be
-  // deallocated during accessing, but that's impossible at this point because
-  // we have a strong pointer to it.
-  for (const auto& event : events) {
-    if (event.eventTarget) {
-      event.eventTarget->release(runtime);
-    }
-  }
+  // EventTarget release happens in the SCOPE_EXIT above.
 }
 
 void EventQueueProcessor::flushStateUpdates(

package/ReactCommon/react/renderer/core/EventTarget.cpp

@@ -7,8 +7,6 @@
 
 #include "EventTarget.h"
 
-#include <react/debug/react_native_assert.h>
-
 namespace facebook::react {
 
 using Tag = EventTarget::Tag;
@@ -51,11 +49,16 @@ void EventTarget::release(jsi::Runtime& /*runtime*/) {
   // It takes it only to ensure thread-safety (if the caller has the reference,
   // we are on a proper thread).
 
-  if (--retainCount_ == 0) {
+  // retainCount_ is unsigned. retain() early-returns when the target is
+  // disabled but the matching release() still runs, so we can land here with
+  // a zero count; an unconditional decrement would wrap to SIZE_MAX and the
+  // strong handle would never be cleared again.
+  if (retainCount_ > 0) {
+    --retainCount_;
+  }
+  if (retainCount_ == 0) {
     strongInstanceHandle_ = jsi::Value::null();
   }
-
-  react_native_assert(retainCount_ >= 0);
 }
 
 jsi::Value EventTarget::getInstanceHandle(jsi::Runtime& runtime) const {