feat(spm): support self-managed Package.swift under <dep>/ios/

Probe both <dep>/Package.swift and <dep>/ios/Package.swift so community RN
libraries can co-locate their hand-authored SPM manifest with their iOS
sources, keeping the npm-package root free of SPM artifacts (.build/,
.swiftpm/, Package.resolved).

- generate-spm-autolinking.js: replace local isSelfManagedPackage with a
  module-scope findSelfManagedPackageDir that returns the actual manifest
  directory. The aggregator's .package(path:) now points at the resolved
  dir, so for the nested layout SPM resolves against <dep>/ios. Headers
  tree still walks from the dep root so cross-package includes stay
  complete. AUTOGEN_MARKER lifted to module scope and exported.
- scaffold-package-swift.js: skip-rule also probes <dep>/ios/Package.swift
  so the scaffolder never writes a stray root manifest that would shadow
  a hand-authored nested one.
- Tests: 6 findSelfManagedPackageDir cases (none / root / autogen-marker
  rejection / nested-only / root-preferred / fallback-when-root-is-autogen)
  plus 1 scaffolder case for the nested skip-rule. 222 spm tests pass.

Author: chrfalch

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

@@ -11,8 +11,10 @@
 'use strict';
 
 const {
+  AUTOGEN_MARKER,
   collectSpmSources,
   expandSpmSourceGlobs,
+  findSelfManagedPackageDir,
   generateAutolinkedPackageSwift,
   generateSynthPackageSwift,
   linkHeaderTree,
@@ -657,3 +659,79 @@ describe('generateSynthPackageSwift (spm.name override)', () => {
     expect(result).not.toContain('ReactNativeWorklets');
   });
 });
+
+// ---------------------------------------------------------------------------
+// findSelfManagedPackageDir — detects hand-authored Package.swift at either
+// the dep root or under ios/. The nested layout lets community libraries
+// keep their npm-package root free of SPM artifacts (.build/, .swiftpm/).
+// ---------------------------------------------------------------------------
+
+describe('findSelfManagedPackageDir', () => {
+  let depRoot;
+
+  beforeEach(() => {
+    depRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'spm-selfmgd-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(depRoot, {recursive: true, force: true});
+  });
+
+  it('returns null when no Package.swift exists at any candidate location', () => {
+    expect(findSelfManagedPackageDir(depRoot)).toBe(null);
+  });
+
+  it('returns the dep root when <dep>/Package.swift exists without the AUTOGEN marker', () => {
+    fs.writeFileSync(
+      path.join(depRoot, 'Package.swift'),
+      '// swift-tools-version: 6.0\n// Hand-authored.\n',
+    );
+    expect(findSelfManagedPackageDir(depRoot)).toBe(depRoot);
+  });
+
+  it('returns null when <dep>/Package.swift carries the AUTOGEN marker', () => {
+    fs.writeFileSync(
+      path.join(depRoot, 'Package.swift'),
+      AUTOGEN_MARKER + '\n// synth wrapper content\n',
+    );
+    expect(findSelfManagedPackageDir(depRoot)).toBe(null);
+  });
+
+  it('returns <dep>/ios when only the nested manifest exists and lacks the AUTOGEN marker', () => {
+    fs.mkdirSync(path.join(depRoot, 'ios'));
+    fs.writeFileSync(
+      path.join(depRoot, 'ios', 'Package.swift'),
+      '// swift-tools-version: 6.0\n// Hand-authored nested manifest.\n',
+    );
+    expect(findSelfManagedPackageDir(depRoot)).toBe(path.join(depRoot, 'ios'));
+  });
+
+  it('prefers the root manifest when both root and nested manifests exist', () => {
+    fs.writeFileSync(
+      path.join(depRoot, 'Package.swift'),
+      '// Root manifest.\n',
+    );
+    fs.mkdirSync(path.join(depRoot, 'ios'));
+    fs.writeFileSync(
+      path.join(depRoot, 'ios', 'Package.swift'),
+      '// Nested manifest.\n',
+    );
+    expect(findSelfManagedPackageDir(depRoot)).toBe(depRoot);
+  });
+
+  it('falls back to the nested manifest when the root one is autolinker-generated', () => {
+    // Models the transition state: dep was previously autolinker-wrapped and
+    // recently shipped its own ios/Package.swift. The root file (a leftover
+    // synth manifest from a prior run) shouldn't shadow the hand-authored one.
+    fs.writeFileSync(
+      path.join(depRoot, 'Package.swift'),
+      AUTOGEN_MARKER + '\n// stale synth\n',
+    );
+    fs.mkdirSync(path.join(depRoot, 'ios'));
+    fs.writeFileSync(
+      path.join(depRoot, 'ios', 'Package.swift'),
+      '// Hand-authored nested manifest.\n',
+    );
+    expect(findSelfManagedPackageDir(depRoot)).toBe(path.join(depRoot, 'ios'));
+  });
+});

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

@@ -470,6 +470,26 @@ end
     );
   });
 
+  it('refuses to scaffold when a nested ios/Package.swift exists without markers', () => {
+    makePodspec();
+    // Library ships its manifest under ios/ to keep the npm-package root
+    // free of SPM artifacts. The scaffolder should NOT write a stray root
+    // Package.swift — that would shadow the nested one (the autolinker
+    // checks the root first).
+    fs.mkdirSync(path.join(depRoot, 'ios'), {recursive: true});
+    const nestedContent =
+      '// swift-tools-version: 6.0\n// Hand-written nested manifest.\n';
+    fs.writeFileSync(path.join(depRoot, 'ios', 'Package.swift'), nestedContent);
+    const result = scaffoldPackageSwiftForDep(makeDep(), makeCtx());
+    expect(result.status).toBe('skipped-self-managed');
+    // Root stayed clean
+    expect(fs.existsSync(path.join(depRoot, 'Package.swift'))).toBe(false);
+    // Nested file untouched
+    expect(
+      fs.readFileSync(path.join(depRoot, 'ios', 'Package.swift'), 'utf8'),
+    ).toBe(nestedContent);
+  });
+
   it('refuses to overwrite a Package.swift carrying the autolinker AUTOGEN_MARKER', () => {
     makePodspec();
     fs.writeFileSync(

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

@@ -210,6 +210,45 @@ const SKIP_DIRS_DEFAULT /*: $ReadOnlySet<string> */ = new Set([
 // like "<WRAPPER_ROOT_NAME>/Foo.mm" by following this link.
 const WRAPPER_ROOT_NAME = 'root';
 
+// Marker the autolinker stamps onto every synth Package.swift it writes.
+// Files lacking this marker are treated as user-managed (self-managed) and
+// are referenced directly rather than wrapped — see findSelfManagedPackageDir.
+const AUTOGEN_MARKER =
+  '// AUTO-GENERATED by scripts/generate-spm-autolinking.js';
+
+/**
+ * A dep is "self-managed" when it ships a hand-written Package.swift
+ * (i.e. one that lacks our AUTOGEN_MARKER). The autolinker skips wrapping
+ * it and references the manifest's directory directly — useful for
+ * libraries that want to ship a real SPM manifest and have full control
+ * over their target settings.
+ *
+ * Two layouts are recognized:
+ *   1. <dep>/Package.swift            — manifest at the npm-package root
+ *   2. <dep>/ios/Package.swift        — manifest co-located with ObjC
+ *                                       sources, keeping the npm-package
+ *                                       root free of SPM artifacts
+ *                                       (.build/, .swiftpm/, Package.resolved)
+ *
+ * Returns the directory that contains the hand-authored manifest, or null
+ * when no candidate exists. That directory is what the aggregator hands to
+ * SPM as `.package(path:)` — for layout 2 that means `<dep>/ios`.
+ */
+function findSelfManagedPackageDir(absSource /*: string */) /*: ?string */ {
+  for (const sub of ['', 'ios']) {
+    const dir = sub === '' ? absSource : path.join(absSource, sub);
+    try {
+      const content = fs.readFileSync(path.join(dir, 'Package.swift'), 'utf8');
+      if (!content.includes(AUTOGEN_MARKER)) {
+        return dir;
+      }
+    } catch {
+      // candidate does not exist; try the next one
+    }
+  }
+  return null;
+}
+
 /**
  * Mirrors every header file under `srcDir` as a relative symlink at the same
  * relative location under `destDir`. Used for the centralized cross-package
@@ -1123,24 +1162,6 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
   const hasXcfwHeaders = xcframeworksRelPath != null;
   const hasDepsHeaders = xcframeworksRelPath != null;
 
-  const AUTOGEN_MARKER =
-    '// AUTO-GENERATED by scripts/generate-spm-autolinking.js';
-
-  // A dep is "self-managed" when its source dir ships a hand-written
-  // Package.swift (i.e. one that lacks our AUTOGEN_MARKER). The autolinker
-  // skips wrapping it and references the dep's source dir directly — useful
-  // for libraries that want to ship a real SPM manifest and have full
-  // control over their target settings.
-  const isSelfManagedPackage = (absSource /*: string */) /*: boolean */ => {
-    const pkgSwift = path.join(absSource, 'Package.swift');
-    try {
-      const content = fs.readFileSync(pkgSwift, 'utf8');
-      return !content.includes(AUTOGEN_MARKER);
-    } catch {
-      return false;
-    }
-  };
-
   // Each entry gets a wrapper dir at <outputDir>/packages/<SwiftName>/ that
   // contains the synth Package.swift and a `root` directory symlink pointing
   // at the dep's real source dir. SPM derives package identity from the path
@@ -1173,8 +1194,12 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
       log(`Skipping ${target.name}: source dir missing (${absSource})`);
       continue;
     }
-    if (isSelfManagedPackage(absSource)) {
-      selfManagedDirs.set(target.name, absSource);
+    const selfManagedDir = findSelfManagedPackageDir(absSource);
+    if (selfManagedDir != null) {
+      // Record the manifest's actual directory — for the nested layout this
+      // is <dep>/ios, not <dep>. SPM resolves `.package(path:)` against that
+      // directory expecting Package.swift to live alongside.
+      selfManagedDirs.set(target.name, selfManagedDir);
       // If a wrapper exists from a prior synth-mode run (i.e. the dep WAS
       // autolinker-wrapped, then later transitioned to self-managed via
       // `spm scaffold` or shipping its own Package.swift), remove the
@@ -1188,7 +1213,7 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
         log(`Removed stale wrapper: packages/${target.name}/`);
       }
       log(
-        `Self-managed: ${target.name} → ${path.relative(appRoot, absSource)} (using its own Package.swift)`,
+        `Self-managed: ${target.name} → ${path.relative(appRoot, selfManagedDir)} (using its own Package.swift)`,
       );
       continue;
     }
@@ -1224,10 +1249,16 @@ function main(argv /*:: ?: Array<string> */) /*: void */ {
     // by file path — synth packages use `-fno-implicit-module-maps`, so
     // we can't rely on SPM's auto-generated module map alone.
     if (selfManagedDirs.has(target.name)) {
+      // Centralized headers tree walks the WHOLE dep root, not just the
+      // manifest's directory — headers may live anywhere (e.g. common/cpp/
+      // outside of ios/), and cross-package consumers should still resolve
+      // them via the centralized -I path.
       linkHeaderTree(absSource, path.join(headersDir, target.name));
+      // packagePath is the directory containing Package.swift — for the
+      // nested layout this is <dep>/ios, not the dep root.
       aggregatorPackageDeps.push({
         swiftName: target.name,
-        packagePath: absSource,
+        packagePath: selfManagedDirs.get(target.name) ?? absSource,
       });
       continue;
     }
@@ -1473,4 +1504,6 @@ module.exports = {
   linkHeaderTree,
   collectSpmSources,
   expandSpmSourceGlobs,
+  findSelfManagedPackageDir,
+  AUTOGEN_MARKER,
 };

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

@@ -493,6 +493,28 @@ function scaffoldPackageSwiftForDep(
 
   const pkgSwiftPath = path.join(dep.root, 'Package.swift');
 
+  // A self-managed Package.swift may live either at the dep root (legacy
+  // convention) or inside ios/ (preferred for community RN libs that want
+  // their npm-package root free of SPM artifacts). If a nested manifest
+  // exists and is user-authored, skip — writing a stray root manifest would
+  // cause the autolinker to prefer the wrong file.
+  const nestedPkgSwiftPath = path.join(dep.root, 'ios', 'Package.swift');
+  if (!fs.existsSync(pkgSwiftPath) && fs.existsSync(nestedPkgSwiftPath)) {
+    const nested = fs.readFileSync(nestedPkgSwiftPath, 'utf8');
+    if (
+      !nested.includes(AUTOGEN_MARKER) &&
+      !nested.includes(SCAFFOLDER_MARKER)
+    ) {
+      return {
+        depName,
+        status: 'skipped-self-managed',
+        reason:
+          'Existing ios/Package.swift was not produced by this scaffolder. ' +
+          'Leaving it alone.',
+      };
+    }
+  }
+
   // Skip rules around existing files.
   if (fs.existsSync(pkgSwiftPath)) {
     const existing = fs.readFileSync(pkgSwiftPath, 'utf8');