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

package/Libraries/Core/ReactNativeVersion.js

@@ -29,7 +29,7 @@ export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 88;
   static patch: number = 0;
-  static prerelease: string | null = 'rc.1';
+  static prerelease: string | null = 'rc.2';
 
   static getVersionString(): string {
     return `${this.major}.${this.minor}.${this.patch}${this.prerelease != null ? `-${this.prerelease}` : ''}`;

package/React/Base/RCTVersion.m

@@ -24,7 +24,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(88),
                   RCTVersionPatch: @(0),
-                  RCTVersionPrerelease: @"rc.1",
+                  RCTVersionPrerelease: @"rc.2",
                   };
   });
   return __rnVersion;

package/React/FBReactNativeSpec/FBReactNativeSpec/FBReactNativeSpec.h

@@ -23,7 +23,6 @@
 #import <RCTRequired/RCTRequired.h>
 #import <RCTTypeSafety/RCTConvertHelpers.h>
 #import <RCTTypeSafety/RCTTypedModuleConstants.h>
-#import <React/RCTArrayBuffer.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTCxxConvert.h>
 #import <React/RCTManagedPointer.h>
@@ -1779,9 +1778,9 @@ namespace JS {
 - (NSDictionary *)getValue:(double)x
                          y:(NSString *)y
                          z:(NSDictionary *)z;
-- (RCTArrayBuffer *)getArrayBuffer:(RCTArrayBuffer *)buffer;
-- (RCTArrayBuffer *)createNativeBuffer:(double)size;
-- (void)processAsyncBuffer:(RCTArrayBuffer *)payload
+- (NSMutableData *)getArrayBuffer:(NSMutableData *)buffer;
+- (NSMutableData *)createNativeBuffer:(double)size;
+- (void)processAsyncBuffer:(NSMutableData *)payload
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject;
 - (void)getValueWithCallback:(RCTResponseSenderBlock)callback;

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.88.0-rc.1
+VERSION_NAME=0.88.0-rc.2
 react.internal.publishingGroup=com.facebook.react
 react.internal.hermesPublishingGroup=com.facebook.hermes
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.kt

@@ -15,6 +15,6 @@ public object ReactNativeVersion {
     "major" to 0,
     "minor" to 88,
     "patch" to 0,
-    "prerelease" to "rc.1"
+    "prerelease" to "rc.2"
   )
 }

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -22,7 +22,7 @@ struct ReactNativeVersionType {
   int32_t Major = 0;
   int32_t Minor = 88;
   int32_t Patch = 0;
-  std::string_view Prerelease = "rc.1";
+  std::string_view Prerelease = "rc.2";
 };
 
 constexpr ReactNativeVersionType ReactNativeVersion;

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/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.1",
+  "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"
     },
@@ -151,12 +154,12 @@
     }
   },
   "dependencies": {
-    "@react-native/asset-utils": "0.88.0-rc.1",
-    "@react-native/codegen": "0.88.0-rc.1",
-    "@react-native/community-cli-plugin": "0.88.0-rc.1",
-    "@react-native/gradle-plugin": "0.88.0-rc.1",
-    "@react-native/normalize-colors": "0.88.0-rc.1",
-    "@react-native/virtualized-lists": "0.88.0-rc.1",
+    "@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",
@@ -165,8 +168,8 @@
     "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",

package/React/Base/RCTArrayBuffer.h

@@ -1,64 +0,0 @@
-/*
- * 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.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * A fixed-length byte buffer shared between JS `ArrayBuffer`s and ObjC TurboModules. Fixed
- * length lets the backing store alias JS memory; `NSMutableData` cannot do that.
- *
- * `isOwningBytes`:
- *  - `YES` — safe to retain and use from any thread (synchronize if aliasing JS
- *     memory).
- *  - `NO` — valid only during the synchronous call on the calling thread; copy with
- *    `arrayBufferWithCopiedBytes:length:` to keep the bytes.
- */
-@interface RCTArrayBuffer : NSObject
-
-/**
- * NULL when `length` is 0, non-NULL otherwise, matching `NSData.bytes`.
- */
-@property (nonatomic, readonly, nullable) void *mutableBytes NS_RETURNS_INNER_POINTER;
-
-@property (nonatomic, readonly) NSUInteger length;
-
-/** Whether the buffer owns its bytes. See the class comment. */
-@property (nonatomic, readonly, getter=isOwningBytes) BOOL owningBytes;
-
-/**
- * A new zero-filled owning buffer.
- */
-+ (instancetype)arrayBufferWithLength:(NSUInteger)length;
-
-/**
- * A new owning buffer holding a copy of `bytes`. Passing NULL zero-fills.
- */
-+ (instancetype)arrayBufferWithCopiedBytes:(const void *_Nullable)bytes length:(NSUInteger)length;
-
-/**
- * An owning buffer aliasing `bytes` without copying. If `cleanup` is non-nil, it runs on dealloc,
- * like `-[NSData dataWithBytesNoCopy:length:freeWhenDone:YES]`; if nil, the caller must keep
- * `bytes` valid until dealloc. NULL `bytes` with non-zero `length` raises NSInvalidArgumentException.
- */
-+ (instancetype)arrayBufferWithOwnedBytes:(nullable void *)bytes
-                                   length:(NSUInteger)length
-                                  cleanup:(nullable void (^)(void))cleanup;
-
-/**
- * A non-owning, zero-copy alias of `bytes`. See the class comment for lifetime rules. NULL `bytes`
- * with non-zero `length` raises NSInvalidArgumentException.
- */
-+ (instancetype)arrayBufferWithUnownedBytes:(nullable void *)bytes length:(NSUInteger)length;
-
-- (instancetype)init NS_UNAVAILABLE;
-+ (instancetype)new NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/React/Base/RCTArrayBuffer.mm

@@ -1,127 +0,0 @@
-/*
- * 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.
- */
-
-#import "RCTArrayBuffer.h"
-
-#include <cstdint>
-#include <cstring>
-#include <utility>
-#include <vector>
-
-@interface RCTArrayBuffer ()
-
-- (instancetype)initWithBytesNoCopy:(nullable void *)bytes
-                             length:(NSUInteger)length
-                        owningBytes:(BOOL)owningBytes
-                            cleanup:(nullable void (^)(void))cleanup NS_DESIGNATED_INITIALIZER;
-- (instancetype)initWithCopiedBytes:(const void *_Nullable)bytes length:(NSUInteger)length;
-
-@end
-
-@implementation RCTArrayBuffer {
-  void *_bytes;
-  NSUInteger _length;
-  BOOL _owningBytes;
-  void (^_cleanup)(void);
-  std::vector<uint8_t> _copiedBytes;
-}
-
-#pragma mark - Initializers
-
-- (instancetype)initWithBytesNoCopy:(void *)bytes
-                             length:(NSUInteger)length
-                        owningBytes:(BOOL)owningBytes
-                            cleanup:(void (^)(void))cleanup
-{
-  if (bytes == NULL && length != 0) {
-    [NSException raise:NSInvalidArgumentException
-                format:@"RCTArrayBuffer: NULL bytes with length %lu", (unsigned long)length];
-  }
-
-  if (self = [super init]) {
-    _bytes = bytes;
-    _length = length;
-    _owningBytes = owningBytes;
-    _cleanup = [cleanup copy];
-  }
-  return self;
-}
-
-- (instancetype)initWithCopiedBytes:(const void *)bytes length:(NSUInteger)length
-{
-  if (length == 0) {
-    return [self initWithBytesNoCopy:NULL length:0 owningBytes:YES cleanup:nil];
-  }
-
-  std::vector<uint8_t> copy(length);
-  if (bytes != NULL) {
-    std::memcpy(copy.data(), bytes, length);
-  }
-
-  // Moving a vector hands over its heap buffer, so `data()` stays valid in `_copiedBytes`.
-  if (self = [self initWithBytesNoCopy:copy.data() length:length owningBytes:YES cleanup:nil]) {
-    _copiedBytes = std::move(copy);
-  }
-  return self;
-}
-
-+ (instancetype)arrayBufferWithLength:(NSUInteger)length
-{
-  return [[self alloc] initWithCopiedBytes:NULL length:length];
-}
-
-+ (instancetype)arrayBufferWithCopiedBytes:(const void *)bytes length:(NSUInteger)length
-{
-  return [[self alloc] initWithCopiedBytes:bytes length:length];
-}
-
-+ (instancetype)arrayBufferWithOwnedBytes:(void *)bytes
-                                   length:(NSUInteger)length
-                                  cleanup:(nullable void (^)(void))cleanup
-{
-  return [[self alloc] initWithBytesNoCopy:bytes length:length owningBytes:YES cleanup:cleanup];
-}
-
-+ (instancetype)arrayBufferWithUnownedBytes:(void *)bytes length:(NSUInteger)length
-{
-  return [[self alloc] initWithBytesNoCopy:bytes length:length owningBytes:NO cleanup:nil];
-}
-
-#pragma mark - Accessors
-
-- (void *)mutableBytes
-{
-  return _bytes;
-}
-
-- (NSUInteger)length
-{
-  return _length;
-}
-
-- (BOOL)isOwningBytes
-{
-  return _owningBytes;
-}
-
-- (NSString *)description
-{
-  return [NSString stringWithFormat:@"<%@: %p; length = %lu; owningBytes = %@>",
-                                    NSStringFromClass([self class]),
-                                    self,
-                                    (unsigned long)_length,
-                                    _owningBytes ? @"YES" : @"NO"];
-}
-
-- (void)dealloc
-{
-  if (_cleanup != nil) {
-    _cleanup();
-  }
-}
-
-@end