react-native 0.84.0-nightly-20251202-b0e754bc7 → 0.84.0-nightly-20251204-5bb3a6d68

package/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.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<<95616bb241e59e35a9f4b3667cbc0822>>
+ * @generated SignedSource<<66f2c701d95db2fbeefb2705ae326e08>>
  */
 
 /**
@@ -57,12 +57,6 @@ class ReactNativeFeatureFlagsJavaProvider
     return method(javaProvider_);
   }
 
-  bool cxxNativeAnimatedRemoveJsSync() override {
-    static const auto method =
-        getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("cxxNativeAnimatedRemoveJsSync");
-    return method(javaProvider_);
-  }
-
   bool disableEarlyViewCommandExecution() override {
     static const auto method =
         getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("disableEarlyViewCommandExecution");
@@ -598,11 +592,6 @@ bool JReactNativeFeatureFlagsCxxInterop::cxxNativeAnimatedEnabled(
   return ReactNativeFeatureFlags::cxxNativeAnimatedEnabled();
 }
 
-bool JReactNativeFeatureFlagsCxxInterop::cxxNativeAnimatedRemoveJsSync(
-    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
-  return ReactNativeFeatureFlags::cxxNativeAnimatedRemoveJsSync();
-}
-
 bool JReactNativeFeatureFlagsCxxInterop::disableEarlyViewCommandExecution(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
   return ReactNativeFeatureFlags::disableEarlyViewCommandExecution();
@@ -1073,9 +1062,6 @@ void JReactNativeFeatureFlagsCxxInterop::registerNatives() {
       makeNativeMethod(
         "cxxNativeAnimatedEnabled",
         JReactNativeFeatureFlagsCxxInterop::cxxNativeAnimatedEnabled),
-      makeNativeMethod(
-        "cxxNativeAnimatedRemoveJsSync",
-        JReactNativeFeatureFlagsCxxInterop::cxxNativeAnimatedRemoveJsSync),
       makeNativeMethod(
         "disableEarlyViewCommandExecution",
         JReactNativeFeatureFlagsCxxInterop::disableEarlyViewCommandExecution),

package/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.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<<4c8932d29eda2db32a3e82cfae202bab>>
+ * @generated SignedSource<<f14600a85cec20388ba1a5bc63010a68>>
  */
 
 /**
@@ -39,9 +39,6 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool cxxNativeAnimatedEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool cxxNativeAnimatedRemoveJsSync(
-    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
-
   static bool disableEarlyViewCommandExecution(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -300,6 +300,7 @@ void JReactHostInspectorTarget::recordFrameTimings(
       frameTimingSequence->getBeginDrawingTimestamp(),
       frameTimingSequence->getCommitTimestamp(),
       frameTimingSequence->getEndDrawingTimestamp(),
+      frameTimingSequence->getScreenshot(),
   });
 }
 

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -67,6 +67,17 @@ struct JFrameTimingSequence : public jni::JavaClass<JFrameTimingSequence> {
     return HighResTimeStamp::fromChronoSteadyClockTimePoint(
         std::chrono::steady_clock::time_point(std::chrono::nanoseconds(getFieldValue(field))));
   }
+
+  std::optional<std::string> getScreenshot() const
+  {
+    auto field = javaClassStatic()->getField<jstring>("screenshot");
+    auto javaScreenshot = getFieldValue(field);
+    if (javaScreenshot) {
+      auto jstring = jni::static_ref_cast<jni::JString>(javaScreenshot);
+      return jstring->toStdString();
+    }
+    return std::nullopt;
+  }
 };
 
 struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -22,7 +22,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 84;
   int32_t Patch = 0;
-  std::string_view Prerelease = "nightly-20251202-b0e754bc7";
+  std::string_view Prerelease = "nightly-20251204-5bb3a6d68";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/jsi/jsi/jsi.cpp

@@ -284,6 +284,10 @@ HostObject::~HostObject() {}
 
 NativeState::~NativeState() {}
 
+#ifdef JSI_UNSTABLE
+Serialized::~Serialized() {}
+#endif
+
 Runtime::~Runtime() {}
 
 ICast* Runtime::castInterface(const UUID& /*interfaceUUID*/) {

package/ReactCommon/jsi/jsi/jsi.h

@@ -257,6 +257,72 @@ class JSI_EXPORT NativeState {
 // the future. Until released, these features may be subject to change. After
 // release, these features will be moved out of JSI_UNSTABLE and become frozen.
 #ifdef JSI_UNSTABLE
+/// Opaque class that is used to store serialized object from a runtime. The
+/// lifetime of this object is orthogonal to the original runtime object, and
+/// may outlive the original object.
+class JSI_EXPORT Serialized {
+ public:
+  /// Uses \p secretAddr to validate if the Serialized data is supported. If so,
+  /// return the pointer to the underlying serialized data. Otherwise, return a
+  /// nullptr. This should be used by the runtime to deserialize the data.
+  virtual void* getPrivate(const void* secretAddr) = 0;
+  virtual ~Serialized();
+};
+
+/// Provides a set of APIs that allows copying objects between different
+/// runtime instances. The runtimes instances must be of the same type. As an
+/// example, a serialized object from Hermes runtime may only be deserialized by
+/// another Hermes runtime.
+class JSI_EXPORT ISerialization : public ICast {
+ public:
+  static constexpr jsi::UUID uuid{
+      0xd40fe0ec,
+      0xa47c,
+      0x42c9,
+      0x8c09,
+      0x661aeab832d8};
+
+  /// Serializes the given Value \p value using the structured clone algorithm.
+  /// It returns a shared pointer of an opaque Serialized object that can be
+  /// deserialized multiple times. The lifetime of the Serialized object is not
+  /// tied to the lifetime of the original object.
+  virtual std::shared_ptr<Serialized> serialize(Value& value) = 0;
+
+  /// Given a Serialized object provided by \p serialized, deserialize it using
+  /// the structured clone algorithm into a JS value in the current runtime.
+  /// Returns the deserialized JS value.
+  virtual Value deserialize(const std::shared_ptr<Serialized>& serialized) = 0;
+
+  /// Serializes the given jsi::Value \p value using the structured clone
+  /// algorithm. \p transferList must be a JS Array. Given the length property
+  /// of \p transferList, this API will transfer everything at index [0, length
+  /// - 1] to the serialized object. The transferred values will no longer be
+  /// usable in the original runtime. It returns a unique pointer of an opaque
+  /// Serialized object that can be deserialized once only by
+  /// deserializeWithTransfer. The lifetime of the Serialized object is not tied
+  /// to the lifetime of the original object.
+  virtual std::unique_ptr<Serialized> serializeWithTransfer(
+      Value& value,
+      const Array& transferList) = 0;
+
+  /// Using the structure clone algorithm, deserialize the object provided by \p
+  /// serialized into a JS value in the current runtime. \p serialized must be
+  /// created by serializeWithTransfer. If the current runtime does not support
+  /// the serialization scheme in \p serialized, then this method will throw and
+  /// \p serialized will remain unmodified. Otherwise, this will consume the
+  /// serialized data entirely and make the serialized objects in the current
+  /// runtime. Any transferred values in the serialized object will be owned by
+  /// the current runtime.
+  //  This method returns an Array containing the deserialized values, where the
+  //  first element is the value passed into serializeWithTransfer,
+  /// followed by all transferred values.
+  virtual Array deserializeWithTransfer(
+      std::unique_ptr<Serialized>& serialized) = 0;
+
+ protected:
+  ~ISerialization() = default;
+};
+
 #endif // JSI_UNSTABLE
 
 /// Represents a JS runtime.  Movable, but not copyable.  Note that

package/ReactCommon/jsinspector-modern/tests/TracingTest.cpp

@@ -95,4 +95,22 @@ TEST_F(TracingTest, EmitsRecordedFrameTimingSequences) {
   EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "DrawFrame")));
 }
 
+TEST_F(TracingTest, EmitsScreenshotEventWhenScreenshotValuePassed) {
+  InSequence s;
+
+  startTracing({tracing::Category::Screenshot});
+  auto now = HighResTimeStamp::now();
+  page_->recordFrameTimings(
+      tracing::FrameTimingSequence(
+          1, // id
+          11, // threadId
+          now,
+          now + HighResDuration::fromNanoseconds(10),
+          now + HighResDuration::fromNanoseconds(50),
+          "base64EncodedScreenshotData"));
+
+  auto allTraceEvents = endTracingAndCollectEvents();
+  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "Screenshot")));
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tracing/FrameTimingSequence.h

@@ -13,6 +13,8 @@
 
 namespace facebook::react::jsinspector_modern::tracing {
 
+using FrameSequenceId = uint64_t;
+
 /**
  * A struct representing a sequence of frame timings that happened on the Host side.
  */
@@ -20,23 +22,25 @@ struct FrameTimingSequence {
   FrameTimingSequence() = delete;
 
   FrameTimingSequence(
-      uint64_t id,
+      FrameSequenceId id,
       ThreadId threadId,
       HighResTimeStamp beginDrawingTimestamp,
       HighResTimeStamp commitTimestamp,
-      HighResTimeStamp endDrawingTimestamp)
+      HighResTimeStamp endDrawingTimestamp,
+      std::optional<std::string> screenshot = std::nullopt)
       : id(id),
         threadId(threadId),
         beginDrawingTimestamp(beginDrawingTimestamp),
         commitTimestamp(commitTimestamp),
-        endDrawingTimestamp(endDrawingTimestamp)
+        endDrawingTimestamp(endDrawingTimestamp),
+        screenshot(std::move(screenshot))
   {
   }
 
   /**
    * Unique ID of the sequence, used by Chrome DevTools Frontend to identify the events that form one sequence.
    */
-  uint64_t id;
+  FrameSequenceId id;
 
   /**
    * The ID of the native thread that is associated with the frame.
@@ -46,6 +50,11 @@ struct FrameTimingSequence {
   HighResTimeStamp beginDrawingTimestamp;
   HighResTimeStamp commitTimestamp;
   HighResTimeStamp endDrawingTimestamp;
+
+  /**
+   * Optional screenshot data (base64 encoded) captured during the frame.
+   */
+  std::optional<std::string> screenshot;
 };
 
 } // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/HostTracingProfileSerializer.cpp

@@ -100,7 +100,7 @@ constexpr int FALLBACK_LAYER_TREE_ID = 1;
   chunk.push_back(
       TraceEventSerializer::serialize(std::move(setLayerTreeIdEvent)));
 
-  for (const auto& frameTimingSequence : frameTimings) {
+  for (auto&& frameTimingSequence : frameTimings) {
     if (chunk.size() >= chunkSize) {
       chunkCallback(std::move(chunk));
       chunk = generateNewChunk(chunkSize);
@@ -121,6 +121,19 @@ constexpr int FALLBACK_LAYER_TREE_ID = 1;
     chunk.push_back(TraceEventSerializer::serialize(std::move(commitEvent)));
     chunk.push_back(
         TraceEventSerializer::serialize(std::move(endDrawingEvent)));
+
+    if (frameTimingSequence.screenshot.has_value()) {
+      auto screenshotEvent = TraceEventGenerator::createScreenshotEvent(
+          frameTimingSequence.id,
+          FALLBACK_LAYER_TREE_ID,
+          std::move(frameTimingSequence.screenshot.value()),
+          frameTimingSequence.endDrawingTimestamp,
+          processId,
+          frameTimingSequence.threadId);
+
+      chunk.push_back(
+          TraceEventSerializer::serialize(std::move(screenshotEvent)));
+    }
   }
 
   if (!chunk.empty()) {

package/ReactCommon/jsinspector-modern/tracing/TraceEventGenerator.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "TraceEventGenerator.h"
+#include "Timing.h"
 #include "TracingCategory.h"
 
 namespace facebook::react::jsinspector_modern::tracing {
@@ -77,4 +78,27 @@ TraceEventGenerator::createFrameTimingsEvents(
   return {std::move(beginEvent), std::move(commitEvent), std::move(drawEvent)};
 }
 
+/* static */ TraceEvent TraceEventGenerator::createScreenshotEvent(
+    FrameSequenceId frameSequenceId,
+    int sourceId,
+    std::string&& snapshot,
+    HighResTimeStamp expectedDisplayTime,
+    ProcessId processId,
+    ThreadId threadId) {
+  folly::dynamic args = folly::dynamic::object("snapshot", std::move(snapshot))(
+      "source_id", sourceId)("frame_sequence", frameSequenceId)(
+      "expected_display_time",
+      highResTimeStampToTracingClockTimeStamp(expectedDisplayTime));
+
+  return TraceEvent{
+      .name = "Screenshot",
+      .cat = {Category::Screenshot},
+      .ph = 'O',
+      .ts = expectedDisplayTime,
+      .pid = processId,
+      .tid = threadId,
+      .args = std::move(args),
+  };
+}
+
 }; // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/TraceEventGenerator.h

@@ -9,6 +9,7 @@
 
 #include "TraceEvent.h"
 
+#include <jsinspector-modern/tracing/FrameTimingSequence.h>
 #include <react/timing/primitives.h>
 
 #include <tuple>
@@ -35,13 +36,24 @@ class TraceEventGenerator {
    * Creates canonical "BeginFrame", "Commit", "DrawFrame" trace events.
    */
   static std::tuple<TraceEvent, TraceEvent, TraceEvent> createFrameTimingsEvents(
-      uint64_t sequenceId,
+      FrameSequenceId sequenceId,
       int layerTreeId,
       HighResTimeStamp beginDrawingTimestamp,
       HighResTimeStamp commitTimestamp,
       HighResTimeStamp endDrawingTimestamp,
       ProcessId processId,
       ThreadId threadId);
+
+  /**
+   * Creates canonical "Screenshot" trace event.
+   */
+  static TraceEvent createScreenshotEvent(
+      FrameSequenceId frameSequenceId,
+      int sourceId,
+      std::string &&snapshot,
+      HighResTimeStamp expectedDisplayTime,
+      ProcessId processId,
+      ThreadId threadId);
 };
 
 }; // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/TracingCategory.h

@@ -58,7 +58,7 @@ inline std::optional<Category> getTracingCategoryFromString(const std::string &s
   } else if (str == "v8.execute") {
     return Category::RuntimeExecution;
   } else if (str == "disabled-by-default-devtools.screenshot") {
-    return Category::RuntimeExecution;
+    return Category::Screenshot;
   } else {
     return std::nullopt;
   }

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.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<<46aafe1d22354ad53f81db7ab41b967e>>
+ * @generated SignedSource<<34d260e51b2f70825c4867c98bbcf3de>>
  */
 
 /**
@@ -38,10 +38,6 @@ bool ReactNativeFeatureFlags::cxxNativeAnimatedEnabled() {
   return getAccessor().cxxNativeAnimatedEnabled();
 }
 
-bool ReactNativeFeatureFlags::cxxNativeAnimatedRemoveJsSync() {
-  return getAccessor().cxxNativeAnimatedRemoveJsSync();
-}
-
 bool ReactNativeFeatureFlags::disableEarlyViewCommandExecution() {
   return getAccessor().disableEarlyViewCommandExecution();
 }

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.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<<e3acef3e3c9b032fce0902019fa6ff3f>>
+ * @generated SignedSource<<502fa8935abd547231be7980d768b817>>
  */
 
 /**
@@ -54,11 +54,6 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool cxxNativeAnimatedEnabled();
 
-  /**
-   * Removes JS sync at end of native animation
-   */
-  RN_EXPORT static bool cxxNativeAnimatedRemoveJsSync();
-
   /**
    * Dispatch view commands in mount item order.
    */