@callstack/brownfield-cli 6.0.0 → 6.0.1

package/dist/brownfield/utils/resolvePackagedFrameworkName.d.ts

@@ -1,3 +1,4 @@
+import { type AppleSdk } from './destinationSdks.js';
 type Resolution = 'explicit' | 'detected' | 'not_found' | 'ambiguous';
 export interface ResolvePackagedFrameworkNameResult {
     frameworkName: string | null;
@@ -8,7 +9,9 @@ interface ResolvePackagedFrameworkNameOptions {
     explicitScheme?: string;
     productsPath: string;
     configuration: string;
+    /** Slices the build produced; defaults to both. */
+    sdks?: AppleSdk[];
 }
-export declare function resolvePackagedFrameworkName({ explicitScheme, productsPath, configuration, }: ResolvePackagedFrameworkNameOptions): ResolvePackagedFrameworkNameResult;
+export declare function resolvePackagedFrameworkName({ explicitScheme, productsPath, configuration, sdks, }: ResolvePackagedFrameworkNameOptions): ResolvePackagedFrameworkNameResult;
 export {};
 //# sourceMappingURL=resolvePackagedFrameworkName.d.ts.map

package/dist/brownfield/utils/resolvePackagedFrameworkName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvePackagedFrameworkName.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/resolvePackagedFrameworkName.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAEtE,MAAM,WAAW,kCAAkC;IACjD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,UAAU,mCAAmC;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AA4CD,wBAAgB,4BAA4B,CAAC,EAC3C,cAAc,EACd,YAAY,EACZ,aAAa,GACd,EAAE,mCAAmC,GAAG,kCAAkC,CAkC1E"}
+{"version":3,"file":"resolvePackagedFrameworkName.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/resolvePackagedFrameworkName.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErE,KAAK,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAEtE,MAAM,WAAW,kCAAkC;IACjD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,UAAU,mCAAmC;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;CACnB;AA4CD,wBAAgB,4BAA4B,CAAC,EAC3C,cAAc,EACd,YAAY,EACZ,aAAa,EACb,IAAqB,GACtB,EAAE,mCAAmC,GAAG,kCAAkC,CAwC1E"}

package/dist/brownfield/utils/resolvePackagedFrameworkName.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { ALL_APPLE_SDKS } from './destinationSdks.js';
 function collectFrameworkCandidates(configurationProductsPath) {
     if (!fs.existsSync(configurationProductsPath)) {
         return [];
@@ -31,15 +32,18 @@ function collectFrameworkCandidates(configurationProductsPath) {
     }
     return [...discoveredFrameworks].sort();
 }
-export function resolvePackagedFrameworkName({ explicitScheme, productsPath, configuration, }) {
+export function resolvePackagedFrameworkName({ explicitScheme, productsPath, configuration, sdks = ALL_APPLE_SDKS, }) {
     if (explicitScheme) {
         return {
             frameworkName: explicitScheme,
             resolution: 'explicit',
         };
     }
-    const configurationProductsPath = path.join(productsPath, `${configuration}-iphoneos`);
-    const candidates = collectFrameworkCandidates(configurationProductsPath);
+    // the JS bundle is emitted per slice, so scan every slice that was built rather
+    // than assuming the device one exists (`--destination simulator` skips it)
+    const candidates = [
+        ...new Set(sdks.flatMap((sdk) => collectFrameworkCandidates(path.join(productsPath, `${configuration}-${sdk}`)))),
+    ].sort();
     if (candidates.length === 1) {
         return {
             frameworkName: candidates[0] ?? null,

package/dist/brownfield/utils/supportsPrebuiltExpo.d.ts

@@ -2,13 +2,33 @@ export declare const MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO = 56;
 export type PrebuiltExpoSupportResult = {
     supported: true;
     enabledByDefault: boolean;
+    /** Why prebuilts are off by default even though they are supported. */
+    defaultDisabledReason?: string;
     reason?: never;
 } | {
     supported: false;
     enabledByDefault?: never;
     reason: string;
 };
+/**
+ * The React Native version the installed Expo SDK pins. Expo ships its
+ * precompiled modules built against this version.
+ */
+export declare function getExpoReactNativeVersion(projectRoot: string): string | null;
+/**
+ * Describes a React Native version the Expo prebuilts were not built for, or
+ * returns null when they match. Prebuilt Expo modules link against React
+ * Native's C++ API, which changes between minor versions, so a mismatch
+ * crashes at runtime.
+ */
+export declare function getPrebuiltExpoReactNativeMismatch(projectRoot: string): string | null;
 export declare function supportsPrebuiltExpo({ projectRoot, }: {
     projectRoot: string;
 }): PrebuiltExpoSupportResult;
+/**
+ * Whether the project's Podfile turns Expo's precompiled modules off. Expo
+ * Podfiles force `EXPO_USE_PRECOMPILED_MODULES` to '0' when
+ * `ios/Podfile.properties.json` sets it to "false", whatever the environment says.
+ */
+export declare function isPrecompiledExpoDisabledByPodfile(projectRoot: string): boolean;
 //# sourceMappingURL=supportsPrebuiltExpo.d.ts.map

package/dist/brownfield/utils/supportsPrebuiltExpo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supportsPrebuiltExpo.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/supportsPrebuiltExpo.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GACjC;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,gBAAgB,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,GAC9D;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,wBAAgB,oBAAoB,CAAC,EACnC,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,yBAAyB,CAqB5B"}
+{"version":3,"file":"supportsPrebuiltExpo.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/supportsPrebuiltExpo.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GACjC;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,MAAM,CAAC,EAAE,KAAK,CAAC;CAChB,GACD;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAMnE;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc5E;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CAYf;AAED,wBAAgB,oBAAoB,CAAC,EACnC,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,yBAAyB,CAsC5B;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,MAAM,GAClB,OAAO,CAYT"}

package/dist/brownfield/utils/supportsPrebuiltExpo.js

@@ -1,5 +1,44 @@
-import { getExpoSdkMajor, isExpoProject } from './project.js';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { getReactNativeVersion } from '@rock-js/tools';
+import { getExpoIosUsePrecompiledModules, getExpoSdkMajor, isExpoProject } from './project.js';
 export const MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO = 56;
+function majorMinor(version) {
+    return version.split('.').slice(0, 2).join('.');
+}
+/**
+ * The React Native version the installed Expo SDK pins. Expo ships its
+ * precompiled modules built against this version.
+ */
+export function getExpoReactNativeVersion(projectRoot) {
+    try {
+        const require = createRequire(path.join(projectRoot, 'package.json'));
+        const expoPackageJson = require.resolve('expo/package.json');
+        const bundledNativeModules = JSON.parse(fs.readFileSync(path.join(path.dirname(expoPackageJson), 'bundledNativeModules.json'), 'utf8'));
+        return bundledNativeModules['react-native'] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Describes a React Native version the Expo prebuilts were not built for, or
+ * returns null when they match. Prebuilt Expo modules link against React
+ * Native's C++ API, which changes between minor versions, so a mismatch
+ * crashes at runtime.
+ */
+export function getPrebuiltExpoReactNativeMismatch(projectRoot) {
+    const expected = getExpoReactNativeVersion(projectRoot);
+    const found = getReactNativeVersion(projectRoot);
+    if (!expected || found === 'unknown') {
+        return null;
+    }
+    if (majorMinor(expected) === majorMinor(found)) {
+        return null;
+    }
+    return `Expo's precompiled modules are built for React Native ${majorMinor(expected)}, but this project uses ${found}.`;
+}
 export function supportsPrebuiltExpo({ projectRoot, }) {
     if (!isExpoProject(projectRoot)) {
         return { supported: true, enabledByDefault: false };
@@ -13,8 +52,36 @@ export function supportsPrebuiltExpo({ projectRoot, }) {
             reason: `--use-prebuilt-expo is unsupported in Expo SDK ${sdkLabel}: packaging brownfield with Expo prebuilts requires Expo SDK ${MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO} or newer.`,
         };
     }
+    const reactNativeMismatch = getPrebuiltExpoReactNativeMismatch(projectRoot);
+    if (reactNativeMismatch) {
+        return {
+            supported: true,
+            enabledByDefault: false,
+            defaultDisabledReason: reactNativeMismatch,
+        };
+    }
+    if (getExpoIosUsePrecompiledModules(projectRoot) === false) {
+        return {
+            supported: false,
+            reason: "--use-prebuilt-expo is unsupported: expo-build-properties sets ios.usePrecompiledModules to false in your Expo config, so prebuilt Expo XCFrameworks are never produced. Set it to true (or remove it) and run 'pod install', or pass --use-prebuilt-expo false to build Expo modules from source.",
+        };
+    }
     return {
         supported: true,
         enabledByDefault: true,
     };
 }
+/**
+ * Whether the project's Podfile turns Expo's precompiled modules off. Expo
+ * Podfiles force `EXPO_USE_PRECOMPILED_MODULES` to '0' when
+ * `ios/Podfile.properties.json` sets it to "false", whatever the environment says.
+ */
+export function isPrecompiledExpoDisabledByPodfile(projectRoot) {
+    try {
+        const properties = JSON.parse(fs.readFileSync(path.join(projectRoot, 'ios', 'Podfile.properties.json'), 'utf8'));
+        return properties.EXPO_USE_PRECOMPILED_MODULES === 'false';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiFA,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAM3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6FA,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAM3C"}

package/dist/index.js

@@ -5,6 +5,16 @@ import { ExampleUsage } from './shared/index.js';
 import brownfieldCommands, { groupName as brownfieldCommandsGroupName, } from './brownfield/index.js';
 import brownieCommands, { groupName as brownieCommandsGroupName, } from './brownie/index.js';
 import navigationCommands, { groupName as navigationCommandsGroupName, } from './navigation/index.js';
+// CocoaPods (spawned by Rock) raises Encoding::CompatibilityError under a non-UTF-8
+// locale. Ruby resolves the character encoding as LC_ALL > LC_CTYPE > LANG, so check
+// them in that precedence. Default to UTF-8 only when the effective value is missing
+// or non-UTF-8.
+const inheritedCharset = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || '';
+if (!/utf-?8/i.test(inheritedCharset)) {
+    process.env.LANG = 'en_US.UTF-8';
+    process.env.LC_CTYPE = 'en_US.UTF-8';
+    process.env.LC_ALL = 'en_US.UTF-8';
+}
 const program = new Command();
 program
     .name(styleText('magenta', 'brownfield'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/brownfield-cli",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "license": "MIT",
   "author": "Artur Morys-Magiera <artus9033@gmail.com>",
   "bin": {
@@ -88,11 +88,11 @@
     "@expo/config": "^12.0.13",
     "@react-native-community/cli-config": "^20.0.0",
     "@react-native-community/cli-config-android": "^20.0.0",
-    "@rock-js/platform-android": "^0.14.0",
-    "@rock-js/platform-apple-helpers": "^0.14.0",
-    "@rock-js/plugin-brownfield-android": "^0.14.0",
-    "@rock-js/plugin-brownfield-ios": "^0.14.0",
-    "@rock-js/tools": "^0.14.0",
+    "@rock-js/platform-android": "^0.15.4",
+    "@rock-js/platform-apple-helpers": "^0.15.4",
+    "@rock-js/plugin-brownfield-android": "^0.15.4",
+    "@rock-js/plugin-brownfield-ios": "^0.15.4",
+    "@rock-js/tools": "^0.15.4",
     "ajv": "^8.20.0",
     "commander": "^14.0.3",
     "quicktype-core": "^23.2.6",

package/src/brownfield/commands/packageIos.ts

@@ -18,8 +18,11 @@ import { Command, Option } from 'commander';
 
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { findProjectRoot } from '../utils/paths.js';
-import { getProjectInfo } from '../utils/project.js';
-import { supportsPrebuiltExpo } from '../utils/supportsPrebuiltExpo.js';
+import { getProjectInfo, isExpoProject } from '../utils/project.js';
+import {
+  isPrecompiledExpoDisabledByPodfile,
+  supportsPrebuiltExpo,
+} from '../utils/supportsPrebuiltExpo.js';
 import { supportsPrebuiltRNCore } from '../utils/supportsPrebuiltRNCore.js';
 import {
   actionRunner,
@@ -29,6 +32,10 @@ import {
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
 import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
 import { copyDebugBundleToSimulatorSlice } from '../utils/copyDebugBundleToSimulatorSlice.js';
+import {
+  collectFrameworkPaths,
+  resolveDestinationSdks,
+} from '../utils/destinationSdks.js';
 import { resolvePackagedFrameworkName } from '../utils/resolvePackagedFrameworkName.js';
 import { stripFrameworkBinary } from '../utils/stripFrameworkBinary.js';
 import type { PackageIosOptions } from '../../types.js';
@@ -75,9 +82,7 @@ export function parseUsePrebuiltRnCoreArgument(
   return parseBooleanOptionArgument('--use-prebuilt-rn-core', value);
 }
 
-export function parseUsePrebuiltExpoArgument(
-  value: string | boolean
-): boolean {
+export function parseUsePrebuiltExpoArgument(value: string | boolean): boolean {
   return parseBooleanOptionArgument('--use-prebuilt-expo', value);
 }
 
@@ -125,6 +130,11 @@ export const packageIosCommand = curryOptions(
   .action(
     actionRunner(async (cliOptions: PackageIosOptions) => {
       const options = mergeBrownfieldConfigWithOptions(cliOptions, 'ios');
+      // captured before the version-aware default below, so that a value from
+      // brownfield.config.json counts as explicit
+      const usePrebuiltExpoExplicit = isUsePrebuiltExpoExplicit(
+        options.usePrebuiltExpo
+      );
       const projectRoot = findProjectRoot();
 
       await runExpoPrebuildIfNeeded({ projectRoot, platform: 'ios' });
@@ -139,10 +149,68 @@ export const packageIosCommand = curryOptions(
         ? prebuiltRNCoreSupport.enabledByDefault
         : false;
 
-        // version-aware default when the flag is omitted
-      options.usePrebuiltExpo ??= prebuiltExpoSupport.supported
-        ? prebuiltExpoSupport.enabledByDefault
-        : false;
+      const usePrebuiltExpoWasPassed = options.usePrebuiltExpo !== undefined;
+      const precompiledExpoDisabledByPodfile =
+        isExpoProject(projectRoot) &&
+        isPrecompiledExpoDisabledByPodfile(projectRoot);
+
+      if (precompiledExpoDisabledByPodfile) {
+        if (options.usePrebuiltExpo) {
+          logger.warn(
+            'ios/Podfile.properties.json sets EXPO_USE_PRECOMPILED_MODULES to "false", so pod install builds Expo modules from source and --use-prebuilt-expo will fail. Remove that property or pass --use-prebuilt-expo false.'
+          );
+        } else if (!usePrebuiltExpoWasPassed) {
+          logger.info(
+            'ios/Podfile.properties.json turns Expo precompiled modules off. Building Expo modules from source.'
+          );
+          options.usePrebuiltExpo = false;
+        }
+      } else if (
+        !usePrebuiltExpoWasPassed &&
+        isExpoProject(projectRoot) &&
+        process.env.EXPO_USE_PRECOMPILED_MODULES === '0'
+      ) {
+        // Respect an exported opt-out, the same way Expo's Podfile does.
+        logger.info(
+          'EXPO_USE_PRECOMPILED_MODULES is set to 0. Building Expo modules from source.'
+        );
+        options.usePrebuiltExpo = false;
+      }
+
+      const usePrebuiltExpoWasChosen =
+        usePrebuiltExpoWasPassed || options.usePrebuiltExpo !== undefined;
+
+      // version-aware default when the flag is omitted; Expo's precompiled
+      // modules also need the prebuilt React Native core
+      if (options.usePrebuiltExpo === undefined) {
+        options.usePrebuiltExpo = prebuiltExpoSupport.supported
+          ? prebuiltExpoSupport.enabledByDefault && !!options.usePrebuiltRnCore
+          : false;
+
+        if (
+          prebuiltExpoSupport.enabledByDefault &&
+          !options.usePrebuiltRnCore
+        ) {
+          logger.info(
+            'Expo precompiled modules need the prebuilt React Native core, which is off. Building Expo modules from source.'
+          );
+        }
+      }
+
+      if (
+        prebuiltExpoSupport.supported &&
+        prebuiltExpoSupport.defaultDisabledReason
+      ) {
+        if (usePrebuiltExpoWasChosen && options.usePrebuiltExpo) {
+          logger.warn(
+            `${prebuiltExpoSupport.defaultDisabledReason} The packaged app will likely crash at runtime. Pass --use-prebuilt-expo false to build Expo modules from source.`
+          );
+        } else if (!usePrebuiltExpoWasChosen) {
+          logger.info(
+            `${prebuiltExpoSupport.defaultDisabledReason} Building Expo modules from source.`
+          );
+        }
+      }
 
       if (prebuiltRNCoreSupport) {
         logger.info(
@@ -167,6 +235,31 @@ export const packageIosCommand = curryOptions(
         throw new RockError(prebuiltExpoSupport.reason);
       }
 
+      if (isExpoProject(projectRoot)) {
+        // Read by Expo's autolinking during `pod install`. Expo-generated
+        // Podfiles default it to on, but a React Native CLI app's Podfile
+        // never sets it, so the flag has to drive it.
+        process.env.EXPO_USE_PRECOMPILED_MODULES = options.usePrebuiltExpo
+          ? '1'
+          : '0';
+      }
+
+      if (
+        options.usePrebuiltExpo &&
+        !options.extraParams?.some((param) =>
+          param.startsWith('SWIFT_ENABLE_EXPLICIT_MODULES=')
+        )
+      ) {
+        // Precompiled Expo builds the React Native pods as static libraries.
+        // With explicit modules off (a leftover older React Native versions
+        // wrote into app projects), Xcode cannot find their module maps when
+        // verifying the framework's Swift interface.
+        options.extraParams = [
+          ...(options.extraParams ?? []),
+          'SWIFT_ENABLE_EXPLICIT_MODULES=YES',
+        ];
+      }
+
       if (!userConfig.project.ios) {
         throw new Error('iOS project not found.');
       }
@@ -197,6 +290,9 @@ export const packageIosCommand = curryOptions(
       // Reference: https://github.com/facebook/react-native/blob/490c5e8dcc6cdb19c334cc39e93a39a48ba71e96/packages/react-native/scripts/cocoapods/new_architecture.rb#L171
       const packageDir = path.join(dotBrownfieldDir, 'package', 'build');
       const configuration = options.configuration ?? 'Debug';
+      // `--destination` narrows which slices Xcode emits, so every path below has to
+      // look at those slices only instead of assuming a device + simulator pair
+      const sdks = resolveDestinationSdks(options.destination);
 
       const { hasBrownie } = await runBrownieCodegenIfApplicable(
         projectRoot,
@@ -225,6 +321,11 @@ export const packageIosCommand = curryOptions(
         projectRoot,
         packageDir,
         usePrebuiltExpo: options.usePrebuiltExpo,
+        usePrebuiltExpoExplicit,
+        // keep the generated SPM manifest consistent with the emitted XCFrameworks
+        onDegradeToSource: () => {
+          options.usePrebuiltExpo = false;
+        },
       });
 
       const productsPath = path.join(options.buildFolder, 'Build', 'Products');
@@ -233,6 +334,7 @@ export const packageIosCommand = curryOptions(
           explicitScheme: options.scheme,
           productsPath,
           configuration,
+          sdks,
         });
 
       if (!frameworkName && options.addSpmPackage) {
@@ -251,24 +353,19 @@ export const packageIosCommand = curryOptions(
           productsPath,
           configuration,
           frameworkName,
+          sdks,
         });
 
         if (configuration.includes('Debug')) {
           // Re-merge only Debug frameworks so the simulator slice includes main.jsbundle.
           await mergeFrameworks({
             sourceDir: userConfig.project.ios.sourceDir,
-            frameworkPaths: [
-              path.join(
-                productsPath,
-                `${configuration}-iphoneos`,
-                `${frameworkName}.framework`
-              ),
-              path.join(
-                productsPath,
-                `${configuration}-iphonesimulator`,
-                `${frameworkName}.framework`
-              ),
-            ],
+            frameworkPaths: collectFrameworkPaths({
+              productsPath,
+              configuration,
+              sdks,
+              frameworkName,
+            }),
             outputPath: path.join(packageDir, `${frameworkName}.xcframework`),
           });
         }
@@ -300,20 +397,13 @@ export const packageIosCommand = curryOptions(
 
         await mergeFrameworks({
           sourceDir: userConfig.project.ios.sourceDir,
-          frameworkPaths: [
-            path.join(
-              productsPath,
-              `${configuration}-iphoneos`,
-              'Brownie',
-              'Brownie.framework'
-            ),
-            path.join(
-              productsPath,
-              `${configuration}-iphonesimulator`,
-              'Brownie',
-              'Brownie.framework'
-            ),
-          ],
+          frameworkPaths: collectFrameworkPaths({
+            productsPath,
+            configuration,
+            sdks,
+            frameworkName: 'Brownie',
+            productSubDir: 'Brownie',
+          }),
           outputPath: brownieOutputPath,
         });
 
@@ -335,20 +425,13 @@ export const packageIosCommand = curryOptions(
 
         await mergeFrameworks({
           sourceDir: userConfig.project.ios.sourceDir,
-          frameworkPaths: [
-            path.join(
-              productsPath,
-              `${configuration}-iphoneos`,
-              'BrownfieldNavigation',
-              'BrownfieldNavigation.framework'
-            ),
-            path.join(
-              productsPath,
-              `${configuration}-iphonesimulator`,
-              'BrownfieldNavigation',
-              'BrownfieldNavigation.framework'
-            ),
-          ],
+          frameworkPaths: collectFrameworkPaths({
+            productsPath,
+            configuration,
+            sdks,
+            frameworkName: 'BrownfieldNavigation',
+            productSubDir: 'BrownfieldNavigation',
+          }),
           outputPath: brownfieldNavigationOutputPath,
         });
 
@@ -378,9 +461,20 @@ export const packageIosCommand = curryOptions(
           'In Xcode, choose File > Add Package Dependencies..., click Add Local..., and select that folder.'
         );
       }
+
+      // The dependency prints its own "Success" before the post-build steps above,
+      // so log a final line marking the true end of the run.
+      logger.success(
+        `package:ios finished. Artifacts are in ${colorLink(relativeToCwd(packageDir))}`
+      );
     })
   );
 
+/** Whether `--use-prebuilt-expo` was chosen (CLI or brownfield.config.json) rather than inferred. */
+export function isUsePrebuiltExpoExplicit(value: boolean | undefined) {
+  return value !== undefined;
+}
+
 export const packageIosExample = new ExampleUsage(
   'package:ios --scheme BrownfieldLib --configuration Release',
   "Build iOS XCFramework for 'BrownfieldLib' scheme in Release configuration"

package/src/brownfield/utils/copyDebugBundleToSimulatorSlice.ts

@@ -3,21 +3,31 @@ import path from 'node:path';
 
 import { colorLink, logger, relativeToCwd } from '@rock-js/tools';
 
+import { ALL_APPLE_SDKS, type AppleSdk } from './destinationSdks.js';
+
 interface CopyDebugBundleToSimulatorSliceOptions {
   productsPath: string;
   configuration: string;
   frameworkName: string;
+  /** Slices the build produced; defaults to both. */
+  sdks?: AppleSdk[];
 }
 
 export function copyDebugBundleToSimulatorSlice({
   productsPath,
   configuration,
   frameworkName,
+  sdks = ALL_APPLE_SDKS,
 }: CopyDebugBundleToSimulatorSliceOptions) {
   if (!configuration.includes('Debug')) {
     return;
   }
 
+  // nothing to copy across when only one slice was built
+  if (!sdks.includes('iphoneos') || !sdks.includes('iphonesimulator')) {
+    return;
+  }
+
   const deviceBundlePath = path.join(
     productsPath,
     `${configuration}-iphoneos`,

package/src/brownfield/utils/destinationSdks.ts

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { RockError } from '@rock-js/tools';
+
+/** Xcode SDK a build product directory belongs to (`Release-iphoneos`, `Release-iphonesimulator`). */
+export type AppleSdk = 'iphoneos' | 'iphonesimulator';
+
+/** Both slices, in the order Rock's `packageIosAction` builds them. */
+export const ALL_APPLE_SDKS: AppleSdk[] = ['iphoneos', 'iphonesimulator'];
+
+/**
+ * Map a single `--destination` value onto the SDK(s) its build products land in.
+ *
+ * Mirrors `resolveDestination` in `@rock-js/platform-apple-helpers`: the aliases
+ * `device`/`simulator` plus any raw `xcodebuild -destination` string. A value we
+ * cannot classify (`id=<udid>`, `name=iPhone 17`) may resolve to either SDK, so it
+ * widens to both rather than silently dropping a slice.
+ */
+function resolveSdksForDestination(destination: string): AppleSdk[] {
+  const normalized = destination.trim().toLowerCase();
+
+  if (normalized === 'device') {
+    return ['iphoneos'];
+  }
+
+  if (normalized === 'simulator' || normalized.includes('simulator')) {
+    return ['iphonesimulator'];
+  }
+
+  if (normalized.includes('platform=ios')) {
+    return ['iphoneos'];
+  }
+
+  return ALL_APPLE_SDKS;
+}
+
+/**
+ * SDK slices a `package:ios` run produces for the given `--destination` values.
+ *
+ * Omitting `--destination` builds both slices, matching Rock's default.
+ */
+export function resolveDestinationSdks(
+  destination?: string[] | null
+): AppleSdk[] {
+  if (!destination || destination.length === 0) {
+    return ALL_APPLE_SDKS;
+  }
+
+  const sdks = new Set(destination.flatMap(resolveSdksForDestination));
+
+  // keep a stable order regardless of the order the flags were passed in
+  return ALL_APPLE_SDKS.filter((sdk) => sdks.has(sdk));
+}
+
+/**
+ * Whether `directoryPath` holds a build product `mergeFrameworks` can consume:
+ * either a real `.framework` bundle or the static library it synthesizes one from.
+ */
+export function hasFrameworkBuildProduct(
+  directoryPath: string,
+  frameworkName: string
+) {
+  return (
+    fs.existsSync(path.join(directoryPath, `${frameworkName}.framework`)) ||
+    fs.existsSync(path.join(directoryPath, `lib${frameworkName}.a`))
+  );
+}
+
+interface CollectFrameworkPathsOptions {
+  productsPath: string;
+  configuration: string;
+  sdks: AppleSdk[];
+  frameworkName: string;
+  /** Sub-directory of the configuration products dir, e.g. `Brownie` for a Pod target. */
+  productSubDir?: string;
+}
+
+/**
+ * `.framework` paths to merge into an XCFramework, limited to the slices that were
+ * actually built. Slices with no build product on disk are dropped, so a
+ * `--destination simulator` run merges the simulator slice alone instead of failing
+ * on a missing `-iphoneos` directory.
+ *
+ * Throws when no slice has a build product: passing an empty list to
+ * `mergeFrameworks` would surface as xcodebuild's opaque
+ * "at least one framework or library must be specified".
+ */
+export function collectFrameworkPaths({
+  productsPath,
+  configuration,
+  sdks,
+  frameworkName,
+  productSubDir,
+}: CollectFrameworkPathsOptions): string[] {
+  const searchedDirectories = sdks.map((sdk) =>
+    path.join(
+      productsPath,
+      `${configuration}-${sdk}`,
+      ...(productSubDir ? [productSubDir] : [])
+    )
+  );
+
+  const frameworkPaths = searchedDirectories
+    .filter((directoryPath) =>
+      hasFrameworkBuildProduct(directoryPath, frameworkName)
+    )
+    .map((directoryPath) =>
+      path.join(directoryPath, `${frameworkName}.framework`)
+    );
+
+  if (frameworkPaths.length === 0) {
+    throw new RockError(
+      `Could not find a build product for ${frameworkName} in the ${configuration} configuration. ` +
+        `Looked for ${frameworkName}.framework or lib${frameworkName}.a in:\n` +
+        searchedDirectories.map((dir) => `  - ${dir}`).join('\n') +
+        `\nIf the build produced an .app instead of a framework, the wrong scheme was built; pass --scheme with your brownfield framework scheme.`
+    );
+  }
+
+  return frameworkPaths;
+}