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

package/scripts/cocoapods/rndeps_facades.rb

@@ -0,0 +1,193 @@
+# 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'
+# Self-contained against require ordering: this module reads
+# Helpers::Constants.socket_rocket_config. react_native_pods.rb normally loads
+# helpers.rb first, but requiring it here (idempotent) removes that implicit
+# dependency. The defined? guard at the use site stays as a backstop.
+require_relative './helpers'
+
+# Dependency-only facade podspecs for the third-party deps in prebuilt-deps
+# mode (deps-side analogue of RNCoreFacades). Design + rationale:
+# scripts/cocoapods/__docs__/prebuilt-deps.md
+module RNDepsFacades
+    # The name of the umbrella prebuilt-deps pod every facade depends on. Its pod
+    # self-serves the third-party headers + carries the binary (see
+    # rndependencies.rb, ReactNativeDependencies.podspec).
+    DEPS_POD = "ReactNativeDependencies"
+
+    # pod name => podspec path (relative to the react-native package root), or
+    # :synthesized for a pod with no local podspec (SocketRocket). Version +
+    # subspecs + default_subspecs are DERIVED from the real podspec where one
+    # exists; synthesized entries derive their version from a constant.
+    FACADE_PODS = {
+        "RCT-Folly"        => "third-party-podspecs/RCT-Folly.podspec",
+        "glog"             => "third-party-podspecs/glog.podspec",
+        "boost"            => "third-party-podspecs/boost.podspec",
+        "DoubleConversion" => "third-party-podspecs/DoubleConversion.podspec",
+        "fmt"              => "third-party-podspecs/fmt.podspec",
+        "fast_float"       => "third-party-podspecs/fast_float.podspec",
+        "SocketRocket"     => :synthesized,
+    }
+
+    # Sub-directory (relative to the install root) that holds the generated
+    # deps facades. Kept separate from RNCoreFacades' `build/rncore-facades` so
+    # the two families never collide.
+    FACADE_RELDIR = File.join("build", "rndeps-facades")
+
+    # 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>` (PathSource uses the spec in place and never downloads
+    # `spec.source`). Idempotent; safe to call once per `pod install`.
+    #
+    # `react_native_path` locates the real third-party podspecs we mirror.
+    # version + subspecs + default_subspecs are DERIVED from the real spec (or,
+    # for SocketRocket, synthesized from the socket_rocket_config version) so the
+    # facade matches the source pod's spec/subspec SHAPE. It is not fully
+    # graph-equivalent: every derived subspec depends only on
+    # ReactNativeDependencies, so intra-pod subspec deps (e.g. RCT-Folly/Fabric
+    # -> RCT-Folly/Default) are not reproduced — harmless here because the deps
+    # are all declared explicitly in react_native_pods.rb. NO source_files and
+    # NO headers are emitted — the ReactNativeDependencies pod supplies both. 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 drift.
+    def self.generate(react_native_path, install_root, ios_version)
+        abs_base = File.join(install_root.to_s, FACADE_RELDIR)
+        FileUtils.mkdir_p(abs_base)
+        FACADE_PODS.each do |name, podspec_rel_path|
+            dir = File.join(abs_base, name)
+            FileUtils.mkdir_p(dir)
+
+            if podspec_rel_path == :synthesized
+                spec = synthesized_spec(name, ios_version)
+            else
+                podspec_path = File.join(react_native_path.to_s, podspec_rel_path)
+                real = load_real_spec(podspec_path, name)
+                spec = derived_spec(name, real, ios_version)
+            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
+
+    # Base spec skeleton shared by derived + synthesized facades: dependency-only,
+    # no source_files, no headers. Depends solely on ReactNativeDependencies.
+    def self.base_spec(name, version, ios_version)
+        {
+            "name" => name,
+            "version" => version,
+            "summary" => "Prebuilt facade for #{name} (code + headers live in #{DEPS_POD}).",
+            "homepage" => "https://reactnative.dev/",
+            "license" => "MIT",
+            "authors" => "Meta Platforms, Inc. and its affiliates",
+            "platforms" => { "ios" => ios_version },
+            # Required podspec attribute, but never fetched: 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" => { DEPS_POD => [] },
+        }
+    end
+    private_class_method :base_spec
+
+    # Facade derived from a real third-party podspec: version + subspecs +
+    # default_subspecs mirror the real spec so a bare `pod '<Name>'` and any
+    # `pod '<Name>/<Subspec>'` resolve to the SAME graph (e.g. RCT-Folly's
+    # bare + /Default + /Fabric). Each subspec is also dependency-only and
+    # depends on ReactNativeDependencies.
+    #
+    # NOTE: resources (e.g. RCT-Folly's PrivacyInfo.xcprivacy) are intentionally
+    # NOT carried. In prebuilt-deps mode the third-party code — and its privacy
+    # manifest — is embedded in the ReactNativeDependencies artifact; the facade
+    # only needs to declare the dependency (see the design note in the PR).
+    def self.derived_spec(name, real, ios_version)
+        spec = base_spec(name, real.version.to_s, ios_version)
+
+        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" => { DEPS_POD => [] } }
+            end
+        end
+
+        spec
+    end
+    private_class_method :derived_spec
+
+    # Facade synthesized for a pod with NO local podspec (SocketRocket, a trunk
+    # pod). Version comes from Helpers::Constants::socket_rocket_config; no
+    # subspecs. A missing/blank constant is a hard error rather than a silent
+    # versionless facade — a bare `pod 'SocketRocket'` in the source path is
+    # `"~> #{socket_rocket_config[:version]}"`, so the facade MUST carry a version
+    # that satisfies that constraint.
+    def self.synthesized_spec(name, ios_version)
+        version = synthesized_version(name)
+        base_spec(name, version, ios_version)
+    end
+    private_class_method :synthesized_spec
+
+    # Resolves the synthesized version for a no-podspec facade. Fail-closed on a
+    # missing constant/version. Only SocketRocket is synthesized today.
+    def self.synthesized_version(name)
+        case name
+        when "SocketRocket"
+            unless defined?(Helpers::Constants) && Helpers::Constants.respond_to?(:socket_rocket_config)
+                raise "[RNDepsFacades] Cannot synthesize facade for '#{name}': " \
+                      "Helpers::Constants.socket_rocket_config is unavailable."
+            end
+            version = Helpers::Constants.socket_rocket_config[:version]
+            if version.nil? || version.to_s.strip.empty?
+                raise "[RNDepsFacades] Cannot synthesize facade for '#{name}': " \
+                      "socket_rocket_config[:version] is missing or empty."
+            end
+            version.to_s
+        else
+            raise "[RNDepsFacades] No synthesized version rule for facaded pod '#{name}'. " \
+                  "Add one to synthesized_version or give it a real podspec in FACADE_PODS."
+        end
+    end
+    private_class_method :synthesized_version
+
+    # Loads the real podspec so we can mirror its structure. A facaded pod with a
+    # declared podspec path MUST have a readable real podspec — if it's missing or
+    # unparseable we raise rather than ship an empty facade (which would silently
+    # drop subspecs / the version, the very drift this mechanism prevents).
+    def self.load_real_spec(path, name)
+        unless File.exist?(path)
+            raise "[RNDepsFacades] Real podspec for facaded pod '#{name}' not found at #{path}. " \
+                  "Update FACADE_PODS in rndeps_facades.rb if the podspec moved."
+        end
+        begin
+            Pod::Specification.from_file(path)
+        rescue => e
+            raise "[RNDepsFacades] Failed to read real podspec for facaded pod '#{name}' at #{path}: #{e.message}"
+        end
+    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>` (e.g. `RCT-Folly/Fabric`) 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
+end

package/scripts/cocoapods/spm.rb

@@ -19,28 +19,46 @@ class SPMManager
     log 'Cleaning old SPM dependencies from Pods project'
     clean_spm_dependencies_from_target(project, @dependencies_by_pod)
     log 'Adding SPM dependencies to Pods project'
+    flattened_pod_names = []
     @dependencies_by_pod.each do |pod_name, dependencies|
+      target = project.targets.find { |t| t.name == pod_name}
       dependencies.each do |spm_spec|
         log "Adding SPM dependency on product #{spm_spec[:products]}"
         add_spm_to_target(
           project,
-          project.targets.find { |t| t.name == pod_name},
+          target,
           spm_spec[:url],
           spm_spec[:requirement],
           spm_spec[:products]
         )
-        log " Adding workaround for Swift package not found issue"
-        target = project.targets.find { |t| t.name == pod_name}
-        target.build_configurations.each do |config|
-          target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'] ||= ['$(inherited)']
-          search_path = '${SYMROOT}/${CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}/'
-          unless target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'].include?(search_path)
-            target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'].push(search_path)
+        if target.product_type == 'com.apple.product-type.library.static'
+          # Xcode emits a package C-target's module map both into the shared
+          # products dir and into this pod's CONFIGURATION_BUILD_DIR, and both
+          # copies are unavoidably visible (the package swiftmodule serializes
+          # the products-root path) — clang hard-errors with "redefinition of
+          # module" on Xcode 26.3. Building the pod straight into the products
+          # root makes both paths the same file, and puts the package
+          # swiftmodule on the pod's default search path.
+          log " Building #{pod_name} into the shared products dir to avoid duplicate module maps"
+          target.build_configurations.each do |config|
+            target.build_settings(config.name)['CONFIGURATION_BUILD_DIR'] = '${PODS_CONFIGURATION_BUILD_DIR}'
+          end
+          flattened_pod_names << pod_name unless flattened_pod_names.include?(pod_name)
+        else
+          log " Adding workaround for Swift package not found issue"
+          target.build_configurations.each do |config|
+            target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'] ||= ['$(inherited)']
+            search_path = '${SYMROOT}/${CONFIGURATION}${EFFECTIVE_PLATFORM_NAME}/'
+            unless target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'].include?(search_path)
+              target.build_settings(config.name)['SWIFT_INCLUDE_PATHS'].push(search_path)
+            end
           end
         end
       end
     end
 
+    rewrite_aggregate_modulemap_references(installer, flattened_pod_names) unless flattened_pod_names.empty?
+
     unless @dependencies_by_pod.empty?
       log_warning "If you're using Xcode 15 or earlier you might need to close and reopen the Xcode workspace"
       unless ENV["USE_FRAMEWORKS"] == "dynamic"
@@ -53,6 +71,55 @@ class SPMManager
 
   private
 
+  # Flattening a pod's build dir moves its generated modulemap from
+  # "<Pod>/<Pod>.modulemap" to "<Pod>.modulemap"; the aggregate xcconfigs
+  # reference the old path via -fmodule-map-file. Must mutate the in-memory
+  # Config attributes — later post_install steps (NewArchitectureHelper) re-save
+  # the same Config objects and would clobber a plain file edit.
+  def rewrite_aggregate_modulemap_references(installer, pod_names)
+    installer.aggregate_targets.each do |aggregate_target|
+      aggregate_target.xcconfigs.each do |config_name, config_file|
+        %w[OTHER_CFLAGS OTHER_SWIFT_FLAGS].each do |key|
+          value = config_file.attributes[key]
+          next unless value
+
+          updated_value = pod_names.reduce(value) do |acc, pod_name|
+            acc.gsub(
+              "${PODS_CONFIGURATION_BUILD_DIR}/#{pod_name}/#{pod_name}.modulemap",
+              "${PODS_CONFIGURATION_BUILD_DIR}/#{pod_name}.modulemap"
+            )
+          end
+          config_file.attributes[key] = updated_value if updated_value != value
+        end
+
+        config_file.save_as(aggregate_target.xcconfig_path(config_name))
+      end
+    end
+  end
+
+  # Creates a new object in the project with a UUID guaranteed not to collide
+  # with any UUID already present in the project.
+  #
+  # `Pod::Project` overrides `generate_available_uuid_list` with a fast,
+  # counter-based scheme (`<sha prefix><counter>0`) that deliberately skips
+  # collision checks, on the assumption that the whole Pods project is generated
+  # in a single pass. That assumption does not hold here: we run in a
+  # `post_install` hook, and the generator's counter can be out of sync with the
+  # UUIDs already assigned to existing objects (e.g. when the project has been
+  # reloaded from disk during an incremental install, the counter restarts at 0
+  # while the root object still occupies `<prefix>00000000`). Using `project.new`
+  # directly can therefore hand back a UUID that is already in use and overwrite
+  # an existing object (notably the root `PBXProject`), producing a Pods project
+  # Xcode refuses to load. We keep the deterministic scheme but probe forward
+  # until we find a UUID that is actually free.
+  def new_object(project, klass)
+    uuid = project.generate_uuid
+    uuid = project.generate_uuid while project.objects_by_uuid.key?(uuid)
+    object = klass.new(project, uuid)
+    object.initialize_defaults
+    object
+  end
+
   def log(msg)
     ::Pod::UI.puts "[SPM] #{msg}"
   end
@@ -76,7 +143,7 @@ class SPMManager
       pkg_class = Xcodeproj::Project::Object::XCLocalSwiftPackageReference
       pkg = project.root_object.package_references.find { |p| p.class == pkg_class && p.relative_path == url }
       if !pkg
-        pkg = project.new(pkg_class)
+        pkg = new_object(project, pkg_class)
         pkg.relative_path = url
         log(" Adding local package to workspace: #{pkg.inspect}")
         project.root_object.package_references << pkg
@@ -85,7 +152,7 @@ class SPMManager
       pkg_class = Xcodeproj::Project::Object::XCRemoteSwiftPackageReference
       pkg = project.root_object.package_references.find { |p| p.class == pkg_class && p.repositoryURL == url }
       if !pkg
-        pkg = project.new(pkg_class)
+        pkg = new_object(project, pkg_class)
         pkg.repositoryURL = url
         pkg.requirement = requirement
         log(" Adding remote package to workspace: #{pkg.inspect}")
@@ -101,7 +168,7 @@ class SPMManager
       next if ref
 
       log(" Adding product dependency #{product_name} to #{target.name}")
-      ref = project.new(ref_class)
+      ref = new_object(project, ref_class)
       ref.package = pkg
       ref.product_name = product_name
       target.package_product_dependencies << ref

package/scripts/codegen/templates/Package.swift.spm-template

@@ -0,0 +1,97 @@
+// swift-tools-version: 6.0
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// AUTO-GENERATED by scripts/setup-apple-spm.js – do not edit manually.
+// This SPM-specific template replaces the CocoaPods codegen template
+// with xcframework configuration built in.
+
+import PackageDescription
+
+// React headers need NO search paths: the React module comes from the
+// invariant ReactHeaders Clang target,
+// every other RN namespace from the ReactNativeHeaders binaryTarget
+// (pure-RN), the third-party deps namespaces (folly/glog/boost/...) from the
+// ReactNativeDependenciesHeaders sidecar, and the per-app generated headers
+// from the ReactAppHeaders target below — all auto-served by SPM through
+// product/target dependencies.
+let headersDep: [Target.Dependency] = [
+    .product(name: "ReactHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+    "ReactAppHeaders",
+]
+
+let package = Package(
+    name: "React-GeneratedCode",
+    platforms: [.iOS(.v15), .macCatalyst(SupportedPlatform.MacCatalystVersion.v13)],
+    products: [
+        .library(
+            name: "ReactCodegen",
+            targets: ["ReactCodegen"]),
+        .library(
+            name: "ReactAppDependencyProvider",
+            targets: ["ReactAppDependencyProvider"]),
+        .library(
+            name: "ReactAppHeaders",
+            targets: ["ReactAppHeaders"]),
+    ],
+    dependencies: [
+        .package(name: "ReactNative", path: "../../xcframeworks"),
+    ],
+    targets: [
+        .target(
+            name: "ReactCodegen",
+            dependencies: headersDep,
+            path: "ReactCodegen",
+            exclude: ["ReactCodegen.podspec"],
+            publicHeadersPath: ".",
+            cSettings: [.headerSearchPath("headers")],
+            // DEBUG/NDEBUG match the prebuilt React.framework's config-gated C++
+            // ABI: NDEBUG (Release) strips DebugStringConvertible's vtable and
+            // shifts the ShadowNode layout that codegen'd Props inherit, so this
+            // target must compile with the same NDEBUG state or the Release link
+            // fails (undefined "vtable for DebugStringConvertible"). Mirrors
+            // packages/react-native/Package.swift.
+            cxxSettings: [
+                .headerSearchPath("headers"),
+                .define("DEBUG", .when(configuration: .debug)),
+                .define("NDEBUG", .when(configuration: .release)),
+            ],
+            linkerSettings: [
+                .linkedFramework("Foundation")
+            ]
+        ),
+        .target(
+            name: "ReactAppDependencyProvider",
+            dependencies: ["ReactCodegen"] + headersDep,
+            path: "ReactAppDependencyProvider",
+            exclude: ["ReactAppDependencyProvider.podspec"],
+            publicHeadersPath: ".",
+            cSettings: [.headerSearchPath(".."), .headerSearchPath("headers")],
+            cxxSettings: [
+                .headerSearchPath(".."),
+                .headerSearchPath("headers"),
+                // Match the prebuilt React.framework NDEBUG-gated C++ ABI (see above).
+                .define("DEBUG", .when(configuration: .debug)),
+                .define("NDEBUG", .when(configuration: .release)),
+            ],
+            linkerSettings: [
+                .linkedFramework("Foundation")
+            ]
+        ),
+        // The per-app generated-headers farm (built by spm sync), vended as a
+        // normal SPM headers target.
+        .target(
+            name: "ReactAppHeaders",
+            path: "ReactAppHeaders",
+            publicHeadersPath: "."
+        ),
+    ],
+    // React Native headers require C++20 (concepts, std::optional, etc.)
+    cxxLanguageStandard: .cxx20
+)

package/scripts/react-native-xcode.sh

@@ -80,6 +80,26 @@ source "$REACT_NATIVE_DIR/scripts/node-binary.sh"
 HERMES_ENGINE_PATH="$PODS_ROOT/hermes-engine"
 [ -z "$HERMES_CLI_PATH" ] && HERMES_CLI_PATH="$HERMES_ENGINE_PATH/destroot/bin/hermesc"
 
+# SwiftPM consumers have no Pods directory to provide hermesc. When there is
+# no Pods installation at all and the current HERMES_CLI_PATH does not exist
+# (unset, or an injector-baked path gone stale after a package-store move),
+# resolve the hermes-compiler npm package THROUGH react-native's own dependency
+# graph — react-native pins the hermes-compiler version, so the compiler's
+# bytecode version always matches the prebuilt hermes VM artifacts (a
+# mismatched pair crashes at launch with "Wrong bytecode version").
+# STRICTLY SwiftPM-scoped: in a CocoaPods build the hermes-engine pod owns both
+# the VM and hermesc, and its hermes train may legitimately differ from the npm
+# hermes-compiler — falling back there would compile bundles the podded VM
+# rejects.
+if [[ ( -z "$PODS_ROOT" || ! -d "$PODS_ROOT" ) && ! -f "$HERMES_CLI_PATH" ]]; then
+  NODE_HERMESC=$(RN_DIR="$REACT_NATIVE_DIR" "$NODE_BINARY" --print \
+    "require('path').join(require('path').dirname(require.resolve('hermes-compiler/package.json', {paths: [process.env.RN_DIR]})), 'hermesc', 'osx-bin', 'hermesc')" \
+    2>/dev/null || true)
+  if [[ -n "$NODE_HERMESC" && -f "$NODE_HERMESC" ]]; then
+    HERMES_CLI_PATH="$NODE_HERMESC"
+  fi
+fi
+
 # If hermesc is not available and USE_HERMES is not set to false, show error.
 if [[ $USE_HERMES != false && -f "$HERMES_ENGINE_PATH" && ! -f "$HERMES_CLI_PATH" ]]; then
   echo "error: Hermes is enabled but the hermesc binary could not be found at ${HERMES_CLI_PATH}." \

package/scripts/react_native_pods.rb

@@ -21,6 +21,8 @@ require_relative './cocoapods/helpers.rb'
 require_relative './cocoapods/privacy_manifest_utils.rb'
 require_relative './cocoapods/spm.rb'
 require_relative './cocoapods/rncore.rb'
+require_relative './cocoapods/rncore_facades.rb'
+require_relative './cocoapods/rndeps_facades.rb'
 # Importing to expose use_native_modules!
 require_relative './cocoapods/autolinking.rb'
 
@@ -52,6 +54,28 @@ def prepare_react_native_project!
   ReactNativePodsUtils.create_xcode_env_if_missing
 end
 
+# Declares a React core pod, choosing source vs prebuilt facade. In prebuilt
+# mode, pods in the RNCoreFacades manifest are installed as dependency-only
+# facades (no source/headers) so they can't shadow the prebuilt artifact; their
+# code + headers come from React-Core-prebuilt. Everything else (and the whole
+# source build) is unaffected. See cocoapods/rncore_facades.rb.
+def rncore_pod(name, **opts)
+  base = name.split('/').first
+  if !ReactNativeCoreUtils.build_rncore_from_source() && RNCoreFacades.facade?(base)
+    # Install as a LOCAL pod (`:path`) from the generated facade directory, so
+    # CocoaPods never fetches the placeholder git source (a `:podspec` external
+    # source would). Both the pod and any subspec declaration point at the SAME
+    # directory, so CocoaPods sees one consistent source for the name (a bare
+    # subspec declaration would otherwise default to the spec repo and conflict).
+    # Preserve the caller's options (e.g. :modular_headers) but replace :path with
+    # the facade directory.
+    facade_opts = opts.reject { |k, _| k == :path }
+    pod name, **facade_opts, :path => RNCoreFacades.facade_path(base)
+  else
+    pod name, **opts
+  end
+end
+
 # Function that setup all the react native dependencies
 # 
 # Parameters
@@ -123,19 +147,25 @@ def use_react_native! (
   # Update ReactNativeCoreUtils so that we can easily switch between source and prebuilt
   ReactNativeCoreUtils.setup_rncore(prefix, react_native_version)
 
+  # In prebuilt mode, generate the facade podspecs the core pods are installed as
+  # (instead of their source podspecs) so they don't ship shadowing headers.
+  unless ReactNativeCoreUtils.build_rncore_from_source()
+    RNCoreFacades.generate(react_native_path, Pod::Config.instance.installation_root, react_native_version, min_ios_version_supported)
+  end
+
   Pod::UI.puts "Configuring the target with the New Architecture\n"
 
   # The Pods which should be included in all projects
-  pod 'FBLazyVector', :path => "#{prefix}/Libraries/FBLazyVector"
-  pod 'RCTRequired', :path => "#{prefix}/Libraries/Required"
+  rncore_pod 'FBLazyVector', :path => "#{prefix}/Libraries/FBLazyVector"
+  rncore_pod 'RCTRequired', :path => "#{prefix}/Libraries/Required"
   pod 'RCTTypeSafety', :path => "#{prefix}/Libraries/TypeSafety", :modular_headers => true
   pod 'React', :path => "#{prefix}/"
   if !ReactNativeCoreUtils.build_rncore_from_source()
     pod 'React-Core-prebuilt', :podspec => "#{prefix}/React-Core-prebuilt.podspec", :modular_headers => true
   end
-  pod 'React-Core', :path => "#{prefix}/"
+  rncore_pod 'React-Core', :path => "#{prefix}/"
   pod 'React-CoreModules', :path => "#{prefix}/React/CoreModules"
-  pod 'React-RCTRuntime', :path => "#{prefix}/React/Runtime"
+  rncore_pod 'React-RCTRuntime', :path => "#{prefix}/React/Runtime"
   pod 'React-RCTAppDelegate', :path => "#{prefix}/Libraries/AppDelegate"
   pod 'React-RCTActionSheet', :path => "#{prefix}/Libraries/ActionSheetIOS"
   pod 'React-RCTAnimation', :path => "#{prefix}/Libraries/NativeAnimation"
@@ -146,7 +176,7 @@ def use_react_native! (
   pod 'React-RCTSettings', :path => "#{prefix}/Libraries/Settings"
   pod 'React-RCTText', :path => "#{prefix}/Libraries/Text"
   pod 'React-RCTVibration', :path => "#{prefix}/Libraries/Vibration"
-  pod 'React-Core/RCTWebSocket', :path => "#{prefix}/"
+  rncore_pod 'React-Core/RCTWebSocket', :path => "#{prefix}/"
   pod 'React-cxxreact', :path => "#{prefix}/ReactCommon/cxxreact"
   pod 'React-cxxstableapi', :path => "#{prefix}/ReactCommon/react/cxxstableapi"
   pod 'React-debug', :path => "#{prefix}/ReactCommon/react/debug"
@@ -164,7 +194,7 @@ def use_react_native! (
   pod 'React-Mapbuffer', :path => "#{prefix}/ReactCommon"
   pod 'React-bridging', :path => "#{prefix}/ReactCommon/react/bridging", :modular_headers => true
   pod 'React-jserrorhandler', :path => "#{prefix}/ReactCommon/jserrorhandler"
-  pod 'RCTDeprecation', :path => "#{prefix}/ReactApple/Libraries/RCTFoundation/RCTDeprecation"
+  rncore_pod 'RCTDeprecation', :path => "#{prefix}/ReactApple/Libraries/RCTFoundation/RCTDeprecation"
   pod 'React-RCTFBReactNativeSpec', :path => "#{prefix}/React"
   pod 'React-jsi', :path => "#{prefix}/ReactCommon/jsi"
   pod 'RCTSwiftUI', :path => "#{prefix}/ReactApple/RCTSwiftUI"
@@ -197,7 +227,7 @@ def use_react_native! (
   pod 'React-logger', :path => "#{prefix}/ReactCommon/logger"
   pod 'ReactCommon/turbomodule/core', :path => "#{prefix}/ReactCommon", :modular_headers => true
   pod 'React-NativeModulesApple', :path => "#{prefix}/ReactCommon/react/nativemodule/core/platform/ios", :modular_headers => true
-  pod 'Yoga', :path => "#{prefix}/ReactCommon/yoga", :modular_headers => true
+  rncore_pod 'Yoga', :path => "#{prefix}/ReactCommon/yoga", :modular_headers => true
   setup_fabric!(:react_native_path => prefix)
   setup_bridgeless!(:react_native_path => prefix, :use_hermes => hermes_enabled)
 
@@ -214,6 +244,17 @@ def use_react_native! (
     ReactNativeCoreUtils.rncore_log("Using React Native Core and React Native Dependencies prebuilt versions.")
     pod 'ReactNativeDependencies', :podspec => "#{prefix}/third-party-podspecs/ReactNativeDependencies.podspec", :modular_headers => true
 
+    # Facades: community pods' hardcoded s.dependency "RCT-Folly"/"glog"/... must
+    # resolve locally instead of from trunk. See __docs__/prebuilt-deps.md.
+    RNDepsFacades.generate(react_native_path, Pod::Config.instance.installation_root, min_ios_version_supported)
+    pod 'DoubleConversion', :path => RNDepsFacades.facade_path('DoubleConversion')
+    pod 'glog', :path => RNDepsFacades.facade_path('glog')
+    pod 'boost', :path => RNDepsFacades.facade_path('boost')
+    pod 'fast_float', :path => RNDepsFacades.facade_path('fast_float')
+    pod 'fmt', :path => RNDepsFacades.facade_path('fmt')
+    pod 'RCT-Folly', :path => RNDepsFacades.facade_path('RCT-Folly')
+    pod 'SocketRocket', :path => RNDepsFacades.facade_path('SocketRocket')
+
     if !ReactNativeCoreUtils.build_rncore_from_source()
       pod 'React-Core-prebuilt', :podspec => "#{prefix}/React-Core-prebuilt.podspec", :modular_headers => true
     end
@@ -569,18 +610,26 @@ def react_native_post_install(
   ReactNativePodsUtils.add_ndebug_flag_to_pods_in_release(installer)
 
   if !ReactNativeCoreUtils.build_rncore_from_source()
-    # In XCode 26 we need to revert the new setting SWIFT_ENABLE_EXPLICIT_MODULES when building
-    # with precompiled binaries.
-    ReactNativePodsUtils.set_build_setting(installer, build_setting: "SWIFT_ENABLE_EXPLICIT_MODULES", value: "NO")
-
-    # Process the VFS overlay for prebuilt React Native Core - this is done as part of the post install so
-    # that we can update paths based on the final location of the Pods installation.
-    ReactNativeCoreUtils.process_vfs_overlay()
-
-    # Configure xcconfig for prebuilt usage (VFS overlay, header paths, cleanup redundant paths)
+    # The Xcode-26 SWIFT_ENABLE_EXPLICIT_MODULES=NO workaround (#53457) is removed:
+    # the modular ReactNativeHeaders layout + React-Core-prebuilt module-map
+    # activation + header-less facades let the React module precompile cleanly with
+    # explicit modules ON (verified cold-DD green), so the override is unnecessary.
+
+    # Make the prebuilt React.xcframework headers resolvable from aggregate (main app)
+    # and third-party pod targets that don't go through add_rncore_dependency. The headers
+    # are served directly from the xcframework's headers-spec layout — no clang VFS overlay.
     ReactNativeCoreUtils.configure_aggregate_xcconfig(installer)
   end
 
+  if !ReactNativeDependenciesUtils.build_react_native_deps_from_source()
+    # Prebuilt-deps mode: make the deps artifact headers (folly/glog/...)
+    # resolvable from the aggregate and every pod target, mirroring the rncore
+    # injection above. ReactNativeHeaders is pure-RN, so the flattened
+    # ReactNativeDependencies/Headers dir is the single global home of the
+    # third-party namespaces (see scripts/cocoapods/__docs__/prebuilt-deps.md).
+    ReactNativeDependenciesUtils.configure_aggregate_xcconfig(installer)
+  end
+
   SPM.apply_on_post_install(installer)
 
   if privacy_file_aggregation_enabled