@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/ReactCommon/react/bridging/React-bridging.podspec

@@ -0,0 +1,44 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-bridging"
+  s.version                = version
+  s.summary                = "-"
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
+  s.header_dir             = "react/bridging"
+  s.pod_target_xcconfig    = {
+    "USE_HEADERMAP" => "YES",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "DEFINES_MODULE" => "YES"
+  }
+
+  resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_bridging")
+
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
+  s.dependency "React-timing"
+
+  add_rn_third_party_dependencies(s)
+  add_rncore_dependency(s)
+end

package/ReactCommon/react/bridging/tests/BridgingTest.cpp

@@ -5,6 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <span>
+#include <utility>
+
 #include "BridgingTest.h"
 
 namespace facebook::react {
@@ -17,6 +20,7 @@ TEST_F(BridgingTest, jsiTest) {
   jsi::Value object = jsi::Object(rt);
   jsi::Value array = jsi::Array::createWithElements(rt, value, object);
   jsi::Value func = function("() => {}");
+  jsi::Value arrayBuffer = eval("new ArrayBuffer(0)");
 
   // The bridging mechanism needs to know how to copy and downcast values.
   EXPECT_NO_THROW(bridging::fromJs<jsi::Value>(rt, value, invoker));
@@ -24,6 +28,7 @@ TEST_F(BridgingTest, jsiTest) {
   EXPECT_NO_THROW(bridging::fromJs<jsi::Object>(rt, object, invoker));
   EXPECT_NO_THROW(bridging::fromJs<jsi::Array>(rt, array, invoker));
   EXPECT_NO_THROW(bridging::fromJs<jsi::Function>(rt, func, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::ArrayBuffer>(rt, arrayBuffer, invoker));
 
   // Should throw when attempting an invalid cast.
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Object>(rt, value, invoker));
@@ -31,6 +36,7 @@ TEST_F(BridgingTest, jsiTest) {
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, object, invoker));
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, string, invoker));
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, func, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::ArrayBuffer>(rt, value, invoker));
 
   // Should be able to generically no-op convert JSI.
   EXPECT_NO_THROW(bridging::toJs(rt, value, invoker));
@@ -69,11 +75,6 @@ TEST_F(BridgingTest, numberTest) {
       -42,
       static_cast<uint32_t>(
           bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
-
-  EXPECT_FALSE(
-      -42 ==
-      static_cast<int32_t>(
-          bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
 }
 
 TEST_F(BridgingTest, stringTest) {
@@ -200,9 +201,8 @@ TEST_F(BridgingTest, functionTest) {
   auto object = jsi::Object(rt);
   object.setProperty(rt, "foo", "bar");
 
-  auto lambda = [](std::map<std::string, std::string> map, std::string key) {
-    return map[key];
-  };
+  auto lambda = [](std::map<std::string, std::string> map,
+                   const std::string& key) { return map[key]; };
 
   auto func = bridging::toJs(rt, lambda, invoker);
 
@@ -285,7 +285,8 @@ TEST_F(BridgingTest, syncCallbackImplicitBridgingTest) {
 TEST_F(BridgingTest, asyncCallbackTest) {
   std::string output;
 
-  auto func = std::function<void(std::string)>([&](auto str) { output = str; });
+  auto func = std::function<void(std::string)>(
+      [&](auto str) { output = std::move(str); });
 
   auto cb = bridging::fromJs<AsyncCallback<decltype(func), std::string>>(
       rt, function("(func, str) => func(str)"), invoker);
@@ -309,7 +310,9 @@ TEST_F(BridgingTest, asyncCallbackTest) {
 
 TEST_F(BridgingTest, asyncCallbackInvalidation) {
   std::string output;
-  std::function<void(std::string)> func = [&](auto str) { output = str; };
+  std::function<void(std::string)> func = [&](auto str) {
+    output = std::move(str);
+  };
 
   auto jsCallback = bridging::fromJs<AsyncCallback<>>(
       rt, bridging::toJs(rt, func, invoker), invoker);
@@ -327,7 +330,8 @@ TEST_F(BridgingTest, asyncCallbackInvalidation) {
 
 TEST_F(BridgingTest, asyncCallbackImplicitBridgingTest) {
   std::string output;
-  auto func = std::function<void(std::string)>([&](auto str) { output = str; });
+  auto func = std::function<void(std::string)>(
+      [&](auto str) { output = std::move(str); });
   { // Value
     auto cb = bridging::fromJs<AsyncCallback<decltype(func), jsi::Value, int>>(
         rt, function("(func, a, b) => func(a + b)"), invoker);
@@ -780,6 +784,176 @@ TEST_F(BridgingTest, dynamicTest) {
   EXPECT_TRUE(undefinedFromJsResult.isNull());
 }
 
+TEST_F(BridgingTest, arrayBufferTest) {
+  auto rawBuf = eval("new ArrayBuffer(7)");
+  auto buf = bridging::fromJs<jsi::ArrayBuffer>(rt, rawBuf, invoker);
+  EXPECT_EQ(7, buf.size(rt));
+
+  auto typedArrayBuf = eval("new Uint8Array([1, 2, 3]).buffer");
+  auto fromTa = bridging::fromJs<jsi::ArrayBuffer>(rt, typedArrayBuf, invoker);
+  EXPECT_EQ(3, fromTa.size(rt));
+
+  auto jsVal = bridging::toJs(rt, std::move(buf), invoker);
+  EXPECT_TRUE(jsVal.isArrayBuffer(rt));
+  auto roundTrip = bridging::fromJs<jsi::ArrayBuffer>(rt, jsVal, invoker);
+  EXPECT_EQ(7, roundTrip.size(rt));
+
+  EXPECT_JSI_THROW(
+      bridging::fromJs<jsi::ArrayBuffer>(rt, jsi::Value(1), invoker));
+}
+
+TEST_F(BridgingTest, asyncArrayBufferConstructorTest) {
+  // JS-heap-allocated buffer: acquire() copies into an internal buffer.
+  {
+    auto jsBuf = eval("new Uint8Array([10, 20, 30]).buffer")
+                     .asObject(rt)
+                     .getArrayBuffer(rt);
+    auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(10, data[0]);
+    EXPECT_EQ(20, data[1]);
+    EXPECT_EQ(30, data[2]);
+  }
+
+  // ArrayBuffer created from a native MutableBuffer: acquire() returns the
+  // same bytes. Whether it's zero-copy depends on whether the runtime
+  // implements tryGetMutableBuffer (e.g. Hermes does not, so acquire falls
+  // back to a copy).
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{1, 2, 3, 4});
+    auto* rawPtr = nativeBuf.get();
+    auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+    auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+    EXPECT_EQ(4, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(1, data[0]);
+    EXPECT_EQ(4, data[3]);
+    if (jsBuf.tryGetMutableBuffer(rt) != nullptr) {
+      EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+    }
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBorrowThrowsOnJsHeapTest) {
+  // JS-heap-allocated buffer: borrow throws.
+  auto jsBuf = eval("new ArrayBuffer(4)").asObject(rt).getArrayBuffer(rt);
+  EXPECT_JSI_THROW(AsyncArrayBuffer::borrow(rt, jsBuf));
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBorrowNativeBackedTest) {
+  // Native-backed buffer: borrow succeeds zero-copy on runtimes that implement
+  // tryGetMutableBuffer; otherwise borrow throws (since there is no native
+  // MutableBuffer to hand back).
+  auto nativeBuf =
+      std::make_shared<detail::OwnedBytesBuffer>(std::vector<uint8_t>{5, 6, 7});
+  auto* rawPtr = nativeBuf.get();
+  auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+  if (jsBuf.tryGetMutableBuffer(rt) == nullptr) {
+    EXPECT_JSI_THROW(AsyncArrayBuffer::borrow(rt, jsBuf));
+    return;
+  }
+  auto safe = AsyncArrayBuffer::borrow(rt, jsBuf);
+  EXPECT_EQ(3, safe.size());
+  auto data = std::span(safe.data(), safe.size());
+  EXPECT_EQ(5, data[0]);
+  EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+}
+
+TEST_F(BridgingTest, asyncArrayBufferCopyTest) {
+  // JS-heap-allocated buffer: copy succeeds.
+  {
+    auto jsBuf = eval("new Uint8Array([100, 200]).buffer")
+                     .asObject(rt)
+                     .getArrayBuffer(rt);
+    auto safe = AsyncArrayBuffer::copy(rt, jsBuf);
+    EXPECT_EQ(2, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(100, data[0]);
+    EXPECT_EQ(200, data[1]);
+  }
+
+  // Native-backed buffer: copy() still copies into an internal buffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{9, 8, 7});
+    auto* rawPtr = nativeBuf.get();
+    auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+    auto safe = AsyncArrayBuffer::copy(rt, jsBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(9, data[0]);
+    EXPECT_NE(rawPtr, safe.getMutableBuffer().get());
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferMoveTest) {
+  auto jsBuf =
+      eval("new Uint8Array([1, 2, 3]).buffer").asObject(rt).getArrayBuffer(rt);
+  auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+  EXPECT_EQ(3, safe.size());
+
+  auto moved = std::move(safe);
+  EXPECT_EQ(3, moved.size());
+  auto data = std::span(moved.data(), moved.size());
+  EXPECT_EQ(1, data[0]);
+}
+
+TEST_F(BridgingTest, asyncArrayBufferWrapTest) {
+  // wrap(shared_ptr<MutableBuffer>): zero-copy, same underlying buffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{1, 2, 3});
+    auto* rawPtr = nativeBuf.get();
+    auto safe = AsyncArrayBuffer::wrap(nativeBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(1, data[0]);
+    EXPECT_EQ(3, data[2]);
+    EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+  }
+
+  // wrap(vector<uint8_t>): bytes are owned by an internal MutableBuffer.
+  {
+    auto safe = AsyncArrayBuffer::wrap(std::vector<uint8_t>{10, 20, 30, 40});
+    EXPECT_EQ(4, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(10, data[0]);
+    EXPECT_EQ(40, data[3]);
+    EXPECT_NE(nullptr, safe.getMutableBuffer());
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBridgingTest) {
+  // toJs with native-backed buffer: JS ArrayBuffer backed by the same
+  // MutableBuffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{5, 6, 7});
+    auto safe = AsyncArrayBuffer::wrap(nativeBuf);
+    auto jsVal = bridging::toJs(rt, std::move(safe), invoker);
+    EXPECT_TRUE(jsVal.asObject(rt).isArrayBuffer(rt));
+    auto jsBuf = jsVal.asObject(rt).getArrayBuffer(rt);
+    EXPECT_EQ(3, jsBuf.size(rt));
+    auto data = std::span(jsBuf.data(rt), jsBuf.size(rt));
+    EXPECT_EQ(5, data[0]);
+    EXPECT_EQ(7, data[2]);
+  }
+
+  // toJs with owned bytes: JS ArrayBuffer contains the correct data.
+  {
+    auto safe = AsyncArrayBuffer::wrap(std::vector<uint8_t>{100, 200});
+    auto jsVal = bridging::toJs(rt, std::move(safe), invoker);
+    EXPECT_TRUE(jsVal.asObject(rt).isArrayBuffer(rt));
+    auto jsBuf = jsVal.asObject(rt).getArrayBuffer(rt);
+    EXPECT_EQ(2, jsBuf.size(rt));
+    auto data = std::span(jsBuf.data(rt), jsBuf.size(rt));
+    EXPECT_EQ(100, data[0]);
+    EXPECT_EQ(200, data[1]);
+  }
+}
+
 TEST_F(BridgingTest, highResTimeStampTest) {
   HighResTimeStamp timestamp = HighResTimeStamp::now();
   EXPECT_EQ(

package/ReactCommon/react/bridging/tests/ClassTest.cpp

@@ -42,6 +42,14 @@ struct TestClass {
     callback();
   }
 
+  size_t byteLength(jsi::Runtime& rt, jsi::ArrayBuffer buffer) {
+    return buffer.size(rt);
+  }
+
+  jsi::ArrayBuffer echo(jsi::Runtime& /*unused*/, jsi::ArrayBuffer buffer) {
+    return buffer;
+  }
+
  private:
   std::shared_ptr<CallInvoker> invoker_;
 };
@@ -99,6 +107,20 @@ TEST_F(BridgingTest, callFromJsTest) {
   EXPECT_TRUE(called);
 }
 
+TEST_F(BridgingTest, arrayBufferCallFromJsTest) {
+  auto instance = TestClass(invoker);
+  auto buf = eval("new ArrayBuffer(5)").asObject(rt).getArrayBuffer(rt);
+  EXPECT_EQ(
+      5,
+      bridging::callFromJs<size_t>(
+          rt, &TestClass::byteLength, invoker, &instance, std::move(buf)));
+
+  auto buf2 = eval("new ArrayBuffer(9)").asObject(rt).getArrayBuffer(rt);
+  auto out = bridging::callFromJs<jsi::ArrayBuffer>(
+      rt, &TestClass::echo, invoker, &instance, std::move(buf2));
+  EXPECT_EQ(9, out.size(rt));
+}
+
 struct MethodReturnTypeCastingTestObject {
  public:
   explicit MethodReturnTypeCastingTestObject(int value) : value_(value) {}

package/ReactCommon/react/cxxstableapi/CMakeLists.txt

@@ -0,0 +1,18 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+# Header-only: the cxxstableapi guards are pure preprocessor headers, so this is
+# an INTERFACE library. Headers resolve as <react/cxxstableapi/*.h> via the
+# shared ${REACT_COMMON_DIR} include root.
+add_library(react_cxxstableapi INTERFACE)
+
+target_include_directories(react_cxxstableapi INTERFACE ${REACT_COMMON_DIR})
+target_compile_reactnative_options(react_cxxstableapi INTERFACE)
+target_compile_options(react_cxxstableapi INTERFACE -Wpedantic)

package/ReactCommon/react/cxxstableapi/FrameworksGuard.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// =============================================================================
+// Shared "for frameworks" guard for React Native's C++ stable API.
+//
+// Include this header at the top of every *for-frameworks* module header:
+//
+//   #include <react/cxxstableapi/FrameworksGuard.h>
+//
+// "For frameworks" headers are APIs intended for framework authors integrating
+// React Native, not for ordinary app code. Including one directly emits a
+// SUPPRESSIBLE warning under enforcement. A framework author acknowledges the
+// usage by defining `RN_ALLOW_FRAMEWORKS`, which silences the warning.
+//
+// See <react/cxxstableapi/UmbrellaGuard.h> for the full `RN_*` macro contract.
+// In short:
+//   RN_STRICT_API        Consumer opt-in master switch; the guard is inert
+//                        without it.
+//   RN_ALLOW_FRAMEWORKS  Consumer opt-out acknowledging framework-tier usage.
+//   RN_UMBRELLA_CONTEXT  Internal marker set by an umbrella around its includes.
+//   RN_BUILDING          Set by React Native's own build.
+//
+// This header is intentionally NOT `#pragma once`-guarded: it must be
+// re-evaluated on every inclusion so each direct include is checked.
+// =============================================================================
+
+#if defined(RN_STRICT_API) && !defined(RN_ALLOW_FRAMEWORKS) && !defined(RN_UMBRELLA_CONTEXT) && !defined(RN_BUILDING)
+#warning \
+    "This is a 'for frameworks' React Native API, intended for framework authors rather than app code. Include it via the module umbrella <React/<Module>.h>, or define RN_ALLOW_FRAMEWORKS to acknowledge framework-tier usage and silence this warning."
+#endif

package/ReactCommon/react/cxxstableapi/PrivateGuard.h

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+
+// =============================================================================
+// Shared "private" guard for React Native's C++ stable API.
+//
+// Include this header at the top of every *private* module header (right after
+// `#pragma once`):
+//
+//   #include <react/cxxstableapi/PrivateGuard.h>
+//
+// Private headers are implementation details with no stability guarantee.
+// Including one from outside React Native's own build is a hard error under
+// enforcement; there is no consumer-facing escape hatch (unlike the
+// for-frameworks guard) — only React Native's own sources, which define
+// `RN_BUILDING`, may include these headers.
+//
+// See <react/cxxstableapi/UmbrellaGuard.h> for the full `RN_*` macro contract.
+// In short:
+//   RN_STRICT_API  Consumer opt-in master switch; the guard is inert without it.
+//   RN_BUILDING    Set by React Native's own build.
+//
+// This header is intentionally NOT `#pragma once`-guarded: it must be
+// re-evaluated on every inclusion so each direct include is checked.
+// =============================================================================
+
+#if defined(RN_STRICT_API) && !defined(RN_BUILDING)
+#error \
+    "This is a private React Native header and is not part of the public API. Do not include it directly; it has no stability guarantee."
+#endif

package/ReactCommon/react/cxxstableapi/React-cxxstableapi.podspec

@@ -0,0 +1,34 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-cxxstableapi"
+  s.version                = version
+  s.summary                = "Header-only guards for React Native's C++ stable API."
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("*.h", "*.h")
+  s.header_dir             = "react/cxxstableapi"
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "DEFINES_MODULE" => "YES" }
+
+  resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_cxxstableapi")
+end

package/ReactCommon/react/cxxstableapi/UmbrellaGuard.h

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+// =============================================================================
+// Shared "public API" guard for React Native's C++ stable API.
+//
+// Include this header at the top of every *public* module header (right after
+// `#pragma once`):
+//
+//   #include <react/cxxstableapi/UmbrellaGuard.h>
+//
+// The guard turns a *direct* include of a public module header into a hard
+// error, steering consumers to the module's umbrella header instead:
+//
+//   #include <React/<Module>.h>   // do this
+//
+// -----------------------------------------------------------------------------
+// Macro contract (all `RN_*` macros are shared across modules)
+//
+//   RN_STRICT_API        Consumer opt-in master switch. Every guard in this
+//                        directory is INERT unless the consuming build defines
+//                        this macro. Shipping the guards therefore changes
+//                        nothing for existing consumers — they only activate
+//                        when a consumer opts into the strict public API by
+//                        defining RN_STRICT_API.
+//
+//   RN_UMBRELLA_CONTEXT  Internal marker (implementation detail; consumers never
+//                        set it). A module umbrella defines it around its own
+//                        `#include`s to signal the blessed inclusion path:
+//                            #define RN_UMBRELLA_CONTEXT
+//                            #include <react/.../PublicHeaderA.h>
+//                            #include <react/.../PublicHeaderB.h>
+//                            #undef RN_UMBRELLA_CONTEXT
+//                        The `#undef` matters: it keeps the marker scoped to the
+//                        umbrella's includes so later *direct* includes in the
+//                        same translation unit are still caught.
+//
+//   RN_BUILDING          Defined by React Native's own build targets so internal
+//                        sources may keep including the fine-grained headers
+//                        directly.
+//
+// This header is intentionally NOT `#pragma once`-guarded: it must be
+// re-evaluated on every inclusion so each direct include is checked.
+// =============================================================================
+
+#if defined(RN_STRICT_API) && !defined(RN_UMBRELLA_CONTEXT) && !defined(RN_BUILDING)
+#error \
+    "Do not include this React Native header directly. Include the module's umbrella header <React/<Module>.h> instead."
+#endif

package/ReactCommon/react/debug/React-debug.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+source = { :git => 'https://github.com/facebook/react-native.git' }
 if version == '1000.0.0'
   # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
   source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")

package/ReactCommon/react/debug/redbox/JscSafeUrl.h

@@ -17,7 +17,7 @@ namespace facebook::react::unstable_redbox {
  * by query string stripping of URLs in JavaScriptCore stack traces
  * introduced in iOS 16.4. This is a direct port of https://www.npmjs.com/package/jsc-safe-url.
  *
- * See https://github.com/react/react-native/issues/36794 for context.
+ * See https://github.com/facebook/react-native/issues/36794 for context.
  */
 
 bool isJscSafeUrl(std::string_view url);

package/ReactCommon/react/featureflags/React-featureflags.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+source = { :git => 'https://github.com/facebook/react-native.git' }
 if version == '1000.0.0'
   # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
   source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")