[iOS][SPM] Refresh the platform floor of scaffolded manifests on add/update

`spm add` and `spm update` now rewrite the `platforms: [.iOS(...)]` element
of every scaffolded manifest carrying the scaffolder marker to the app's
deployment target, covering the `.iOS(.v15)` form older scaffolds carry.
Nothing else in the file is touched and no scaffold is created; the full
re-render stays with `spm scaffold`.

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

Author: chrfalch

packages/react-native/scripts/setup-apple-spm.js

@@ -107,7 +107,10 @@ const {
   MIN_IOS_VERSION_SUPPORTED,
   resolveIosDeploymentTarget,
 } = require('./spm/ios-deployment-target');
-const {scaffoldAll} = require('./spm/scaffold-package-swift');
+const {
+  refreshScaffoldedPlatformFloors,
+  scaffoldAll,
+} = require('./spm/scaffold-package-swift');
 const {
   RemoteVersionError,
   buildPerAppHeaderTree,
@@ -1226,6 +1229,25 @@ async function main(argv /*:: ?: Array<string> */) /*: Promise<void> */ {
   }
 
   runCodegenStep(projectRoot, appRoot, reactNativeRoot, args.skipCodegen);
+
+  // A manifest scaffolded before the app's deployment target changed (or by a
+  // pre-v20 scaffolder) would pin a floor SwiftPM then refuses to link against.
+  if (
+    (action === 'add' || action === 'update') &&
+    autolinkingConfigResult != null
+  ) {
+    for (const refreshed of refreshScaffoldedPlatformFloors({
+      appRoot,
+      autolinkingJsonPath: autolinkingConfigResult.outputPath,
+      iosDeploymentTarget,
+    })) {
+      log(
+        `Refreshed platform floor in ${path.relative(appRoot, refreshed.path)}: ` +
+          `${refreshed.from} → ${refreshed.to}`,
+      );
+    }
+  }
+
   log('Generating build/generated/autolinking/Package.swift...');
   try {
     generateAutolinking([

packages/react-native/scripts/spm/__docs__/spm-scripts.md

@@ -228,9 +228,10 @@ raise the deployment target in Xcode and re-run `react-native spm update`.
 
 A floor set in an `.xcconfig` your configuration is based on is honored,
 `#include` chains included; one set through a build-setting variable
-(`$(MY_FLOOR)`) is not, and falls back to React Native's minimum. Scaffolded
-packages keep the floor they were scaffolded with until you re-run
-`react-native spm scaffold`.
+(`$(MY_FLOOR)`) is not, and falls back to React Native's minimum. `spm add` and
+`spm update` also refresh the platform-floor line of existing scaffolded
+manifests (they never create new ones) — if you persisted a scaffold with
+`patch-package`, re-run `npx patch-package <dep>` afterwards.
 
 ## Files the tool touches
 

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

@@ -14,6 +14,7 @@ const {
   SCAFFOLDER_MARKER,
   SCAFFOLDER_VERSION,
   emitScaffoldedPackageSwift,
+  refreshScaffoldedPlatformFloors,
   scaffoldAll,
   scaffoldPackageSwiftForDep,
   translatePodspecToSpmTarget,
@@ -1336,3 +1337,152 @@ describe('scaffoldPackageSwiftForDep — version-based regen', () => {
     expect(result.status).toBe('skipped-scaffolder-marker');
   });
 });
+
+// ---------------------------------------------------------------------------
+// refreshScaffoldedPlatformFloors — `spm add`/`update` bring the floor of
+// manifests scaffolded earlier (possibly by an older generator) up to the
+// app's current deployment target, without regenerating them.
+// ---------------------------------------------------------------------------
+
+describe('refreshScaffoldedPlatformFloors', () => {
+  let appRoot;
+
+  beforeEach(() => {
+    appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'spm-refresh-floor-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(appRoot, {recursive: true, force: true});
+  });
+
+  function manifest(floorLine) {
+    return (
+      `// swift-tools-version: 6.0\n${SCAFFOLDER_MARKER}\n` +
+      '// AUTO-SCAFFOLDED-VERSION: 19\n\nlet package = Package(\n' +
+      '    name: "foo",\n' +
+      `    ${floorLine}\n` +
+      '    products: [],\n)\n'
+    );
+  }
+
+  // One dep per entry: `content` is written to <root>/Package.swift unless null.
+  function writeApp(deps) {
+    const autolinkingDir = path.join(appRoot, 'build/generated/autolinking');
+    fs.mkdirSync(autolinkingDir, {recursive: true});
+    const dependencies = {};
+    for (const [name, content] of Object.entries(deps)) {
+      const root = path.join(appRoot, 'node_modules', name);
+      fs.mkdirSync(root, {recursive: true});
+      if (content != null) {
+        fs.writeFileSync(path.join(root, 'Package.swift'), content, 'utf8');
+      }
+      dependencies[name] = {root, platforms: {ios: {}}};
+    }
+    fs.writeFileSync(
+      path.join(autolinkingDir, 'autolinking.json'),
+      JSON.stringify({dependencies}),
+    );
+  }
+
+  function refresh() {
+    return refreshScaffoldedPlatformFloors({
+      appRoot,
+      iosDeploymentTarget: '16.4',
+    });
+  }
+
+  function read(depName) {
+    return fs.readFileSync(
+      path.join(appRoot, 'node_modules', depName, 'Package.swift'),
+      'utf8',
+    );
+  }
+
+  it('rewrites only the platform line of a scaffolded manifest', () => {
+    const before = manifest('platforms: [.iOS("15.1")],');
+    writeApp({'react-native-foo': before});
+
+    expect(refresh()).toEqual([
+      {
+        depName: 'react-native-foo',
+        path: path.join(appRoot, 'node_modules/react-native-foo/Package.swift'),
+        from: '15.1',
+        to: '16.4',
+      },
+    ]);
+    expect(read('react-native-foo')).toBe(
+      before.replace('.iOS("15.1")', '.iOS("16.4")'),
+    );
+  });
+
+  it('rewrites the enum form an older scaffolder emitted', () => {
+    writeApp({'react-native-foo': manifest('platforms: [.iOS(.v15)],')});
+
+    expect(refresh()).toEqual([
+      expect.objectContaining({from: '.v15', to: '16.4'}),
+    ]);
+    expect(read('react-native-foo')).toContain('platforms: [.iOS("16.4")]');
+  });
+
+  it('rewrites only the .iOS element of an extended platforms array', () => {
+    writeApp({
+      'react-native-foo': manifest(
+        'platforms: [.iOS("15.1"), .macOS(.v13), .tvOS("16.0")],',
+      ),
+    });
+
+    expect(refresh()).toEqual([expect.objectContaining({from: '15.1'})]);
+    expect(read('react-native-foo')).toContain(
+      'platforms: [.iOS("16.4"), .macOS(.v13), .tvOS("16.0")],',
+    );
+  });
+
+  it('leaves a manifest already on the floor untouched', () => {
+    writeApp({'react-native-foo': manifest('platforms: [.iOS("16.4")],')});
+    const manifestPath = path.join(
+      appRoot,
+      'node_modules/react-native-foo/Package.swift',
+    );
+    const before = fs.statSync(manifestPath).mtimeMs;
+
+    expect(refresh()).toEqual([]);
+    expect(fs.statSync(manifestPath).mtimeMs).toBe(before);
+  });
+
+  it('ignores manifests it does not own, and deps with none', () => {
+    const upstream = '// hand-authored\nplatforms: [.iOS("15.1")],\n';
+    const autogen = `// AUTO-GENERATED by scripts/generate-spm-autolinking.js\n${SCAFFOLDER_MARKER}\nplatforms: [.iOS("15.1")],\n`;
+    writeApp({
+      'react-native-upstream': upstream,
+      'react-native-autogen': autogen,
+      'react-native-none': null,
+    });
+
+    expect(refresh()).toEqual([]);
+    expect(read('react-native-upstream')).toBe(upstream);
+    expect(read('react-native-autogen')).toBe(autogen);
+  });
+
+  it('returns nothing when there is no autolinking.json', () => {
+    expect(refresh()).toEqual([]);
+  });
+
+  it('honors an autolinking.json written outside the default location', () => {
+    writeApp({'react-native-foo': manifest('platforms: [.iOS("15.1")],')});
+    const moved = path.join(appRoot, 'elsewhere', 'autolinking.json');
+    fs.mkdirSync(path.dirname(moved));
+    fs.renameSync(
+      path.join(appRoot, 'build/generated/autolinking/autolinking.json'),
+      moved,
+    );
+
+    expect(refresh()).toEqual([]);
+    expect(
+      refreshScaffoldedPlatformFloors({
+        appRoot,
+        autolinkingJsonPath: moved,
+        iosDeploymentTarget: '16.4',
+      }),
+    ).toEqual([expect.objectContaining({depName: 'react-native-foo'})]);
+  });
+});

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

@@ -1081,6 +1081,81 @@ function scaffoldPackageSwiftForDep(
   };
 }
 
+// The `.iOS(...)` element of the emitted platforms array — the `.v15` enum form
+// pre-v20 scaffolds carry included, and without the array's closing bracket so
+// a user-extended array (`[.iOS(…), .macOS(…)]`) is still matched.
+const PLATFORM_FLOOR_RE = /platforms: \[\.iOS\((\.v\d+|"[^"]*")\)/;
+
+/**
+ * Bring the platform floor of already-scaffolded manifests up to the app's
+ * deployment target — `spm add`/`update` must not leave a dep pinned below the
+ * app (SwiftPM would refuse to link it), and re-scaffolding is the user's call.
+ * Only the platform line of a file carrying our own marker is rewritten; no
+ * file is created. `from` is the previous token, verbatim (`15.1` or `.v15`).
+ */
+function refreshScaffoldedPlatformFloors(
+  opts /*: {appRoot: string, autolinkingJsonPath?: string, iosDeploymentTarget: string} */,
+) /*: Array<{depName: string, path: string, from: string, to: string}> */ {
+  const {appRoot, iosDeploymentTarget} = opts;
+  const autolinkingJsonPath =
+    opts.autolinkingJsonPath ??
+    path.join(appRoot, 'build', 'generated', 'autolinking', 'autolinking.json');
+  const refreshed = [];
+
+  let deps;
+  try {
+    // $FlowFixMe[incompatible-type] JSON.parse returns any
+    deps = JSON.parse(
+      fs.readFileSync(autolinkingJsonPath, 'utf8'),
+    ).dependencies;
+  } catch {
+    return refreshed;
+  }
+  if (deps == null) {
+    return refreshed;
+  }
+
+  for (const depName of Object.keys(deps)) {
+    const root = deps[depName]?.root;
+    if (typeof root !== 'string') {
+      continue;
+    }
+    const manifestPath = path.join(root, 'Package.swift');
+    let content;
+    try {
+      content = fs.readFileSync(manifestPath, 'utf8');
+    } catch {
+      continue;
+    }
+    if (
+      !content.includes(SCAFFOLDER_MARKER) ||
+      content.includes(AUTOGEN_MARKER)
+    ) {
+      continue;
+    }
+    const match = content.match(PLATFORM_FLOOR_RE);
+    if (match == null) {
+      continue;
+    }
+    const from = match[1].replace(/"/g, '');
+    if (from === iosDeploymentTarget) {
+      continue;
+    }
+    fs.writeFileSync(
+      manifestPath,
+      content.replace(match[0], `platforms: [.iOS("${iosDeploymentTarget}")`),
+      'utf8',
+    );
+    refreshed.push({
+      depName,
+      path: manifestPath,
+      from,
+      to: iosDeploymentTarget,
+    });
+  }
+  return refreshed;
+}
+
 // ---------------------------------------------------------------------------
 // Multi-dep orchestrator
 // ---------------------------------------------------------------------------
@@ -1248,6 +1323,7 @@ function scaffoldAll(
 }
 
 module.exports = {
+  refreshScaffoldedPlatformFloors,
   scaffoldAll,
   scaffoldPackageSwiftForDep,
   translatePodspecToSpmTarget,