react-native-tvos 0.87.1-0 → 0.88.0-0rc2

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

@@ -10,7 +10,10 @@
 #import <ReactCommon/RCTTurboModule.h>
 #import <hermes/hermes.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 
+#import <array>
+#import <memory>
 #import <vector>
 
 #import <OCMock/OCMock.h>
@@ -19,6 +22,12 @@ using namespace facebook::react;
 
 @interface RCTTestTurboModule : NSObject <RCTBridgeModule>
 
+// Deliberately not exported with RCT_EXPORT_METHOD: without `__rct_export__` metadata,
+// `getArgumentTypeName` returns nil for the arguments.
+- (void)testMethodWhichTakesStringWithoutExportMacro:(NSString *)string;
+
+- (void)logEvent:(NSString *)eventName data:(NSDictionary *)data analyticsModule:(nullable NSString *)analyticsModule;
+
 @end
 
 @implementation RCTTestTurboModule
@@ -27,8 +36,45 @@ RCT_EXPORT_MODULE()
 
 RCT_EXPORT_METHOD(testMethodWhichTakesObject : (id)object) {}
 
+- (void)testMethodWhichTakesStringWithoutExportMacro:(NSString *)string
+{
+}
+
+- (void)logEvent:(NSString *)eventName data:(NSDictionary *)data analyticsModule:(nullable NSString *)analyticsModule
+{
+}
+
 @end
 
+@interface RCTThrowingTurboModule : NSObject <RCTBridgeModule>
+
+@end
+
+@implementation RCTThrowingTurboModule
+
+RCT_EXPORT_MODULE()
+
+// A plain `NSArray *` parameter has no element converter to sanitise it (unlike, say,
+// `NSArray<NSString *> *`, which RCTConvert routes through `NSStringArray:` and which drops nulls),
+// so `convertJSIArrayToNSArray` substituting `[NSNull null]` for a null element to preserve the
+// indices is what this loop actually receives from a JS caller passing `['a', null]`.
+RCT_EXPORT_METHOD(testMethodWhichReadsStringsFromArray : (NSArray *)items)
+{
+  for (NSUInteger i = 0; i < items.count; i++) {
+    (void)[(NSString *)items[i] length];
+  }
+}
+
+@end
+
+class ReactNativeFeatureFlagsNSNullConversionEnabled : public ReactNativeFeatureFlagsDefaults {
+ public:
+  bool enableModuleArgumentNSNullConversionIOS() override
+  {
+    return true;
+  }
+};
+
 // Minimal concrete MutableBuffer that owns its bytes, used to observe lifetime.
 class TestMutableBuffer : public facebook::jsi::MutableBuffer {
  public:
@@ -58,6 +104,37 @@ class StubNativeMethodCallInvoker : public NativeMethodCallInvoker {
   }
 };
 
+// `NativeMethodCallInvoker::invokeAsync` is noexcept, so an NSException escaping the async
+// invocation terminates the process — which is the production failure mode, but leaves nothing for
+// a test to inspect. Catching here stands in for the process-level handler and puts the exception
+// exactly where that handler would see it.
+class ExceptionCapturingNativeMethodCallInvoker : public NativeMethodCallInvoker {
+ public:
+  __strong NSException *caught = nil;
+
+  void invokeAsync(const std::string & /*methodName*/, NativeMethodCallFunc &&func) noexcept override
+  {
+    // The outer C++ handler is what makes the `noexcept` honest: `func` is a std::function, and
+    // invoking an empty one throws a `std::bad_function_call` that `@catch (NSException *)` cannot
+    // bind.
+    try {
+      @try {
+        func();
+      } @catch (NSException *exception) {
+        caught = exception;
+      }
+    } catch (...) {
+    }
+  }
+  void invokeSync(const std::string & /*methodName*/, NativeMethodCallFunc &&func) noexcept override
+  {
+    try {
+      func();
+    } catch (...) {
+    }
+  }
+};
+
 @interface RCTTurboModuleTests : XCTestCase
 @end
 
@@ -86,6 +163,8 @@ class StubNativeMethodCallInvoker : public NativeMethodCallInvoker {
   module_ = nullptr;
   instance_ = nil;
 
+  ReactNativeFeatureFlags::dangerouslyReset();
+
   [super tearDown];
 }
 
@@ -123,6 +202,123 @@ class StubNativeMethodCallInvoker : public NativeMethodCallInvoker {
   OCMVerify(OCMTimes(1), [instance_ testMethodWhichTakesObject:nil]);
 }
 
+- (void)testInvokeUnexportedTurboModuleMethodWithNullPassesNil
+{
+  ReactNativeFeatureFlags::dangerouslyForceOverride(std::make_unique<ReactNativeFeatureFlagsNSNullConversionEnabled>());
+
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
+
+  std::array<facebook::jsi::Value, 1> args = {facebook::jsi::Value::null()};
+  module_->invokeObjCMethod(
+      *rt,
+      VoidKind,
+      "testMethodWhichTakesStringWithoutExportMacro",
+      @selector(testMethodWhichTakesStringWithoutExportMacro:),
+      args.data(),
+      args.size());
+
+  OCMVerify(OCMTimes(1), [instance_ testMethodWhichTakesStringWithoutExportMacro:nil]);
+  OCMVerify(OCMNever(), [instance_ testMethodWhichTakesStringWithoutExportMacro:(id)kCFNull]);
+}
+
+- (void)testInvokeUnexportedTurboModuleMethodWithNullTrailingArgumentPassesNil
+{
+  ReactNativeFeatureFlags::dangerouslyForceOverride(std::make_unique<ReactNativeFeatureFlagsNSNullConversionEnabled>());
+
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
+
+  __block id capturedAnalyticsModule = (id)kCFNull;
+  OCMStub([instance_ logEvent:OCMOCK_ANY
+                         data:OCMOCK_ANY
+              analyticsModule:[OCMArg checkWithBlock:^BOOL(id value) {
+                capturedAnalyticsModule = value;
+                return YES;
+              }]]);
+
+  std::array<facebook::jsi::Value, 3> args = {
+      facebook::jsi::String::createFromAscii(*rt, "some_event"),
+      facebook::jsi::Object(*rt),
+      facebook::jsi::Value::null()};
+  args[1].asObject(*rt).setProperty(*rt, "key", "value");
+
+  module_->invokeObjCMethod(
+      *rt, VoidKind, "logEvent", @selector(logEvent:data:analyticsModule:), args.data(), args.size());
+
+  OCMVerify(OCMTimes(1), [instance_ logEvent:@"some_event" data:@{@"key" : @"value"} analyticsModule:nil]);
+  XCTAssertNil(capturedAnalyticsModule);
+
+  // `NSNull` is truthy, so this fallback would forward it and throw on -mutableCopy.
+  NSString *analyticsModule = (capturedAnalyticsModule != nullptr) ? capturedAnalyticsModule : @"";
+  XCTAssertNoThrow([analyticsModule mutableCopy]);
+}
+
+// Scrubbing a null in argument position must not scrub nulls nested inside a collection argument.
+- (void)testInvokeTurboModuleKeepsNestedNullAsNSNullWhenFlagEnabled
+{
+  ReactNativeFeatureFlags::dangerouslyForceOverride(std::make_unique<ReactNativeFeatureFlagsNSNullConversionEnabled>());
+
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
+
+  std::array<facebook::jsi::Value, 1> args = {facebook::jsi::Object(*rt)};
+  args[0].asObject(*rt).setProperty(*rt, "foo", facebook::jsi::Value::null());
+  module_->invokeObjCMethod(
+      *rt, VoidKind, "testMethodWhichTakesObject", @selector(testMethodWhichTakesObject:), args.data(), args.size());
+
+  OCMVerify(OCMTimes(1), [instance_ testMethodWhichTakesObject:@{@"foo" : (id)kCFNull}]);
+}
+
+// Void methods are always async, so an NSException raised by the module unwinds past every module
+// frame before anything reports it. The rethrow is the last point at which the failing module and
+// method are still known, so it has to put them on the exception.
+- (void)testVoidMethodExceptionCarriesModuleAndMethodName
+{
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  facebook::jsi::Runtime *rt = hermesRuntime.get();
+
+  auto invoker = std::make_shared<ExceptionCapturingNativeMethodCallInvoker>();
+  RCTThrowingTurboModule *instance = [RCTThrowingTurboModule new];
+  ObjCTurboModule::InitParams params = {
+      .moduleName = "ThrowingTestModule",
+      .instance = instance,
+      .jsInvoker = nullptr,
+      .nativeMethodCallInvoker = invoker,
+      .isSyncModule = false,
+  };
+  ObjCTurboModule module(params);
+
+  auto items = facebook::jsi::Array(*rt, 2);
+  items.setValueAtIndex(*rt, 0, facebook::jsi::String::createFromAscii(*rt, "a"));
+  items.setValueAtIndex(*rt, 1, facebook::jsi::Value::null());
+  std::array<facebook::jsi::Value, 1> args = {facebook::jsi::Value(*rt, items)};
+
+  module.invokeObjCMethod(
+      *rt,
+      VoidKind,
+      "testMethodWhichReadsStringsFromArray",
+      @selector(testMethodWhichReadsStringsFromArray:),
+      args.data(),
+      1);
+
+  NSException *caught = invoker->caught;
+  XCTAssertNotNil(caught, @"Sending -length to the NSNull standing in for the null element must raise");
+  XCTAssertEqualObjects(caught.name, NSInvalidArgumentException);
+  XCTAssertTrue(
+      [caught.reason containsString:@"ThrowingTestModule"], @"reason must name the module: %@", caught.reason);
+  XCTAssertTrue(
+      [caught.reason containsString:@"testMethodWhichReadsStringsFromArray"],
+      @"reason must name the method: %@",
+      caught.reason);
+  // The original failure has to survive alongside the identity rather than be replaced by it.
+  XCTAssertTrue([caught.reason containsString:@"unrecognized selector"], @"%@", caught.reason);
+  NSException *original = caught.userInfo[@"RCTTurboModuleOriginalException"];
+  XCTAssertNotNil(original);
+  XCTAssertNotNil(original.callStackReturnAddresses);
+  XCTAssertNotNil(original.callStackSymbols);
+}
+
 // 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

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -5,10 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <cstring>
+#include <limits>
 #include <memory>
 #include <string>
 
 #include <cxxreact/TraceSection.h>
+#include <fbjni/ByteBuffer.h>
 #include <fbjni/fbjni.h>
 #include <glog/logging.h>
 #include <jsi/jsi.h>
@@ -20,6 +23,7 @@
 #include <react/bridging/Bridging.h>
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/jni/JArrayBuffer.h>
 #include <react/jni/JDynamicNative.h>
 #include <react/jni/NativeMap.h>
 #include <react/jni/ReadableNativeMap.h>
@@ -59,6 +63,12 @@ JavaTurboModule::~JavaTurboModule() {
 
 namespace {
 
+// A method whose result is delivered synchronously, so JS-heap bytes passed as
+// arguments stay valid for the duration of the call.
+bool isSyncMethod(TurboModuleMethodValueKind valueKind) {
+  return valueKind != VoidKind && valueKind != PromiseKind;
+}
+
 struct JNIArgs {
   JNIArgs(size_t count) : args(count) {}
   JNIArgs(const JNIArgs&) = delete;
@@ -69,8 +79,19 @@ struct JNIArgs {
 
   std::vector<jvalue> args;
   std::vector<jobject> globalRefs;
+  // ArrayBuffers aliasing JS-heap bytes lent for this call only. Local refs are
+  // enough because bytes are only lent on the synchronous path, where this
+  // JNIArgs is destroyed in the same native frame that created the refs.
+  std::vector<jni::local_ref<JArrayBuffer::javaobject>> borrowedBuffers;
 
   ~JNIArgs() {
+    // Revoke the borrows before the call frame that lent the bytes unwinds, so
+    // a module that retained one cannot read freed or relocated memory. Runs on
+    // the throw path too.
+    for (auto& borrowedBuffer : borrowedBuffers) {
+      borrowedBuffer->cthis()->invalidate();
+    }
+
     JNIEnv* env = jni::Environment::current();
     for (auto globalRef : globalRefs) {
       env->DeleteGlobalRef(globalRef);
@@ -311,8 +332,10 @@ JNIArgs convertJSIArgsToJNIArgs(
   auto& jargs = jniArgs.args;
   auto& globalRefs = jniArgs.globalRefs;
 
+  auto isSyncInvocation = isSyncMethod(valueKind);
+
   auto makeGlobalIfNecessary = [&](jobject obj) {
-    if (valueKind == VoidKind || valueKind == PromiseKind) {
+    if (!isSyncInvocation) {
       jobject globalObj = env->NewGlobalRef(obj);
       globalRefs.push_back(globalObj);
       env->DeleteLocalRef(obj);
@@ -322,7 +345,7 @@ JNIArgs convertJSIArgsToJNIArgs(
     return obj;
   };
 
-  for (unsigned int argIndex = 0; argIndex < count; argIndex += 1) {
+  for (int argIndex = 0; argIndex < static_cast<int>(count); argIndex += 1) {
     const std::string& type = methodArgTypes.at(argIndex);
 
     const jsi::Value* arg = &args[argIndex];
@@ -402,8 +425,10 @@ JNIArgs convertJSIArgsToJNIArgs(
         throw JavaTurboModuleArgumentConversionException(
             "string", argIndex, methodName, arg, &rt);
       }
-      jarg->l = makeGlobalIfNecessary(
-          env->NewStringUTF(arg->getString(rt).utf8(rt).c_str()));
+      auto utf16 = rt.utf16(arg->getString(rt));
+      jarg->l = makeGlobalIfNecessary(env->NewString(
+          reinterpret_cast<const jchar*>(utf16.data()),
+          static_cast<jsize>(utf16.size())));
     } else if (type == "Lcom/facebook/react/bridge/Callback;") {
       if (!(arg->isObject() && arg->getObject(rt).isFunction(rt))) {
         throw JavaTurboModuleArgumentConversionException(
@@ -434,6 +459,58 @@ JNIArgs convertJSIArgsToJNIArgs(
       auto dynamicFromValue = jsi::dynamicFromValue(rt, *arg);
       auto jParams = JDynamicNative::newObjectCxxArgs(dynamicFromValue);
       jarg->l = makeGlobalIfNecessary(jParams.release());
+    } else if (type == "Lcom/facebook/react/bridge/ArrayBuffer;") {
+      if (!(arg->isObject() && arg->getObject(rt).isArrayBuffer(rt))) {
+        throw JavaTurboModuleArgumentConversionException(
+            "ArrayBuffer", argIndex, methodName, arg, &rt);
+      }
+
+      auto arrayBuffer = arg->getObject(rt).getArrayBuffer(rt);
+      AsyncArrayBuffer::throwIfDetached(
+          rt, arrayBuffer, "JavaTurboModule::convertJSIArgsToJNIArgs");
+
+      auto size = arrayBuffer.size(rt);
+      if (size > static_cast<size_t>(std::numeric_limits<jint>::max())) {
+        throw jsi::JSError(
+            rt,
+            "JavaTurboModule::convertJSIArgsToJNIArgs: ArrayBuffer exceeds maximum size.");
+      }
+
+      // Runtimes without a native buffer for this ArrayBuffer return nullptr,
+      // but the Static Hermes tracing runtime throws instead, and argument
+      // conversion runs outside any std::exception handler. Treat a failed
+      // probe as "no native buffer" so a traced session copies the bytes rather
+      // than aborting the process.
+      std::shared_ptr<jsi::MutableBuffer> mutableBuffer;
+      try {
+        mutableBuffer = arrayBuffer.tryGetMutableBuffer(rt);
+      } catch (const std::exception&) {
+        mutableBuffer = nullptr;
+      }
+
+      bool borrowsJSBytes = false;
+      auto jArrayBuffer = [&]() {
+        // Backed by a native buffer: alias it and retain its owner, so the
+        // bytes stay valid for as long as the module holds the ArrayBuffer.
+        if (mutableBuffer) {
+          return JArrayBuffer::createOwning(std::move(mutableBuffer));
+        }
+
+        // JS heap bytes on a synchronous call: lend them for the duration of
+        // the call.
+        if (isSyncInvocation) {
+          borrowsJSBytes = true;
+          return JArrayBuffer::createUnowned(arrayBuffer.data(rt), size);
+        }
+
+        // JS heap bytes that outlive the call: copy.
+        return JArrayBuffer::createOwned(arrayBuffer.data(rt), size);
+      }();
+
+      if (borrowsJSBytes) {
+        jniArgs.borrowedBuffers.push_back(jni::make_local(jArrayBuffer));
+      }
+      jarg->l = makeGlobalIfNecessary(jArrayBuffer.release());
     } else {
       throw JavaTurboModuleInvalidArgumentTypeException(
           type, argIndex, methodName);
@@ -522,7 +599,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
   const char* methodName = methodNameStr.c_str();
   const char* moduleName = name_.c_str();
 
-  bool isMethodSync = valueKind != VoidKind && valueKind != PromiseKind;
+  bool isMethodSync = isSyncMethod(valueKind);
 
   if (isMethodSync) {
     TMPL::syncMethodCallStart(moduleName, methodName);
@@ -750,11 +827,14 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
 
       jsi::Value returnValue = jsi::Value::null();
       if (returnString != nullptr) {
-        const char* js = env->GetStringUTFChars(returnString, nullptr);
-        std::string result = js;
-        env->ReleaseStringUTFChars(returnString, js);
-        returnValue =
-            jsi::Value(runtime, jsi::String::createFromUtf8(runtime, result));
+        jsize length = env->GetStringLength(returnString);
+        const jchar* chars = env->GetStringChars(returnString, nullptr);
+        auto jsiString = jsi::String::createFromUtf16(
+            runtime,
+            reinterpret_cast<const char16_t*>(chars),
+            static_cast<size_t>(length));
+        env->ReleaseStringChars(returnString, chars);
+        returnValue = jsi::Value(runtime, jsiString);
       }
 
       TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
@@ -963,6 +1043,36 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       TMPL::asyncMethodCallEnd(moduleName, methodName);
       return jsPromise;
     }
+    case ArrayBufferKind: {
+      auto returnObject =
+          (jobject)env->CallObjectMethodA(instance, methodID, jargs.data());
+      checkJNIErrorForMethodCall();
+
+      TMPL::syncMethodCallExecutionEnd(moduleName, methodName);
+      TMPL::syncMethodCallReturnConversionStart(moduleName, methodName);
+
+      jsi::Value returnValue = jsi::Value::null();
+      if (returnObject != nullptr) {
+        auto returnRef = jni::adopt_local(returnObject);
+        if (!returnRef->isInstanceOf(JArrayBuffer::javaClassStatic())) {
+          throw jsi::JSError(
+              runtime,
+              "JavaTurboModule::invokeJavaMethod: expected " + methodNameStr +
+                  " to return a com.facebook.react.bridge.ArrayBuffer.");
+        }
+
+        auto jArrayBuffer =
+            jni::static_ref_cast<JArrayBuffer::javaobject>(returnRef);
+        returnValue = {
+            runtime,
+            jsi::ArrayBuffer{
+                runtime, JArrayBuffer::toJSBuffer(runtime, jArrayBuffer)}};
+      }
+
+      TMPL::syncMethodCallReturnConversionEnd(moduleName, methodName);
+      TMPL::syncMethodCallEnd(moduleName, methodName);
+      return returnValue;
+    }
     default:
       throw std::runtime_error(
           "Unable to find method module: " + methodNameStr + "(" +
@@ -982,12 +1092,20 @@ void JavaTurboModule::configureEventEmitterCallback() {
     FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
   }
 
-  auto callback = JCxxCallbackImpl::newObjectCxxArgs([&](folly::dynamic args) {
-    auto eventName = args.at(0).asString();
-    auto& eventEmitter = static_cast<AsyncEventEmitter<folly::dynamic>&>(
-        *eventEmitterMap_[eventName].get());
-    eventEmitter.emit(args.size() > 1 ? std::move(args).at(1) : nullptr);
-  });
+  // The Java module owns the callback and can outlive this object, so the
+  // lambda captures its own copy of the map rather than referencing
+  // eventEmitterMap_. Callers register every emitter before reaching here;
+  // emitters added afterwards are not visible to this callback.
+  auto callback = JCxxCallbackImpl::newObjectCxxArgs(
+      [eventEmitterMap = eventEmitterMap_](folly::dynamic args) {
+        auto eventName = args.at(0).asString();
+        auto it = eventEmitterMap.find(eventName);
+        if (it == eventEmitterMap.end() || !it->second) {
+          return;
+        }
+        static_cast<AsyncEventEmitter<folly::dynamic>&>(*it->second)
+            .emit(args.size() > 1 ? std::move(args).at(1) : nullptr);
+      });
 
   jvalue args[1];
   args[0].l = callback.release();

package/ReactCommon/react/nativemodule/core/platform/ios/React-NativeModulesApple.podspec

@@ -52,4 +52,6 @@ Pod::Spec.new do |s|
     depend_on_js_engine(s)
     add_rn_third_party_dependencies(s)
     add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

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

@@ -143,7 +143,9 @@ jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
 
 static NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value)
 {
-  return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
+  auto utf8 = value.utf8(runtime);
+  NSString *result = [[NSString alloc] initWithBytes:utf8.data() length:utf8.size() encoding:NSUTF8StringEncoding];
+  return result != nil ? result : @"";
 }
 
 static NSArray *convertJSIArrayToNSArray(
@@ -278,6 +280,35 @@ static jsi::JSError convertNSExceptionToJSError(
   return {runtime, std::move(error)};
 }
 
+/**
+ * userInfo key under which `addModuleIdentityToException` preserves the exception it wraps, so its
+ * raise-site `callStackReturnAddresses` and `callStackSymbols` stay available to symbolication.
+ */
+static NSString *const RCTTurboModuleOriginalExceptionKey = @"RCTTurboModuleOriginalException";
+
+/**
+ * Async and void method calls have no JS runtime to attach a JSError to, so an NSException raised
+ * by the module escapes to the process-level handler instead. The stack it arrives with has
+ * already unwound past the module, so unless the module and method names travel on the exception
+ * itself the resulting crash cannot be attributed to an owning module.
+ */
+static NSException *
+addModuleIdentityToException(NSException *exception, const std::string &moduleName, const std::string &methodName)
+{
+  // A newly constructed NSException captures its call stack at @throw rather than at the original
+  // raise, so the original exception is carried across whole.
+  NSMutableDictionary *userInfo =
+      [NSMutableDictionary dictionaryWithDictionary:exception.userInfo != nil ? exception.userInfo : @{}];
+  userInfo[RCTTurboModuleOriginalExceptionKey] = exception;
+
+  return [NSException exceptionWithName:exception.name
+                                 reason:[NSString stringWithFormat:@"%s.%s raised an exception: %@",
+                                                                   moduleName.c_str(),
+                                                                   methodName.c_str(),
+                                                                   exception.reason]
+                               userInfo:userInfo];
+}
+
 /**
  * Creates JS error value with current JS runtime and error details.
  */
@@ -448,7 +479,7 @@ id ObjCTurboModule::performMethodInvocation(
         // See https://github.com/reactwg/react-native-new-architecture/discussions/276#discussioncomment-12567155
         throw convertNSExceptionToJSError(runtime, exception, std::string{moduleName}, methodNameStr);
       } else {
-        @throw exception;
+        @throw addModuleIdentityToException(exception, std::string{moduleName}, methodNameStr);
       }
     } @finally {
       [retainedObjectsForInvocation removeAllObjects];
@@ -510,7 +541,7 @@ void ObjCTurboModule::performVoidMethodInvocation(
     } @catch (NSException *exception) {
       // Void methods are always async, re-throw instead of converting to
       // JSError, same as the async branch in performMethodInvocation.
-      @throw exception;
+      @throw addModuleIdentityToException(exception, std::string{moduleName}, methodNameStr);
     } @finally {
       [retainedObjectsForInvocation removeAllObjects];
     }
@@ -696,6 +727,12 @@ void ObjCTurboModule::setInvocationArg(
    */
   BOOL enableModuleArgumentNSNullConversionIOS = ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS();
   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);
 

package/ReactCommon/react/nativemodule/cputime/CMakeLists.txt

@@ -15,6 +15,7 @@ target_include_directories(react_nativemodule_cpu PUBLIC ${REACT_COMMON_DIR})
 
 target_link_libraries(react_nativemodule_cpu
         react_codegen_rncore
+        react_cxxstableapi
 )
 target_compile_reactnative_options(react_nativemodule_cpu PRIVATE)
 target_compile_options(react_nativemodule_cpu PRIVATE -Wpedantic)

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #if defined USE_POSIX_TIME
 #include <time.h>
 #elif defined __MACH__

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #if __has_include("rncoreJSI.h") // Cmake headers on Android
 #include "rncoreJSI.h"
 #elif __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple

package/ReactCommon/react/nativemodule/defaults/CMakeLists.txt

@@ -15,6 +15,7 @@ target_include_directories(react_nativemodule_defaults PUBLIC ${REACT_COMMON_DIR
 
 target_link_libraries(react_nativemodule_defaults
         react_codegen_rncore
+        react_cxxstableapi
         react_nativemodule_core
         react_nativemodule_dom
         react_nativemodule_devtoolsruntimesettings
@@ -23,6 +24,7 @@ target_link_libraries(react_nativemodule_defaults
         react_nativemodule_idlecallbacks
         react_nativemodule_intersectionobserver
         react_nativemodule_mutationobserver
+        react_nativemodule_resizeobserver
         react_nativemodule_viewtransition
         react_nativemodule_webperformance
         react_renderer_animated

package/ReactCommon/react/nativemodule/defaults/DefaultTurboModules.cpp

@@ -13,6 +13,7 @@
 #include <react/nativemodule/intersectionobserver/NativeIntersectionObserver.h>
 #include <react/nativemodule/microtasks/NativeMicrotasks.h>
 #include <react/nativemodule/mutationobserver/NativeMutationObserver.h>
+#include <react/nativemodule/resizeobserver/NativeResizeObserver.h>
 #include <react/nativemodule/viewtransition/NativeViewTransition.h>
 #include <react/nativemodule/webperformance/NativePerformance.h>
 #include <react/renderer/animated/AnimatedModule.h>
@@ -58,6 +59,12 @@ namespace facebook::react {
     }
   }
 
+  if (ReactNativeFeatureFlags::enableResizeObserverByDefault()) {
+    if (name == NativeResizeObserver::kModuleName) {
+      return std::make_shared<NativeResizeObserver>(jsInvoker);
+    }
+  }
+
   if (ReactNativeFeatureFlags::viewTransitionEnabled()) {
     if (name == NativeViewTransition::kModuleName) {
       return std::make_shared<NativeViewTransition>(jsInvoker);

package/ReactCommon/react/nativemodule/defaults/DefaultTurboModules.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <ReactCommon/TurboModule.h>
 
 namespace facebook::react {

package/ReactCommon/react/nativemodule/defaults/React-defaultsnativemodule.podspec

@@ -54,10 +54,14 @@ Pod::Spec.new do |s|
   s.dependency "React-idlecallbacksnativemodule"
   s.dependency "React-intersectionobservernativemodule"
   s.dependency "React-mutationobservernativemodule"
+  s.dependency "React-resizeobservernativemodule"
   s.dependency "React-viewtransitionnativemodule"
   s.dependency "React-webperformancenativemodule"
   s.dependency "React-Fabric/animated"
+  s.dependency "React-cxxstableapi"
   add_dependency(s, "React-RCTFBReactNativeSpec")
   add_dependency(s, "React-featureflags")
   add_dependency(s, "React-featureflagsnativemodule")
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/nativemodule/devtoolsruntimesettings/CMakeLists.txt

@@ -15,6 +15,7 @@ target_include_directories(react_nativemodule_devtoolsruntimesettings PUBLIC ${R
 
 target_link_libraries(react_nativemodule_devtoolsruntimesettings
         devtoolsruntimesettings
+        react_cxxstableapi
 )
 target_compile_reactnative_options(react_nativemodule_devtoolsruntimesettings PRIVATE)
 target_compile_options(react_nativemodule_devtoolsruntimesettings PRIVATE -Wpedantic)

package/ReactCommon/react/nativemodule/devtoolsruntimesettings/DevToolsRuntimeSettingsModule.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/PrivateGuard.h>
+
 #include <devtoolsruntimesettings/DevToolsRuntimeSettings.h>
 
 namespace facebook::react {