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

package/ReactCommon/jsinspector-modern/tracing/React-jsinspectortracing.podspec

@@ -44,6 +44,7 @@ Pod::Spec.new do |s|
   resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: module_name)
 
   add_dependency(s, "React-jsinspectornetwork", :framework_name => 'jsinspector_modernnetwork')
+  s.dependency "React-cxxstableapi"
   s.dependency "React-jsi"
   s.dependency "React-oscompat"
   s.dependency "React-timing"
@@ -55,4 +56,6 @@ Pod::Spec.new do |s|
 
   add_rn_third_party_dependencies(s)
   add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "TraceEvent.h"
 
 #include <memory>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "RuntimeSamplingProfile.h"
 
 #include <react/timing/primitives.h>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "TraceRecordingState.h"
 
 namespace facebook::react::jsinspector_modern::tracing {

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <algorithm>
 #include <functional>
 #include <optional>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <cassert>
 
 #include <react/timing/primitives.h>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <jsinspector-modern/tracing/TracingCategory.h>
 #include <react/timing/primitives.h>
 

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

@@ -34,6 +34,47 @@ namespace facebook::react::jsinspector_modern::tracing {
   };
 }
 
+/* static */ TraceEvent TraceEventGenerator::createNeedsBeginFrameChangedEvent(
+    int layerTreeId,
+    HighResTimeStamp timestamp,
+    ProcessId processId,
+    ThreadId threadId) {
+  folly::dynamic data = folly::dynamic::object("needsBeginFrame", 1);
+
+  return TraceEvent{
+      .name = "NeedsBeginFrameChanged",
+      .cat = {Category::Frame},
+      .ph = 'I',
+      .ts = timestamp,
+      .pid = processId,
+      .s = 't',
+      .tid = threadId,
+      .args = folly::dynamic::object("layerTreeId", layerTreeId)(
+          "data", std::move(data)),
+  };
+}
+
+/* static */ TraceEvent TraceEventGenerator::createIdleBeginFrameEvent(
+    FrameSequenceId sequenceId,
+    int layerTreeId,
+    HighResTimeStamp timestamp,
+    ProcessId processId,
+    ThreadId threadId) {
+  folly::dynamic args = folly::dynamic::object("frameSeqId", sequenceId)(
+      "layerTreeId", layerTreeId);
+
+  return TraceEvent{
+      .name = "BeginFrame",
+      .cat = {Category::Frame},
+      .ph = 'I',
+      .ts = timestamp,
+      .pid = processId,
+      .s = 't',
+      .tid = threadId,
+      .args = std::move(args),
+  };
+}
+
 /* static */ std::pair<TraceEvent, TraceEvent>
 TraceEventGenerator::createFrameTimingsEvents(
     uint64_t sequenceId,

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "TraceEvent.h"
 
 #include <jsinspector-modern/tracing/FrameTimingSequence.h>
@@ -35,7 +37,29 @@ class TraceEventGenerator {
       HighResTimeStamp timestamp);
 
   /**
-   * Creates canonical "BeginFrame", "Commit", "DrawFrame" trace events.
+   * Creates a "NeedsBeginFrameChanged" trace event to mark the start of an
+   * idle frame period.
+   */
+  static TraceEvent createNeedsBeginFrameChangedEvent(
+      int layerTreeId,
+      HighResTimeStamp timestamp,
+      ProcessId processId,
+      ThreadId threadId);
+
+  /**
+   * Creates a single "BeginFrame" trace event for an idle frame (no
+   * DrawFrame). Chrome DevTools renders a BeginFrame without a corresponding
+   * DrawFrame as an "Idle frame" in the Frames track.
+   */
+  static TraceEvent createIdleBeginFrameEvent(
+      FrameSequenceId sequenceId,
+      int layerTreeId,
+      HighResTimeStamp timestamp,
+      ProcessId processId,
+      ThreadId threadId);
+
+  /**
+   * Creates canonical "BeginFrame", "DrawFrame" trace events.
    */
   static std::pair<TraceEvent, TraceEvent> createFrameTimingsEvents(
       FrameSequenceId sequenceId,

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <react/timing/primitives.h>
 
 #include <optional>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "TraceEvent.h"
 #include "TraceEventProfile.h"
 

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

@@ -7,11 +7,12 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include "InstanceTracingProfile.h"
 #include "RuntimeSamplingProfile.h"
 #include "TracingMode.h"
 
-#include <oscompat/OSCompat.h>
 #include <react/timing/primitives.h>
 
 #include <vector>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <folly/container/small_vector.h>
 
 #include <optional>

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

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 namespace facebook::react::jsinspector_modern::tracing {
 
 enum class Mode {

package/ReactCommon/jsitooling/CMakeLists.txt

@@ -20,7 +20,8 @@ target_link_libraries(jsitooling
         react_cxxreact
         folly_runtime
         glog
-        jsi)
+        jsi
+        react_cxxstableapi)
 
 target_compile_reactnative_options(jsitooling PRIVATE)
 target_compile_options(jsitooling PRIVATE -Wpedantic)

package/ReactCommon/jsitooling/React-jsitooling.podspec

@@ -16,6 +16,12 @@ else
   source[:tag] = "v#{version}"
 end
 
+header_search_paths = []
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/..\"" # ReactCommon, for <react/cxxstableapi/...>
+end
+
 Pod::Spec.new do |s|
   s.name                   = "React-jsitooling"
   s.version                = version
@@ -31,12 +37,14 @@ Pod::Spec.new do |s|
   resolve_use_frameworks(s, header_mappings_dir: "./", module_name: "JSITooling")
 
   s.pod_target_xcconfig    = {
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
     "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
     "DEFINES_MODULE" => "YES",
   }
 
   s.dependency "React-cxxreact", version
   s.dependency "React-jsi", version
+  s.dependency "React-cxxstableapi"
   add_dependency(s, "React-debug")
   add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
@@ -50,4 +58,6 @@ Pod::Spec.new do |s|
 
   add_rn_third_party_dependencies(s)
   add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/jsitooling/react/runtime/JSRuntimeBindings.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <jsi/jsi.h>
 #include <string>
 

package/ReactCommon/jsitooling/react/runtime/JSRuntimeFactory.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #ifdef __cplusplus
 
 #include <jsi/jsi.h>

package/ReactCommon/jsitooling/react/runtime/JSRuntimeFactoryCAPI.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/ReactCommon/logger/React-logger.podspec

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

package/ReactCommon/oscompat/CMakeLists.txt

@@ -12,4 +12,7 @@ file(GLOB oscompat_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(oscompat OBJECT ${oscompat_SRC})
 
 target_include_directories(oscompat PUBLIC .)
+
+target_link_libraries(oscompat
+        react_cxxstableapi)
 target_compile_reactnative_options(oscompat PRIVATE)

package/ReactCommon/oscompat/OSCompat.h

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

package/ReactCommon/oscompat/React-oscompat.podspec

@@ -16,6 +16,12 @@ else
   source[:tag] = "v#{version}"
 end
 
+header_search_paths = []
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/..\"" # ReactCommon, for <react/cxxstableapi/...>
+end
+
 Pod::Spec.new do |s|
   s.name                   = "React-oscompat"
   s.version                = version
@@ -26,6 +32,10 @@ Pod::Spec.new do |s|
   s.platforms              = min_supported_versions
   s.source                 = source
   s.source_files           = podspec_sources("*.{cpp,h}", "*.{h}")
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "" }
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => header_search_paths.join(' ') }
   s.header_dir             = "oscompat"
+
+  s.dependency "React-cxxstableapi"
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/bridging/ArrayBuffer.h

@@ -140,15 +140,6 @@ class AsyncArrayBuffer {
     return buffer_;
   }
 
- private:
-  explicit AsyncArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer) noexcept : buffer_{std::move(buffer)} {}
-
-  static AsyncArrayBuffer copyBytes(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
-  {
-    auto bytes = std::span(buffer.data(rt), buffer.size(rt));
-    return wrap(std::vector<uint8_t>(bytes.begin(), bytes.end()));
-  }
-
   // Best-effort detached check. jsi::ArrayBuffer::detached relies on the JS-level
   // `detached` property, which some runtimes (e.g. Hermes) don't implement and
   // signal by throwing. In that case we silently skip the check rather than
@@ -166,6 +157,15 @@ class AsyncArrayBuffer {
     }
   }
 
+ private:
+  explicit AsyncArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer) noexcept : buffer_{std::move(buffer)} {}
+
+  static AsyncArrayBuffer copyBytes(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
+  {
+    auto bytes = std::span(buffer.data(rt), buffer.size(rt));
+    return wrap(std::vector<uint8_t>(bytes.begin(), bytes.end()));
+  }
+
   std::shared_ptr<jsi::MutableBuffer> buffer_;
 };
 

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

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

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

@@ -5,6 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <chrono>
 #include <span>
 #include <utility>
 
@@ -542,6 +543,59 @@ TEST_F(BridgingTest, eventEmitterTest) {
   }
 }
 
+TEST_F(BridgingTest, eventEmitterMapLookupTest) {
+  // Mirrors the lookup the codegen'd setEventEmitterCallback lambda performs:
+  // an unknown event name must not insert an entry, and a null emitter must not
+  // be dereferenced.
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
+      eventEmitterMap;
+  eventEmitterMap["onEvent"] = std::make_shared<AsyncEventEmitter<EventType>>();
+  eventEmitterMap["onNullEvent"] = nullptr;
+
+  // Subscribe to the valid emitter so the emit("onEvent") case can be verified
+  // by an observable side effect, not merely EXPECT_NO_THROW.
+  EventSubscriptionsWithLastEvent eventSubscriptionsWithListener;
+  addEventSubscription<EventType>(
+      rt,
+      static_cast<AsyncEventEmitter<EventType>&>(*eventEmitterMap["onEvent"]),
+      eventSubscriptionsWithListener,
+      invoker);
+
+  auto emit = [&eventEmitterMap](const std::string& name) {
+    auto it = eventEmitterMap.find(name);
+    if (it == eventEmitterMap.end() || !it->second) {
+      return;
+    }
+    static_cast<AsyncEventEmitter<EventType>&>(*it->second)
+        .emit({"one", "two", "three"});
+  };
+
+  EXPECT_NO_THROW(emit("onUnknownEvent"));
+  EXPECT_NO_THROW(emit("onNullEvent"));
+  EXPECT_NO_THROW(emit("onEvent"));
+
+  // The valid emit must actually reach the subscribed listener.
+  flushQueue();
+  ASSERT_EQ(1, eventSubscriptionsWithListener.size());
+  const auto& lastEvent = eventSubscriptionsWithListener[0].second;
+  ASSERT_EQ(3, lastEvent->size());
+  EXPECT_EQ("one", lastEvent->at(0));
+  EXPECT_EQ("two", lastEvent->at(1));
+  EXPECT_EQ("three", lastEvent->at(2));
+
+  // The miss must not have grown the map, which operator[] would have done.
+  EXPECT_EQ(2, eventEmitterMap.size());
+  EXPECT_FALSE(eventEmitterMap.contains("onUnknownEvent"));
+
+  // Clean up the subscription so the LongLivedObjectCollection leak check in
+  // TearDown passes.
+  for (const auto& [eventSubscription, _] : eventSubscriptionsWithListener) {
+    eventSubscription.getPropertyAsFunction(rt, "remove")
+        .callWithThis(rt, eventSubscription);
+  }
+  flushQueue();
+}
+
 TEST_F(BridgingTest, optionalTest) {
   EXPECT_EQ(
       1, bridging::fromJs<std::optional<int>>(rt, jsi::Value(1), invoker));
@@ -955,17 +1009,29 @@ TEST_F(BridgingTest, asyncArrayBufferBridgingTest) {
 }
 
 TEST_F(BridgingTest, highResTimeStampTest) {
-  HighResTimeStamp timestamp = HighResTimeStamp::now();
-  EXPECT_EQ(
-      timestamp,
-      bridging::fromJs<HighResTimeStamp>(
-          rt, bridging::toJs(rt, timestamp), invoker));
+  // Nanosecond counts that are not a whole number of milliseconds, spanning the
+  // magnitudes a monotonic clock reports (seconds to weeks since boot). Fixed
+  // values are used instead of `HighResTimeStamp::now()` so that the precision
+  // of the round trip does not depend on the uptime of the host running this
+  // test.
+  for (int64_t nanoseconds :
+       {1LL, 999'999LL, 1'000'001LL, 12'345'678'901LL, 537'648'854'729'250LL}) {
+    auto timestamp = HighResTimeStamp::fromChronoSteadyClockTimePoint(
+        std::chrono::steady_clock::time_point(
+            std::chrono::nanoseconds(nanoseconds)));
+    EXPECT_EQ(
+        timestamp,
+        bridging::fromJs<HighResTimeStamp>(
+            rt, bridging::toJs(rt, timestamp), invoker))
+        << "timestamp of " << nanoseconds << "ns did not round trip";
 
-  auto duration = HighResDuration::fromNanoseconds(1);
-  EXPECT_EQ(
-      duration,
-      bridging::fromJs<HighResDuration>(
-          rt, bridging::toJs(rt, duration), invoker));
+    auto duration = HighResDuration::fromNanoseconds(nanoseconds);
+    EXPECT_EQ(
+        duration,
+        bridging::fromJs<HighResDuration>(
+            rt, bridging::toJs(rt, duration), invoker))
+        << "duration of " << nanoseconds << "ns did not round trip";
+  }
 
   EXPECT_EQ(1.0, bridging::toJs(rt, HighResDuration::fromNanoseconds(1e6)));
   EXPECT_EQ(

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

@@ -25,10 +25,12 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = podspec_sources("*.h", "*.h")
+  s.source_files           = podspec_sources("*.{cpp,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")
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/cxxstableapi/StableApiAnchor.cpp

@@ -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.
+ */
+
+// Anchor translation unit for the `react/cxxstableapi` pod.
+//
+// The guards in this module are pure preprocessor headers, so the pod would
+// otherwise ship no compilable source. CocoaPods emits a PBXAggregateTarget for
+// a pod with no compilable sources, and an aggregate target produces no
+// `.framework` under `use_frameworks!` — dependents are then unable to resolve
+// the guard headers. Giving the pod a single source file forces CocoaPods to
+// emit a real framework target instead.
+//
+// This file intentionally declares nothing: `react/cxxstableapi` has no runtime
+// API, only preprocessor guards. Do not add code here.

package/ReactCommon/react/cxxstableapi/UmbrellaGuard.h

@@ -29,15 +29,25 @@
 //                        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
+//                        set it). A module umbrella brackets its own `#include`s
+//                        with it to signal the blessed inclusion path:
+//                            #pragma push_macro("RN_UMBRELLA_CONTEXT")
+//                            #undef RN_UMBRELLA_CONTEXT
+//                            #define RN_UMBRELLA_CONTEXT 1
 //                            #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.
+//                            #pragma pop_macro("RN_UMBRELLA_CONTEXT")
+//                        Saving and restoring, rather than a bare
+//                        `#define`/`#undef` pair, is what makes the scope both
+//                        end at the umbrella -- later *direct* includes in the
+//                        same translation unit are still caught -- and nest: an
+//                        umbrella reached from inside another umbrella's
+//                        context leaves the outer one armed. A bare `#undef`
+//                        would disarm it, and every public header the outer
+//                        umbrella included afterwards would hard-error.
+//                        `scripts/add-cxxstableapi-guard.js --tier=public`
+//                        emits this block; do not hand-write or "simplify" it.
 //
 //   RN_BUILDING          Defined by React Native's own build targets so internal
 //                        sources may keep including the fine-grained headers

package/ReactCommon/react/debug/CMakeLists.txt

@@ -14,7 +14,7 @@ add_library(react_debug OBJECT ${react_debug_SRC} ${react_debug_redbox_SRC})
 
 target_include_directories(react_debug PUBLIC ${REACT_COMMON_DIR})
 
-target_link_libraries(react_debug folly_runtime)
+target_link_libraries(react_debug folly_runtime react_cxxstableapi)
 
 if(ANDROID)
   target_link_libraries(react_debug log)

package/ReactCommon/react/debug/React/Debug.h

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+// =============================================================================
+// Umbrella header for the `react/debug` module - public entry point.
+//
+//   #include <React/Debug.h>
+//
+// Re-exports the module's public interface headers. React Native's own code
+// should keep using the fine-grained `<react/debug/...>` includes; only outside
+// consumers use this umbrella.
+//
+// The `redbox/` headers are deliberately absent: they are implementation
+// details of the dev-menu red box and carry no stability guarantee.
+// =============================================================================
+
+// Marks that the following headers are pulled in through the umbrella, so their
+// shared guard (<react/cxxstableapi/UmbrellaGuard.h>) accepts them. The marker
+// is saved and restored rather than defined and undefined: the scope ends at
+// this block, so later *direct* includes in the same TU are still caught, and
+// it nests inside an enclosing umbrella rather than disarming it.
+#pragma push_macro("RN_UMBRELLA_CONTEXT")
+#undef RN_UMBRELLA_CONTEXT
+#define RN_UMBRELLA_CONTEXT 1
+
+#include <react/debug/flags.h>
+#include <react/debug/react_native_assert.h>
+#include <react/debug/react_native_expect.h>
+
+#undef RN_UMBRELLA_CONTEXT
+#pragma pop_macro("RN_UMBRELLA_CONTEXT")

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

@@ -16,6 +16,12 @@ else
   source[:tag] = "v#{version}"
 end
 
+header_search_paths = []
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/../..\"" # ReactCommon, for <react/cxxstableapi/...>
+end
+
 Pod::Spec.new do |s|
   s.name                   = "React-debug"
   s.version                = version
@@ -28,13 +34,24 @@ Pod::Spec.new do |s|
   s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
   s.header_dir             = "react/debug"
   s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
-                               "DEFINES_MODULE" => "YES" }
+                               "DEFINES_MODULE" => "YES",
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' ') }
 
   resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_debug")
 
+  s.subspec "debugUmbrella" do |ss|
+    ss.source_files         = "React/*.h"
+    ss.header_dir           = ""
+    ss.header_mappings_dir  = "."
+  end
+
   s.subspec "redbox" do |ss|
     ss.source_files         = podspec_sources("redbox/*.{cpp,h}", "redbox/*.h")
     ss.exclude_files        = "redbox/tests/**/*.{cpp,h}"
     ss.header_dir           = "react/debug/redbox"
   end
+
+  s.dependency "React-cxxstableapi"
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/debug/flags.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/UmbrellaGuard.h>
+
 //
 // Preprocessor flags which control whether code meant for debugging the
 // internals of React Native is included in the build. E.g. debug assertions.