feat: rebuild Hermes xcframework to include macOS slice from Maven tarball

When downloading prebuilt Hermes from Maven, the tarball contains a
standalone macOS framework at destroot/Library/Frameworks/macosx/ but
the xcframework at destroot/Library/Frameworks/universal/ does not
include it. After extraction, rebuild the xcframework using
xcodebuild -create-xcframework to include the macOS slice.

This is a workaround until the upstream build-ios-framework.sh change
(commit 2) is adopted by Meta's CI pipeline.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Saadnajmi

packages/react-native/scripts/ios-prebuild/hermes.js

@@ -234,6 +234,13 @@ async function prepareHermesArtifactsAsync(
     fs.unlinkSync(localPath);
   }
 
+  // [macOS] The Maven tarball contains a standalone macOS framework at
+  // destroot/Library/Frameworks/macosx/ but does NOT include it in the
+  // xcframework at destroot/Library/Frameworks/universal/. SPM's BinaryTarget
+  // requires an xcframework, so we rebuild it to include the macOS slice.
+  ensureMacOSSliceInXCFramework(artifactsPath);
+  // macOS]
+
   return artifactsPath;
 }
 
@@ -525,6 +532,114 @@ async function downloadHermesTarball(
 }
 
 // [macOS
+/**
+ * The Hermes tarball from Maven contains a standalone macOS framework at
+ * destroot/Library/Frameworks/macosx/hermes.framework (or hermesvm.framework)
+ * but the xcframework at destroot/Library/Frameworks/universal/ does not include
+ * a macOS slice. This function rebuilds the xcframework to include it.
+ *
+ * This is needed because SPM's BinaryTarget requires an xcframework, and
+ * xcodebuild needs the macOS slice present to build for macOS.
+ */
+function ensureMacOSSliceInXCFramework(artifactsPath /*: string */) {
+  const frameworksDir = path.join(
+    artifactsPath,
+    'destroot',
+    'Library',
+    'Frameworks',
+  );
+  const macosDir = path.join(frameworksDir, 'macosx');
+  const universalDir = path.join(frameworksDir, 'universal');
+
+  if (!fs.existsSync(macosDir)) {
+    hermesLog('No macOS framework found in tarball, skipping xcframework rebuild');
+    return;
+  }
+
+  // Find the framework name (hermes.framework or hermesvm.framework)
+  const macosFrameworks = fs.readdirSync(macosDir).filter(f => f.endsWith('.framework'));
+  if (macosFrameworks.length === 0) {
+    hermesLog('No .framework found in macosx directory, skipping');
+    return;
+  }
+  const frameworkName = macosFrameworks[0];
+
+  // Find the existing xcframework
+  const xcframeworks = fs.existsSync(universalDir)
+    ? fs.readdirSync(universalDir).filter(f => f.endsWith('.xcframework'))
+    : [];
+
+  if (xcframeworks.length === 0) {
+    hermesLog('No existing xcframework found, creating one from macOS framework only');
+    fs.mkdirSync(universalDir, {recursive: true});
+    const xcframeworkName = frameworkName.replace('.framework', '.xcframework');
+    execSync(
+      `xcodebuild -create-xcframework ` +
+        `-framework "${path.join(macosDir, frameworkName)}" ` +
+        `-output "${path.join(universalDir, xcframeworkName)}"`,
+      {stdio: 'inherit'},
+    );
+    hermesLog(`Created ${xcframeworkName} with macOS slice`);
+    return;
+  }
+
+  const xcframeworkName = xcframeworks[0];
+  const xcframeworkPath = path.join(universalDir, xcframeworkName);
+
+  // Check if macOS slice already exists in the xcframework
+  const existingSlices = fs.readdirSync(xcframeworkPath).filter(d => d.startsWith('macos-'));
+  if (existingSlices.length > 0) {
+    hermesLog('macOS slice already present in xcframework, skipping rebuild');
+    return;
+  }
+
+  hermesLog(`Rebuilding ${xcframeworkName} to include macOS slice...`);
+
+  // Collect all existing framework slices from the xcframework
+  const sliceDirs = fs.readdirSync(xcframeworkPath).filter(d => {
+    const slicePath = path.join(xcframeworkPath, d);
+    return fs.statSync(slicePath).isDirectory() && d !== '_CodeSignature';
+  });
+
+  // Build the -framework arguments for xcodebuild -create-xcframework
+  const frameworkArgs = sliceDirs.map(sliceDir => {
+    const slicePath = path.join(xcframeworkPath, sliceDir);
+    const frameworks = fs.readdirSync(slicePath).filter(f => f.endsWith('.framework'));
+    if (frameworks.length > 0) {
+      return `-framework "${path.join(slicePath, frameworks[0])}"`;
+    }
+    return null;
+  }).filter(Boolean);
+
+  // Add the macOS framework
+  frameworkArgs.push(`-framework "${path.join(macosDir, frameworkName)}"`);
+
+  // Rebuild the xcframework
+  const tmpXCFramework = path.join(universalDir, `${xcframeworkName}.tmp`);
+  try {
+    execSync(
+      `xcodebuild -create-xcframework ${frameworkArgs.join(' ')} -output "${tmpXCFramework}"`,
+      {stdio: 'inherit'},
+    );
+
+    // Replace the original xcframework
+    fs.rmSync(xcframeworkPath, {recursive: true, force: true});
+    fs.renameSync(tmpXCFramework, xcframeworkPath);
+
+    hermesLog(`Rebuilt ${xcframeworkName} with macOS slice added`);
+  } catch (e) {
+    // Clean up on failure
+    if (fs.existsSync(tmpXCFramework)) {
+      fs.rmSync(tmpXCFramework, {recursive: true, force: true});
+    }
+    hermesLog(
+      `Warning: Failed to rebuild xcframework with macOS slice: ${e.message}. ` +
+        `The macOS framework is available at ${path.join(macosDir, frameworkName)} ` +
+        `but could not be added to the xcframework.`,
+    );
+  }
+}
+
 /**
  * Handles the case where no prebuilt Hermes artifacts are available.
  * Determines the Hermes commit at the merge base with facebook/react-native