fix(spm): migration fixes surfaced by rn-tester + helloworld SPM builds

Migrating rn-tester (RNTesterPods.xcodeproj, in-place) and helloworld to
SwiftPM surfaced five latent bugs:

- scaffold: podspecs with root-level sources (s.source_files =
  "*.{h,m,mm}") got no publicHeadersPath, so SPM rejected the target
  over the nonexistent default include/. The scaffolder now mirrors
  root headers into a generated include/<SwiftName>/ shim dir
  (publicHeadersPath: "include"), giving dependents the CocoaPods
  header-map spelling `#import <SwiftName/Header.h>`.
- scaffold: root podspec globs matched the scaffolder's own output on
  re-runs — Package.swift's `.swift` extension tripped the
  mixed-language gate into DELETING the manifest it had just written
  (runs alternated between scaffolding and self-destructing). Scaffold
  artifacts (Package.swift, the prefix header, include/ shims) are now
  excluded from source expansion.
- autolinking: the one-time legacy-layout cleanup unconditionally
  removed `<dep>/include/`, nuking the scaffolder's shim dirs on every
  sync. It now only removes include/ together with a marker-bearing
  legacy in-place Package.swift.
- scaffold: transitive spm.dependencies entries carry no podspecPath,
  so podspec-name sibling deps (s.dependency "TestLibraryCommon")
  could not be wired ("Unknown dependency"). The sibling map now
  discovers podspecs at those deps' roots.
- add --deintegrate: a ${PODS_ROOT}-anchored REACT_NATIVE_PATH (the
  CocoaPods template default) dangles once CocoaPods is deintegrated,
  breaking the "Bundle React Native code and images" phase. The
  injection now replaces it with the SPM-computed path, recording the
  original in the marker so deinit restores it exactly.

Also declares TestLibraryApple's real dependency on TestLibraryCommon
in its podspec (CocoaPods resolved the undeclared edge leniently
through the shared Public headers dir; SPM needs it for sibling
package wiring).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: chrfalch

packages/react-native-test-library/apple/TestLibraryApple.podspec

@@ -19,5 +19,11 @@ Pod::Spec.new do |s|
   s.source_files    = "*.{h,m,mm,swift}"
   s.requires_arc    = true
 
+  # TestLibraryApple.mm imports <ReactNativeTestLibraryCommon/TestLibraryCommon.h>.
+  # CocoaPods resolves it leniently through the shared Public headers dir, but the
+  # dependency edge must be declared for SwiftPM (the scaffolder wires sibling
+  # packages from podspec dependencies).
+  s.dependency "TestLibraryCommon"
+
   install_modules_dependencies(s)
 end

packages/react-native/scripts/spm/generate-spm-autolinking.js

@@ -1570,27 +1570,36 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
   }
   for (const absSource of entryAbsDirs.values()) {
     const legacyPkg = path.join(absSource, 'Package.swift');
+    let removedLegacyPkg = false;
     try {
       const content = fs.readFileSync(legacyPkg, 'utf8');
       if (content.includes(AUTOGEN_MARKER)) {
         fs.unlinkSync(legacyPkg);
+        removedLegacyPkg = true;
         log(
           `Removed legacy in-place synth: ${path.relative(appRoot, legacyPkg)}`,
         );
       }
     } catch {
       // not present – fine
     }
-    const legacyInclude = path.join(absSource, 'include');
-    try {
-      if (fs.lstatSync(legacyInclude).isDirectory()) {
-        fs.rmSync(legacyInclude, {recursive: true, force: true});
-        log(
-          `Removed legacy in-place include/: ${path.relative(appRoot, legacyInclude)}`,
-        );
+    // Only treat include/ as a legacy leftover when the in-place synth
+    // manifest was just removed alongside it: a SCAFFOLDED dep legitimately
+    // owns include/<SwiftName>/ (the namespaced shim headers behind its
+    // publicHeadersPath: "include") — nuking it unconditionally would break
+    // every dependent's `#import <SwiftName/Header.h>` on the next sync.
+    if (removedLegacyPkg) {
+      const legacyInclude = path.join(absSource, 'include');
+      try {
+        if (fs.lstatSync(legacyInclude).isDirectory()) {
+          fs.rmSync(legacyInclude, {recursive: true, force: true});
+          log(
+            `Removed legacy in-place include/: ${path.relative(appRoot, legacyInclude)}`,
+          );
+        }
+      } catch {
+        // not present – fine
       }
-    } catch {
-      // not present – fine
     }
   }
 }

packages/react-native/scripts/spm/generate-spm-xcodeproj.js

@@ -96,6 +96,10 @@ type BuildSettingChange = {
   createdArrayKeys: Array<string>,
   appendedArrayValues: {[string]: Array<string>},
   createdScalars: Array<string>,
+  // Scalars whose pre-injection value was replaced (key → original raw
+  // value), e.g. a ${PODS_ROOT}-anchored REACT_NATIVE_PATH that dangles once
+  // CocoaPods is deintegrated. Deinit restores the original.
+  replacedScalars?: {[string]: string},
 };
 type SpmGraph = {
   uniquePackages: Array<{packagePath: string, packageName: string}>,
@@ -942,19 +946,44 @@ function mergeReactBuildSettings(
     }
     text = addArrayStringValues(text, d, key, values);
   }
+  const replacedScalars /*: {[string]: string} */ = {};
   for (const {key, value} of scalars) {
     const d = dict();
     if (d == null) {
       continue;
     }
-    if (findField(text, d, key) == null) {
+    const existing = findField(text, d, key);
+    if (existing == null) {
       createdScalars.push(key);
+    } else if (
+      key === 'REACT_NATIVE_PATH' &&
+      existing.value.includes('PODS_ROOT')
+    ) {
+      // A ${PODS_ROOT}-anchored REACT_NATIVE_PATH (the CocoaPods template
+      // default) dangles once CocoaPods is deintegrated: PODS_ROOT resolves
+      // empty at build time, so the Bundle React Native code and images
+      // phase looks for "/../…/scripts/xcode/with-environment.sh". Replace
+      // it with the SPM-computed path, recording the original for deinit.
+      replacedScalars[key] = existing.value;
+      text = removeField(text, d, key);
+      const d2 = dict();
+      if (d2 == null) {
+        continue;
+      }
+      text = ensureScalarField(text, d2, key, value);
+      continue;
     }
     text = ensureScalarField(text, d, key, value);
   }
   return {
     text,
-    change: {configUuid, createdArrayKeys, appendedArrayValues, createdScalars},
+    change: {
+      configUuid,
+      createdArrayKeys,
+      appendedArrayValues,
+      createdScalars,
+      replacedScalars,
+    },
   };
 }
 
@@ -1270,6 +1299,17 @@ function removeSpmInjection(
         text = removeField(text, d, key);
       }
     }
+    const replaced = change.replacedScalars ?? {};
+    for (const key of Object.keys(replaced)) {
+      const d = dict();
+      if (d != null) {
+        text = removeField(text, d, key);
+        const d2 = dict();
+        if (d2 != null) {
+          text = ensureScalarField(text, d2, key, replaced[key]);
+        }
+      }
+    }
   }
 
   writeIfChanged(pbxprojPath, text);

packages/react-native/scripts/spm/scaffold-package-swift.js

@@ -390,6 +390,18 @@ function translatePodspecToSpmTarget(
       );
     }
   }
+  // Never self-ingest scaffold artifacts: a re-scaffold runs with the
+  // previous run's output on disk, and root-level podspec globs sweep it
+  // into sources — `*.{h,...,swift}` matches Package.swift itself, whose
+  // `.swift` extension then trips the mixed-language gate into DELETING the
+  // manifest it just wrote (alternating scaffold/self-destruct runs); the
+  // prefix header and the include/ shim mirror would similarly feed back.
+  expandedSources = expandedSources.filter(
+    f =>
+      f !== SCAFFOLD_PREFIX_HEADER &&
+      f !== 'Package.swift' &&
+      !f.startsWith('include/'),
+  );
 
   // Header-map emulation: CocoaPods builds a header map (USE_HEADERMAP=YES by
   // default) so a source can `#import "Foo.h"` by bare name regardless of which
@@ -457,6 +469,22 @@ function translatePodspecToSpmTarget(
       }
     }
   }
+  let namespacedShimHeaders /*: Array<string> */ = [];
+  if (publicHeadersPath == null) {
+    // Root-level podspecs (`s.source_files = "*.{h,m,mm}"`) keep their
+    // headers in the package root. CocoaPods exposes them to dependents as
+    // `#import <PodName/Header.h>` via header maps; SPM has no equivalent, so
+    // the scaffold writer mirrors them into a generated include/<SwiftName>/
+    // shim dir and publicHeadersPath points there (also fixing SPM's
+    // rejection over the nonexistent default `include/`).
+    const rootHeaders = expandedSources.filter(
+      f => f.endsWith('.h') && !f.includes('/'),
+    );
+    if (rootHeaders.length > 0) {
+      namespacedShimHeaders = rootHeaders;
+      publicHeadersPath = 'include';
+    }
+  }
   if (publicHeadersPath == null) {
     warnings.push(
       `Could not infer publicHeadersPath from source globs. SPM may reject the target — add a publicHeadersPath manually to the scaffolded Package.swift.`,
@@ -475,6 +503,7 @@ function translatePodspecToSpmTarget(
     weakFrameworks: model.weakFrameworks,
     compilerFlags: model.compilerFlags,
     publicHeadersPath,
+    namespacedShimHeaders,
     resources: model.resources,
     warnings,
   };
@@ -960,6 +989,23 @@ function scaffoldPackageSwiftForDep(
         'utf8',
       );
     }
+    // Mirror root-level headers into the generated include/<SwiftName>/ shim
+    // dir (publicHeadersPath) so dependents can use the CocoaPods header-map
+    // spelling `#import <SwiftName/Header.h>`.
+    if (spec.namespacedShimHeaders.length > 0) {
+      const shimDir = path.join(dep.root, 'include', spec.swiftName);
+      fs.mkdirSync(shimDir, {recursive: true});
+      for (const header of spec.namespacedShimHeaders) {
+        fs.writeFileSync(
+          path.join(shimDir, header),
+          `// AUTO-SCAFFOLDED by react-native spm scaffold — the namespaced\n` +
+            `// spelling (<${spec.swiftName}/${header}>) of the package-root header,\n` +
+            `// matching how CocoaPods header maps expose it.\n` +
+            `#import "../../${header}"\n`,
+          'utf8',
+        );
+      }
+    }
   }
 
   return {
@@ -1070,6 +1116,21 @@ function scaffoldAll(
     const podspecPath = dep.platforms?.ios?.podspecPath;
     if (typeof podspecPath === 'string' && podspecPath.length > 0) {
       podToNpm.set(path.basename(podspecPath, '.podspec'), dep.name);
+    } else {
+      // Transitive entries synthesized by expandSpmDependencies (declared via
+      // `spm.dependencies` in react-native.config.js) carry no podspecPath —
+      // discover the podspec at the dep root so podspec-name sibling deps
+      // (e.g. `s.dependency "TestLibraryCommon"`) still wire to their npm
+      // package.
+      try {
+        for (const f of fs.readdirSync(dep.root)) {
+          if (f.endsWith('.podspec')) {
+            podToNpm.set(path.basename(f, '.podspec'), dep.name);
+          }
+        }
+      } catch {
+        // unreadable dep root — sibling wiring falls back to the warning path
+      }
     }
   }
 

packages/react-native/scripts/spm/spm-types.js

@@ -338,6 +338,11 @@ export type SpmScaffoldSpec = {
   // Public-headers strategy. `mappingsDir` (when set) drives publicHeadersPath
   // so the autolinker's centralized headers tree exposes `#import <SwiftName/...>`.
   publicHeadersPath: ?string,
+  // Root-level headers (podspecs like `s.source_files = "*.{h,m,mm}"`) that the
+  // scaffold writer mirrors into a generated include/<SwiftName>/ shim dir so
+  // the CocoaPods header-map spelling `#import <SwiftName/Header.h>` resolves
+  // for dependents (publicHeadersPath is then "include").
+  namespacedShimHeaders: Array<string>,
   // File paths (relative to dep root) the emitter should declare as `.copy(...)`
   // resources on the target.
   resources: Array<string>,