@expo/build-tools 18.4.0 → 18.6.0

package/dist/steps/functions/repack.js

@@ -15,6 +15,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const resolve_from_1 = __importDefault(require("resolve-from"));
 const fastlane_1 = require("../../common/fastlane");
 const manager_1 = __importDefault(require("../utils/ios/credentials/manager"));
+const packageManager_1 = require("../../utils/packageManager");
 function createRepackBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -42,6 +43,11 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'js_bundle_only',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -68,7 +74,10 @@ function createRepackBuildFunction() {
             if (![eas_build_job_1.Platform.ANDROID, eas_build_job_1.Platform.IOS].includes(platform)) {
                 throw new Error(`Unsupported platform: ${platform}. Platform must be "${eas_build_job_1.Platform.ANDROID}" or "${eas_build_job_1.Platform.IOS}"`);
             }
-            const repackSpawnAsync = createSpawnAsyncStepAdapter({ verbose, logger: stepsCtx.logger });
+            const repackSpawnAsync = createSpawnAsyncStepAdapter({
+                verbose,
+                logger: stepsCtx.logger,
+            });
             const tmpDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), `repack-`));
             const workingDirectory = node_path_1.default.join(tmpDir, 'working-directory');
             await node_fs_1.default.promises.mkdir(workingDirectory);
@@ -81,10 +90,16 @@ function createRepackBuildFunction() {
                     sourcemapOutput: undefined,
                 }
                 : undefined;
-            stepsCtx.logger.info(`Using repack from: ${inputs.repack_package.value}@${inputs.repack_version.value}`);
+            const jsBundleOnly = inputs.js_bundle_only.value ?? false;
+            const resolvedRepackVersion = (await (0, packageManager_1.resolvePackageVersionAsync)({
+                logger: stepsCtx.logger,
+                packageName: inputs.repack_package.value,
+                distTag: inputs.repack_version.value,
+            })) ?? inputs.repack_version.value;
+            stepsCtx.logger.info(`Using repack from: ${inputs.repack_package.value}@${inputs.repack_version.value} (${resolvedRepackVersion})`);
             const repackApp = await installAndImportRepackAsync({
                 packageName: inputs.repack_package.value,
-                version: inputs.repack_version.value,
+                version: resolvedRepackVersion,
             });
             const { repackAppIosAsync, repackAppAndroidAsync } = repackApp;
             stepsCtx.logger.info('Repacking the app...');
@@ -97,6 +112,7 @@ function createRepackBuildFunction() {
                         outputPath,
                         workingDirectory,
                         exportEmbedOptions,
+                        jsBundleOnly,
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
@@ -124,6 +140,7 @@ function createRepackBuildFunction() {
                                 outputPath,
                                 workingDirectory,
                                 exportEmbedOptions,
+                                jsBundleOnly,
                                 androidSigningOptions,
                                 logger: stepsCtx.logger,
                                 spawnAsync: repackSpawnAsync,

package/dist/steps/functions/restoreBuildCache.d.ts

@@ -12,6 +12,14 @@ export declare function restoreCcacheAsync({ logger, workingDirectory, platform,
         robotAccessToken?: string;
     };
 }): Promise<void>;
+export declare function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }: {
+    logger: bunyan;
+    workingDirectory: string;
+    env: Record<string, string | undefined>;
+    secrets?: {
+        robotAccessToken?: string;
+    };
+}): Promise<void>;
 export declare function cacheStatsAsync({ logger, env, secrets, }: {
     logger: bunyan;
     env: Record<string, string | undefined>;

package/dist/steps/functions/restoreBuildCache.js

@@ -6,14 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRestoreBuildCacheFunction = createRestoreBuildCacheFunction;
 exports.createCacheStatsBuildFunction = createCacheStatsBuildFunction;
 exports.restoreCcacheAsync = restoreCcacheAsync;
+exports.restoreGradleCacheAsync = restoreGradleCacheAsync;
 exports.cacheStatsAsync = cacheStatsAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
+const fs_1 = __importDefault(require("fs"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const ccacheStats_1 = require("./ccacheStats");
 const restoreCache_1 = require("./restoreCache");
 const cacheKey_1 = require("../../utils/cacheKey");
+const gradleCacheKey_1 = require("../../utils/gradleCacheKey");
 const turtleFetch_1 = require("../../utils/turtleFetch");
 function createRestoreBuildCacheFunction() {
     return new steps_1.BuildFunction({
@@ -43,6 +48,14 @@ function createRestoreBuildCacheFunction() {
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
             });
+            if (platform === eas_build_job_1.Platform.ANDROID) {
+                await restoreGradleCacheAsync({
+                    logger,
+                    workingDirectory,
+                    env,
+                    secrets: stepCtx.global.staticContext.job.secrets,
+                });
+            }
         },
     });
 }
@@ -140,6 +153,78 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
         }
     }
 }
+async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
+    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+        return;
+    }
+    try {
+        const gradlePropertiesPath = path_1.default.join(workingDirectory, 'android', 'gradle.properties');
+        const gradlePropertiesContent = await fs_1.default.promises.readFile(gradlePropertiesPath, 'utf-8');
+        await fs_1.default.promises.writeFile(gradlePropertiesPath, `${gradlePropertiesContent}\n\norg.gradle.caching=true\n`);
+        // Configure cache cleanup via init script (works with both Gradle 8 and 9,
+        // org.gradle.cache.cleanup property was removed in Gradle 9)
+        const initScriptDir = path_1.default.join(os_1.default.homedir(), '.gradle', 'init.d');
+        await fs_1.default.promises.mkdir(initScriptDir, { recursive: true });
+        await fs_1.default.promises.writeFile(path_1.default.join(initScriptDir, 'eas-cache-cleanup.gradle'), [
+            'def cacheDir = new File(System.getProperty("user.home"), ".gradle/caches/build-cache-1")',
+            'def countBefore = cacheDir.exists() ? cacheDir.listFiles()?.length ?: 0 : 0',
+            'println "[EAS] Gradle build cache entries before cleanup: ${countBefore}"',
+            '',
+            'beforeSettings { settings ->',
+            '    try {',
+            '        settings.caches {',
+            '            cleanup = Cleanup.ALWAYS',
+            '            buildCache {',
+            '                setRemoveUnusedEntriesAfterDays(3)',
+            '            }',
+            '        }',
+            '        println "[EAS] Configured Gradle cache cleanup via init script"',
+            '    } catch (Exception e) {',
+            '        println "[EAS] Failed to configure cache cleanup: ${e.message}"',
+            '    }',
+            '}',
+            '',
+            'gradle.buildFinished {',
+            '    def countAfter = cacheDir.exists() ? cacheDir.listFiles()?.length ?: 0 : 0',
+            '    println "[EAS] Gradle build cache entries after build: ${countAfter} (was ${countBefore})"',
+            '}',
+            '',
+        ].join('\n'));
+        const robotAccessToken = (0, nullthrows_1.default)(secrets?.robotAccessToken, 'Robot access token is required for cache operations');
+        const expoApiServerURL = (0, nullthrows_1.default)(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
+        const cacheKey = await (0, gradleCacheKey_1.generateGradleCacheKeyAsync)(workingDirectory);
+        logger.info(`Restoring Gradle cache key: ${cacheKey}`);
+        const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
+        const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+        const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
+            logger,
+            jobId,
+            expoApiServerURL,
+            robotAccessToken,
+            paths: [buildCachePath],
+            key: cacheKey,
+            keyPrefixes: [gradleCacheKey_1.GRADLE_CACHE_KEY_PREFIX],
+            platform: eas_build_job_1.Platform.ANDROID,
+        });
+        await fs_1.default.promises.mkdir(gradleCachesPath, { recursive: true });
+        await (0, restoreCache_1.decompressCacheAsync)({
+            archivePath,
+            workingDirectory: gradleCachesPath,
+            verbose: env.EXPO_DEBUG === '1',
+            logger,
+        });
+        logger.info(`Gradle cache restored to ${gradleCachesPath} ${matchedKey === cacheKey ? '(direct hit)' : '(prefix match)'}`);
+    }
+    catch (err) {
+        if (err instanceof turtleFetch_1.TurtleFetchError && err.response?.status === 404) {
+            logger.info('No Gradle cache found for this key');
+        }
+        else {
+            logger.warn('Failed to restore Gradle cache: ', err);
+        }
+    }
+}
 async function cacheStatsAsync({ logger, env, secrets, }) {
     const enabled = env.EAS_RESTORE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_RESTORE_CACHE !== '0');
     if (!enabled) {

package/dist/steps/functions/saveBuildCache.d.ts

@@ -12,3 +12,11 @@ export declare function saveCcacheAsync({ logger, workingDirectory, platform, ev
         robotAccessToken?: string;
     };
 }): Promise<void>;
+export declare function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, }: {
+    logger: bunyan;
+    workingDirectory: string;
+    env: Record<string, string | undefined>;
+    secrets?: {
+        robotAccessToken?: string;
+    };
+}): Promise<void>;

package/dist/steps/functions/saveBuildCache.js

@@ -5,13 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSaveBuildCacheFunction = createSaveBuildCacheFunction;
 exports.saveCcacheAsync = saveCcacheAsync;
+exports.saveGradleCacheAsync = saveGradleCacheAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const fs_1 = __importDefault(require("fs"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const saveCache_1 = require("./saveCache");
+const artifacts_1 = require("../../utils/artifacts");
 const cacheKey_1 = require("../../utils/cacheKey");
+const gradleCacheKey_1 = require("../../utils/gradleCacheKey");
 function createSaveBuildCacheFunction(evictUsedBefore) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -41,6 +46,14 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
             });
+            if (platform === eas_build_job_1.Platform.ANDROID) {
+                await saveGradleCacheAsync({
+                    logger,
+                    workingDirectory,
+                    env,
+                    secrets: stepCtx.global.staticContext.job.secrets,
+                });
+            }
         },
     });
 }
@@ -98,3 +111,47 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
         logger.error({ err }, 'Failed to save cache');
     }
 }
+async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
+    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+        return;
+    }
+    const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
+    const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+    try {
+        await fs_1.default.promises.access(buildCachePath);
+    }
+    catch {
+        logger.warn('No Gradle build cache found, skipping save');
+        return;
+    }
+    try {
+        const cacheKey = await (0, gradleCacheKey_1.generateGradleCacheKeyAsync)(workingDirectory);
+        logger.info(`Saving Gradle cache key: ${cacheKey}`);
+        const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
+        const robotAccessToken = (0, nullthrows_1.default)(secrets?.robotAccessToken, 'Robot access token is required for cache operations');
+        const expoApiServerURL = (0, nullthrows_1.default)(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        logger.info('Compressing Gradle build cache...');
+        const { archivePath } = await (0, saveCache_1.compressCacheAsync)({
+            paths: [buildCachePath],
+            workingDirectory: gradleCachesPath,
+            verbose: env.EXPO_DEBUG === '1',
+            logger,
+        });
+        const { size } = await fs_1.default.promises.stat(archivePath);
+        logger.info(`Gradle cache archive size: ${(0, artifacts_1.formatBytes)(size)}`);
+        await (0, saveCache_1.uploadCacheAsync)({
+            logger,
+            jobId,
+            expoApiServerURL,
+            robotAccessToken,
+            archivePath,
+            key: cacheKey,
+            paths: [buildCachePath],
+            size,
+            platform: eas_build_job_1.Platform.ANDROID,
+        });
+    }
+    catch (err) {
+        logger.error({ err }, 'Failed to save Gradle cache');
+    }
+}

package/dist/steps/functions/startAndroidEmulator.js

@@ -57,6 +57,11 @@ function createStartAndroidEmulatorBuildFunction() {
             const systemImagePackage = `${inputs.system_image_package.value}`;
             // We can cast because allowedValueTypeName validated this is a string.
             const deviceIdentifier = inputs.device_identifier.value;
+            const shouldAdjustAnimationScale = env.ANDROID_EMULATOR_ADJUST_ANIMATION_SCALE !== 'false' &&
+                env.ANDROID_EMULATOR_ADJUST_ANIMATION_SCALE !== '0';
+            if (!shouldAdjustAnimationScale) {
+                logger.info('Skipping Android emulator animation scale adjustments because $ANDROID_EMULATOR_ADJUST_ANIMATION_SCALE is disabled.');
+            }
             logger.info('Making sure system image is installed');
             await (0, retry_1.retryAsync)(async () => {
                 await (0, turtle_spawn_1.default)('sdkmanager', [systemImagePackage], {
@@ -99,6 +104,13 @@ function createStartAndroidEmulatorBuildFunction() {
                         timeoutMs,
                         logger,
                     });
+                    if (shouldAdjustAnimationScale) {
+                        await AndroidEmulatorUtils_1.AndroidEmulatorUtils.disableWindowAndTransitionAnimationsAsync({
+                            env,
+                            logger,
+                            serialId: attemptSerialId,
+                        });
+                    }
                     logger.info(`${deviceName} is ready.`);
                     serialId = attemptSerialId;
                     emulatorPromise = startResult.emulatorPromise;
@@ -174,6 +186,13 @@ function createStartAndroidEmulatorBuildFunction() {
                                 timeoutMs,
                                 logger,
                             });
+                            if (shouldAdjustAnimationScale) {
+                                await AndroidEmulatorUtils_1.AndroidEmulatorUtils.disableWindowAndTransitionAnimationsAsync({
+                                    env,
+                                    logger,
+                                    serialId: cloneSerialId,
+                                });
+                            }
                             logger.info(`${cloneIdentifier} is ready.`);
                         }
                         catch (err) {

package/dist/steps/functions/uploadToAsc.d.ts

@@ -3,6 +3,9 @@ export declare function createUploadToAscBuildFunction(): BuildFunction;
 export declare function isClosedVersionTrainError(messages: {
     code: string;
 }[]): boolean;
+export declare function isSdkVersionIssueError(messages: {
+    code: string;
+}[]): boolean;
 export declare function isInvalidBundleIdentifierError(messages: {
     code: string;
 }[]): boolean;

package/dist/steps/functions/uploadToAsc.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUploadToAscBuildFunction = createUploadToAscBuildFunction;
 exports.isClosedVersionTrainError = isClosedVersionTrainError;
+exports.isSdkVersionIssueError = isSdkVersionIssueError;
 exports.isInvalidBundleIdentifierError = isInvalidBundleIdentifierError;
 exports.isMissingPurposeStringError = isMissingPurposeStringError;
 exports.parseMissingUsageDescriptionKeys = parseMissingUsageDescriptionKeys;
@@ -247,17 +248,36 @@ function createUploadToAscBuildFunction() {
                     stepsCtx.logger.error(`Errors:\n${itemizeMessages(errors)}\n`);
                 }
                 if (state.state === 'FAILED') {
+                    if (isSdkVersionIssueError(errors)) {
+                        throw new eas_build_job_1.UserError('EAS_UPLOAD_TO_ASC_SDK_VERSION_ISSUE', 'Build upload was rejected by App Store Connect because the IPA was built with an iOS SDK that is too old for current App Store Connect requirements. ' +
+                            'In an Expo project, this usually means the build used an outdated EAS iOS image or the project still depends on an Expo SDK / native setup that does not support the required Xcode toolchain. ' +
+                            'Upgrade to a supported Expo SDK if needed and/or select a newer iOS image in `eas.json`, rebuild, and submit again.', {
+                            docsUrl: 'https://docs.expo.dev/workflow/upgrading-expo-sdk-walkthrough/',
+                        });
+                    }
                     if (isInvalidBundleIdentifierError(errors)) {
                         const ipaInfoResult = await (0, results_1.asyncResult)((0, readIpaInfo_1.readIpaInfoAsync)(ipaPath));
                         const ipaBundleIdentifier = ipaInfoResult.ok
                             ? ipaInfoResult.value.bundleIdentifier
                             : null;
+                        let visibleAppsSummary = null;
+                        try {
+                            const apps = await AscApiUtils_1.AscApiUtils.getAppsAsync({ client, limit: 5 });
+                            visibleAppsSummary = AscApiUtils_1.AscApiUtils.formatAppsList(apps);
+                        }
+                        catch {
+                            // Ok to fail, this is just trying to be helpful.
+                        }
                         throw new eas_build_job_1.UserError('EAS_UPLOAD_TO_ASC_INVALID_BUNDLE_ID', `Build upload was rejected by App Store Connect because the app bundle identifier in the IPA does not match the selected App Store Connect app.\n\n` +
                             `IPA bundle identifier: ${ipaBundleIdentifier ?? '(unavailable)'}\n` +
                             `App Store Connect app bundle identifier: ${ascAppBundleIdentifier}\n\n` +
                             'Bundle identifier cannot be changed for an existing App Store Connect app. ' +
                             'If you selected the wrong app, change the Apple app identifier in the submit profile. ' +
-                            'If you selected the right app, you may want to select a different build to upload (or rebuild with a different profile).');
+                            'If you selected the right app, you may want to select a different build to upload (or rebuild with a different profile).' +
+                            '\n\nOther App Store Connect apps visible to this API key:\n' +
+                            (visibleAppsSummary ?? '  (unable to retrieve)'), {
+                            docsUrl: 'https://expo.fyi/asc-app-id',
+                        });
                     }
                     if (isMissingPurposeStringError(errors)) {
                         const missingUsageDescriptionKeys = parseMissingUsageDescriptionKeys(errors);
@@ -293,6 +313,9 @@ function isClosedVersionTrainError(messages) {
     return (messages.length > 0 &&
         messages.every(message => ['90062', '90186', '90478'].includes(message.code)));
 }
+function isSdkVersionIssueError(messages) {
+    return messages.length > 0 && messages.every(message => message.code === '90725');
+}
 function isInvalidBundleIdentifierError(messages) {
     return (messages.length > 0 && messages.every(message => ['90054', '90055'].includes(message.code)));
 }

package/dist/steps/utils/ios/AscApiClient.d.ts

@@ -92,8 +92,8 @@ declare const GetApi: {
         }, z.core.$strip>;
         request: z.ZodObject<{
             'fields[buildUploads]': z.ZodArray<z.ZodEnum<{
-                build: "build";
                 state: "state";
+                build: "build";
             }>>;
             include: z.ZodArray<z.ZodEnum<{
                 build: "build";

package/dist/steps/utils/ios/AscApiUtils.d.ts

@@ -10,4 +10,9 @@ export declare namespace AscApiUtils {
         bundleShortVersion: string;
         bundleVersion: string;
     }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']>;
+    function getAppsAsync({ client, limit, }: {
+        client: Pick<AscApiClient, 'getAsync'>;
+        limit?: number;
+    }): Promise<AscApiClientGetApi['/v1/apps']['response']['data']>;
+    function formatAppsList(apps: AscApiClientGetApi['/v1/apps']['response']['data']): string;
 }

package/dist/steps/utils/ios/AscApiUtils.js

@@ -19,7 +19,8 @@ var AscApiUtils;
             }
             let visibleAppsSummary = null;
             try {
-                visibleAppsSummary = await getVisibleAppsSummaryAsync(client);
+                const apps = await AscApiUtils.getAppsAsync({ client, limit: 10 });
+                visibleAppsSummary = AscApiUtils.formatAppsList(apps);
             }
             catch {
                 // Don't hide the original NOT_FOUND error with a secondary lookup failure.
@@ -75,16 +76,18 @@ var AscApiUtils;
         }
     }
     AscApiUtils.createBuildUploadAsync = createBuildUploadAsync;
-})(AscApiUtils || (exports.AscApiUtils = AscApiUtils = {}));
-async function getVisibleAppsSummaryAsync(client) {
-    const appsResponse = await client.getAsync('/v1/apps', {
-        'fields[apps]': ['bundleId', 'name'],
-        limit: 10,
-    });
-    if (appsResponse.data.length === 0) {
-        return '  (none)';
+    async function getAppsAsync({ client, limit, }) {
+        const appsResponse = await client.getAsync('/v1/apps', {
+            'fields[apps]': ['bundleId', 'name'],
+            limit: limit ?? 10,
+        });
+        return appsResponse.data;
+    }
+    AscApiUtils.getAppsAsync = getAppsAsync;
+    function formatAppsList(apps) {
+        return (apps
+            .map(app => `- ${app.attributes.name} (${app.attributes.bundleId}) (ID: ${app.id})`)
+            .join('\n') || '  (none)');
     }
-    return appsResponse.data
-        .map(app => `- ${app.attributes.name} (${app.attributes.bundleId}) (ID: ${app.id})`)
-        .join('\n');
-}
+    AscApiUtils.formatAppsList = formatAppsList;
+})(AscApiUtils || (exports.AscApiUtils = AscApiUtils = {}));

package/dist/steps/utils/ios/configure.js

@@ -11,6 +11,7 @@ const plist_1 = __importDefault(require("@expo/plist"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const uniq_1 = __importDefault(require("lodash/uniq"));
 const path_1 = __importDefault(require("path"));
+const provisioningProfile_1 = require("./credentials/provisioningProfile");
 async function configureCredentialsAsync(logger, workingDir, { credentials, buildConfiguration, }) {
     const targetNames = Object.keys(credentials.targetProvisioningProfiles);
     for (const targetName of targetNames) {
@@ -21,6 +22,9 @@ async function configureCredentialsAsync(logger, workingDir, { credentials, buil
             profileName: profile.name,
             appleTeamId: profile.teamId,
             buildConfiguration,
+            ...(credentials.distributionType === provisioningProfile_1.DistributionType.DEVELOPMENT && {
+                codeSignIdentity: profile.certificateCommonName,
+            }),
         });
     }
 }

package/dist/steps/utils/ios/credentials/provisioningProfile.d.ts

@@ -13,6 +13,7 @@ export interface ProvisioningProfileData {
 export declare enum DistributionType {
     AD_HOC = "ad-hoc",
     APP_STORE = "app-store",
+    DEVELOPMENT = "development",
     ENTERPRISE = "enterprise"
 }
 export default class ProvisioningProfile {

package/dist/steps/utils/ios/credentials/provisioningProfile.js

@@ -16,6 +16,7 @@ var DistributionType;
 (function (DistributionType) {
     DistributionType["AD_HOC"] = "ad-hoc";
     DistributionType["APP_STORE"] = "app-store";
+    DistributionType["DEVELOPMENT"] = "development";
     DistributionType["ENTERPRISE"] = "enterprise";
 })(DistributionType || (exports.DistributionType = DistributionType = {}));
 const PROVISIONING_PROFILES_DIRECTORY = path_1.default.join(os_1.default.homedir(), 'Library/MobileDevice/Provisioning Profiles');
@@ -105,6 +106,10 @@ class ProvisioningProfile {
             return DistributionType.ENTERPRISE;
         }
         else if (plistData.ProvisionedDevices) {
+            const entitlements = plistData.Entitlements;
+            if (entitlements?.['get-task-allow']) {
+                return DistributionType.DEVELOPMENT;
+            }
             return DistributionType.AD_HOC;
         }
         else {

package/dist/utils/AndroidEmulatorUtils.d.ts

@@ -47,6 +47,11 @@ export declare namespace AndroidEmulatorUtils {
         timeoutMs?: number;
         logger?: bunyan;
     }): Promise<void>;
+    function disableWindowAndTransitionAnimationsAsync({ serialId, env, logger, }: {
+        serialId: AndroidDeviceSerialId;
+        env: NodeJS.ProcessEnv;
+        logger: bunyan;
+    }): Promise<void>;
     function collectLogsAsync({ serialId, env, }: {
         serialId: AndroidDeviceSerialId;
         env: NodeJS.ProcessEnv;

package/dist/utils/AndroidEmulatorUtils.js

@@ -275,6 +275,23 @@ var AndroidEmulatorUtils;
         });
     }
     AndroidEmulatorUtils.waitForReadyAsync = waitForReadyAsync;
+    async function disableWindowAndTransitionAnimationsAsync({ serialId, env, logger, }) {
+        logger.info('Disabling Android emulator window animations.');
+        try {
+            await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'shell', 'settings', 'put', 'global', 'window_animation_scale', '0'], { env });
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to disable Android emulator window animations.');
+        }
+        logger.info('Disabling Android emulator transition animations.');
+        try {
+            await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'shell', 'settings', 'put', 'global', 'transition_animation_scale', '0'], { env });
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to disable Android emulator transition animations.');
+        }
+    }
+    AndroidEmulatorUtils.disableWindowAndTransitionAnimationsAsync = disableWindowAndTransitionAnimationsAsync;
     async function hasNetworkConnectionAsync({ serialId, env, }) {
         const networkReadyCheckCommand = env.ANDROID_EMULATOR_NETWORK_READY_COMMAND?.trim();
         if (networkReadyCheckCommand) {

package/dist/utils/appConfig.d.ts

@@ -1,9 +1,11 @@
 import { ProjectConfig } from '@expo/config';
 import { Env } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
-export declare function readAppConfig({ projectDir, env, logger, sdkVersion, }: {
+interface ReadAppConfigParams {
     projectDir: string;
     env: Env;
     logger: bunyan;
     sdkVersion?: string;
-}): ProjectConfig;
+}
+export declare function readAppConfig(params: ReadAppConfigParams): Promise<ProjectConfig>;
+export {};

package/dist/utils/appConfig.js

@@ -8,18 +8,49 @@ const config_1 = require("@expo/config");
 const env_1 = require("@expo/env");
 const logger_1 = require("@expo/logger");
 const semver_1 = __importDefault(require("semver"));
-function readAppConfig({ projectDir, env, logger, sdkVersion, }) {
+const expoCli_1 = require("./expoCli");
+async function readAppConfig(params) {
+    const shouldLoadEnvVarsFromDotenvFile = params.sdkVersion && semver_1.default.satisfies(params.sdkVersion, '>=49');
+    if (shouldLoadEnvVarsFromDotenvFile) {
+        const envVarsFromDotenvFile = (0, env_1.load)(params.projectDir);
+        const env = { ...params.env, ...envVarsFromDotenvFile };
+        params = { ...params, env };
+    }
+    // Reading the app config is done in two steps/attempts. We first attempt to run `expo config` as a CLI,
+    try {
+        return await getAppConfigFromExpo(params);
+    }
+    catch (error) {
+        params.logger.warn('Failed to read the app config file with `expo config` command:\n' +
+            `${error?.message || error}`);
+    }
+    // If this fails, we fall back to directly using `@expo/config`
+    // This can fail, since it's tied to a specific SDK version, so reading for older SDKs isn't guaranteed to work
+    return getAppConfigFromExpoConfig(params);
+}
+async function getAppConfigFromExpo({ projectDir, env, }) {
+    const result = await (0, expoCli_1.expoCommandAsync)(projectDir, ['config', '--json', '--full', '--type', 'public'], { env });
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new Error(`Failed to parse JSON output from 'expo config'.\nOutput: ${result.stdout.slice(0, 500)}`);
+    }
+    if (!('exp' in parsed)) {
+        throw new Error(`Unexpected output from 'expo config': missing 'exp' field.`);
+    }
+    return parsed;
+}
+function getAppConfigFromExpoConfig({ projectDir, env, logger, }) {
     const originalProcessExit = process.exit;
     const originalProcessCwd = process.cwd;
     const originalStdoutWrite = process.stdout.write;
     const originalStderrWrite = process.stderr.write;
     const originalProcessEnv = process.env;
     const stdoutStore = [];
-    const shouldLoadEnvVarsFromDotenvFile = sdkVersion && semver_1.default.satisfies(sdkVersion, '>=49');
-    const envVarsFromDotenvFile = shouldLoadEnvVarsFromDotenvFile ? (0, env_1.load)(projectDir) : {};
-    const newEnvsToUse = { ...env, ...envVarsFromDotenvFile };
     try {
-        process.env = newEnvsToUse;
+        process.env = env;
         process.exit = () => {
             throw new Error('Failed to evaluate app config file');
         };

package/dist/utils/expoCli.d.ts

@@ -0,0 +1,4 @@
+import { type SpawnOptions } from '@expo/turtle-spawn';
+export declare class ExpoCLIModuleNotFoundError extends Error {
+}
+export declare function expoCommandAsync(projectDir: string, args: string[], options: Omit<SpawnOptions, 'cwd'>): Promise<import("@expo/spawn-async").SpawnResult>;