@callstack/brownfield-cli 6.0.0 → 6.0.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @callstack/brownfield-cli
 
+## 6.0.1
+
+### Patch Changes
+
+- [#487](https://github.com/callstack/react-native-brownfield/pull/487) [`79817d1`](https://github.com/callstack/react-native-brownfield/commit/79817d1a21b0cb28ae63d41e935c57af8e7db39f) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Support Expo modules in React Native CLI apps. `brownfield package:*` no longer runs `expo prebuild` on projects with committed `android/` and `ios/` directories, which used to delete the brownfield library module. Prebuild now runs only when the native directory is missing or gitignored. If you commit the generated directories of an Expo app, run `npx expo prebuild` yourself after changing `app.json` or config plugins. `create-react-native-brownfield` now detects Expo and sets up the iOS framework to use the Expo runtime. On a re-run after adding Expo, it also raises an existing framework target to iOS 16.4.
+
+  `--use-prebuilt-expo` now also turns Expo's precompiled modules on or off for `pod install`, and turns on Swift explicit modules so packaging works in projects that still carry the old `SWIFT_ENABLE_EXPLICIT_MODULES = NO` workaround. It defaults to building Expo from source when the app's React Native version doesn't match the one Expo's precompiled modules were built for.
+
+  `package:ios` now copies the expo-image dependency XCFrameworks (SDWebImage and libavif) as real files instead of symlinks into `node_modules`, so the package works when moved to another machine.
+
+  Re-running `create-react-native-brownfield` after `pod install` no longer adds a second Sources build phase to the framework target, which made the next `pod install` fail.
+
+  The `package:ios` script that `create-react-native-brownfield` adds now passes `--add-spm-package`, so the iOS app adds one local Swift package instead of every XCFramework. Existing scripts aren't changed.
+
+- [#485](https://github.com/callstack/react-native-brownfield/pull/485) [`69fe3e3`](https://github.com/callstack/react-native-brownfield/commit/69fe3e3f05a49036cae1f3564a47ef3eed186155) Thanks [@hurali97](https://github.com/hurali97)! - respect `--destination` in `package:ios` when merging XCFrameworks
+
 ## 6.0.0
 
 ## 5.3.0

package/dist/brownfield/commands/packageIos.d.ts

@@ -3,5 +3,7 @@ import { ExampleUsage } from '../../shared/index.js';
 export declare function parseUsePrebuiltRnCoreArgument(value: string | boolean): boolean;
 export declare function parseUsePrebuiltExpoArgument(value: string | boolean): boolean;
 export declare const packageIosCommand: Command;
+/** Whether `--use-prebuilt-expo` was chosen (CLI or brownfield.config.json) rather than inferred. */
+export declare function isUsePrebuiltExpoExplicit(value: boolean | undefined): value is boolean;
 export declare const packageIosExample: ExampleUsage;
 //# sourceMappingURL=packageIos.d.ts.map

package/dist/brownfield/commands/packageIos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packageIos.d.ts","sourceRoot":"","sources":["../../../src/brownfield/commands/packageIos.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAO5C,OAAO,EAGL,YAAY,EACb,MAAM,uBAAuB,CAAC;AA4C/B,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAET;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAET;AAcD,eAAO,MAAM,iBAAiB,SA8R3B,CAAC;AAEJ,eAAO,MAAM,iBAAiB,cAG7B,CAAC"}
+{"version":3,"file":"packageIos.d.ts","sourceRoot":"","sources":["../../../src/brownfield/commands/packageIos.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAU5C,OAAO,EAGL,YAAY,EACb,MAAM,uBAAuB,CAAC;AAgD/B,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAET;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAE7E;AAcD,eAAO,MAAM,iBAAiB,SAkX3B,CAAC;AAEJ,qGAAqG;AACrG,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,oBAEnE;AAED,eAAO,MAAM,iBAAiB,cAG7B,CAAC"}

package/dist/brownfield/commands/packageIos.js

@@ -6,13 +6,14 @@ import { RockError, colorLink, getReactNativeVersion, logger, relativeToCwd, } f
 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, curryOptions, ExampleUsage, } from '../../shared/index.js';
 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 { createLocalSpmPackage } from '../utils/createLocalSpmPackage.js';
@@ -68,6 +69,9 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
     .addOption(new Option('--add-spm-package', 'Generate a local Swift Package Manager manifest next to the packaged XCFramework outputs'))
     .action(actionRunner(async (cliOptions) => {
     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' });
     const { platformConfig, userConfig } = getProjectInfo('ios');
@@ -77,10 +81,46 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
     options.usePrebuiltRnCore ??= prebuiltRNCoreSupport.supported
         ? 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(`${options.usePrebuiltRnCore ? 'Using' : 'Not using'} prebuilt RN core`);
         if (!prebuiltRNCoreSupport.enabledByDefault &&
@@ -94,6 +134,25 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
     if (options.usePrebuiltExpo && !prebuiltExpoSupport.supported) {
         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.');
     }
@@ -117,6 +176,9 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
     // 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, 'swift');
     const { hasNavigation } = await runNavigationCodegenIfApplicable(projectRoot);
     await packageIosAction(options, {
@@ -134,12 +196,18 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         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');
     const { frameworkName, resolution, candidates } = resolvePackagedFrameworkName({
         explicitScheme: options.scheme,
         productsPath,
         configuration,
+        sdks,
     });
     if (!frameworkName && options.addSpmPackage) {
         throw new RockError(`Cannot generate local SPM package: ${getPackagedFrameworkResolutionFailureMessage({
@@ -152,15 +220,18 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
             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`),
             });
         }
@@ -182,10 +253,13 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         const brownieOutputPath = path.join(packageDir, 'Brownie.xcframework');
         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,
         });
         // Strip the binary from Brownie.xcframework to make it interface-only.
@@ -198,10 +272,13 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         const brownfieldNavigationOutputPath = path.join(packageDir, 'BrownfieldNavigation.xcframework');
         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,
         });
         stripFrameworkBinary(brownfieldNavigationOutputPath);
@@ -218,5 +295,12 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         logger.info(`Add the local package folder in Xcode: ${colorLink(relativeToCwd(packageDir))}`);
         logger.info('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) {
+    return value !== undefined;
+}
 export const packageIosExample = new ExampleUsage('package:ios --scheme BrownfieldLib --configuration Release', "Build iOS XCFramework for 'BrownfieldLib' scheme in Release configuration");

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

@@ -1,8 +1,11 @@
+import { type AppleSdk } from './destinationSdks.js';
 interface CopyDebugBundleToSimulatorSliceOptions {
     productsPath: string;
     configuration: string;
     frameworkName: string;
+    /** Slices the build produced; defaults to both. */
+    sdks?: AppleSdk[];
 }
-export declare function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, }: CopyDebugBundleToSimulatorSliceOptions): void;
+export declare function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, sdks, }: CopyDebugBundleToSimulatorSliceOptions): void;
 export {};
 //# sourceMappingURL=copyDebugBundleToSimulatorSlice.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"copyDebugBundleToSimulatorSlice.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/copyDebugBundleToSimulatorSlice.ts"],"names":[],"mappings":"AAKA,UAAU,sCAAsC;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,YAAY,EACZ,aAAa,EACb,aAAa,GACd,EAAE,sCAAsC,QA0CxC"}
+{"version":3,"file":"copyDebugBundleToSimulatorSlice.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/copyDebugBundleToSimulatorSlice.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErE,UAAU,sCAAsC;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,YAAY,EACZ,aAAa,EACb,aAAa,EACb,IAAqB,GACtB,EAAE,sCAAsC,QA+CxC"}

package/dist/brownfield/utils/copyDebugBundleToSimulatorSlice.js

@@ -1,10 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { colorLink, logger, relativeToCwd } from '@rock-js/tools';
-export function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, }) {
+import { ALL_APPLE_SDKS } from './destinationSdks.js';
+export function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, sdks = ALL_APPLE_SDKS, }) {
     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`, `${frameworkName}.framework`, 'main.jsbundle');
     const simulatorFrameworkPath = path.join(productsPath, `${configuration}-iphonesimulator`, `${frameworkName}.framework`);
     const simulatorBundlePath = path.join(simulatorFrameworkPath, 'main.jsbundle');

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

@@ -0,0 +1,36 @@
+/** 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 declare const ALL_APPLE_SDKS: AppleSdk[];
+/**
+ * SDK slices a `package:ios` run produces for the given `--destination` values.
+ *
+ * Omitting `--destination` builds both slices, matching Rock's default.
+ */
+export declare function resolveDestinationSdks(destination?: string[] | null): AppleSdk[];
+/**
+ * Whether `directoryPath` holds a build product `mergeFrameworks` can consume:
+ * either a real `.framework` bundle or the static library it synthesizes one from.
+ */
+export declare function hasFrameworkBuildProduct(directoryPath: string, frameworkName: string): boolean;
+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 declare function collectFrameworkPaths({ productsPath, configuration, sdks, frameworkName, productSubDir, }: CollectFrameworkPathsOptions): string[];
+export {};
+//# sourceMappingURL=destinationSdks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"destinationSdks.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/destinationSdks.ts"],"names":[],"mappings":"AAKA,sGAAsG;AACtG,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,iBAAiB,CAAC;AAEtD,uEAAuE;AACvE,eAAO,MAAM,cAAc,EAAE,QAAQ,EAAoC,CAAC;AA4B1E;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,GAC5B,QAAQ,EAAE,CASZ;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,WAMtB;AAED,UAAU,4BAA4B;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,aAAa,EACb,aAAa,GACd,EAAE,4BAA4B,GAAG,MAAM,EAAE,CA2BzC"}

package/dist/brownfield/utils/destinationSdks.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { RockError } from '@rock-js/tools';
+/** Both slices, in the order Rock's `packageIosAction` builds them. */
+export const ALL_APPLE_SDKS = ['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) {
+    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) {
+    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, frameworkName) {
+    return (fs.existsSync(path.join(directoryPath, `${frameworkName}.framework`)) ||
+        fs.existsSync(path.join(directoryPath, `lib${frameworkName}.a`)));
+}
+/**
+ * `.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, }) {
+    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;
+}

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

@@ -1,9 +1,17 @@
 export declare const EXPO_SUPPORT_XCFRAMEWORK_NAMES: readonly ["ExpoModulesJSI", "ExpoFileSystem", "ExpoFont", "ExpoModulesCore", "ExpoImage", "ExpoModulesWorklets"];
 export declare const ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES: readonly ["ExpoModulesJSI", "ExpoFileSystem", "ExpoFont", "ExpoModulesCore", "ExpoImage", "ExpoModulesWorklets", "SDWebImage", "SDWebImageSVGCoder", "SDWebImageWebPCoder", "SDWebImageAVIFCoder", "libavif"];
 export declare function getExpoSupportXcframeworkNames(usePrebuiltExpo: boolean): readonly ["ExpoModulesJSI", "ExpoFileSystem", "ExpoFont", "ExpoModulesCore", "ExpoImage", "ExpoModulesWorklets", "SDWebImage", "SDWebImageSVGCoder", "SDWebImageWebPCoder", "SDWebImageAVIFCoder", "libavif"] | readonly ["ExpoModulesJSI"];
-export declare function emitExpoSupportXcframeworks({ projectRoot, packageDir, usePrebuiltExpo, }: {
+export declare function emitExpoSupportXcframeworks({ projectRoot, packageDir, usePrebuiltExpo, usePrebuiltExpoExplicit, onDegradeToSource, }: {
     projectRoot: string;
     packageDir: string;
     usePrebuiltExpo?: boolean;
+    /**
+     * Whether `usePrebuiltExpo` was chosen by the user (CLI flag or brownfield.config.json)
+     * rather than inferred from the Expo SDK version. When inferred, missing prebuilts
+     * degrade to building Expo modules from source instead of throwing.
+     */
+    usePrebuiltExpoExplicit?: boolean;
+    /** Called when an inferred `usePrebuiltExpo` was degraded to `false` because prebuilts are absent */
+    onDegradeToSource?: () => void;
 }): boolean;
 //# sourceMappingURL=emitExpoSupportXcframeworks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"emitExpoSupportXcframeworks.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/emitExpoSupportXcframeworks.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,8BAA8B,kHAOjC,CAAC;AAEX,eAAO,MAAM,kCAAkC,+MAGrC,CAAC;AAEX,wBAAgB,8BAA8B,CAAC,eAAe,EAAE,OAAO,+OAItE;AA8CD,wBAAgB,2BAA2B,CAAC,EAC1C,WAAW,EACX,UAAU,EACV,eAAsB,GACvB,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,WAkCA"}
+{"version":3,"file":"emitExpoSupportXcframeworks.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/emitExpoSupportXcframeworks.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,8BAA8B,kHAOjC,CAAC;AAEX,eAAO,MAAM,kCAAkC,+MAGrC,CAAC;AAEX,wBAAgB,8BAA8B,CAAC,eAAe,EAAE,OAAO,+OAItE;AAsDD,wBAAgB,2BAA2B,CAAC,EAC1C,WAAW,EACX,UAAU,EACV,eAAsB,EACtB,uBAA8B,EAC9B,iBAAiB,GAClB,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;CAChC,WAwDA"}

package/dist/brownfield/utils/emitExpoSupportXcframeworks.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { RockError } from '@rock-js/tools';
+import { logger, RockError } from '@rock-js/tools';
 import { normalizeCopiedXcframework } from './normalizeCopiedXcframework.js';
-import { getExpoSdkMajor, isExpoProject } from './project.js';
+import { getExpoIosUsePrecompiledModules, getExpoSdkMajor, isExpoProject, } from './project.js';
 import { MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO } from './supportsPrebuiltExpo.js';
 /**
  * Swift support XCFrameworks
@@ -47,7 +47,13 @@ function resolveExpoFrameworkSourcePath(projectRoot, frameworkName) {
     }
     throw new RockError(`Unsupported Expo XCFramework: ${frameworkName}`);
 }
-export function emitExpoSupportXcframeworks({ projectRoot, packageDir, usePrebuiltExpo = true, }) {
+function getPrebuiltExpoRemedy(projectRoot) {
+    const cause = getExpoIosUsePrecompiledModules(projectRoot) === false
+        ? 'expo-build-properties sets ios.usePrecompiledModules to false, so prebuilt Expo XCFrameworks are never produced. '
+        : '';
+    return `${cause}Either re-run with --use-prebuilt-expo false to build Expo modules from source, or run \`pod install\` (with ios.usePrecompiledModules enabled) to materialize the prebuilts.`;
+}
+export function emitExpoSupportXcframeworks({ projectRoot, packageDir, usePrebuiltExpo = true, usePrebuiltExpoExplicit = true, onDegradeToSource, }) {
     if (!isExpoProject(projectRoot)) {
         return false;
     }
@@ -56,14 +62,30 @@ export function emitExpoSupportXcframeworks({ projectRoot, packageDir, usePrebui
         expoSdkMajor < MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO) {
         return false;
     }
+    if (usePrebuiltExpo && !usePrebuiltExpoExplicit) {
+        const missingPrebuilts = ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES.filter((frameworkName) => !fs.existsSync(resolveExpoFrameworkSourcePath(projectRoot, frameworkName)));
+        // ExpoModulesJSI ships in node_modules and is not a Pods prebuilt; only degrade
+        // when Pods-provided prebuilts are absent.
+        if (missingPrebuilts.some((name) => name !== 'ExpoModulesJSI')) {
+            logger.warn(`Prebuilt Expo XCFrameworks were not found (${missingPrebuilts.join(', ')}). ${getPrebuiltExpoRemedy(projectRoot)} Continuing without prebuilt Expo (--use-prebuilt-expo false); pass --use-prebuilt-expo true to make this an error.`);
+            usePrebuiltExpo = false;
+            onDegradeToSource?.();
+        }
+    }
     for (const frameworkName of getExpoSupportXcframeworkNames(usePrebuiltExpo)) {
         const sourcePath = resolveExpoFrameworkSourcePath(projectRoot, frameworkName);
         if (!fs.existsSync(sourcePath)) {
-            throw new RockError(`Expected Expo SDK ${MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO}+ XCFramework not found: ${frameworkName}.xcframework at ${path.relative(projectRoot, sourcePath)}`);
+            throw new RockError(`Expected Expo SDK ${MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO}+ XCFramework not found: ${frameworkName}.xcframework at ${path.relative(projectRoot, sourcePath)}. ${getPrebuiltExpoRemedy(projectRoot)}`);
         }
         const destinationPath = path.join(packageDir, `${frameworkName}.xcframework`);
         fs.rmSync(destinationPath, { recursive: true, force: true });
-        fs.cpSync(sourcePath, destinationPath, { recursive: true });
+        // With precompiled Expo, CocoaPods symlinks expo-image's dependencies into
+        // node_modules. Copy what the link points to, so the package is portable
+        // and normalizing it doesn't modify node_modules.
+        fs.cpSync(fs.realpathSync(sourcePath), destinationPath, {
+            recursive: true,
+            verbatimSymlinks: true,
+        });
         normalizeCopiedXcframework(destinationPath);
     }
     return true;

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

@@ -1,4 +1,11 @@
 type ExpoPlatform = 'ios' | 'android';
+/**
+ * Whether the platform's native project is generated by `expo prebuild` (Continuous Native
+ * Generation) rather than maintained by hand. A bare React Native app that installed Expo modules
+ * commits its native directories; running prebuild there would wipe them (including the
+ * brownfield library module), so prebuild only runs when the directory is missing or gitignored.
+ */
+export declare function usesContinuousNativeGeneration(projectRoot: string, platform: ExpoPlatform): boolean;
 export declare function runExpoPrebuildIfNeeded({ projectRoot, platform, }: {
     projectRoot: string;
     platform: ExpoPlatform;

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

@@ -1 +1 @@
-{"version":3,"file":"expo.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/expo.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AAqCtC,wBAAsB,uBAAuB,CAAC,EAC5C,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,YAAY,CAAC;CACxB,oBAqBA"}
+{"version":3,"file":"expo.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/expo.ts"],"names":[],"mappings":"AAQA,KAAK,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AAmDtC;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,YAAY,GACrB,OAAO,CAGT;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,YAAY,CAAC;CACxB,oBA4BA"}

package/dist/brownfield/utils/expo.js

@@ -1,4 +1,6 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { logger } from '@rock-js/tools';
 import { isExpoProject } from './project.js';
 async function spawnCommand({ command, args, cwd, }) {
@@ -22,10 +24,35 @@ async function spawnCommand({ command, args, cwd, }) {
 function getNpxCommand() {
     return process.platform === 'win32' ? 'npx.cmd' : 'npx';
 }
+function isGitIgnored(targetPath) {
+    // `git check-ignore` exits 0 when ignored, 1 when not, 128 outside a repo.
+    const result = spawnSync('git', ['check-ignore', '-q', targetPath], {
+        cwd: path.dirname(targetPath),
+        stdio: 'ignore',
+    });
+    if (result.status !== 0 && result.status !== 1) {
+        logger.warn(`Couldn't check with git whether ${path.basename(targetPath)}/ is gitignored, so it's treated as committed and expo prebuild is skipped. If this project uses Continuous Native Generation, run \`npx expo prebuild\` before packaging.`);
+    }
+    return result.status === 0;
+}
+/**
+ * Whether the platform's native project is generated by `expo prebuild` (Continuous Native
+ * Generation) rather than maintained by hand. A bare React Native app that installed Expo modules
+ * commits its native directories; running prebuild there would wipe them (including the
+ * brownfield library module), so prebuild only runs when the directory is missing or gitignored.
+ */
+export function usesContinuousNativeGeneration(projectRoot, platform) {
+    const nativeDir = path.join(projectRoot, platform);
+    return !fs.existsSync(nativeDir) || isGitIgnored(nativeDir);
+}
 export async function runExpoPrebuildIfNeeded({ projectRoot, platform, }) {
     if (!isExpoProject(projectRoot)) {
         return false;
     }
+    if (!usesContinuousNativeGeneration(projectRoot, platform)) {
+        logger.info(`Expo modules detected in a project with a committed ${platform} directory. Skipping expo prebuild.`);
+        return false;
+    }
     logger.info(`Expo project detected. Running expo prebuild for ${platform}...`);
     const args = ['expo', 'prebuild', '--platform', platform];
     if (platform === 'ios') {

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

@@ -14,6 +14,20 @@ export declare function getExpoConfigIfIsExpo(projectRoot: string): ExpoProjectC
  * @returns Whether the project is an Expo project
  */
 export declare function isExpoProject(projectRoot: string): boolean;
+/**
+ * Reads `ios.usePrecompiledModules` from the `expo-build-properties` plugin entry.
+ *
+ * `getExpoConfigIfIsExpo` uses `skipPlugins: true`, which makes `@expo/config`
+ * delete `exp.plugins`, so the plugins array is read from `rootConfig` (the raw
+ * static app.json / app.config.json) instead. `rootConfig` is the raw *static*
+ * config only, so a dynamic config (app.config.js/ts) exposes no plugins that
+ * way; for those we retry once with plugins enabled, which keeps the plugins
+ * array. That retry can throw for plugins that are not loadable as Node modules
+ * (the reason `skipPlugins` is set in the first place), so it is best-effort.
+ *
+ * @returns the explicit boolean value, or `undefined` if it is not set or not resolvable
+ */
+export declare function getExpoIosUsePrecompiledModules(projectRoot: string): boolean | undefined;
 export declare function getExpoSdkMajor(projectRoot: string): number | null;
 /**
  * Fills the RNC CLI project config from the Expo config by mutating the passed in `options.projectConfig` object in place

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

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/project.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,UAAU,EACX,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAEL,KAAK,aAAa,IAAI,iBAAiB,EACxC,MAAM,cAAc,CAAC;AAiCtB;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,4BAkBxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOlE;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,EAC9C,aAAa,EACb,UAAU,EAAE,EAAE,GAAG,EAAE,EACnB,WAAW,GACZ,EAAE;IACD,8CAA8C;IAC9C,aAAa,EAAE,aAAa,CAAC;IAE7B,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAE9B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB,QAuBA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,KAAK,GAAG,SAAS,EAC/D,QAAQ,EAAE,QAAQ,GACjB;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CACzC,CAeA;AAED,wBAAgB,aAAa,CAAC,EAC5B,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;CAC7B,GAAG,UAAU,CAuBb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,oBAAoB;;;EAQpC"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/project.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,UAAU,EACX,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAEL,KAAK,aAAa,IAAI,iBAAiB,EACxC,MAAM,cAAc,CAAC;AAiCtB;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,4BAkBxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAE1D;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,MAAM,GAClB,OAAO,GAAG,SAAS,CA8CrB;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOlE;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,EAC9C,aAAa,EACb,UAAU,EAAE,EAAE,GAAG,EAAE,EACnB,WAAW,GACZ,EAAE;IACD,8CAA8C;IAC9C,aAAa,EAAE,aAAa,CAAC;IAE7B,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAE9B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB,QAuBA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,KAAK,GAAG,SAAS,EAC/D,QAAQ,EAAE,QAAQ,GACjB;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CACzC,CAeA;AAED,wBAAgB,aAAa,CAAC,EAC5B,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;CAC7B,GAAG,UAAU,CAuBb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,oBAAoB;;;EAQpC"}

package/dist/brownfield/utils/project.js

@@ -53,6 +53,53 @@ export function getExpoConfigIfIsExpo(projectRoot) {
 export function isExpoProject(projectRoot) {
     return hasExpoAppConfig(projectRoot) && projectDependsOnExpo(projectRoot);
 }
+/**
+ * Reads `ios.usePrecompiledModules` from the `expo-build-properties` plugin entry.
+ *
+ * `getExpoConfigIfIsExpo` uses `skipPlugins: true`, which makes `@expo/config`
+ * delete `exp.plugins`, so the plugins array is read from `rootConfig` (the raw
+ * static app.json / app.config.json) instead. `rootConfig` is the raw *static*
+ * config only, so a dynamic config (app.config.js/ts) exposes no plugins that
+ * way; for those we retry once with plugins enabled, which keeps the plugins
+ * array. That retry can throw for plugins that are not loadable as Node modules
+ * (the reason `skipPlugins` is set in the first place), so it is best-effort.
+ *
+ * @returns the explicit boolean value, or `undefined` if it is not set or not resolvable
+ */
+export function getExpoIosUsePrecompiledModules(projectRoot) {
+    const config = getExpoConfigIfIsExpo(projectRoot);
+    if (!config) {
+        return undefined;
+    }
+    const rootConfig = config.rootConfig;
+    let plugins = config.exp.plugins ??
+        rootConfig?.expo?.plugins ??
+        rootConfig?.plugins;
+    if (!Array.isArray(plugins)) {
+        // Dynamic config: no static plugins array exists. Retry with plugins
+        // enabled, which preserves `exp.plugins`. Best-effort — plugin resolution
+        // can throw, and an unreadable config is treated the same as an unset value.
+        try {
+            plugins = getConfig(projectRoot, { skipSDKVersionRequirement: true }).exp.plugins;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!Array.isArray(plugins)) {
+        return undefined;
+    }
+    for (const plugin of plugins) {
+        if (!Array.isArray(plugin) || plugin[0] !== 'expo-build-properties') {
+            continue;
+        }
+        const value = plugin[1]?.ios?.usePrecompiledModules;
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return undefined;
+}
 export function getExpoSdkMajor(projectRoot) {
     const rawExpoVersion = getExpoConfigIfIsExpo(projectRoot)?.exp.sdkVersion;
     if (!rawExpoVersion) {