react-native 0.88.0-rc.0 → 0.88.0-rc.2

package/ReactCommon/react/nativemodule/core/iostests/RCTTurboModuleTests.mm

@@ -7,10 +7,8 @@
 
 #import <XCTest/XCTest.h>
 
-#import <React/RCTArrayBuffer.h>
 #import <ReactCommon/RCTTurboModule.h>
 #import <hermes/hermes.h>
-#import <jsi/decorator.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 
@@ -94,39 +92,6 @@ class TestMutableBuffer : public facebook::jsi::MutableBuffer {
   std::vector<uint8_t> bytes_;
 };
 
-// `jsi::Runtime::tryGetMutableBuffer` is optional — the Hermes branch linked into apps returns
-// nullptr for every ArrayBuffer — so decorate the runtime to answer it for the buffers created
-// through it. That keeps the coverage of the native-backed path independent of the engine.
-// The registry is weak, so the only owners of a backing store remain the JS ArrayBuffer and
-// whatever the conversion retains.
-class MutableBufferAwareRuntime final : public facebook::jsi::RuntimeDecorator<facebook::jsi::Runtime> {
- public:
-  explicit MutableBufferAwareRuntime(facebook::jsi::Runtime &plain) : RuntimeDecorator(plain) {}
-
-  facebook::jsi::ArrayBuffer createArrayBuffer(std::shared_ptr<facebook::jsi::MutableBuffer> buffer) override
-  {
-    auto arrayBuffer = RuntimeDecorator::createArrayBuffer(buffer);
-    buffers_.push_back(buffer);
-    return arrayBuffer;
-  }
-
-  std::shared_ptr<facebook::jsi::MutableBuffer> tryGetMutableBuffer(
-      const facebook::jsi::ArrayBuffer &arrayBuffer) override
-  {
-    uint8_t *data = arrayBuffer.data(*this);
-    for (const auto &weakBuffer : buffers_) {
-      auto buffer = weakBuffer.lock();
-      if (buffer != nullptr && buffer->data() == data) {
-        return buffer;
-      }
-    }
-    return nullptr;
-  }
-
- private:
-  std::vector<std::weak_ptr<facebook::jsi::MutableBuffer>> buffers_;
-};
-
 class StubNativeMethodCallInvoker : public NativeMethodCallInvoker {
  public:
   void invokeAsync(const std::string &methodName, NativeMethodCallFunc &&func) noexcept override
@@ -354,46 +319,34 @@ class ExceptionCapturingNativeMethodCallInvoker : public NativeMethodCallInvoker
   XCTAssertNotNil(original.callStackSymbols);
 }
 
-// A native-backed ArrayBuffer is aliased rather than copied, and the RCTArrayBuffer retains
-// the backing MutableBuffer, so the alias outlives the JS object.
-- (void)testNativeBackedArrayBufferIsAliasedAndKeepsBackingStoreAlive
+// A JS ArrayBuffer converts to an NSMutableData that owns an independent copy of
+// the bytes — NSMutableData cannot alias a foreign buffer, so the result stays
+// valid and is safe to mutate after the source buffer is gone. This covers the
+// ArrayBuffer-backed-by-native-MutableBuffer case, which is the one that could in
+// principle have been aliased zero-copy.
+- (void)testArrayBufferConvertsToIndependentNSMutableData
 {
   constexpr size_t kBufferSize = 64 * 1024;
 
   auto hermesRuntime = facebook::hermes::makeHermesRuntime();
-  MutableBufferAwareRuntime runtime(*hermesRuntime);
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
 
   auto buffer = std::make_shared<TestMutableBuffer>(kBufferSize);
   *buffer->data() = 0xAB;
-  const uint8_t *sourceBytes = buffer->data();
-
-  RCTArrayBuffer *converted = nil;
-  {
-    facebook::jsi::ArrayBuffer arrayBuffer(runtime, buffer);
-    const long ownersBeforeConversion = buffer.use_count();
-
-    id result = TurboModuleConvertUtils::convertJSIValueToObjCObject(
-        runtime, facebook::jsi::Value(runtime, arrayBuffer), nullptr, NO, NO);
-    XCTAssertTrue([result isKindOfClass:[RCTArrayBuffer class]]);
-    converted = (RCTArrayBuffer *)result;
-
-    XCTAssertEqual(
-        buffer.use_count(), ownersBeforeConversion + 1, @"The RCTArrayBuffer must retain the backing MutableBuffer");
-  }
 
-  XCTAssertTrue(converted.isOwningBytes, @"A native-backed buffer must be safe to retain");
-  XCTAssertEqual(converted.length, (NSUInteger)kBufferSize);
-  XCTAssertEqual(converted.mutableBytes, (void *)sourceBytes, @"Bytes must be aliased, not copied");
+  facebook::jsi::ArrayBuffer arrayBuffer(*rt, buffer);
+  id converted =
+      TurboModuleConvertUtils::convertJSIValueToObjCObject(*rt, facebook::jsi::Value(*rt, arrayBuffer), nullptr);
 
-  // Writes through the source are visible, and vice versa: one shared allocation.
-  *buffer->data() = 0xCD;
-  XCTAssertEqual(*static_cast<const uint8_t *>(converted.mutableBytes), 0xCD);
-  *static_cast<uint8_t *>(converted.mutableBytes) = 0xEF;
-  XCTAssertEqual(*buffer->data(), 0xEF);
+  XCTAssertTrue([converted isKindOfClass:[NSMutableData class]]);
+  NSMutableData *data = (NSMutableData *)converted;
+  XCTAssertEqual(data.length, (NSUInteger)kBufferSize);
+  XCTAssertEqual(*static_cast<const uint8_t *>(data.bytes), 0xAB);
 
-  // Dropping the caller's reference leaves the bytes valid.
-  buffer.reset();
-  XCTAssertEqual(*static_cast<const uint8_t *>(converted.mutableBytes), 0xEF);
+  // Independent copy: mutating the NSMutableData must not write through to the
+  // source MutableBuffer.
+  *static_cast<uint8_t *>(data.mutableBytes) = 0xCD;
+  XCTAssertEqual(*buffer->data(), 0xAB, @"NSMutableData must not alias the source buffer");
 }
 
 @end

package/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTInteropTurboModule.h

@@ -75,8 +75,7 @@ class JSI_EXPORT ObjCInteropTurboModule : public ObjCTurboModule {
       const jsi::Value &arg,
       size_t i,
       NSInvocation *inv,
-      NSMutableArray *retainedObjectsForInvocation,
-      bool mustCopyBytes) override;
+      NSMutableArray *retainedObjectsForInvocation) override;
 
  private:
   std::vector<MethodDescriptor> methodDescriptors_;

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

@@ -363,8 +363,7 @@ void ObjCInteropTurboModule::setInvocationArg(
     const jsi::Value &jsiArg,
     size_t index,
     NSInvocation *inv,
-    NSMutableArray *retainedObjectsForInvocation,
-    [[maybe_unused]] bool mustCopyBytes)
+    NSMutableArray *retainedObjectsForInvocation)
 {
   NSString *methodName = @(methodNameCStr);
   std::string methodJsSignature = name_ + "." + methodNameCStr + "()";

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

@@ -35,8 +35,7 @@ id convertJSIValueToObjCObject(
     jsi::Runtime &runtime,
     const jsi::Value &value,
     const std::shared_ptr<CallInvoker> &jsInvoker,
-    BOOL useNSNull = NO,
-    BOOL mustCopyBytes = YES);
+    BOOL useNSNull = NO);
 } // namespace TurboModuleConvertUtils
 
 template <>
@@ -114,9 +113,6 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
    * ObjCInteropTurboModule relies heavily on RCTConvert to convert arguments from JavaScript values to Objective C
    * values. ObjCTurboModule tries to minimize reliance on RCTConvert: RCTConvert uses the RCT_EXPORT_METHOD macros,
    * which we want to remove long term from React Native.
-   *
-   * mustCopyBytes says whether the invocation may outlive the JS call, in which case ArrayBuffer arguments must be
-   * copied rather than aliased.
    */
   virtual void setInvocationArg(
       jsi::Runtime &runtime,
@@ -125,8 +121,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       const jsi::Value &arg,
       size_t i,
       NSInvocation *inv,
-      NSMutableArray *retainedObjectsForInvocation,
-      bool mustCopyBytes);
+      NSMutableArray *retainedObjectsForInvocation);
 
  private:
   // Does the NativeModule dispatch async methods to the JS thread?
@@ -142,13 +137,11 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
   NSDictionary<NSString *, NSArray<NSString *> *> *methodArgumentTypeNames_;
 
   bool isMethodSync(TurboModuleMethodValueKind returnType);
-  bool mustCopyJSHeapArrayBufferBytes(TurboModuleMethodValueKind returnType);
   BOOL hasMethodArgConversionSelector(NSString *methodName, size_t argIndex);
   SEL getMethodArgConversionSelector(NSString *methodName, size_t argIndex);
   NSInvocation *createMethodInvocation(
       jsi::Runtime &runtime,
       bool isSync,
-      bool mustCopyBytes,
       const char *methodName,
       SEL selector,
       const jsi::Value *args,

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

@@ -7,7 +7,6 @@
 
 #import "RCTTurboModule.h"
 
-#import <React/RCTArrayBuffer.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTConvert.h>
 #import <React/RCTCxxConvert.h>
@@ -90,43 +89,35 @@ static std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime,
   return result;
 }
 
-static jsi::ArrayBuffer convertRCTArrayBufferToJSIArrayBuffer(jsi::Runtime &runtime, RCTArrayBuffer *value)
+static jsi::ArrayBuffer convertNSMutableDataToJSIArrayBuffer(jsi::Runtime &runtime, NSMutableData *value)
 {
-  class RCTArrayBufferMutableBuffer final : public jsi::MutableBuffer {
+  class NSMutableDataBuffer final : public jsi::MutableBuffer {
    public:
-    explicit RCTArrayBufferMutableBuffer(RCTArrayBuffer *buffer)
-        : buffer_(buffer), data_(static_cast<uint8_t *>(buffer.mutableBytes)), size_(buffer.length)
-    {
-    }
+    explicit NSMutableDataBuffer(NSMutableData *data) : data_(data) {}
 
     size_t size() const override
     {
-      return size_;
+      return data_.length;
     }
 
     uint8_t *data() override
     {
-      return data_;
+      return static_cast<uint8_t *>(data_.mutableBytes);
     }
 
    private:
-    // Never read: retains the buffer so `data_` stays valid for the ArrayBuffer's lifetime.
-    [[maybe_unused]] RCTArrayBuffer *buffer_;
-    uint8_t *data_;
-    size_t size_;
+    NSMutableData *data_;
   };
 
-  // nil would yield a NULL pointer via ObjC nil-messaging and corrupt the ArrayBuffer.
+  // A nil NSMutableData would silently yield a NULL `mutableBytes` pointer
+  // (ObjC nil-messaging) and corrupt the resulting ArrayBuffer. Substitute a
+  // fresh empty NSMutableData so the wrapped pointer is always well-defined.
   if (value == nil) {
-    RCTLogWarn(@"convertRCTArrayBufferToJSIArrayBuffer: received nil RCTArrayBuffer; returning empty ArrayBuffer");
-    value = [RCTArrayBuffer arrayBufferWithLength:0];
-  }
-
-  if (!value.isOwningBytes) {
-    value = [RCTArrayBuffer arrayBufferWithCopiedBytes:value.mutableBytes length:value.length];
+    RCTLogWarn(@"convertNSMutableDataToJSIArrayBuffer: received nil NSMutableData; returning empty ArrayBuffer");
+    value = [NSMutableData data];
   }
-
-  return {runtime, std::make_shared<RCTArrayBufferMutableBuffer>(value)};
+  auto buffer = std::make_shared<NSMutableDataBuffer>(value);
+  return {runtime, std::move(buffer)};
 }
 
 jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
@@ -142,8 +133,8 @@ jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
     return convertNSDictionaryToJSIObject(runtime, (NSDictionary *)value);
   } else if ([value isKindOfClass:[NSArray class]]) {
     return convertNSArrayToJSIArray(runtime, (NSArray *)value);
-  } else if ([value isKindOfClass:[RCTArrayBuffer class]]) {
-    return convertRCTArrayBufferToJSIArrayBuffer(runtime, (RCTArrayBuffer *)value);
+  } else if ([value isKindOfClass:[NSMutableData class]]) {
+    return convertNSMutableDataToJSIArrayBuffer(runtime, (NSMutableData *)value);
   } else if (value == (id)kCFNull) {
     return jsi::Value::null();
   }
@@ -210,41 +201,23 @@ convertJSIFunctionToCallback(jsi::Runtime &rt, jsi::Function &&function, const s
   };
 }
 
-// Native-backed buffers are aliased and keep their backing store alive, so they stay valid for
-// as long as the module holds them. JS-heap buffers have nothing to retain — their bytes are
-// freed when the ArrayBuffer is collected or detached — so `mustCopyBytes` is set whenever the
-// invocation may outlive the JS call, and they are aliased only when it cannot. Engines that
-// don't hand out the backing MutableBuffer fall back to those JS-heap rules for every buffer.
-static RCTArrayBuffer *
-convertJSIArrayBufferToRCTArrayBuffer(jsi::Runtime &rt, const jsi::ArrayBuffer &arrayBuffer, BOOL mustCopyBytes)
+// Copy the ArrayBuffer's bytes into an NSMutableData. A zero-copy wrap is not
+// possible here: NSMutableData needs its own resizable backing store and cannot
+// alias a foreign buffer (even via initWithBytesNoCopy:length:deallocator:, which
+// copies eagerly for the mutable subclass). Copying also makes the result safe to
+// retain in a block, store, or dispatch to another thread, regardless of whether
+// the bytes were owned by JS (valid only for this callstack) or by a native
+// MutableBuffer (which the JS ArrayBuffer may GC concurrently).
+static NSMutableData *convertJSIArrayBufferToNSMutableData(jsi::Runtime &rt, const jsi::ArrayBuffer &value)
 {
-  if (auto nativeBuffer = arrayBuffer.tryGetMutableBuffer(rt)) {
-    auto keepAlive = std::move(nativeBuffer);
-    return [RCTArrayBuffer arrayBufferWithOwnedBytes:keepAlive->data()
-                                              length:keepAlive->size()
-                                             cleanup:^{
-                                               (void)keepAlive;
-                                             }];
-  }
-
-  void *bytes = arrayBuffer.data(rt);
-  size_t size = arrayBuffer.size(rt);
-
-  // The bytes belong to the JS heap -> async call.
-  if (mustCopyBytes) {
-    return [RCTArrayBuffer arrayBufferWithCopiedBytes:bytes length:size];
-  }
-
-  // The bytes belong to the JS heap -> sync call.
-  return [RCTArrayBuffer arrayBufferWithUnownedBytes:bytes length:size];
+  return [NSMutableData dataWithBytes:value.data(rt) length:value.size(rt)];
 }
 
 id convertJSIValueToObjCObject(
     jsi::Runtime &runtime,
     const jsi::Value &value,
     const std::shared_ptr<CallInvoker> &jsInvoker,
-    BOOL useNSNull,
-    BOOL mustCopyBytes)
+    BOOL useNSNull)
 {
   if (value.isUndefined() || (value.isNull() && !useNSNull)) {
     return nil;
@@ -270,7 +243,7 @@ id convertJSIValueToObjCObject(
       return convertJSIFunctionToCallback(runtime, o.getFunction(runtime), jsInvoker);
     }
     if (o.isArrayBuffer(runtime)) {
-      return convertJSIArrayBufferToRCTArrayBuffer(runtime, o.getArrayBuffer(runtime), mustCopyBytes);
+      return convertJSIArrayBufferToNSMutableData(runtime, o.getArrayBuffer(runtime));
     }
     return convertJSIObjectToNSDictionary(runtime, o, jsInvoker, useNSNull);
   }
@@ -629,11 +602,11 @@ jsi::Value ObjCTurboModule::convertReturnIdToJSIValue(
       break;
     }
     case ArrayBufferKind: {
-      if (result != nil && ![result isKindOfClass:[RCTArrayBuffer class]]) {
-        RCTLogError(@"convertReturnIdToJSIValue: expected RCTArrayBuffer for ArrayBufferKind, got %@", [result class]);
+      if (result != nil && ![result isKindOfClass:[NSMutableData class]]) {
+        RCTLogError(@"convertReturnIdToJSIValue: expected NSMutableData for ArrayBufferKind, got %@", [result class]);
         break;
       }
-      returnValue = convertRCTArrayBufferToJSIArrayBuffer(runtime, (RCTArrayBuffer *)result);
+      returnValue = convertNSMutableDataToJSIArrayBuffer(runtime, (NSMutableData *)result);
       break;
     }
     case FunctionKind:
@@ -710,8 +683,7 @@ void ObjCTurboModule::setInvocationArg(
     const jsi::Value &arg,
     size_t i,
     NSInvocation *inv,
-    NSMutableArray *retainedObjectsForInvocation,
-    bool mustCopyBytes)
+    NSMutableArray *retainedObjectsForInvocation)
 {
   if (arg.isBool()) {
     bool v = arg.getBool();
@@ -754,15 +726,13 @@ void ObjCTurboModule::setInvocationArg(
    * Convert arg to ObjC objects.
    */
   BOOL enableModuleArgumentNSNullConversionIOS = ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS();
-  id objCArg =
-      convertJSIValueToObjCObject(runtime, arg, jsInvoker_, enableModuleArgumentNSNullConversionIOS, mustCopyBytes);
+  id objCArg = convertJSIValueToObjCObject(runtime, arg, jsInvoker_, enableModuleArgumentNSNullConversionIOS);
 
   // A JS `null` in argument position must reach ObjC as `nil`; only nulls nested inside arrays and
   // dictionaries are preserved as `kCFNull`. Skipping `setArgument:` leaves the slot zeroed.
   if (enableModuleArgumentNSNullConversionIOS && objCArg == (id)kCFNull) {
     return;
   }
-
   if (objCArg != nullptr) {
     NSString *methodNameNSString = @(methodName);
 
@@ -823,7 +793,6 @@ void ObjCTurboModule::setInvocationArg(
 NSInvocation *ObjCTurboModule::createMethodInvocation(
     jsi::Runtime &runtime,
     bool isSync,
-    bool mustCopyBytes,
     const char *methodName,
     SEL selector,
     const jsi::Value *args,
@@ -852,7 +821,7 @@ NSInvocation *ObjCTurboModule::createMethodInvocation(
   for (size_t i = 0; i < count; i++) {
     const jsi::Value &arg = args[i];
     const std::string objCArgType = [methodSignature getArgumentTypeAtIndex:i + 2];
-    setInvocationArg(runtime, methodName, objCArgType, arg, i, inv, retainedObjectsForInvocation, mustCopyBytes);
+    setInvocationArg(runtime, methodName, objCArgType, arg, i, inv, retainedObjectsForInvocation);
   }
 
   if (isSync) {
@@ -873,12 +842,6 @@ bool ObjCTurboModule::isMethodSync(TurboModuleMethodValueKind returnType)
   return returnType != VoidKind && returnType != PromiseKind;
 }
 
-bool ObjCTurboModule::mustCopyJSHeapArrayBufferBytes(TurboModuleMethodValueKind returnType)
-{
-  // Void always dispatches via invokeAsync and promise may.
-  return returnType == VoidKind || returnType == PromiseKind;
-}
-
 ObjCTurboModule::ObjCTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(params.instance),
@@ -899,7 +862,6 @@ jsi::Value ObjCTurboModule::invokeObjCMethod(
   const char *methodName = methodNameStr.c_str();
 
   bool isSyncInvocation = isMethodSync(returnType);
-  bool mustCopyBytes = mustCopyJSHeapArrayBufferBytes(returnType);
 
   if (isSyncInvocation) {
     TurboModulePerfLogger::syncMethodCallStart(moduleName, methodName);
@@ -909,7 +871,7 @@ jsi::Value ObjCTurboModule::invokeObjCMethod(
 
   NSMutableArray *retainedObjectsForInvocation = [NSMutableArray arrayWithCapacity:count + 2];
   NSInvocation *inv = createMethodInvocation(
-      runtime, isSyncInvocation, mustCopyBytes, methodName, selector, args, count, retainedObjectsForInvocation);
+      runtime, isSyncInvocation, methodName, selector, args, count, retainedObjectsForInvocation);
 
   jsi::Value returnValue = jsi::Value::undefined();
 

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<<7505981b27be5298787edef4d80527e8>>
+ * @generated SignedSource<<909f4afa6f96b4e77577432e4d98ba76>>
  */
 
 /**
@@ -199,6 +199,11 @@ bool NativeReactNativeFeatureFlags::enableImmediateUpdateModeForContentOffsetCha
   return ReactNativeFeatureFlags::enableImmediateUpdateModeForContentOffsetChanges();
 }
 
+bool NativeReactNativeFeatureFlags::enableImperativeEvents(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableImperativeEvents();
+}
+
 bool NativeReactNativeFeatureFlags::enableImperativeFocus(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableImperativeFocus();

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<<be495e72a7b96977ec6d029710d669a3>>
+ * @generated SignedSource<<88f2554b7033d38f5b275eac1d52ae6e>>
  */
 
 /**
@@ -100,6 +100,8 @@ class NativeReactNativeFeatureFlags
 
   bool enableImmediateUpdateModeForContentOffsetChanges(jsi::Runtime& runtime);
 
+  bool enableImperativeEvents(jsi::Runtime& runtime);
+
   bool enableImperativeFocus(jsi::Runtime& runtime);
 
   bool enableInteropViewManagerClassLookUpOptimizationIOS(jsi::Runtime& runtime);

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.mm

@@ -6,8 +6,6 @@
  */
 
 #import "RCTSampleTurboModule.h"
-
-#import <React/RCTArrayBuffer.h>
 #import "RCTSampleTurboModulePlugin.h"
 
 #import <React/RCTAssert.h>
@@ -16,8 +14,6 @@
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
 #import <UIKit/UIKit.h>
 
-#include <span>
-
 using namespace facebook::react;
 
 @interface RCTSampleTurboModule () <RCTTurboModuleWithJSIBindings, RCTInitializing>
@@ -149,27 +145,20 @@ RCT_EXPORT_MODULE()
   };
 }
 
-// The argument aliases the JS ArrayBuffer's bytes, so mutating in place is visible to JS.
-- (RCTArrayBuffer *)getArrayBuffer:(RCTArrayBuffer *)buffer
+// Arguments arrive as an immutable NSData, but an ArrayBuffer return must be
+// NSMutableData: it is handed to JS as a jsi::MutableBuffer, whose data() is
+// non-const. Echoing the argument back therefore needs a mutable copy.
+- (NSMutableData *)getArrayBuffer:(NSData *)buffer
 {
-  auto *bytes = static_cast<uint8_t *>(buffer.mutableBytes);
-  if (bytes == nullptr) {
-    return buffer;
-  }
-
-  std::span<uint8_t> byteSpan(bytes, static_cast<size_t>(buffer.length));
-  for (auto &byte : byteSpan) {
-    byte = static_cast<uint8_t>(byte * 2);
-  }
-  return buffer;
+  return [buffer mutableCopy];
 }
 
-- (RCTArrayBuffer *)createNativeBuffer:(double)size
+- (NSMutableData *)createNativeBuffer:(double)size
 {
-  return [RCTArrayBuffer arrayBufferWithLength:(NSUInteger)size];
+  return [NSMutableData dataWithLength:(NSUInteger)size];
 }
 
-- (void)processAsyncBuffer:(RCTArrayBuffer *)payload
+- (void)processAsyncBuffer:(NSData *)payload
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native",
-  "version": "0.88.0-rc.0",
+  "version": "0.88.0-rc.2",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {
@@ -34,7 +34,10 @@
       "default": "./index.js"
     },
     "./Libraries/*": {
-      "react-native-legacy-deep-imports": "./types_DEPRECATED/Libraries/*.d.ts",
+      "react-native-legacy-deep-imports": [
+        "./types_DEPRECATED/Libraries/*.d.ts",
+        "./Libraries/*.d.ts"
+      ],
       "types": null,
       "default": "./Libraries/*.js"
     },
@@ -143,7 +146,7 @@
   },
   "peerDependencies": {
     "@types/react": "^19.1.1",
-    "react": "^19.2.3"
+    "react": "^19.3.0"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -151,29 +154,29 @@
     }
   },
   "dependencies": {
-    "@react-native/asset-utils": "0.88.0-rc.0",
-    "@react-native/codegen": "0.88.0-rc.0",
-    "@react-native/community-cli-plugin": "0.88.0-rc.0",
-    "@react-native/gradle-plugin": "0.88.0-rc.0",
-    "@react-native/normalize-colors": "0.88.0-rc.0",
-    "@react-native/virtualized-lists": "0.88.0-rc.0",
+    "@react-native/asset-utils": "0.88.0-rc.2",
+    "@react-native/codegen": "0.88.0-rc.2",
+    "@react-native/community-cli-plugin": "0.88.0-rc.2",
+    "@react-native/gradle-plugin": "0.88.0-rc.2",
+    "@react-native/normalize-colors": "0.88.0-rc.2",
+    "@react-native/virtualized-lists": "0.88.0-rc.2",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",
     "flow-parser": "0.327.0",
     "base64-js": "^1.5.1",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-compiler": "260318099.0.2",
+    "hermes-compiler": "260318099.0.3",
     "invariant": "^2.2.4",
     "memoize-one": "^5.0.0",
-    "metro-runtime": "^0.87.0",
-    "metro-source-map": "^0.87.0",
+    "metro-runtime": "^0.87.1",
+    "metro-source-map": "^0.87.1",
     "nullthrows": "^1.1.1",
     "pretty-format": "^29.7.0",
     "promise": "^8.3.0",
     "react-devtools-core": "^6.1.5",
     "react-refresh": "^0.14.0",
     "regenerator-runtime": "^0.13.2",
-    "scheduler": "0.27.0",
+    "scheduler": "0.28.0",
     "semver": "^7.1.3",
     "stacktrace-parser": "^0.1.10",
     "tinyglobby": "^0.2.15",

package/scripts/codegen/generate-artifacts-executor/generateRCTThirdPartyComponents.js

@@ -177,10 +177,24 @@ function findFilesWithExtension(
       return null;
     }
 
-    if (
-      fs.existsSync(absolutePath) &&
-      fs.statSync(absolutePath).isDirectory()
-    ) {
+    // A library's own sources never live in its dependencies, and crawling them
+    // is what makes this walk explode on large projects.
+    if (file === 'node_modules') {
+      return null;
+    }
+
+    if (!fs.existsSync(absolutePath)) {
+      return null;
+    }
+
+    // `lstatSync` does not resolve symlinks: following them can loop forever,
+    // e.g. workspace packages that link into each other under pnpm.
+    const stats = fs.lstatSync(absolutePath);
+    if (stats.isSymbolicLink()) {
+      return null;
+    }
+
+    if (stats.isDirectory()) {
       files.push(...findFilesWithExtension(absolutePath, extension));
     } else if (file.endsWith(extension)) {
       files.push(absolutePath);