@callstack/brownfield-cli 3.13.1 → 3.14.0

package/src/brownfield/commands/packageIos.ts

@@ -17,7 +17,9 @@ import {
 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 { supportsPrebuiltRNCore } from '../utils/supportsPrebuiltRNCore.js';
 import {
   actionRunner,
@@ -31,7 +33,9 @@ import { resolvePackagedFrameworkName } from '../utils/resolvePackagedFrameworkN
 import { stripFrameworkBinary } from '../utils/stripFrameworkBinary.js';
 import type { PackageIosOptions } from '../../types.js';
 import { createLocalSpmPackage } from '../utils/createLocalSpmPackage.js';
+import { emitExpoSupportXcframeworks } from '../utils/emitExpoSupportXcframeworks.js';
 import { mergeBrownfieldConfigWithOptions } from '../../config.js';
+import { removeCodeSignatureArtifacts } from '../utils/normalizeCopiedXcframework.js';
 
 /** Help text for `--use-prebuilt-rn-core` (keep in sync with docs/docs/docs/getting-started/ios.mdx, "React Native Prebuilts" section). */
 const USE_PREBUILT_RN_CORE_HELP =
@@ -40,7 +44,14 @@ const USE_PREBUILT_RN_CORE_HELP =
   'Pass true or false to force either behavior. Use the flag without a value as shorthand for true (same as `--use-prebuilt-rn-core true`). ' +
   'See the Brownfield iOS guide for details: https://oss.callstack.com/react-native-brownfield/docs/getting-started/ios#react-native-prebuilts';
 
-export function parseUsePrebuiltRnCoreArgument(
+/** Help text for `--use-prebuilt-expo`. */
+const USE_PREBUILT_EXPO_HELP =
+  'Whether the Xcode build for packaging should use prebuilt Expo support XCFrameworks. ' +
+  'If you omit this flag, Brownfield follows version-aware defaults for supported Expo projects. ' +
+  'Pass true or false to force either behavior. Use the flag without a value as shorthand for true (same as `--use-prebuilt-expo true`).';
+
+function parseBooleanOptionArgument(
+  flagName: string,
   value: string | boolean
 ): boolean {
   if (typeof value === 'boolean') {
@@ -54,10 +65,22 @@ export function parseUsePrebuiltRnCoreArgument(
     return false;
   }
   throw new RockError(
-    `Invalid value for --use-prebuilt-rn-core: expected true or false, received "${value}"`
+    `Invalid value for ${flagName}: expected true or false, received "${value}"`
   );
 }
 
+export function parseUsePrebuiltRnCoreArgument(
+  value: string | boolean
+): boolean {
+  return parseBooleanOptionArgument('--use-prebuilt-rn-core', value);
+}
+
+export function parseUsePrebuiltExpoArgument(
+  value: string | boolean
+): boolean {
+  return parseBooleanOptionArgument('--use-prebuilt-expo', value);
+}
+
 function getPackagedFrameworkResolutionFailureMessage({
   resolution,
   candidates,
@@ -88,6 +111,11 @@ export const packageIosCommand = curryOptions(
       .preset(true)
       .argParser(parseUsePrebuiltRnCoreArgument)
   )
+  .addOption(
+    new Option('--use-prebuilt-expo [bool]', USE_PREBUILT_EXPO_HELP)
+      .preset(true)
+      .argParser(parseUsePrebuiltExpoArgument)
+  )
   .addOption(
     new Option(
       '--add-spm-package',
@@ -97,16 +125,25 @@ export const packageIosCommand = curryOptions(
   .action(
     actionRunner(async (cliOptions: PackageIosOptions) => {
       const options = mergeBrownfieldConfigWithOptions(cliOptions, 'ios');
+      const projectRoot = findProjectRoot();
+
+      await runExpoPrebuildIfNeeded({ projectRoot, platform: 'ios' });
 
-      const { projectRoot, platformConfig, userConfig } = getProjectInfo('ios');
+      const { platformConfig, userConfig } = getProjectInfo('ios');
 
       const prebuiltRNCoreSupport = supportsPrebuiltRNCore({ projectRoot });
+      const prebuiltExpoSupport = supportsPrebuiltExpo({ projectRoot });
 
       // version-aware default when the flag is omitted (see ios.mdx "React Native Prebuilts")
       options.usePrebuiltRnCore ??= prebuiltRNCoreSupport.supported
         ? prebuiltRNCoreSupport.enabledByDefault
         : false;
 
+        // version-aware default when the flag is omitted
+      options.usePrebuiltExpo ??= prebuiltExpoSupport.supported
+        ? prebuiltExpoSupport.enabledByDefault
+        : false;
+
       if (prebuiltRNCoreSupport) {
         logger.info(
           `${options.usePrebuiltRnCore ? 'Using' : 'Not using'} prebuilt RN core`
@@ -126,7 +163,9 @@ export const packageIosCommand = curryOptions(
         throw new RockError(prebuiltRNCoreSupport.reason);
       }
 
-      await runExpoPrebuildIfNeeded({ projectRoot, platform: 'ios' });
+      if (options.usePrebuiltExpo && !prebuiltExpoSupport.supported) {
+        throw new RockError(prebuiltExpoSupport.reason);
+      }
 
       if (!userConfig.project.ios) {
         throw new Error('iOS project not found.');
@@ -182,6 +221,12 @@ export const packageIosCommand = curryOptions(
         platformConfig
       );
 
+      emitExpoSupportXcframeworks({
+        projectRoot,
+        packageDir,
+        usePrebuiltExpo: options.usePrebuiltExpo,
+      });
+
       const productsPath = path.join(options.buildFolder, 'Build', 'Products');
       const { frameworkName, resolution, candidates } =
         resolvePackagedFrameworkName({
@@ -242,6 +287,7 @@ export const packageIosCommand = curryOptions(
         packageDir,
         'ReactBrownfield.xcframework'
       );
+
       if (fs.existsSync(reactBrownfieldXcframeworkPath)) {
         // Strip the binary from ReactBrownfield.xcframework to make it interface-only.
         // This avoids duplicate symbols when consumer apps embed both BrownfieldLib
@@ -313,10 +359,13 @@ export const packageIosCommand = curryOptions(
         );
       }
 
+      removeCodeSignatureArtifacts(packageDir);
+
       if (options.addSpmPackage) {
         const { packageManifestPath } = createLocalSpmPackage({
           packageDir,
           frameworkName: frameworkName ?? undefined,
+          usePrebuiltExpo: options.usePrebuiltExpo,
         });
 
         logger.success(

package/src/brownfield/commands/publishAndroid.ts

@@ -12,6 +12,7 @@ import {
   ExampleUsage,
 } from '../../shared/index.js';
 import { getProjectInfo } from '../utils/project.js';
+import { findProjectRoot } from '../utils/paths.js';
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
 import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
@@ -25,13 +26,15 @@ export const publishAndroidCommand = curryOptions(
 ).action(
   actionRunner(async (cliOptions: PublishLocalAarFlags) => {
     const options = mergeBrownfieldConfigWithOptions(cliOptions, 'android');
+    const projectRoot = findProjectRoot();
 
-    const { projectRoot, platformConfig } = getProjectInfo('android');
     await runExpoPrebuildIfNeeded({
       projectRoot,
       platform: 'android',
     });
 
+    const { platformConfig } = getProjectInfo('android');
+
     await runBrownieCodegenIfApplicable(projectRoot, 'kotlin');
     await runNavigationCodegenIfApplicable(projectRoot);
 

package/src/brownfield/utils/createLocalSpmPackage.ts

@@ -5,10 +5,15 @@ import {
   prepareLocalSpmArtifacts,
   SPM_ARTIFACTS_DIR_NAME,
 } from './prepareLocalSpmArtifacts.js';
+import {
+  ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES,
+  getExpoSupportXcframeworkNames,
+} from './emitExpoSupportXcframeworks.js';
 
 type CreateLocalSpmPackageOptions = {
   packageDir: string;
   frameworkName?: string;
+  usePrebuiltExpo?: boolean;
 };
 
 type CreateLocalSpmPackageResult = {
@@ -23,6 +28,7 @@ const RESERVED_FRAMEWORK_NAMES = new Set([
   'BrownfieldNavigation',
   'React',
   'ReactNativeDependencies',
+  ...ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES,
 ]);
 
 function requireXcframework(packageDir: string, name: string) {
@@ -130,7 +136,9 @@ function renderReadme({
   libraryName: string;
   targetNames: string[];
 }) {
-  const frameworks = targetNames.map((targetName) => `- \`${targetName}\``).join('\n');
+  const frameworks = targetNames
+    .map((targetName) => `- \`${targetName}\``)
+    .join('\n');
 
   return `# ${packageName}
 
@@ -167,17 +175,23 @@ This folder is generated by \`brownfield package:ios --add-spm-package\`. Re-run
 export function createLocalSpmPackage({
   packageDir,
   frameworkName,
+  usePrebuiltExpo = true,
 }: CreateLocalSpmPackageOptions): CreateLocalSpmPackageResult {
   const resolvedFrameworkName = resolveAppFrameworkName(
     packageDir,
     frameworkName
   );
+  const expoSupportXcframeworkNames =
+    getExpoSupportXcframeworkNames(usePrebuiltExpo);
   const targetNames = [
     resolvedFrameworkName,
     requireHermesXcframework(packageDir),
     requireXcframework(packageDir, 'ReactBrownfield'),
     optionalXcframework(packageDir, 'Brownie'),
     optionalXcframework(packageDir, 'BrownfieldNavigation'),
+    ...expoSupportXcframeworkNames.map((frameworkName) =>
+      optionalXcframework(packageDir, frameworkName)
+    ),
     optionalXcframework(packageDir, 'React'),
     optionalXcframework(packageDir, 'ReactNativeDependencies'),
   ].filter((targetName): targetName is string => targetName !== null);

package/src/brownfield/utils/emitExpoSupportXcframeworks.ts

@@ -0,0 +1,132 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { RockError } from '@rock-js/tools';
+
+import { normalizeCopiedXcframework } from './normalizeCopiedXcframework.js';
+import { getExpoSdkMajor, isExpoProject } from './project.js';
+
+import { MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO } from './supportsPrebuiltExpo.js';
+
+/**
+ * Swift support XCFrameworks
+ *
+ * These are required for the Expo Image module to work.
+ * 
+ * TODO: This needs investigation and maybe a discussion with the Expo team.
+ */
+const SWIFT_SUPPORT_XCFRAMEWORK_NAMES = [
+  'SDWebImage',
+  'SDWebImageSVGCoder',
+  'SDWebImageWebPCoder',
+  'SDWebImageAVIFCoder',
+  'libavif',
+] as const;
+
+export const EXPO_SUPPORT_XCFRAMEWORK_NAMES = [
+  'ExpoModulesJSI',
+  'ExpoFileSystem',
+  'ExpoFont',
+  'ExpoModulesCore',
+  'ExpoImage',
+  'ExpoModulesWorklets'
+] as const;
+
+export const ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES = [
+  ...EXPO_SUPPORT_XCFRAMEWORK_NAMES,
+  ...SWIFT_SUPPORT_XCFRAMEWORK_NAMES,
+] as const;
+
+export function getExpoSupportXcframeworkNames(usePrebuiltExpo: boolean) {
+  return usePrebuiltExpo
+    ? ALL_EXPO_SUPPORT_XCFRAMEWORK_NAMES
+    : (['ExpoModulesJSI'] as const);
+}
+
+type SwiftSupportXcframeworkName =
+  (typeof SWIFT_SUPPORT_XCFRAMEWORK_NAMES)[number];
+
+type ExpoSupportXcframeworkName =
+  (typeof EXPO_SUPPORT_XCFRAMEWORK_NAMES)[number];
+
+function resolveExpoFrameworkSourcePath(
+  projectRoot: string,
+  frameworkName: SwiftSupportXcframeworkName | ExpoSupportXcframeworkName
+) {
+  if (frameworkName === 'ExpoModulesJSI') {
+    return path.join(
+      projectRoot,
+      'node_modules',
+      'expo-modules-jsi',
+      'apple',
+      'Products',
+      'ExpoModulesJSI.xcframework'
+    );
+  }
+
+  if (SWIFT_SUPPORT_XCFRAMEWORK_NAMES.includes(frameworkName as SwiftSupportXcframeworkName)) {
+    return path.join(
+      projectRoot,
+      'ios',
+      'Pods',
+      'ExpoImage',
+      `${frameworkName}.xcframework`
+    );
+  }
+
+  if (EXPO_SUPPORT_XCFRAMEWORK_NAMES.includes(frameworkName as ExpoSupportXcframeworkName)) {
+    return path.join(
+      projectRoot,
+      'ios',
+      'Pods',
+      frameworkName,
+      `${frameworkName}.xcframework`
+    );
+  }
+
+  throw new RockError(`Unsupported Expo XCFramework: ${frameworkName}`);
+}
+
+export function emitExpoSupportXcframeworks({
+  projectRoot,
+  packageDir,
+  usePrebuiltExpo = true,
+}: {
+  projectRoot: string;
+  packageDir: string;
+  usePrebuiltExpo?: boolean;
+}) {
+  if (!isExpoProject(projectRoot)) {
+    return false;
+  }
+
+  const expoSdkMajor = getExpoSdkMajor(projectRoot);
+  if (
+    expoSdkMajor === null ||
+    expoSdkMajor < MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO
+  ) {
+    return false;
+  }
+
+  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)}`
+      );
+    }
+
+    const destinationPath = path.join(
+      packageDir,
+      `${frameworkName}.xcframework`
+    );
+    fs.rmSync(destinationPath, { recursive: true, force: true });
+    fs.cpSync(sourcePath, destinationPath, { recursive: true });
+    normalizeCopiedXcframework(destinationPath);
+  }
+
+  return true;
+}

package/src/brownfield/utils/normalizeCopiedXcframework.ts

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+export function removeCodeSignatureArtifacts(dirPath: string) {
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const entryPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      if (entry.name === '_CodeSignature') {
+        fs.rmSync(entryPath, { recursive: true, force: true });
+        continue;
+      }
+
+      removeCodeSignatureArtifacts(entryPath);
+      continue;
+    }
+
+    if (entry.name === 'CodeResources') {
+      fs.rmSync(entryPath, { force: true });
+    }
+  }
+}
+
+function resolveFrameworkExecutablePath(
+  frameworkDir: string,
+  frameworkName: string
+) {
+  const directExecutablePath = path.join(frameworkDir, frameworkName);
+  if (fs.existsSync(directExecutablePath)) {
+    return directExecutablePath;
+  }
+
+  const versionedExecutablePath = path.join(
+    frameworkDir,
+    'Versions',
+    'Current',
+    frameworkName
+  );
+  if (fs.existsSync(versionedExecutablePath)) {
+    return versionedExecutablePath;
+  }
+
+  return null;
+}
+
+function removeExecutableSignature(executablePath: string) {
+  try {
+    execFileSync('codesign', ['--remove-signature', executablePath], {
+      stdio: 'pipe',
+    });
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.includes('code object is not signed at all')
+    ) {
+      return;
+    }
+
+    throw error;
+  }
+}
+
+export function normalizeCopiedXcframework(xcframeworkPath: string) {
+  removeCodeSignatureArtifacts(xcframeworkPath);
+
+  for (const sliceName of fs.readdirSync(xcframeworkPath)) {
+    const slicePath = path.join(xcframeworkPath, sliceName);
+    if (!fs.statSync(slicePath).isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(slicePath)) {
+      if (!entry.endsWith('.framework')) {
+        continue;
+      }
+
+      const frameworkName = path.basename(entry, '.framework');
+      const frameworkDir = path.join(slicePath, entry);
+      const executablePath = resolveFrameworkExecutablePath(
+        frameworkDir,
+        frameworkName
+      );
+
+      if (executablePath) {
+        removeExecutableSignature(executablePath);
+      }
+    }
+  }
+}

package/src/brownfield/utils/prepareLocalSpmArtifacts.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
+
+import { normalizeCopiedXcframework } from './normalizeCopiedXcframework.js';
 
 type PrepareLocalSpmArtifactsOptions = {
   packageDir: string;
@@ -9,93 +10,6 @@ type PrepareLocalSpmArtifactsOptions = {
 
 export const SPM_ARTIFACTS_DIR_NAME = 'spm-artifacts';
 
-function removeCodeSignatureArtifacts(dirPath: string) {
-  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
-    const entryPath = path.join(dirPath, entry.name);
-
-    if (entry.isDirectory()) {
-      if (entry.name === '_CodeSignature') {
-        fs.rmSync(entryPath, { recursive: true, force: true });
-        continue;
-      }
-
-      removeCodeSignatureArtifacts(entryPath);
-      continue;
-    }
-
-    if (entry.name === 'CodeResources') {
-      fs.rmSync(entryPath, { force: true });
-    }
-  }
-}
-
-function resolveFrameworkExecutablePath(
-  frameworkDir: string,
-  frameworkName: string
-) {
-  const directExecutablePath = path.join(frameworkDir, frameworkName);
-  if (fs.existsSync(directExecutablePath)) {
-    return directExecutablePath;
-  }
-
-  const versionedExecutablePath = path.join(
-    frameworkDir,
-    'Versions',
-    'Current',
-    frameworkName
-  );
-  if (fs.existsSync(versionedExecutablePath)) {
-    return versionedExecutablePath;
-  }
-
-  return null;
-}
-
-function removeExecutableSignature(executablePath: string) {
-  try {
-    execFileSync('codesign', ['--remove-signature', executablePath], {
-      stdio: 'pipe',
-    });
-  } catch (error) {
-    if (
-      error instanceof Error &&
-      error.message.includes('code object is not signed at all')
-    ) {
-      return;
-    }
-
-    throw error;
-  }
-}
-
-function normalizeCopiedXcframeworkSignature(xcframeworkPath: string) {
-  removeCodeSignatureArtifacts(xcframeworkPath);
-
-  for (const sliceName of fs.readdirSync(xcframeworkPath)) {
-    const slicePath = path.join(xcframeworkPath, sliceName);
-    if (!fs.statSync(slicePath).isDirectory()) {
-      continue;
-    }
-
-    for (const entry of fs.readdirSync(slicePath)) {
-      if (!entry.endsWith('.framework')) {
-        continue;
-      }
-
-      const frameworkName = path.basename(entry, '.framework');
-      const frameworkDir = path.join(slicePath, entry);
-      const executablePath = resolveFrameworkExecutablePath(
-        frameworkDir,
-        frameworkName
-      );
-
-      if (executablePath) {
-        removeExecutableSignature(executablePath);
-      }
-    }
-  }
-}
-
 export function prepareLocalSpmArtifacts({
   packageDir,
   targetNames,
@@ -107,10 +21,13 @@ export function prepareLocalSpmArtifacts({
 
   for (const targetName of targetNames) {
     const sourcePath = path.join(packageDir, `${targetName}.xcframework`);
-    const destinationPath = path.join(spmArtifactsDir, `${targetName}.xcframework`);
+    const destinationPath = path.join(
+      spmArtifactsDir,
+      `${targetName}.xcframework`
+    );
 
     fs.renameSync(sourcePath, destinationPath);
-    normalizeCopiedXcframeworkSignature(destinationPath);
+    normalizeCopiedXcframework(destinationPath);
   }
 
   return spmArtifactsDir;

package/src/brownfield/utils/project.ts

@@ -21,15 +21,46 @@ const cliConfig: typeof cliConfigImport =
     : // @ts-expect-error: interop default
       cliConfigImport.default;
 
+function hasExpoAppConfig(projectRoot: string): boolean {
+  return (
+    fs.existsSync(path.join(projectRoot, 'app.json')) ||
+    fs.existsSync(path.join(projectRoot, 'app.config.js')) ||
+    fs.existsSync(path.join(projectRoot, 'app.config.ts')) ||
+    fs.existsSync(path.join(projectRoot, 'app.config.mjs'))
+  );
+}
+
+function projectDependsOnExpo(projectRoot: string): boolean {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, 'utf-8')
+  ) as Record<string, Record<string, string>>;
+
+  return ['dependencies', 'peerDependencies', 'devDependencies'].some(
+    (key) => packageJson[key]?.expo
+  );
+}
+
 /**
  * Gets the Expo config if the project is an Expo project
  * @param projectRoot The project root path
  * @returns The Expo config if the project is an Expo project, null otherwise
  */
 export function getExpoConfigIfIsExpo(projectRoot: string) {
+  const hasAppConfig = hasExpoAppConfig(projectRoot);
+
   try {
     return getConfig(projectRoot, { skipSDKVersionRequirement: true });
-  } catch {
+  } catch (error) {
+    if (hasAppConfig) {
+      throw error;
+    }
+
     return null;
   }
 }
@@ -41,19 +72,7 @@ export function getExpoConfigIfIsExpo(projectRoot: string) {
  * @returns Whether the project is an Expo project
  */
 export function isExpoProject(projectRoot: string): boolean {
-  const hasExpoConfig = getExpoConfigIfIsExpo(projectRoot) !== null;
-
-  // additionally, it is needed to check if the project depends on Expo packages explicitly
-  // to prevent false positives in a monorepo setup
-  const rnProjectRoot = findProjectRoot();
-  const packageJsonPath = path.join(rnProjectRoot, 'package.json');
-  const dependsOnExpo =
-    fs.existsSync(packageJsonPath) &&
-    ['dependencies', 'peerDependencies', 'devDependencies'].some(
-      (key) => JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))[key]?.expo
-    );
-
-  return hasExpoConfig && dependsOnExpo;
+  return hasExpoAppConfig(projectRoot) && projectDependsOnExpo(projectRoot);
 }
 
 export function getExpoSdkMajor(projectRoot: string): number | null {

package/src/brownfield/utils/supportsPrebuiltExpo.ts

@@ -0,0 +1,34 @@
+import { getExpoSdkMajor, isExpoProject } from './project.js';
+
+export const MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO = 56;
+
+export type PrebuiltExpoSupportResult =
+  | { supported: true; enabledByDefault: boolean; reason?: never }
+  | { supported: false; enabledByDefault?: never; reason: string };
+
+export function supportsPrebuiltExpo({
+  projectRoot,
+}: {
+  projectRoot: string;
+}): PrebuiltExpoSupportResult {
+  if (!isExpoProject(projectRoot)) {
+    return { supported: true, enabledByDefault: false };
+  }
+
+  const expoSdkMajor = getExpoSdkMajor(projectRoot);
+  if (
+    expoSdkMajor === null ||
+    expoSdkMajor < MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_EXPO
+  ) {
+    const sdkLabel = expoSdkMajor === null ? 'unknown' : String(expoSdkMajor);
+    return {
+      supported: false,
+      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.`,
+    };
+  }
+
+  return {
+    supported: true,
+    enabledByDefault: true,
+  };
+}

package/src/brownie/config.ts

@@ -108,7 +108,7 @@ export function resolveBrownieCodegenConfig({
   const legacyConfig = hasLegacyConfig(projectRoot)
     ? loadConfig(projectRoot)
     : undefined;
-  const brownfieldBrownie = loadBrownfieldConfig(projectRoot).brownie;
+  const brownfieldBrownie = loadBrownfieldConfig(projectRoot)?.brownie;
 
   if (legacyConfig !== undefined && (brownie ?? brownfieldBrownie)) {
     throw new Error(LEGACY_AND_NEW_BROWNIE_CONFIG_ERROR);