react-native-tvos 0.87.0-0rc3 → 0.87.1-0

package/scripts/replace-rncore-version.js

@@ -18,6 +18,9 @@ const yargs = require('yargs');
 
 const LAST_BUILD_FILENAME = 'React-Core-prebuilt/.last_build_configuration';
 
+// Not a valid configuration, so finding it means the swap did not finish.
+const REPLACEMENT_IN_PROGRESS = 'in-progress';
+
 function validateBuildConfiguration(configuration /*: string */) {
   if (!['Debug', 'Release'].includes(configuration)) {
     throw new Error(`Invalid configuration ${configuration}`);
@@ -42,10 +45,12 @@ function shouldReplaceRnCoreConfiguration(configuration /*: string */) {
       );
       return false;
     }
+    return true;
   }
 
-  // Assumption: if there is no stored last build, we assume that it was build for debug.
-  if (!fileExists && configuration === 'Debug') {
+  // With no marker the on-disk flavor is Debug: the podspec installs the debug
+  // tarball (see resolve_podspec_source in scripts/cocoapods/rncore.rb).
+  if (configuration === 'Debug') {
     console.log(
       'No previous build detected, but Debug Configuration. No need to replace React-Core-prebuilt',
     );
@@ -59,7 +64,7 @@ function replaceRNCoreConfiguration(
   configuration /*: string */,
   version /*: string */,
   podsRoot /*: string */,
-) {
+) /*: void */ {
   // Filename comes from rncore.rb
   const tarballURLPath = `${podsRoot}/ReactNativeCore-artifacts/reactnative-core-${version.toLowerCase()}-${configuration.toLowerCase()}.tar.gz`;
 
@@ -73,18 +78,6 @@ function replaceRNCoreConfiguration(
   const tmpExtractDir = path.join(tmpDir, 'React-Core-prebuilt');
   fs.mkdirSync(tmpExtractDir, {recursive: true});
 
-  // Preserve Expo-generated modulemap before replacing directories
-  const useFrameworksModulemapName = 'React-use-frameworks.modulemap';
-  const useFrameworksModulemapPath = path.join(
-    finalLocation,
-    useFrameworksModulemapName,
-  );
-  let savedModulemap = null;
-  if (fs.existsSync(useFrameworksModulemapPath)) {
-    console.log('Preserving', useFrameworksModulemapName);
-    savedModulemap = fs.readFileSync(useFrameworksModulemapPath);
-  }
-
   try {
     console.log('Extracting the tarball to temp dir', tarballURLPath);
     const result = spawnSync(
@@ -110,98 +103,30 @@ function replaceRNCoreConfiguration(
       );
     }
 
-    // Delete only directories in finalLocation (e.g. the React.xcframework) -
-    // not files, so any sibling files written during pod install are preserved.
-    const dirs = fs
-      .readdirSync(finalLocation, {withFileTypes: true})
-      .filter(dirent => dirent.isDirectory());
-    for (const dirent of dirs) {
-      const direntName =
-        typeof dirent.name === 'string' ? dirent.name : dirent.name.toString();
-      const dirPath = `${finalLocation}/${direntName}`;
-      console.log('Removing directory', dirPath);
-      fs.rmSync(dirPath, {force: true, recursive: true});
-    }
-
-    // Move extracted directories from temp to final location
-    const extractedEntries = fs
-      .readdirSync(tmpExtractDir, {withFileTypes: true})
-      .filter(dirent => dirent.isDirectory());
-    for (const dirent of extractedEntries) {
-      const direntName =
-        typeof dirent.name === 'string' ? dirent.name : dirent.name.toString();
-      const src = path.join(tmpExtractDir, direntName);
-      const dst = path.join(finalLocation, direntName);
-      const mvResult = spawnSync('mv', [src, dst], {stdio: 'inherit'});
-      if (mvResult.status !== 0) {
-        // Fallback: copy recursively then remove source
-        console.log(`mv failed for ${direntName}, falling back to cp -R`);
-        const cpResult = spawnSync('cp', ['-R', src, dst], {
-          stdio: 'inherit',
-        });
-        if (cpResult.status !== 0) {
-          throw new Error(
-            `cp fallback failed with exit code ${cpResult.status}`,
-          );
-        }
+    // Replace only the compiled framework. Headers/ is flattened from
+    // ReactNativeHeaders by the podspec prepare_command, and the prebuild
+    // compose job emits one set of those headers for both configurations, so a
+    // config switch leaves them identical. Leaving them alone keeps
+    // Headers/module.modulemap — which consumers activate through
+    // -fmodule-map-file — in place for the whole build; deleting and recreating
+    // it mid-build lets a concurrent dependency scan miss it, and the React
+    // module then precompiles without it (#57803).
+    const dest = path.join(finalLocation, 'React.xcframework');
+    console.log('Replacing', dest);
+    fs.rmSync(dest, {force: true, recursive: true});
+    const mvResult = spawnSync('mv', [xcfwPath, dest], {stdio: 'inherit'});
+    if (mvResult.status !== 0) {
+      // Fallback: copy recursively then remove source
+      console.log('mv failed for React.xcframework, falling back to cp -R');
+      const cpResult = spawnSync('cp', ['-R', xcfwPath, dest], {
+        stdio: 'inherit',
+      });
+      if (cpResult.status !== 0) {
+        throw new Error(`cp fallback failed with exit code ${cpResult.status}`);
       }
     }
-
-    // The podspec prepare_command flattens ReactNativeHeaders' headers into a
-    // top-level Headers/ dir, but it does not re-run on a config swap. Mirror
-    // it here: re-flatten the headers (identical across slices) and drop the
-    // now-redundant xcframework so $(PODS_ROOT)/React-Core-prebuilt/Headers
-    // keeps resolving <react/...>, <yoga/...>, etc.
-    //
-    // Fail closed when the swapped-in tarball lacks ReactNativeHeaders: the
-    // directory purge above already deleted the previous Headers/, so
-    // continuing silently would leave the injected -fmodule-map-file flag
-    // dangling and break every <react/...> include only on a config switch —
-    // with no pointer to the version-skewed artifact that caused it.
-    const rnhXcfw = path.join(finalLocation, 'ReactNativeHeaders.xcframework');
-    if (!fs.existsSync(rnhXcfw)) {
-      throw new Error(
-        `ReactNativeHeaders.xcframework not found in the extracted tarball at ${finalLocation}. ` +
-          'The downloaded artifact predates the headers-spec layout (or is incomplete); ' +
-          'use a prebuilt tarball matching this react-native version.',
-      );
-    }
-    const slice = fs
-      .readdirSync(rnhXcfw, {withFileTypes: true})
-      .find(
-        dirent =>
-          dirent.isDirectory() &&
-          fs.existsSync(path.join(rnhXcfw, dirent.name.toString(), 'Headers')),
-      );
-    if (!slice) {
-      throw new Error(
-        `No slice with a Headers directory found inside ${rnhXcfw}.`,
-      );
-    }
-    const headersDest = path.join(finalLocation, 'Headers');
-    fs.rmSync(headersDest, {force: true, recursive: true});
-    const cpHeaders = spawnSync(
-      'cp',
-      ['-R', path.join(rnhXcfw, slice.name.toString(), 'Headers'), headersDest],
-      {stdio: 'inherit'},
-    );
-    if (cpHeaders.status !== 0) {
-      throw new Error(
-        `Flattening ReactNativeHeaders failed with exit code ${cpHeaders.status}`,
-      );
-    }
-    fs.rmSync(rnhXcfw, {force: true, recursive: true});
   } finally {
-    // Clean up temp directory
     fs.rmSync(tmpDir, {force: true, recursive: true});
-
-    // Restore Expo-generated modulemap after directory replacement.
-    // Runs in finally so it is not skipped if mv/cp partially fails.
-    if (savedModulemap != null) {
-      const restoredPath = path.join(finalLocation, useFrameworksModulemapName);
-      fs.writeFileSync(restoredPath, savedModulemap);
-      console.log('Restored', useFrameworksModulemapName);
-    }
   }
 }
 
@@ -210,6 +135,10 @@ function updateLastBuildConfiguration(configuration /*: string */) {
   fs.writeFileSync(LAST_BUILD_FILENAME, configuration);
 }
 
+function markReplacementInProgress() /*: void */ {
+  fs.writeFileSync(LAST_BUILD_FILENAME, REPLACEMENT_IN_PROGRESS);
+}
+
 function main(
   configuration /*: string */,
   version /*: string */,
@@ -219,37 +148,48 @@ function main(
   validateVersion(version);
 
   if (!shouldReplaceRnCoreConfiguration(configuration)) {
+    // A fresh install leaves no marker; record the flavor we skipped on.
+    if (!fs.existsSync(LAST_BUILD_FILENAME)) {
+      updateLastBuildConfiguration(configuration);
+    }
     return;
   }
 
+  // Invalidate before touching the framework so an interrupted swap is
+  // detectable on the next run.
+  markReplacementInProgress();
   replaceRNCoreConfiguration(configuration, version, podsRoot);
   updateLastBuildConfiguration(configuration);
   console.log('Done replacing React Native prebuilt');
 }
 
-// This script is executed in the Pods folder, which is usually not synched to Github, so it should be ok
-const argv = yargs
-  .option('c', {
-    alias: 'configuration',
-    description:
-      'Configuration to use to download the right React-Core prebuilt version. Allowed values are "Debug" and "Release".',
-  })
-  .option('r', {
-    alias: 'reactNativeVersion',
-    description:
-      'The Version of React Native associated with the React-Core prebuilt tarball.',
-  })
-  .option('p', {
-    alias: 'podsRoot',
-    description: 'The path to the Pods root folder',
-  })
-  .usage('Usage: $0 -c Debug -r <version> -p <path/to/react-native>').argv;
-
-// $FlowFixMe[prop-missing]
-const configuration = argv.configuration;
-// $FlowFixMe[prop-missing]
-const version = argv.reactNativeVersion;
-// $FlowFixMe[prop-missing]
-const podsRoot = argv.podsRoot;
-
-main(configuration, version, podsRoot);
+if (require.main === module) {
+  // This script is executed in the Pods folder, which is usually not synched to Github, so it should be ok
+  const argv = yargs
+    .option('c', {
+      alias: 'configuration',
+      description:
+        'Configuration to use to download the right React-Core prebuilt version. Allowed values are "Debug" and "Release".',
+    })
+    .option('r', {
+      alias: 'reactNativeVersion',
+      description:
+        'The Version of React Native associated with the React-Core prebuilt tarball.',
+    })
+    .option('p', {
+      alias: 'podsRoot',
+      description: 'The path to the Pods root folder',
+    })
+    .usage('Usage: $0 -c Debug -r <version> -p <path/to/react-native>').argv;
+
+  // $FlowFixMe[prop-missing]
+  const configuration = argv.configuration;
+  // $FlowFixMe[prop-missing]
+  const version = argv.reactNativeVersion;
+  // $FlowFixMe[prop-missing]
+  const podsRoot = argv.podsRoot;
+
+  main(configuration, version, podsRoot);
+}
+
+module.exports = {replaceRNCoreConfiguration};

package/scripts/setup-apple-spm.js

@@ -44,8 +44,10 @@
  * directing you to `--deintegrate`).
  *
  * Options:
- *   --version <ver>             React Native version (default: the resolved
- *                               node_modules/react-native version).
+ *   --version <ver>             React Native version. Pinned into
+ *                               .spm-injected.json and reused by later runs
+ *                               until a new one is passed (default: the
+ *                               resolved node_modules/react-native version).
  *   --yes                       Skip the dirty-pbxproj confirmation prompt.
  *   [add] --xcodeproj <path>    Which .xcodeproj to inject into (when several).
  *   [add] --product-name <name> Which app target to inject into (when several).
@@ -55,6 +57,7 @@
  *                               must contain debug/ and release/ cache slots.
  *   [advanced] --download <auto|skip|force> Artifact policy (default: auto).
  *   [advanced] --skip-codegen   Skip the react-native codegen step.
+ *   [advanced] --config-command <json> Override the autolinking config command.
  *
  * Steps performed (add/update):
  *   1. react-native codegen → build/generated/ios/ + install SPM codegen template
@@ -83,14 +86,20 @@ const {
 } = require('./spm/generate-spm-autolinking');
 const {
   generateAutolinkingConfig,
+  parseConfigCommandJson,
+  readEnvConfigCommand,
+  resolveEnvConfigCommand,
 } = require('./spm/generate-spm-autolinking-config');
 const {main: generatePackage} = require('./spm/generate-spm-package');
 const {findSourcePath} = require('./spm/generate-spm-package');
 const {
+  SPM_INJECTED_MARKER,
   cleanupDanglingJavaScriptCoreRef,
   cleanupLeftoverPodsGroup,
   findInjectedXcodeproj,
   injectSpmIntoExistingXcodeproj,
+  readArtifactsVersionOverride,
+  readPinnedConfigCommand,
   removeSpmInjection,
 } = require('./spm/generate-spm-xcodeproj');
 const {scaffoldAll} = require('./spm/scaffold-package-swift');
@@ -147,7 +156,7 @@ function parseArgs(argv /*: Array<string> */) /*: SetupArgs */ {
     .option('version', {
       type: 'string',
       describe:
-        'React Native version (e.g. 0.80.0). Defaults to the version in node_modules/react-native/package.json',
+        'React Native version (e.g. 0.80.0). Sticks: later runs reuse it until you pass a new one. Defaults to the version in node_modules/react-native/package.json',
     })
     .option('yes', {
       type: 'boolean',
@@ -187,6 +196,11 @@ function parseArgs(argv /*: Array<string> */) /*: SetupArgs */ {
       default: false,
       describe: '[advanced] Skip the react-native codegen step',
     })
+    .option('config-command', {
+      type: 'string',
+      describe:
+        '[advanced] JSON array of the argv used to generate autolinking.json, overriding the default @react-native-community/cli config command. Also settable via RCT_SPM_AUTOLINKING_CONFIG_COMMAND. Either way `add`/`update` remembers the value in .spm-injected.json, so later runs and Xcode builds reuse it. Example: \'["npx","expo-modules-autolinking","react-native-config","--json","--platform","ios"]\'',
+    })
     .usage(
       'Usage: $0 [action] [options]\n\nSets up Swift Package Manager support in a React Native app.',
     )
@@ -214,6 +228,10 @@ function parseArgs(argv /*: Array<string> */) /*: SetupArgs */ {
     version: parsed.version ?? null,
     artifacts: parsed.artifacts ?? null,
     skipCodegen: parsed['skip-codegen'],
+    configCommand:
+      parsed['config-command'] != null
+        ? parseConfigCommandJson(parsed['config-command'], '--config-command')
+        : null,
     downloadPolicy: parsed.download,
     productName: parsed['product-name'] ?? null,
     xcodeprojPath: parsed.xcodeproj ?? null,
@@ -362,19 +380,31 @@ function resolveReactNativeRoot(
   return reactNativeRoot;
 }
 
+// Explicit `--version` → the version an earlier `--version` pinned into the
+// injection marker → node_modules/react-native/package.json. The pin makes
+// `--version` stick for later flagless runs, which would otherwise re-point the
+// project at a different artifact slot than the one it was wired to.
 function determineVersion(
   args /*: SetupArgs */,
   reactNativeRoot /*: string */,
+  appRoot /*: string */,
 ) /*: string */ {
-  let version = args.version;
-  if (version == null) {
-    // $FlowFixMe[incompatible-type] JSON.parse returns any
-    const pkgJson /*: {version: string} */ = JSON.parse(
-      fs.readFileSync(path.join(reactNativeRoot, 'package.json'), 'utf8'),
+  if (args.version != null) {
+    return args.version;
+  }
+  const pinned = readArtifactsVersionOverride(appRoot);
+  if (pinned != null) {
+    log(
+      `Using version ${pinned} pinned in ${SPM_INJECTED_MARKER} by an earlier ` +
+        '--version. Pass --version to change it.',
     );
-    version = pkgJson.version;
+    return pinned;
   }
-  return version;
+  // $FlowFixMe[incompatible-type] JSON.parse returns any
+  const pkgJson /*: {version: string} */ = JSON.parse(
+    fs.readFileSync(path.join(reactNativeRoot, 'package.json'), 'utf8'),
+  );
+  return pkgJson.version;
 }
 
 function runCodegenStep(
@@ -427,7 +457,7 @@ async function runScaffold(
   // a comment — that's how SPM's manifest hash bumps on slot transitions.
   let cacheSlotLabel /*: ?string */ = null;
   try {
-    const rawVersion = args.version ?? determineVersion(args, reactNativeRoot);
+    const rawVersion = determineVersion(args, reactNativeRoot, appRoot);
     const slotVersion = await resolveCacheSlotVersion(rawVersion);
     cacheSlotLabel = `${slotVersion}/dual-flavor`;
   } catch {
@@ -833,6 +863,7 @@ async function setupXcodeproj(
     // (injectSpmIntoExistingXcodeproj preserves it — see
     // generate-spm-xcodeproj.js).
     artifactsVersionOverride: args.version ?? null,
+    configCommand: resolveConfigCommandToPin(args),
   });
   if (result.status !== 'injected') {
     logError(`SPM injection failed: ${result.reason}`);
@@ -892,6 +923,88 @@ function logNextSteps(
   log('To remove SPM later: `npx react-native spm deinit`');
 }
 
+// The autolinking config command for this run: an explicit `--config-command`
+// first, then the value a previous `add`/`update` pinned into the injection
+// marker. undefined means "no explicit command", which is what makes
+// generateAutolinkingConfig fall back to RCT_SPM_AUTOLINKING_CONFIG_COMMAND and
+// then to the built-in default — so the pin has to be WITHHELD while the env
+// var is set, or a stale pin would outrank a developer's env override.
+function resolveExplicitConfigCommand(
+  args /*: SetupArgs */,
+  appRoot /*: string */,
+) /*: Array<string> | void */ {
+  if (args.configCommand != null) {
+    return args.configCommand;
+  }
+  if (readEnvConfigCommand() != null) {
+    return undefined;
+  }
+  const pinned = readPinnedConfigCommand(appRoot);
+  if (pinned == null) {
+    return undefined;
+  }
+  log(
+    `Autolinking config command (pinned in ${SPM_INJECTED_MARKER}): ` +
+      pinned.join(' '),
+  );
+  return pinned;
+}
+
+// The command to record in the injection marker. The env var is resolved here
+// too, because the Xcode build phase inherits neither the flag nor the shell
+// that set it — an env-only override that went unpinned would leave the build
+// re-deriving autolinking.json with the default command. null pins nothing and
+// preserves any earlier pin. An invalid env value throws, as the flag does,
+// though `add` has already failed closed on it by this point.
+function resolveConfigCommandToPin(
+  args /*: SetupArgs */,
+) /*: ?Array<string> */ {
+  return args.configCommand ?? resolveEnvConfigCommand();
+}
+
+// Generate autolinking.json, failing closed on a config-command error.
+//
+// generateAutolinkingConfig throws ONLY when the config command itself fails —
+// a non-zero exit, unparseable output, or a config missing
+// project.ios.sourceDir. Swallowing that (the old behavior) let the run proceed
+// and emit an empty Autolinked package, which only surfaced much later as an
+// inscrutable `unable to resolve module dependency` at build time. Instead we
+// set process.exitCode = 2 (a hard Xcode build-phase error, matching the
+// RemoteVersionError path) and return null so the caller stops.
+//
+// A genuinely native-module-free app does NOT reach the error path: its command
+// exits 0 with valid, empty-dependency JSON, so generateAutolinkingConfig
+// returns normally and the empty-package path downstream stays valid.
+function generateAutolinkingConfigOrFailClosed(
+  opts /*: {
+    projectRoot: string,
+    configCommand?: Array<string>,
+    generate?: typeof generateAutolinkingConfig,
+  } */,
+) /*: ?AutolinkingConfigResult */ {
+  const generate = opts.generate ?? generateAutolinkingConfig;
+  try {
+    return generate({
+      projectRoot: opts.projectRoot,
+      configCommand: opts.configCommand,
+    });
+  } catch (e) {
+    logError(
+      `Failed to generate autolinking.json: ${e.message}\n` +
+        'The autolinking config command failed. If this app replaces ' +
+        '@react-native-community/cli autolinking (e.g. an Expo app), set ' +
+        'RCT_SPM_AUTOLINKING_CONFIG_COMMAND (or pass --config-command) to a ' +
+        'JSON argv array whose command prints the React Native CLI config, ' +
+        'e.g. \'["npx","expo-modules-autolinking","react-native-config",' +
+        '"--json","--platform","ios"]\'. An earlier `add`/`update` may also ' +
+        `have pinned a command in ${SPM_INJECTED_MARKER}; re-run with ` +
+        '--config-command to replace a stale one.',
+    );
+    process.exitCode = 2;
+    return null;
+  }
+}
+
 async function main(argv /*:: ?: Array<string> */) /*: Promise<void> */ {
   let appRoot = process.cwd();
   const projectRoot = findProjectRoot(appRoot);
@@ -981,22 +1094,22 @@ async function main(argv /*:: ?: Array<string> */) /*: Promise<void> */ {
   let autolinkingConfigResult /*: ?AutolinkingConfigResult */ = null;
   if (needsCliConfig) {
     log('Generating autolinking.json (CLI config)...');
-    try {
-      autolinkingConfigResult = generateAutolinkingConfig({projectRoot});
-      log(
-        `Wrote ${path.relative(appRoot, autolinkingConfigResult.outputPath)}`,
-      );
-    } catch (e) {
-      logError(
-        `generate-spm-autolinking-config failed: ${e.message}. External native modules may not be discovered.`,
-      );
+    autolinkingConfigResult = generateAutolinkingConfigOrFailClosed({
+      projectRoot,
+      configCommand: resolveExplicitConfigCommand(args, appRoot),
+    });
+    if (autolinkingConfigResult == null) {
+      // Fail closed: the config command errored and the helper already set
+      // process.exitCode = 2. Stop rather than emit an empty Autolinked package.
+      return;
     }
+    log(`Wrote ${path.relative(appRoot, autolinkingConfigResult.outputPath)}`);
   }
   const reactNativeRoot = resolveReactNativeRoot(
     autolinkingConfigResult,
     projectRoot,
   );
-  const version = determineVersion(args, reactNativeRoot);
+  const version = determineVersion(args, reactNativeRoot, appRoot);
   log(`React Native version: ${version}`);
 
   // Resolve remote SPM mode ONCE up front. remotePackageConfig throws
@@ -1158,8 +1271,13 @@ if (require.main === module) {
 module.exports = {
   main,
   detectStandardRnLayoutRedirect,
+  determineVersion,
   findInjectedXcodeproj,
+  generateAutolinkingConfigOrFailClosed,
+  parseArgs,
   resolveAction,
+  resolveConfigCommandToPin,
+  resolveExplicitConfigCommand,
   shouldAutoDeintegrate,
   ensureBothArtifactFlavors,
 };

package/scripts/spm/autolinking-plugins.js

@@ -69,6 +69,14 @@
  *         // dir add/remove there re-triggers the sync. Relative/empty/non-string
  *         // entries are dropped with a warning; a non-array is ignored.
  *         watchPaths: ['/abs/path/Package.swift', '/abs/dir'],
+ *         // Build-time shell phases on the app target — SwiftPM has no
+ *         // `script_phase`. Only id/name/script are required; `id` is the
+ *         // ledger key and UUID seed, `position` defaults to 'end'. Recorded
+ *         // to `.spm-plugin-script-phases.json`, from which the `spm add`/
+ *         // `update` injector emits a PBXShellScriptBuildPhase per entry.
+ *         // Malformed entries and duplicate ids are fatal.
+ *         scriptPhases: [{id, name, script, position, inputPaths, outputPaths,
+ *           alwaysOutOfDate}],
  *       };
  *     };
  *
@@ -76,12 +84,14 @@
  * the merge, so regeneration stays deterministic and idempotent.
  */
 
+const {isValidScriptPhaseId, isValidScriptPhaseName} = require('./spm-utils');
 const path = require('path');
 
 /*:: import type {
   AutolinkedDep,
   PluginContext,
   PluginResult,
+  PluginScriptPhase,
   DiscoveredPlugin,
 } from './spm-types';
 */
@@ -117,7 +127,7 @@ function discoverPlugins(
       );
     }
     const pluginPath = path.resolve(dep.root, rel);
-    let fn: unknown;
+    let fn /*: unknown */ = null;
     try {
       // $FlowFixMe[unsupported-syntax] dynamic require by computed path
       fn = require(pluginPath);
@@ -149,6 +159,12 @@ function discoverPlugins(
   return found;
 }
 
+const isNonEmptyString = (value /*: unknown */) /*: boolean */ =>
+  typeof value === 'string' && value.length > 0;
+
+const isOptionalStringList = (value /*: unknown */) /*: boolean */ =>
+  value == null || (Array.isArray(value) && value.every(isNonEmptyString));
+
 /**
  * Invoke discovered plugins and merge their results. Each plugin gets the same
  * context. Fail-closed: a throwing plugin aborts (named), and a malformed
@@ -169,13 +185,15 @@ function invokePlugins(
   const flavoredFrameworks /*: Array<{id: string, frameworkName: string, linkage: 'dynamic', flavors: {debug: string, release: string}}> */ =
     [];
   const watchPaths /*: Array<string> */ = [];
+  const scriptPhases /*: Array<PluginScriptPhase> */ = [];
   const seenPackages /*: Set<string> */ = new Set();
   const seenProducts /*: Set<string> */ = new Set();
   const seenFrameworkIds /*: Set<string> */ = new Set();
   const seenFrameworkNames /*: Set<string> */ = new Set();
+  const seenScriptPhaseIds /*: Set<string> */ = new Set();
 
   for (const {depName, pluginPath, plugin} of plugins) {
-    let result: unknown;
+    let result /*: unknown */ = null;
     try {
       result = plugin(context);
     } catch (e) {
@@ -203,11 +221,18 @@ function invokePlugins(
     const rawFrameworks = result.flavoredFrameworks ?? [];
     // $FlowFixMe[incompatible-use]
     const rawWatch = result.watchPaths ?? [];
+    // $FlowFixMe[incompatible-use]
+    const rawScriptPhases = result.scriptPhases ?? [];
     if (!Array.isArray(rawFrameworks)) {
       throw new Error(
         `react-native spm: '${depName}' returned a non-array flavoredFrameworks.`,
       );
     }
+    if (!Array.isArray(rawScriptPhases)) {
+      throw new Error(
+        `react-native spm: '${depName}' returned a non-array scriptPhases.`,
+      );
+    }
     // Watch paths are best-effort staleness hints, so
     // a non-array is ignored (warn, never fatal).
     if (!Array.isArray(rawWatch)) {
@@ -314,6 +339,60 @@ function invokePlugins(
       }
       watchPaths.push(w);
     }
+    // Fatal like flavoredFrameworks, not dropped like watchPaths: a missing
+    // phase produces a GREEN build whose generated content was never written.
+    for (const phase of rawScriptPhases) {
+      if (
+        phase == null ||
+        !isValidScriptPhaseId(phase.id) ||
+        !isNonEmptyString(phase.script) ||
+        (phase.position != null &&
+          phase.position !== 'beforeCompile' &&
+          phase.position !== 'end') ||
+        !isOptionalStringList(phase.inputPaths) ||
+        !isOptionalStringList(phase.outputPaths) ||
+        (phase.alwaysOutOfDate != null &&
+          typeof phase.alwaysOutOfDate !== 'boolean')
+      ) {
+        const named = typeof phase?.id === 'string' ? ` '${phase.id}'` : '';
+        throw new Error(
+          `react-native spm: '${depName}' returned an invalid scriptPhase${named} ` +
+            '(need {id (matching /^[@A-Za-z0-9_./-]+$/, and not __proto__, ' +
+            'constructor or prototype), name, script} plus optional ' +
+            '{position: "beforeCompile" | "end", inputPaths, outputPaths, ' +
+            'alwaysOutOfDate}).',
+        );
+      }
+      if (!isValidScriptPhaseName(phase.name)) {
+        throw new Error(
+          `react-native spm: '${depName}' returned an invalid scriptPhase name for ` +
+            `'${phase.id}' (a name must be a non-empty single-line string — it is ` +
+            "the phase's display name in Xcode).",
+        );
+      }
+      if (seenScriptPhaseIds.has(phase.id)) {
+        throw new Error(
+          `react-native spm: duplicate script phase id '${phase.id}'.`,
+        );
+      }
+      seenScriptPhaseIds.add(phase.id);
+      const normalized /*: PluginScriptPhase */ = {
+        id: phase.id,
+        name: phase.name,
+        script: phase.script,
+        position: phase.position ?? 'end',
+      };
+      if (phase.inputPaths != null) {
+        normalized.inputPaths = [...phase.inputPaths];
+      }
+      if (phase.outputPaths != null) {
+        normalized.outputPaths = [...phase.outputPaths];
+      }
+      if (phase.alwaysOutOfDate != null) {
+        normalized.alwaysOutOfDate = phase.alwaysOutOfDate;
+      }
+      scriptPhases.push(normalized);
+    }
   }
 
   return {
@@ -322,6 +401,7 @@ function invokePlugins(
     generatedSources,
     flavoredFrameworks,
     watchPaths,
+    scriptPhases,
   };
 }