react-native-tvos 0.77.0-0rc5 → 0.78.0-0

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm

@@ -16,7 +16,7 @@
 #import <ReactCommon/CallInvoker.h>
 #import <ReactCommon/TurboModule.h>
 #import <ReactCommon/TurboModulePerfLogger.h>
-#import <cxxreact/SystraceSection.h>
+#import <cxxreact/TraceSection.h>
 #import <react/bridging/Bridging.h>
 
 #include <glog/logging.h>
@@ -112,20 +112,20 @@ static NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::St
 }
 
 static NSArray *
-convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker)
+convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
 {
   size_t size = value.size(runtime);
   NSMutableArray *result = [NSMutableArray new];
   for (size_t i = 0; i < size; i++) {
     // Insert kCFNull when it's `undefined` value to preserve the indices.
-    id convertedObject = convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker);
+    id convertedObject = convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker, useNSNull);
     [result addObject:convertedObject ? convertedObject : (id)kCFNull];
   }
   return [result copy];
 }
 
 static NSDictionary *
-convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)
+convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
 {
   jsi::Array propertyNames = value.getPropertyNames(runtime);
   size_t size = propertyNames.size(runtime);
@@ -133,7 +133,7 @@ convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value,
   for (size_t i = 0; i < size; i++) {
     jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
     NSString *k = convertJSIStringToNSString(runtime, name);
-    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker);
+    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker, useNSNull);
     if (v) {
       result[k] = v;
     }
@@ -159,11 +159,14 @@ convertJSIFunctionToCallback(jsi::Runtime &rt, jsi::Function &&function, std::sh
   };
 }
 
-id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker, BOOL useNSNull)
 {
-  if (value.isUndefined() || value.isNull()) {
+  if (value.isUndefined() || (value.isNull() && !useNSNull)) {
     return nil;
   }
+  if (value.isNull() && useNSNull) {
+    return [NSNull null];
+  }
   if (value.isBool()) {
     return @(value.getBool());
   }
@@ -176,17 +179,22 @@ id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, s
   if (value.isObject()) {
     jsi::Object o = value.getObject(runtime);
     if (o.isArray(runtime)) {
-      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker);
+      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker, useNSNull);
     }
     if (o.isFunction(runtime)) {
       return convertJSIFunctionToCallback(runtime, o.getFunction(runtime), jsInvoker);
     }
-    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
+    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker, useNSNull);
   }
 
   throw std::runtime_error("Unsupported jsi::Value kind");
 }
 
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  return convertJSIValueToObjCObject(runtime, value, jsInvoker, NO);
+}
+
 static jsi::Value createJSRuntimeError(jsi::Runtime &runtime, const std::string &message)
 {
   return runtime.global().getPropertyAsFunction(runtime, "Error").call(runtime, message);
@@ -369,7 +377,7 @@ id ObjCTurboModule::performMethodInvocation(
     asyncCallCounter = getUniqueId();
     TurboModulePerfLogger::asyncMethodCallDispatch(moduleName, methodName);
     nativeMethodCallInvoker_->invokeAsync(methodNameStr, [block, moduleName, methodNameStr]() -> void {
-      SystraceSection s(
+      TraceSection s(
           "RCTTurboModuleAsyncMethodInvocation",
           "module",
           moduleName,
@@ -429,7 +437,7 @@ void ObjCTurboModule::performVoidMethodInvocation(
     asyncCallCounter = getUniqueId();
     TurboModulePerfLogger::asyncMethodCallDispatch(moduleName, methodName);
     nativeMethodCallInvoker_->invokeAsync(methodNameStr, [moduleName, methodNameStr, block]() -> void {
-      SystraceSection s(
+      TraceSection s(
           "RCTTurboModuleAsyncMethodInvocation", "module", moduleName, "method", methodNameStr, "returnType", "void");
       block();
     });

package/ReactCommon/react/nativemodule/cputime/CPUTime.h

@@ -0,0 +1,55 @@
+/*
+ * 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
+
+#ifdef USE_POSIX_TIME
+#include <time.h>
+#else
+#include <chrono>
+#endif
+
+#ifdef USE_POSIX_TIME
+
+namespace {
+const double NANOSECONDS_IN_A_SECOND = 1000000000;
+} // namespace
+
+#endif
+
+namespace facebook::react {
+
+#ifdef USE_POSIX_TIME
+
+inline double getCPUTimeNanos() {
+  struct timespec time {};
+  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time);
+  return static_cast<double>(time.tv_sec) * NANOSECONDS_IN_A_SECOND +
+      static_cast<double>(time.tv_nsec);
+}
+
+inline bool hasAccurateCPUTimeNanosForBenchmarks() {
+  return true;
+}
+
+#else
+
+inline double getCPUTimeNanos() {
+  auto now = std::chrono::steady_clock::now();
+  return static_cast<double>(
+      std::chrono::duration_cast<std::chrono::nanoseconds>(
+          now.time_since_epoch())
+          .count());
+}
+
+inline bool hasAccurateCPUTimeNanosForBenchmarks() {
+  return false;
+}
+
+#endif
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/cputime/NativeCPUTime.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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 "NativeCPUTime.h"
+
+#include "CPUTime.h"
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+#include "Plugins.h"
+#endif
+
+std::shared_ptr<facebook::react::TurboModule> NativeCPUTimeModuleProvider(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+  return std::make_shared<facebook::react::NativeCPUTime>(std::move(jsInvoker));
+}
+
+namespace facebook::react {
+
+NativeCPUTime::NativeCPUTime(std::shared_ptr<CallInvoker> jsInvoker)
+    : NativeCPUTimeCxxSpec(std::move(jsInvoker)) {}
+
+double NativeCPUTime::getCPUTimeNanos(jsi::Runtime& /*runtime*/) {
+  return facebook::react::getCPUTimeNanos();
+}
+
+bool NativeCPUTime::hasAccurateCPUTimeNanosForBenchmarks(
+    jsi::Runtime& /*runtime*/) {
+  return facebook::react::hasAccurateCPUTimeNanosForBenchmarks();
+}
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/cputime/NativeCPUTime.h

@@ -0,0 +1,28 @@
+/*
+ * 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
+
+#if __has_include("rncoreJSI.h") // Cmake headers on Android
+#include "rncoreJSI.h"
+#elif __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple
+#include "FBReactNativeSpecJSI.h"
+#else
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#endif
+
+namespace facebook::react {
+
+class NativeCPUTime : public NativeCPUTimeCxxSpec<NativeCPUTime> {
+ public:
+  explicit NativeCPUTime(std::shared_ptr<CallInvoker> jsInvoker);
+
+  double getCPUTimeNanos(jsi::Runtime& runtime);
+  bool hasAccurateCPUTimeNanosForBenchmarks(jsi::Runtime& runtime);
+};
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<aeb742608efce797a86b73e243a62d0c>>
+ * @generated SignedSource<<f5a1ea8dd3d64e435b6954c39dacb76a>>
  */
 
 /**
@@ -64,14 +64,9 @@ bool NativeReactNativeFeatureFlags::disableMountItemReorderingAndroid(
   return ReactNativeFeatureFlags::disableMountItemReorderingAndroid();
 }
 
-bool NativeReactNativeFeatureFlags::enableAlignItemsBaselineOnFabricIOS(
+bool NativeReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid(
     jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableAlignItemsBaselineOnFabricIOS();
-}
-
-bool NativeReactNativeFeatureFlags::enableAndroidLineHeightCentering(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableAndroidLineHeightCentering();
+  return ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid();
 }
 
 bool NativeReactNativeFeatureFlags::enableBridgelessArchitecture(
@@ -109,11 +104,6 @@ bool NativeReactNativeFeatureFlags::enableFabricRenderer(
   return ReactNativeFeatureFlags::enableFabricRenderer();
 }
 
-bool NativeReactNativeFeatureFlags::enableFabricRendererExclusively(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableFabricRendererExclusively();
-}
-
 bool NativeReactNativeFeatureFlags::enableFixForViewCommandRace(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableFixForViewCommandRace();
@@ -129,6 +119,11 @@ bool NativeReactNativeFeatureFlags::enableIOSViewClipToPaddingBox(
   return ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox();
 }
 
+bool NativeReactNativeFeatureFlags::enableImagePrefetchingAndroid(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableImagePrefetchingAndroid();
+}
+
 bool NativeReactNativeFeatureFlags::enableLayoutAnimationsOnAndroid(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableLayoutAnimationsOnAndroid();
@@ -184,6 +179,11 @@ bool NativeReactNativeFeatureFlags::excludeYogaFromRawProps(
   return ReactNativeFeatureFlags::excludeYogaFromRawProps();
 }
 
+bool NativeReactNativeFeatureFlags::fixDifferentiatorEmittingUpdatesWithWrongParentTag(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::fixDifferentiatorEmittingUpdatesWithWrongParentTag();
+}
+
 bool NativeReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact();
@@ -194,11 +194,6 @@ bool NativeReactNativeFeatureFlags::fixMountingCoordinatorReportedPendingTransac
   return ReactNativeFeatureFlags::fixMountingCoordinatorReportedPendingTransactionsOnAndroid();
 }
 
-bool NativeReactNativeFeatureFlags::fuseboxEnabledDebug(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::fuseboxEnabledDebug();
-}
-
 bool NativeReactNativeFeatureFlags::fuseboxEnabledRelease(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::fuseboxEnabledRelease();
@@ -254,6 +249,11 @@ bool NativeReactNativeFeatureFlags::useOptimizedEventBatchingOnAndroid(
   return ReactNativeFeatureFlags::useOptimizedEventBatchingOnAndroid();
 }
 
+bool NativeReactNativeFeatureFlags::useRawPropsJsiValue(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::useRawPropsJsiValue();
+}
+
 bool NativeReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdate(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdate();

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<b42cf9d00bd5b0d01f3d14b633771201>>
+ * @generated SignedSource<<fc3960bfa407d1fc123ee4c71eac644a>>
  */
 
 /**
@@ -45,9 +45,7 @@ class NativeReactNativeFeatureFlags
 
   bool disableMountItemReorderingAndroid(jsi::Runtime& runtime);
 
-  bool enableAlignItemsBaselineOnFabricIOS(jsi::Runtime& runtime);
-
-  bool enableAndroidLineHeightCentering(jsi::Runtime& runtime);
+  bool enableAccumulatedUpdatesInRawPropsAndroid(jsi::Runtime& runtime);
 
   bool enableBridgelessArchitecture(jsi::Runtime& runtime);
 
@@ -63,14 +61,14 @@ class NativeReactNativeFeatureFlags
 
   bool enableFabricRenderer(jsi::Runtime& runtime);
 
-  bool enableFabricRendererExclusively(jsi::Runtime& runtime);
-
   bool enableFixForViewCommandRace(jsi::Runtime& runtime);
 
   bool enableGranularShadowTreeStateReconciliation(jsi::Runtime& runtime);
 
   bool enableIOSViewClipToPaddingBox(jsi::Runtime& runtime);
 
+  bool enableImagePrefetchingAndroid(jsi::Runtime& runtime);
+
   bool enableLayoutAnimationsOnAndroid(jsi::Runtime& runtime);
 
   bool enableLayoutAnimationsOnIOS(jsi::Runtime& runtime);
@@ -93,12 +91,12 @@ class NativeReactNativeFeatureFlags
 
   bool excludeYogaFromRawProps(jsi::Runtime& runtime);
 
+  bool fixDifferentiatorEmittingUpdatesWithWrongParentTag(jsi::Runtime& runtime);
+
   bool fixMappingOfEventPrioritiesBetweenFabricAndReact(jsi::Runtime& runtime);
 
   bool fixMountingCoordinatorReportedPendingTransactionsOnAndroid(jsi::Runtime& runtime);
 
-  bool fuseboxEnabledDebug(jsi::Runtime& runtime);
-
   bool fuseboxEnabledRelease(jsi::Runtime& runtime);
 
   bool initEagerTurboModulesOnNativeModulesQueueAndroid(jsi::Runtime& runtime);
@@ -121,6 +119,8 @@ class NativeReactNativeFeatureFlags
 
   bool useOptimizedEventBatchingOnAndroid(jsi::Runtime& runtime);
 
+  bool useRawPropsJsiValue(jsi::Runtime& runtime);
+
   bool useRuntimeShadowNodeReferenceUpdate(jsi::Runtime& runtime);
 
   bool useTurboModuleInterop(jsi::Runtime& runtime);

package/ReactCommon/react/nativemodule/idlecallbacks/React-idlecallbacksnativemodule.podspec

@@ -61,4 +61,5 @@ Pod::Spec.new do |s|
   s.dependency "ReactCommon/turbomodule/core"
   s.dependency "React-runtimescheduler"
   add_dependency(s, "React-RCTFBReactNativeSpec")
+  s.dependency "glog"
 end

package/ReactCommon/react/nativemodule/intersectionobserver/NativeIntersectionObserver.cpp

@@ -93,14 +93,11 @@ NativeIntersectionObserver::convertToNativeModuleEntry(
       entry.rootRect.origin.y,
       entry.rootRect.size.width,
       entry.rootRect.size.height};
-  std::optional<RectAsTuple> intersectionRect;
-  if (entry.intersectionRect) {
-    intersectionRect = {
-        entry.intersectionRect.value().origin.x,
-        entry.intersectionRect.value().origin.y,
-        entry.intersectionRect.value().size.width,
-        entry.intersectionRect.value().size.height};
-  }
+  RectAsTuple intersectionRect = {
+      entry.intersectionRect.origin.x,
+      entry.intersectionRect.origin.y,
+      entry.intersectionRect.size.width,
+      entry.intersectionRect.size.height};
 
   NativeIntersectionObserverEntry nativeModuleEntry = {
       entry.intersectionObserverId,

package/ReactCommon/react/nativemodule/mutationobserver/NativeMutationObserver.cpp

@@ -6,7 +6,7 @@
  */
 
 #include "NativeMutationObserver.h"
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
@@ -111,7 +111,7 @@ NativeMutationObserver::getPublicInstancesFromShadowNodes(
 }
 
 void NativeMutationObserver::onMutations(std::vector<MutationRecord>& records) {
-  SystraceSection s("NativeMutationObserver::onMutations");
+  TraceSection s("NativeMutationObserver::onMutations");
 
   for (const auto& record : records) {
     pendingRecords_.emplace_back(NativeMutationRecord{
@@ -141,7 +141,7 @@ void NativeMutationObserver::notifyMutationObserversIfNecessary() {
   }
 
   if (dispatchNotification) {
-    SystraceSection s("NativeMutationObserver::notifyObservers");
+    TraceSection s("NativeMutationObserver::notifyObservers");
     if (ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
         !ReactNativeFeatureFlags::disableEventLoopOnBridgeless()) {
       runtime_->queueMicrotask(notifyMutationObservers_.value());

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.cpp

@@ -14,9 +14,10 @@
 #include <cxxreact/JSExecutor.h>
 #include <cxxreact/ReactMarker.h>
 #include <jsi/instrumentation.h>
+#include <jsinspector-modern/tracing/CdpTracing.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/performance/timeline/PerformanceObserver.h>
-#include <reactperflogger/ReactPerfLogger.h>
+#include <reactperflogger/ReactPerfettoLogger.h>
 
 #include "NativePerformance.h"
 
@@ -45,10 +46,8 @@ namespace {
 #endif
 
 NO_DESTROY const std::string TRACK_PREFIX = "Track:";
-NO_DESTROY const std::string DEFAULT_TRACK_NAME = "# Web Performance";
-NO_DESTROY const std::string CUSTOM_TRACK_NAME_PREFIX = "# Web Performance: ";
 
-std::tuple<std::string, std::string_view> parseTrackName(
+std::tuple<std::optional<std::string>, std::string_view> parseTrackName(
     const std::string& name) {
   // Until there's a standard way to pass through track information, parse it
   // manually, e.g., "Track:Foo:Event name"
@@ -58,16 +57,13 @@ std::tuple<std::string, std::string_view> parseTrackName(
   if (name.starts_with(TRACK_PREFIX)) {
     const auto trackNameDelimiter = name.find(':', TRACK_PREFIX.length());
     if (trackNameDelimiter != std::string::npos) {
-      trackName = CUSTOM_TRACK_NAME_PREFIX +
-          name.substr(
-              TRACK_PREFIX.length(),
-              trackNameDelimiter - TRACK_PREFIX.length());
+      trackName = name.substr(
+          TRACK_PREFIX.length(), trackNameDelimiter - TRACK_PREFIX.length());
       eventName = std::string_view(name).substr(trackNameDelimiter + 1);
     }
   }
 
-  auto& trackNameRef = trackName.has_value() ? *trackName : DEFAULT_TRACK_NAME;
-  return std::make_tuple(trackNameRef, eventName);
+  return std::make_tuple(trackName, eventName);
 }
 
 class PerformanceObserverWrapper : public jsi::NativeState {
@@ -125,7 +121,7 @@ double NativePerformance::markWithResult(
   auto entry =
       PerformanceEntryReporter::getInstance()->reportMark(name, startTime);
 
-  ReactPerfLogger::mark(eventName, entry.startTime, trackName);
+  ReactPerfettoLogger::mark(eventName, entry.startTime, trackName);
 
   return entry.startTime;
 }
@@ -140,44 +136,27 @@ std::tuple<double, double> NativePerformance::measureWithResult(
     std::optional<std::string> endMark) {
   auto [trackName, eventName] = parseTrackName(name);
 
-  auto entry = PerformanceEntryReporter::getInstance()->reportMeasure(
-      eventName, startTime, endTime, duration, startMark, endMark);
+  std::optional<jsinspector_modern::DevToolsTrackEntryPayload> trackMetadata;
+
+  if (trackName.has_value()) {
+    trackMetadata = {.track = trackName.value()};
+  }
 
-  ReactPerfLogger::measure(
+  auto entry = PerformanceEntryReporter::getInstance()->reportMeasure(
+      eventName,
+      startTime,
+      endTime,
+      duration,
+      startMark,
+      endMark,
+      trackMetadata);
+
+  ReactPerfettoLogger::measure(
       eventName, entry.startTime, entry.startTime + entry.duration, trackName);
 
   return std::tuple{entry.startTime, entry.duration};
 }
 
-void NativePerformance::mark(
-    jsi::Runtime& rt,
-    std::string name,
-    double startTime) {
-  auto [trackName, eventName] = parseTrackName(name);
-  ReactPerfLogger::mark(eventName, startTime, trackName);
-
-  PerformanceEntryReporter::getInstance()->reportMark(name, startTime);
-}
-
-void NativePerformance::measure(
-    jsi::Runtime& rt,
-    std::string name,
-    double startTime,
-    double endTime,
-    std::optional<double> duration,
-    std::optional<std::string> startMark,
-    std::optional<std::string> endMark) {
-  auto [trackName, eventName] = parseTrackName(name);
-
-  // TODO T190600850 support startMark/endMark
-  if (!startMark && !endMark) {
-    ReactPerfLogger::measure(eventName, startTime, endTime, trackName);
-  }
-
-  PerformanceEntryReporter::getInstance()->reportMeasure(
-      eventName, startTime, endTime, duration, startMark, endMark);
-}
-
 void NativePerformance::clearMarks(
     jsi::Runtime& /*rt*/,
     std::optional<std::string> entryName) {

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.h

@@ -69,21 +69,6 @@ class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
 
 #pragma mark - User Timing Level 3 functions (https://w3c.github.io/user-timing/)
 
-  // https://w3c.github.io/user-timing/#mark-method
-  // TODO delete when `markWithResult` is fully rolled out
-  void mark(jsi::Runtime& rt, std::string name, double startTime);
-
-  // https://w3c.github.io/user-timing/#measure-method
-  // TODO delete when `measureWithResult` is fully rolled out
-  void measure(
-      jsi::Runtime& rt,
-      std::string name,
-      double startTime,
-      double endTime,
-      std::optional<double> duration,
-      std::optional<std::string> startMark,
-      std::optional<std::string> endMark);
-
   // https://w3c.github.io/user-timing/#mark-method
   double markWithResult(
       jsi::Runtime& rt,

package/ReactCommon/react/performance/timeline/CMakeLists.txt

@@ -19,5 +19,6 @@ add_library(react_performance_timeline OBJECT ${react_performance_timeline_SRC})
 
 target_include_directories(react_performance_timeline PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_performance_timeline
+        jsinspector_tracing
         react_timing
         react_cxxreact)

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.cpp

@@ -8,11 +8,13 @@
 #include "PerformanceEntryReporter.h"
 
 #include <cxxreact/JSExecutor.h>
+#include <jsinspector-modern/tracing/PerformanceTracer.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 
 namespace facebook::react {
 
 namespace {
+
 std::vector<PerformanceEntryType> getSupportedEntryTypesInternal() {
   std::vector<PerformanceEntryType> supportedEntryTypes{
       PerformanceEntryType::MARK,
@@ -26,6 +28,11 @@ std::vector<PerformanceEntryType> getSupportedEntryTypesInternal() {
 
   return supportedEntryTypes;
 }
+
+uint64_t timestampToMicroseconds(DOMHighResTimeStamp timestamp) {
+  return static_cast<uint64_t>(timestamp * 1000);
+}
+
 } // namespace
 
 std::shared_ptr<PerformanceEntryReporter>&
@@ -128,16 +135,20 @@ void PerformanceEntryReporter::clearEntries(
 PerformanceEntry PerformanceEntryReporter::reportMark(
     const std::string& name,
     const std::optional<DOMHighResTimeStamp>& startTime) {
+  auto startTimeVal = startTime ? *startTime : getCurrentTimeStamp();
   const auto entry = PerformanceEntry{
       .name = name,
       .entryType = PerformanceEntryType::MARK,
-      .startTime = startTime ? *startTime : getCurrentTimeStamp()};
+      .startTime = startTimeVal};
 
   {
     std::unique_lock lock(buffersMutex_);
     markBuffer_.add(entry);
   }
 
+  jsinspector_modern::PerformanceTracer::getInstance().reportMark(
+      name, timestampToMicroseconds(startTimeVal));
+
   observerRegistry_->queuePerformanceEntry(entry);
   return entry;
 }
@@ -148,7 +159,9 @@ PerformanceEntry PerformanceEntryReporter::reportMeasure(
     DOMHighResTimeStamp endTime,
     const std::optional<DOMHighResTimeStamp>& duration,
     const std::optional<std::string>& startMark,
-    const std::optional<std::string>& endMark) {
+    const std::optional<std::string>& endMark,
+    const std::optional<jsinspector_modern::DevToolsTrackEntryPayload>&
+        trackMetadata) {
   DOMHighResTimeStamp startTimeVal =
       startMark ? getMarkTime(*startMark) : startTime;
   DOMHighResTimeStamp endTimeVal = endMark ? getMarkTime(*endMark) : endTime;
@@ -173,6 +186,12 @@ PerformanceEntry PerformanceEntryReporter::reportMeasure(
     measureBuffer_.add(entry);
   }
 
+  jsinspector_modern::PerformanceTracer::getInstance().reportMeasure(
+      name,
+      timestampToMicroseconds(startTimeVal),
+      timestampToMicroseconds(durationVal),
+      trackMetadata);
+
   observerRegistry_->queuePerformanceEntry(entry);
   return entry;
 }
@@ -217,6 +236,7 @@ void PerformanceEntryReporter::reportEvent(
     eventBuffer_.add(entry);
   }
 
+  // TODO(T198982346): Log interaction events to jsinspector_modern
   observerRegistry_->queuePerformanceEntry(entry);
 }
 

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.h

@@ -7,14 +7,17 @@
 
 #pragma once
 
+#include "PerformanceEntryCircularBuffer.h"
+#include "PerformanceEntryKeyedBuffer.h"
+#include "PerformanceObserverRegistry.h"
+
+#include <jsinspector-modern/tracing/CdpTracing.h>
 #include <react/timing/primitives.h>
+
 #include <memory>
 #include <optional>
 #include <shared_mutex>
 #include <vector>
-#include "PerformanceEntryCircularBuffer.h"
-#include "PerformanceEntryKeyedBuffer.h"
-#include "PerformanceObserverRegistry.h"
 
 namespace facebook::react {
 
@@ -84,7 +87,9 @@ class PerformanceEntryReporter {
       double endTime,
       const std::optional<double>& duration = std::nullopt,
       const std::optional<std::string>& startMark = std::nullopt,
-      const std::optional<std::string>& endMark = std::nullopt);
+      const std::optional<std::string>& endMark = std::nullopt,
+      const std::optional<jsinspector_modern::DevToolsTrackEntryPayload>&
+          trackMetadata = std::nullopt);
 
   void reportEvent(
       std::string name,