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

package/scripts/cocoapods/rncore.rb

@@ -11,30 +11,16 @@ require_relative './utils.rb'
 
 ### Adds ReactNativeCore-prebuilt as a dependency to the given podspec if we're not
 ### building ReactNativeCore from source (then this function does nothing).
+###
+### `<React/...>` resolves through the vendored React.framework; every other namespace
+### (`<react/...>`, `<yoga/...>`, `<hermes/...>`, ...) resolves through the flattened
+### ReactNativeHeaders headers that React-Core-prebuilt exposes. The header search path
+### and the ReactNativeHeaders module-map activation are NOT added here: they are applied
+### post-install by configure_aggregate_xcconfig, which covers aggregate, third-party AND
+### these pods from a single injection site. No clang VFS overlay.
 def add_rncore_dependency(s)
     if !ReactNativeCoreUtils.build_rncore_from_source()
-        # Add the dependency
         s.dependency "React-Core-prebuilt"
-
-        current_pod_target_xcconfig = s.to_hash["pod_target_xcconfig"] || {}
-        current_pod_target_xcconfig = current_pod_target_xcconfig.to_h unless current_pod_target_xcconfig.is_a?(Hash)
-
-        # Add VFS overlay flags for both Objective-C and Swift
-        # The VFS overlay file is pre-resolved at pod install time for each platform slice.
-        # We reference it directly in the xcframework using the React-VFS.yaml file that
-        # is written to the React-Core-prebuilt folder during setup_vfs_overlay.
-        # See scripts/ios-prebuild/__docs__/README.md for more details on VFS overlays.
-        vfs_overlay_flag = "-ivfsoverlay $(PODS_ROOT)/React-Core-prebuilt/React-VFS.yaml"
-        current_pod_target_xcconfig["OTHER_CFLAGS"] ||= "$(inherited)"
-        current_pod_target_xcconfig["OTHER_CFLAGS"] += " #{vfs_overlay_flag}"
-        current_pod_target_xcconfig["OTHER_CPLUSPLUSFLAGS"] ||= "$(inherited)"
-        current_pod_target_xcconfig["OTHER_CPLUSPLUSFLAGS"] += " #{vfs_overlay_flag}"
-        # For Swift, we need to use -Xcc to pass flags to the underlying Clang compiler
-        # Both the flag and its argument need separate -Xcc prefixes
-        current_pod_target_xcconfig["OTHER_SWIFT_FLAGS"] ||= "$(inherited)"
-        current_pod_target_xcconfig["OTHER_SWIFT_FLAGS"] += " -Xcc -ivfsoverlay -Xcc $(PODS_ROOT)/React-Core-prebuilt/React-VFS.yaml"
-
-        s.pod_target_xcconfig = current_pod_target_xcconfig
     end
 end
 
@@ -521,71 +507,36 @@ class ReactNativeCoreUtils
         return latest_nightly
     end
 
-    # Processes the VFS overlay file from the React.xcframework to resolve the ${ROOT_PATH} placeholder.
-    # This method should be called from react_native_post_install after pod install completes.
+    # Single post-install injection site for the prebuilt header resolution. Adds the
+    # ReactNativeHeaders search path + module-map activation to the aggregate (main app)
+    # target AND every pod target — RN core pods, third-party pods alike. (add_rncore_dependency
+    # only declares the React-Core-prebuilt dependency; it no longer touches xcconfigs.)
     #
-    # The VFS overlay file maps header import paths to their actual locations within the xcframework.
-    # Since the xcframework contains platform-specific slices, we generate a resolved VFS file for each
-    # slice and also create a default VFS file that can be used immediately (before script phases run).
-    def self.process_vfs_overlay()
-        return if @@build_from_source
-
-        prebuilt_path = File.join(Pod::Config.instance.project_pods_root, "React-Core-prebuilt")
-        xcframework_path = File.join(prebuilt_path, "React.xcframework")
-        vfs_template_path = File.join(xcframework_path, "React-VFS-template.yaml")
-
-        unless File.exist?(vfs_template_path)
-            rncore_log("VFS overlay template not found at #{vfs_template_path}", :error)
-            exit 1
-        end
-
-        rncore_log("Processing VFS overlay file...")
-
-        # Read the template content
-        vfs_template_content = File.read(vfs_template_path)
-
-        # Write the VFS file - use the top-level xcframework path
-        # so that ${ROOT_PATH}/Headers points to the xcframework's Headers folder
-        resolved_vfs_content = vfs_template_content.gsub('${ROOT_PATH}', xcframework_path)
-        resolved_vfs_path = File.join(prebuilt_path, "React-VFS.yaml")
-        File.write(resolved_vfs_path, resolved_vfs_content)
-        rncore_log("  Created VFS overlay at #{resolved_vfs_path}")
-
-        rncore_log("VFS overlay setup complete")
-    end
-
-    # Configures the xcconfig files for aggregate (main app) targets to enable VFS overlay for React Native Core.
-    # This is needed because the main app target does not go through podspec processing,
-    # so it won't get the VFS overlay flags from add_rncore_dependency.
+    # `<React/...>` resolves through the vendored React.framework; this adds the search
+    # path to the flattened ReactNativeHeaders headers (every other RN namespace —
+    # the third-party deps namespaces are served by the ReactNativeDependencies pod,
+    # see ReactNativeDependenciesUtils.configure_aggregate_xcconfig). There is
+    # no clang VFS overlay.
     #
     # Parameters:
     # - installer: The CocoaPods installer object
     def self.configure_aggregate_xcconfig(installer)
         return if @@build_from_source
 
-        prebuilt_path = File.join(Pod::Config.instance.project_pods_root, "React-Core-prebuilt")
-        vfs_overlay_path = File.join(prebuilt_path, "React-VFS.yaml")
-
-        unless File.exist?(vfs_overlay_path)
-            rncore_log("VFS overlay not found at #{vfs_overlay_path}, skipping prebuilt xcconfig configuration", :error)
-            exit 1
-        end
-
         rncore_log("Configuring xcconfig for prebuilt React Native Core...")
 
-        vfs_overlay_flag = " -ivfsoverlay \"#{vfs_overlay_path}\""
-        swift_vfs_overlay_flag = " -Xcc -ivfsoverlay -Xcc \"#{vfs_overlay_path}\""
+        headers_search_path = " \"$(PODS_ROOT)/React-Core-prebuilt/Headers\""
 
-        # Add flags to aggregate target xcconfigs (these are used by the main app target)
+        # Add the header search path to aggregate target xcconfigs (used by the main app target)
         installer.aggregate_targets.each do |aggregate_target|
             aggregate_target.xcconfigs.each do |config_name, config_file|
-                add_vfs_overlay_flags(config_file.attributes, vfs_overlay_flag, swift_vfs_overlay_flag)
+                add_prebuilt_header_search_paths(config_file.attributes, headers_search_path)
                 xcconfig_path = aggregate_target.xcconfig_path(config_name)
                 config_file.save_as(xcconfig_path)
             end
         end
 
-        # Add flags to ALL pod targets (for third-party pods that don't call add_rncore_dependency)
+        # Add the header search path to ALL pod targets (for third-party pods that don't call add_rncore_dependency)
         installer.pod_targets.each do |pod_target|
             pod_target.build_settings.each do |config_name, build_settings|
                 xcconfig_path = pod_target.xcconfig_path(config_name)
@@ -593,11 +544,11 @@ class ReactNativeCoreUtils
 
                 xcconfig = Xcodeproj::Config.new(xcconfig_path)
 
-                # Check if VFS overlay is already present
-                other_cflags = xcconfig.attributes["OTHER_CFLAGS"] || ""
-                next if other_cflags.include?("ivfsoverlay")
+                # Skip if the prebuilt header search path is already present
+                header_search_paths = xcconfig.attributes["HEADER_SEARCH_PATHS"] || ""
+                next if header_search_paths.include?("React-Core-prebuilt/Headers")
 
-                add_vfs_overlay_flags(xcconfig.attributes, vfs_overlay_flag, swift_vfs_overlay_flag)
+                add_prebuilt_header_search_paths(xcconfig.attributes, headers_search_path)
                 xcconfig.save_as(xcconfig_path)
             end
         end
@@ -605,12 +556,18 @@ class ReactNativeCoreUtils
         rncore_log("Prebuilt xcconfig configuration complete")
     end
 
-    # Helper method to add VFS overlay flags to an xcconfig attributes map
-    def self.add_vfs_overlay_flags(attributes, vfs_overlay_flag, swift_vfs_overlay_flag)
-        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_CFLAGS", vfs_overlay_flag)
-        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_CPLUSPLUSFLAGS", vfs_overlay_flag)
-        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_SWIFT_FLAGS", swift_vfs_overlay_flag)
+    # Helper method to add the prebuilt ReactNativeHeaders header search path to an xcconfig attributes map
+    def self.add_prebuilt_header_search_paths(attributes, headers_search_path)
+        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "HEADER_SEARCH_PATHS", headers_search_path)
         # Suppress incomplete umbrella warnings for the prebuilt frameworks (it is expected, as our umbrella headers do not include all headers)
         ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_SWIFT_FLAGS", " -Xcc -Wno-incomplete-umbrella")
+        # Activate the ReactNativeHeaders module map so the relocated namespaces
+        # (`yoga`, `RCTDeprecation`, `ReactNativeHeaders_react`, ...) are modular —
+        # otherwise the React framework's clang explicit-module precompile trips
+        # -Wnon-modular-include-in-framework-module on `<yoga/...>` / `<react/...>`.
+        # Quoted so a $(PODS_ROOT) containing spaces stays a single clang argument.
+        module_map_flag = " \"-fmodule-map-file=$(PODS_ROOT)/React-Core-prebuilt/Headers/module.modulemap\""
+        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_CFLAGS", module_map_flag)
+        ReactNativePodsUtils.add_flag_to_map_with_inheritance(attributes, "OTHER_SWIFT_FLAGS", " -Xcc" + module_map_flag)
     end
 end

package/scripts/cocoapods/rncore_facades.rb

@@ -0,0 +1,232 @@
+# 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'
+require 'fileutils'
+
+# Facade podspecs for the prebuilt React Native Core path.
+#
+# In prebuilt mode the compiled code AND headers for the React core pods live
+# entirely inside React.xcframework + React-Core-prebuilt (which flattens the
+# ReactNativeHeaders namespaces into its Headers/). Re-installing the SOURCE
+# podspecs in that mode is what makes them ship duplicate headers that shadow the
+# prebuilt artifact (via HEADER_SEARCH_PATHS, CocoaPods .hmap header maps, and
+# the all-product-headers VFS overlay) and break the React framework's clang
+# explicit-module precompile.
+#
+# Instead we install dependency-only FACADE podspecs for those names: they ship
+# no source files and (with one narrow exception, see FACADE_REEXPOSED_HEADERS)
+# no headers, so CocoaPods makes them PBXAggregateTarget
+# placeholders (should_build? == false) and nothing is laid down to shadow. Each
+# facade depends on React-Core-prebuilt so its consumers transitively pick up the
+# prebuilt framework + headers. The pod NAMES still resolve, so ReactCodegen,
+# third-party modules, and RN's own podspec graph keep resolving `React-Core`,
+# `Yoga`, `React-Core/Default`, etc.
+#
+# MAINTENANCE MODEL: the set of facaded pods is explicit (FACADE_PODS) so the
+# prebuilt rollout can be staged, but each facade's VERSION and SUBSPECS are
+# DERIVED from the real podspec at `pod install` time (Pod::Specification.from_file).
+# That removes the drift risk that would otherwise bite third-party libraries:
+# if React adds/renames `React-Core/<Subspec>`, the facade exposes it
+# automatically — nobody has to hand-maintain a parallel subspec list.
+#
+# This is staged: phase 1 facades a small set and KEEPS the existing
+# podspec_sources / add_rncore_dependency / configure_aggregate_xcconfig /
+# -fmodule-map-file machinery. The set is expanded until the cold prebuilt
+# build passes; the distributed prebuilt helpers are only deleted afterwards.
+module RNCoreFacades
+    # pod name => podspec path (relative to the react-native package root).
+    # These are the React-core pods whose code + headers are fully provided by
+    # the prebuilt React.xcframework / React-Core-prebuilt. Start small; expand as
+    # the cold build surfaces more shadowing pods. (NOTE: not every caller of
+    # add_rncore_dependency belongs here — e.g. ReactCodegen depends on the
+    # prebuilt but still builds its own generated sources, so it is NOT a facade.)
+    FACADE_PODS = {
+        "React-Core"       => "React-Core.podspec",
+        "React-RCTFabric"  => "React/React-RCTFabric.podspec",
+        "React-RCTRuntime" => "React/Runtime/React-RCTRuntime.podspec",
+        "Yoga"             => "ReactCommon/yoga/Yoga.podspec",
+        "RCTDeprecation"   => "ReactApple/Libraries/RCTFoundation/RCTDeprecation/RCTDeprecation.podspec",
+        "FBLazyVector"     => "Libraries/FBLazyVector/FBLazyVector.podspec",
+        "RCTRequired"      => "Libraries/Required/RCTRequired.podspec",
+    }
+
+    # A facade ships NO headers by default — the prebuilt React.framework /
+    # React-Core-prebuilt own them. NARROW EXCEPTION: a few headers live ONLY
+    # inside React.framework/Headers (served angle-only as <React/...>, e.g.
+    # because they reach unguarded C++ and are excluded from the framework module
+    # map) and are NOT in the flattened React-Core-prebuilt/Headers. A quoted
+    # `#import "<name>.h"` therefore has no resolution target in prebuilt mode.
+    #
+    # Community Fabric modules quote-import RCTFabricComponentsPlugins.h (47x in a
+    # full app: slider, maps, pager-view, keyboard-controller, ...). In source it
+    # was vended by React-RCTFabric at header_dir "React", which put it in
+    # dependents' CocoaPods header maps so the bare quoted name resolved. The
+    # facade dropped it. We re-vend JUST that header here so dependents' header
+    # maps carry it again, exactly as the source pod did.
+    #
+    # Re-exposing a SINGLE header (not the whole React/ namespace) does not put
+    # <react/...>/<yoga/...> on -I, so it does NOT reintroduce the
+    # -Wnon-modular-include-in-framework-module shadowing the modular prebuilt
+    # layout exists to eliminate. The header is core-only (matches source: it
+    # only ever declared RN's built-in components; third-party Fabric components
+    # register via the codegen RCTThirdPartyComponentsProvider, shipped by the
+    # non-facaded ReactCodegen pod).
+    #
+    # pod name => { "header_dir" => <dir>, "globs" => [<glob rel. to its podspec dir>] }
+    FACADE_REEXPOSED_HEADERS = {
+        "React-RCTFabric" => {
+            "header_dir" => "React",
+            "globs" => ["Fabric/Mounting/ComponentViews/RCTFabricComponentsPlugins.h"],
+        },
+    }
+
+    # Sub-directory (relative to the install root) that holds the generated facades.
+    FACADE_RELDIR = File.join("build", "rncore-facades")
+
+    @@install_root = nil
+
+    # True when `name` should be installed as a facade instead of its source podspec.
+    def self.facade?(name)
+        FACADE_PODS.key?(name)
+    end
+
+    # Generates the facade podspecs and returns the base directory holding them.
+    # Each facade gets its OWN sub-directory containing a single
+    # `<Name>.podspec.json`, so it can be installed as a LOCAL pod via
+    # `:path => <dir>`. `:path` (PathSource) uses the spec in place and never
+    # downloads `spec.source` — unlike `:podspec` (PodspecSource), which is an
+    # *external* source whose `root_spec.source` CocoaPods would actually fetch
+    # (i.e. git-clone react-native for every empty facade). Idempotent; safe to
+    # call once per `pod install`.
+    #
+    # `react_native_path` locates the real podspecs we mirror. version + subspecs +
+    # default_subspecs are DERIVED from the real spec so the facade stays
+    # graph-equivalent to the source pod (resources are NOT carried — they live in
+    # the prebuilt artifact; see the note in the loop). A facaded pod whose real
+    # podspec can't be read is a hard error (see load_real_spec) — silently shipping
+    # an empty facade would hide exactly the drift this guards against.
+    def self.generate(react_native_path, install_root, version, ios_version)
+        @@install_root = install_root.to_s
+        abs_base = File.join(@@install_root, FACADE_RELDIR)
+        FileUtils.mkdir_p(abs_base)
+        FACADE_PODS.each do |name, podspec_rel_path|
+            podspec_path = File.join(react_native_path.to_s, podspec_rel_path)
+            podspec_dir = File.dirname(podspec_path)
+            real = load_real_spec(podspec_path, name)
+            dir = File.join(abs_base, name)
+            FileUtils.mkdir_p(dir)
+
+            spec = {
+                "name" => name,
+                "version" => real.version.to_s,
+                "summary" => "Prebuilt facade for #{name} (code + headers live in React-Core-prebuilt).",
+                "homepage" => "https://reactnative.dev/",
+                "license" => "MIT",
+                "authors" => "Meta Platforms, Inc. and its affiliates",
+                "platforms" => { "ios" => ios_version },
+                # Required podspec attribute, but never fetched: the pod is installed
+                # as a LOCAL pod (`:path => <dir>`), which uses this spec in place and
+                # ships no source_files. Placeholder only.
+                "source" => { "git" => "https://github.com/facebook/react-native.git" },
+                "dependencies" => { "React-Core-prebuilt" => [] },
+            }
+
+            # NOTE: the facade carries NO resources. The pods' non-code resources
+            # (e.g. the privacy manifest) are embedded directly in the prebuilt
+            # React.xcframework by the ios-prebuild compose (see ios-prebuild/framework-resources.js),
+            # so they reach both CocoaPods-prebuilt and SwiftPM from the artifact —
+            # the facade only needs to declare the React-Core-prebuilt dependency.
+
+            # Re-vend the narrow set of angle-only framework headers that community
+            # modules quote-import (see FACADE_REEXPOSED_HEADERS). The header is
+            # COPIED into the facade dir (a self-contained snapshot — robust, no
+            # `..` globs reaching out of the pod) and exposed as a public header.
+            # It's header-only (a `.h` has nothing to compile, so the facade stays
+            # a placeholder), but CocoaPods lays it into
+            # Pods/Headers/Public/<Name>/<header_dir>/ and dependents' .hmap,
+            # restoring quoted resolution exactly as the source pod did.
+            reexposed = FACADE_REEXPOSED_HEADERS[name]
+            if reexposed
+                copied = copy_reexposed_headers(reexposed["globs"], podspec_dir, dir, name)
+                unless copied.empty?
+                    spec["source_files"] = copied
+                    spec["public_header_files"] = copied
+                    spec["header_dir"] = reexposed["header_dir"] if reexposed["header_dir"]
+                end
+            end
+
+            # Preserve default_subspec so a bare `pod '<Name>'` resolves to the SAME
+            # subspec graph as the source pod (without it CocoaPods pulls every
+            # subspec, which is not graph-equivalent).
+            defaults = Array(real.default_subspecs)
+            spec["default_subspecs"] = defaults unless defaults.empty?
+
+            subspecs = derive_subspecs(real)
+            unless subspecs.empty?
+                spec["subspecs"] = subspecs.map do |ss|
+                    { "name" => ss, "dependencies" => { "React-Core-prebuilt" => [] } }
+                end
+            end
+
+            File.write(File.join(dir, "#{name}.podspec.json"), JSON.pretty_generate(spec))
+        end
+        abs_base
+    end
+
+    # Facade dir for `<name>`, RELATIVE to the install root — pass to `pod :path =>`.
+    # Relative (not absolute) so the path CocoaPods records in Podfile.lock is
+    # portable rather than machine-specific.
+    def self.facade_path(name)
+        File.join(FACADE_RELDIR, name)
+    end
+
+    # Loads the real podspec so we can mirror its structure. A facaded pod MUST have
+    # a readable real podspec — if it's missing or unparseable we raise rather than
+    # ship an empty facade, since that would silently drop subspecs (the very drift
+    # this mechanism exists to prevent).
+    def self.load_real_spec(path, name)
+        unless File.exist?(path)
+            raise "[RNCoreFacades] Real podspec for facaded pod '#{name}' not found at #{path}. " \
+                  "Update FACADE_PODS in rncore_facades.rb if the podspec moved."
+        end
+        Pod::Specification.from_file(path)
+    rescue => e
+        raise "[RNCoreFacades] Failed to read real podspec for facaded pod '#{name}' at #{path}: #{e.message}"
+    end
+    private_class_method :load_real_spec
+
+    # Library (non-test, non-app) subspec names of the real spec, so third-party
+    # libs depending on `<pod>/<subspec>` keep resolving. Derived, never hand-listed.
+    def self.derive_subspecs(real)
+        real.subspecs
+            .reject { |ss| ss.test_specification? || (ss.respond_to?(:app_specification?) && ss.app_specification?) }
+            .map(&:base_name)
+    end
+    private_class_method :derive_subspecs
+
+    # Copy the re-exposed header(s) into the facade dir (flat) and return the
+    # facade-relative source_files entries. `globs` are resolved against the real
+    # podspec dir. A glob that matches nothing is a hard error: the whole point is
+    # to keep a quoted-import header resolvable, so silently shipping a facade
+    # without it would reintroduce the exact "file not found" we're fixing.
+    def self.copy_reexposed_headers(globs, podspec_dir, facade_dir, name)
+        copied = []
+        Array(globs).each do |g|
+            matches = Dir.glob(File.expand_path(g, podspec_dir))
+            if matches.empty?
+                raise "[RNCoreFacades] Re-exposed header glob '#{g}' for facade '#{name}' " \
+                      "matched no files under #{podspec_dir}. Update FACADE_REEXPOSED_HEADERS."
+            end
+            matches.each do |src|
+                base = File.basename(src)
+                FileUtils.cp(src, File.join(facade_dir, base))
+                copied << base
+            end
+        end
+        copied.uniq
+    end
+    private_class_method :copy_reexposed_headers
+end

package/scripts/cocoapods/rndependencies.rb

@@ -6,6 +6,7 @@
 require "json"
 require 'net/http'
 require 'rexml/document'
+require 'shellwords'
 
 require_relative './utils.rb'
 
@@ -36,7 +37,7 @@ def add_rn_third_party_dependencies(s)
         header_search_paths = current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] || []
 
         if header_search_paths.is_a?(String)
-            header_search_paths = header_search_paths.split(" ")
+            header_search_paths = Shellwords.shellsplit(header_search_paths)
         end
 
         header_search_paths << "$(PODS_ROOT)/glog"
@@ -47,10 +48,24 @@ def add_rn_third_party_dependencies(s)
         header_search_paths << "$(PODS_ROOT)/SocketRocket"
         header_search_paths << "$(PODS_ROOT)/RCT-Folly"
 
-        current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] = header_search_paths
+        # uniq so a second call on the same spec can't duplicate entries.
+        current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] = header_search_paths.uniq
     else
+        # Prebuilt-deps mode: this pod SELF-SERVES the third-party headers from its
+        # own xcframework (incl. SocketRocket - sole supplier in this mode). See
+        # scripts/cocoapods/__docs__/prebuilt-deps.md for the full contract.
         s.dependency "ReactNativeDependencies"
-        current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] ||= [] << "$(PODS_ROOT)/ReactNativeDependencies"
+
+        header_search_paths = current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] || []
+        if header_search_paths.is_a?(String)
+            header_search_paths = Shellwords.shellsplit(header_search_paths)
+        end
+        # Artifact headers are flattened into the pod-local Headers/ by the podspec
+        # prepare_command (see __docs__/prebuilt-deps.md).
+        header_search_paths << "$(PODS_ROOT)/ReactNativeDependencies/Headers"
+
+        # uniq so a second call on the same spec can't duplicate entries.
+        current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] = header_search_paths.uniq
     end
 
     s.pod_target_xcconfig = current_pod_target_xcconfig
@@ -139,6 +154,52 @@ class ReactNativeDependenciesUtils
       end
     end
 
+    # Single post-install injection site for the prebuilt deps header resolution.
+    # Adds the flattened ReactNativeDependencies/Headers search path to the
+    # aggregate (main app) target AND every pod target, mirroring
+    # ReactNativeCoreUtils.configure_aggregate_xcconfig. ReactNativeHeaders is
+    # pure-RN, so this path is the single global home of the third-party
+    # namespaces (folly/glog/boost/fmt/double-conversion/fast_float/
+    # SocketRocket): pods that never call add_rn_third_party_dependencies (nor
+    # depend on a facade) still compile RN headers that textually reach
+    # <folly/...>. No module-map activation needed — the deps headers are
+    # served textually; modules come from the ReactNativeDependencies pod.
+    def self.configure_aggregate_xcconfig(installer)
+        return if @@build_from_source
+
+        rndeps_log("Configuring xcconfig for prebuilt React Native Dependencies...")
+        headers_search_path = " \"$(PODS_ROOT)/ReactNativeDependencies/Headers\""
+
+        # Add the header search path to aggregate target xcconfigs (used by the main app target)
+        installer.aggregate_targets.each do |aggregate_target|
+            aggregate_target.xcconfigs.each do |config_name, config_file|
+                ReactNativePodsUtils.add_flag_to_map_with_inheritance(config_file.attributes, "HEADER_SEARCH_PATHS", headers_search_path)
+                xcconfig_path = aggregate_target.xcconfig_path(config_name)
+                config_file.save_as(xcconfig_path)
+            end
+        end
+
+        # Add the header search path to ALL pod targets (for pods that don't go
+        # through add_rn_third_party_dependencies)
+        installer.pod_targets.each do |pod_target|
+            pod_target.build_settings.each do |config_name, build_settings|
+                xcconfig_path = pod_target.xcconfig_path(config_name)
+                next unless File.exist?(xcconfig_path)
+
+                xcconfig = Xcodeproj::Config.new(xcconfig_path)
+
+                # Skip if the deps header search path is already present
+                header_search_paths = xcconfig.attributes["HEADER_SEARCH_PATHS"] || ""
+                next if header_search_paths.include?("ReactNativeDependencies/Headers")
+
+                ReactNativePodsUtils.add_flag_to_map_with_inheritance(xcconfig.attributes, "HEADER_SEARCH_PATHS", headers_search_path)
+                xcconfig.save_as(xcconfig_path)
+            end
+        end
+
+        rndeps_log("Prebuilt deps xcconfig configuration complete")
+    end
+
     def self.podspec_source_download_prebuild_release_tarball()
         # Warn if @@react_native_path is not set
         if @@react_native_path == ""