@expo/build-tools 22.0.0 → 22.3.0

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

@@ -264,6 +264,7 @@ export type AscApiClientPostApi = {
         response: z.output<(typeof PostApi)[Path]['response']>;
     };
 };
+export type AscPlatform = AscApiClientPostApi['/v1/buildUploads']['request']['data']['attributes']['platform'];
 export type AscApiClientPatchApi = {
     [Path in keyof typeof PatchApi]: {
         request: z.input<(typeof PatchApi)[Path]['request']>;

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

@@ -1,14 +1,23 @@
-import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi } from './AscApiClient';
+import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi, AscPlatform } from './AscApiClient';
 export declare namespace AscApiUtils {
+    /**
+     * Maps a bundle's `DTPlatformName` (from its Info.plist) to the App Store
+     * Connect platform used for a build upload. Unknown or missing values fall
+     * back to `IOS` to preserve the previous default.
+     */
+    function ascPlatformFromDtPlatformName(dtPlatformName: string | null): AscPlatform;
+    /** The App Store Connect TestFlight URL path segment for a platform. */
+    function testFlightPlatformPathSegment(platform: AscPlatform): string;
     function getAppInfoAsync({ client, appleAppIdentifier, }: {
         client: Pick<AscApiClient, 'getAsync'>;
         appleAppIdentifier: string;
     }): Promise<AscApiClientGetApi['/v1/apps/:id']['response']>;
-    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }: {
+    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, platform, }: {
         client: Pick<AscApiClient, 'postAsync'>;
         appleAppIdentifier: string;
         bundleShortVersion: string;
         bundleVersion: string;
+        platform: AscPlatform;
     }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']>;
     function getAppsAsync({ client, limit, }: {
         client: Pick<AscApiClient, 'getAsync'>;

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

@@ -5,6 +5,40 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const AscApiClient_1 = require("./AscApiClient");
 var AscApiUtils;
 (function (AscApiUtils) {
+    /**
+     * Maps a bundle's `DTPlatformName` (from its Info.plist) to the App Store
+     * Connect platform used for a build upload. Unknown or missing values fall
+     * back to `IOS` to preserve the previous default.
+     */
+    function ascPlatformFromDtPlatformName(dtPlatformName) {
+        switch (dtPlatformName) {
+            case 'appletvos':
+                return 'TV_OS';
+            case 'macosx':
+                return 'MAC_OS';
+            case 'xros':
+                return 'VISION_OS';
+            case 'iphoneos':
+            default:
+                return 'IOS';
+        }
+    }
+    AscApiUtils.ascPlatformFromDtPlatformName = ascPlatformFromDtPlatformName;
+    /** The App Store Connect TestFlight URL path segment for a platform. */
+    function testFlightPlatformPathSegment(platform) {
+        switch (platform) {
+            case 'TV_OS':
+                return 'tvos';
+            case 'MAC_OS':
+                return 'macos';
+            case 'VISION_OS':
+                return 'visionos';
+            case 'IOS':
+            default:
+                return 'ios';
+        }
+    }
+    AscApiUtils.testFlightPlatformPathSegment = testFlightPlatformPathSegment;
     async function getAppInfoAsync({ client, appleAppIdentifier, }) {
         try {
             return await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
@@ -37,13 +71,13 @@ var AscApiUtils;
         }
     }
     AscApiUtils.getAppInfoAsync = getAppInfoAsync;
-    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }) {
+    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, platform, }) {
         try {
             return await client.postAsync('/v1/buildUploads', {
                 data: {
                     type: 'buildUploads',
                     attributes: {
-                        platform: 'IOS',
+                        platform,
                         cfBundleShortVersionString: bundleShortVersion,
                         cfBundleVersion: bundleVersion,
                     },

package/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -25,10 +25,11 @@ export type DeviceRunSessionIdleTimeout = {
      */
     getLastEventObservedAt: () => Date | undefined;
 };
-export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }: {
+export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, maxDurationSeconds, signal: cancelSignal, idleTimeout, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
     logger: bunyan;
+    maxDurationSeconds?: number;
     signal?: AbortSignal;
     idleTimeout?: DeviceRunSessionIdleTimeout;
 }): Promise<void>;
@@ -91,10 +92,11 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     env: BuildStepEnv;
 }): DetachedProcessHandle;
 export declare function metricsCorsOriginToServeSimArgs(env: BuildStepEnv): string[];
-export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, }: {
+export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion, }: {
     port: number;
     turnArgs?: string[];
     metricsCorsArgs?: string[];
+    packageVersion?: string;
 }): string[];
 export declare function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }: {
     serveSim: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
@@ -105,11 +107,12 @@ export type ServeSimPreviewHandle = {
     previewUrl: string;
     stopAsync: () => Promise<void>;
 };
-export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, }: {
+export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, packageVersion, }: {
     baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
     timeoutMs: number;
+    packageVersion?: string;
 }): Promise<ServeSimPreviewHandle>;
 export type NgrokTunnelHandle = {
     url: string;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -63,12 +63,13 @@ const zod_1 = require("zod");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_net_1 = require("node:net");
+const node_timers_1 = require("node:timers");
 const promises_1 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
 const turtleFetch_1 = require("../../utils/turtleFetch");
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
-const SERVE_SIM_PACKAGE_SPEC = '@expo/serve-sim@latest';
+const SERVE_SIM_PACKAGE_NAME = '@expo/serve-sim';
 const SERVE_SIM_HOST = '127.0.0.1';
 const SERVE_SIM_MAX_DIMENSION = '1280';
 const SERVE_SIM_MJPEG_QUALITY = '0.55';
@@ -152,58 +153,83 @@ async function selectXcodeDeveloperDirectoryAsync({ env, logger, }) {
         stdio: ['ignore', 'pipe', 'pipe'],
     });
 }
-async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }) {
-    logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
-    if (idleTimeout) {
-        logger.info(`The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`);
-    }
-    let pollErrorCount = 0;
-    let lastActivityAt = new Date();
-    while (!signal?.aborted) {
+async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, maxDurationSeconds, signal: cancelSignal, idleTimeout, }) {
+    const durationAbortController = new AbortController();
+    const signal = cancelSignal
+        ? AbortSignal.any([cancelSignal, durationAbortController.signal])
+        : durationAbortController.signal;
+    // Nothing to wait for if the step was already aborted before we started;
+    // return before logging so we don't claim to be polling a session we never poll.
+    if (signal.aborted) {
+        return;
+    }
+    const durationTimeout = maxDurationSeconds === undefined
+        ? undefined
+        : (0, node_timers_1.setTimeout)(() => {
+            logger.info(`Device run session ${deviceRunSessionId} reached its maximum duration.`);
+            durationAbortController.abort();
+        }, maxDurationSeconds * 1_000);
+    try {
+        logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
+        if (durationTimeout !== undefined) {
+            logger.info(`The device run session will stop automatically after ${maxDurationSeconds} seconds.`);
+        }
         if (idleTimeout) {
-            const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
-            if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
-                lastActivityAt = lastEventObservedAt;
-            }
-            if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
-                logger.info(`Device run session ${deviceRunSessionId} had no activity for ` +
-                    `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`);
-                await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
-                return;
-            }
+            logger.info(`The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`);
         }
-        try {
-            const result = await ctx.graphqlClient
-                .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
-                .toPromise();
-            if (result.error) {
-                throw result.error;
-            }
-            const status = result.data?.deviceRunSessions?.byId?.status;
-            if (!status) {
-                throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+        let pollErrorCount = 0;
+        let lastActivityAt = new Date();
+        while (!signal.aborted) {
+            if (idleTimeout) {
+                const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
+                if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
+                    lastActivityAt = lastEventObservedAt;
+                }
+                if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
+                    logger.info(`Device run session ${deviceRunSessionId} had no activity for ` +
+                        `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`);
+                    await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
+                    return;
+                }
             }
-            pollErrorCount = 0;
-            if (status === 'STOPPED') {
-                logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
-                return;
+            try {
+                const result = await ctx.graphqlClient
+                    .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
+                    .toPromise();
+                if (result.error) {
+                    throw result.error;
+                }
+                const status = result.data?.deviceRunSessions?.byId?.status;
+                if (!status) {
+                    throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+                }
+                pollErrorCount = 0;
+                if (status === 'STOPPED') {
+                    logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
+                    return;
+                }
+                if (status === 'ERRORED') {
+                    throw new eas_build_job_1.SystemError(`Device run session ${deviceRunSessionId} errored.`);
+                }
             }
-            if (status === 'ERRORED') {
-                throw new eas_build_job_1.SystemError(`Device run session ${deviceRunSessionId} errored.`);
+            catch (err) {
+                if (err instanceof eas_build_job_1.SystemError) {
+                    throw err;
+                }
+                const error = err instanceof Error ? err : new Error(String(err));
+                pollErrorCount += 1;
+                if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
+                    sentry_1.Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
+                    logger.warn({ err: error, failedStatusPollCount: pollErrorCount }, 'Could not poll device run session status; will retry.');
+                }
             }
+            await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
         }
-        catch (err) {
-            if (err instanceof eas_build_job_1.SystemError) {
-                throw err;
-            }
-            const error = err instanceof Error ? err : new Error(String(err));
-            pollErrorCount += 1;
-            if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
-                sentry_1.Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
-                logger.warn({ err: error, failedStatusPollCount: pollErrorCount }, 'Could not poll device run session status; will retry.');
-            }
+    }
+    finally {
+        if (durationTimeout !== undefined) {
+            (0, node_timers_1.clearTimeout)(durationTimeout);
         }
-        await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
     }
 }
 // Best effort: when this fails, the caller still tears the session down and the
@@ -447,10 +473,13 @@ function metricsCorsOriginToServeSimArgs(env) {
     }
     return args;
 }
-function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], }) {
+function createServeSimPackageSpec(packageVersion) {
+    return `${SERVE_SIM_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
+}
+function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], packageVersion, }) {
     return [
         '--yes',
-        SERVE_SIM_PACKAGE_SPEC,
+        createServeSimPackageSpec(packageVersion),
         '--port',
         String(port),
         '--host',
@@ -514,14 +543,14 @@ async function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }) {
     }
     throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim readiness at ${readyUrl}${lastError instanceof Error ? `: ${lastError.message}` : ''}. Last output:\n${serveSim.getOutput() || '<empty>'}`);
 }
-async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, }) {
+async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, packageVersion, }) {
     const port = await findAvailablePortAsync();
-    logger.info(`Launching ${SERVE_SIM_PACKAGE_SPEC} on ${SERVE_SIM_HOST}:${port}.`);
+    logger.info(`Launching ${createServeSimPackageSpec(packageVersion)} on ${SERVE_SIM_HOST}:${port}.`);
     const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
     const metricsCorsArgs = metricsCorsOriginToServeSimArgs(env);
     const serveSim = spawnDetached({
         command: 'npx',
-        args: createServeSimArgs({ port, turnArgs, metricsCorsArgs }),
+        args: createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion }),
         env,
     });
     try {
@@ -529,7 +558,7 @@ async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, time
         await waitForServeSimReadyAsync({ serveSim, port, timeoutMs });
         const tunnel = await startNgrokTunnelAsync({
             port,
-            subdomainPrefix: 'serve-sim',
+            subdomainPrefix: 'web-preview',
             baseDomain,
             authtoken: getNgrokAuthtokenOrThrow(env),
             logger,

package/dist/utils/AndroidEmulatorUtils.d.ts

@@ -42,6 +42,7 @@ export declare namespace AndroidEmulatorUtils {
         emulatorPromise: SpawnPromise<SpawnResult>;
         serialId: AndroidDeviceSerialId;
         logcatOutputPath: string;
+        emulatorOutputPath: string;
     }>;
     function waitForReadyAsync({ serialId, env, timeoutMs, logger, }: {
         serialId: AndroidDeviceSerialId;

package/dist/utils/AndroidEmulatorUtils.js

@@ -11,9 +11,11 @@ const assert_1 = __importDefault(require("assert"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = require("node:net");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = require("node:timers/promises");
+const sentry_1 = require("../sentry");
 const retry_1 = require("./retry");
 var AndroidEmulatorUtils;
 (function (AndroidEmulatorUtils) {
@@ -216,17 +218,21 @@ var AndroidEmulatorUtils;
     AndroidEmulatorUtils.cloneAsync = cloneAsync;
     async function startAsync({ deviceName, env, logcatDirectory, }) {
         let logcatOutputPath;
+        let emulatorOutputPath;
         try {
             await node_fs_1.default.promises.mkdir(logcatDirectory, { recursive: true });
             const safeDeviceName = deviceName.replace(/[^a-zA-Z0-9_.-]/g, '_');
             const timestamp = Math.floor(Date.now() / 1000)
                 .toString(16)
                 .padStart(8, '0');
-            logcatOutputPath = node_path_1.default.join(logcatDirectory, `${safeDeviceName}-${timestamp}-${(0, node_crypto_1.randomBytes)(2).toString('hex')}.log`);
+            const outputName = `${safeDeviceName}-${timestamp}-${(0, node_crypto_1.randomBytes)(2).toString('hex')}`;
+            logcatOutputPath = node_path_1.default.join(logcatDirectory, `${outputName}-logcat.log`);
+            emulatorOutputPath = node_path_1.default.join(logcatDirectory, `${outputName}-emulator.log`);
             await node_fs_1.default.promises.writeFile(logcatOutputPath, '');
+            await node_fs_1.default.promises.writeFile(emulatorOutputPath, '');
         }
         catch (err) {
-            throw new eas_build_job_1.SystemError(`Failed to prepare Android emulator logcat output for ${deviceName}.`, {
+            throw new eas_build_job_1.SystemError(`Failed to prepare Android emulator output for ${deviceName}.`, {
                 cause: err,
             });
         }
@@ -249,13 +255,49 @@ var AndroidEmulatorUtils;
                 : []),
         ], {
             detached: true,
-            stdio: 'inherit',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            ignoreStdio: true,
             env: {
                 ...env,
                 // We don't need to wait for emulator to exit gracefully.
                 ANDROID_EMULATOR_WAIT_TIME_BEFORE_KILL: '1',
             },
         });
+        const emulatorOutputStream = node_fs_1.default.createWriteStream(emulatorOutputPath, { flags: 'a' });
+        let reportedEmulatorOutputError = false;
+        emulatorOutputStream.on('error', err => {
+            process.stderr.write(`Failed to write Android emulator output to ${emulatorOutputPath}: ${err}\n`);
+            if (!reportedEmulatorOutputError) {
+                reportedEmulatorOutputError = true;
+                sentry_1.Sentry.capture('Failed to write Android emulator process output', err, {
+                    level: 'warning',
+                    tags: {
+                        errorCode: err.code ?? 'unknown',
+                    },
+                    extras: {
+                        deviceName,
+                        emulatorOutputPath,
+                    },
+                });
+            }
+        });
+        // Only into the log file -- this process' stdout/stderr is not watched or uploaded.
+        emulatorPromise.child.stdout?.pipe(emulatorOutputStream, { end: false });
+        emulatorPromise.child.stderr?.pipe(emulatorOutputStream, { end: false });
+        emulatorPromise.child.once('close', () => {
+            emulatorOutputStream.end();
+        });
+        // Piped stdio creates socket handles in this process which, unlike inherited
+        // file descriptors, keep the event loop alive for as long as the emulator runs.
+        // We never stop the emulator explicitly, so without unref-ing these the process
+        // would never exit on its own -- defeating the `detached` + `unref()` below.
+        // Output is still captured for as long as this process lives.
+        if (emulatorPromise.child.stdout instanceof node_net_1.Socket) {
+            emulatorPromise.child.stdout.unref();
+        }
+        if (emulatorPromise.child.stderr instanceof node_net_1.Socket) {
+            emulatorPromise.child.stderr.unref();
+        }
         // If emulator fails to start, throw its error.
         if (!emulatorPromise.child.pid) {
             await emulatorPromise;
@@ -276,7 +318,7 @@ var AndroidEmulatorUtils;
         });
         // We don't want to await the SpawnPromise here.
         // eslint-disable-next-line @typescript-eslint/return-await
-        return { emulatorPromise, serialId, logcatOutputPath };
+        return { emulatorPromise, serialId, logcatOutputPath, emulatorOutputPath };
     }
     AndroidEmulatorUtils.startAsync = startAsync;
     async function waitForReadyAsync({ serialId, env, timeoutMs = 3 * 60 * 1_000, logger, }) {

package/dist/utils/cacheKey.d.ts

@@ -1,5 +1,11 @@
 import { Platform } from '@expo/eas-build-job';
-export declare const CACHE_KEY_PREFIX_BY_PLATFORM: Record<Platform, string>;
+export type CcacheBuildTarget = {
+    platform: Platform.ANDROID;
+} | {
+    platform: Platform.IOS;
+    simulator: boolean;
+};
+export declare function getCcacheKeyPrefix(target: CcacheBuildTarget): string;
 export declare const PUBLIC_CACHE_KEY_PREFIX_BY_PLATFORM: Record<Platform, string>;
 export declare function getCcachePath(env: Record<string, string | undefined>): string;
-export declare function generateDefaultBuildCacheKeyAsync(workingDirectory: string, platform: Platform): Promise<string>;
+export declare function generateDefaultBuildCacheKeyAsync(workingDirectory: string, target: CcacheBuildTarget): Promise<string>;

package/dist/utils/cacheKey.js

@@ -36,7 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PUBLIC_CACHE_KEY_PREFIX_BY_PLATFORM = exports.CACHE_KEY_PREFIX_BY_PLATFORM = void 0;
+exports.PUBLIC_CACHE_KEY_PREFIX_BY_PLATFORM = void 0;
+exports.getCcacheKeyPrefix = getCcacheKeyPrefix;
 exports.getCcachePath = getCcachePath;
 exports.generateDefaultBuildCacheKeyAsync = generateDefaultBuildCacheKeyAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -46,16 +47,19 @@ const assert_1 = __importDefault(require("assert"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const packageManager_1 = require("./packageManager");
-const IOS_CACHE_KEY_PREFIX = 'ios-ccache-';
+const IOS_DEVICE_CACHE_KEY_PREFIX = 'ios-device-ccache-';
+const IOS_SIMULATOR_CACHE_KEY_PREFIX = 'ios-simulator-ccache-';
 const ANDROID_CACHE_KEY_PREFIX = 'android-ccache-';
 const PUBLIC_IOS_CACHE_KEY_PREFIX = 'public-ios-ccache-';
 const PUBLIC_ANDROID_CACHE_KEY_PREFIX = 'public-android-ccache-';
 const DARWIN_CACHE_PATH = 'Library/Caches/ccache';
 const LINUX_CACHE_PATH = '.cache/ccache';
-exports.CACHE_KEY_PREFIX_BY_PLATFORM = {
-    [eas_build_job_1.Platform.ANDROID]: ANDROID_CACHE_KEY_PREFIX,
-    [eas_build_job_1.Platform.IOS]: IOS_CACHE_KEY_PREFIX,
-};
+function getCcacheKeyPrefix(target) {
+    if (target.platform === eas_build_job_1.Platform.IOS) {
+        return target.simulator ? IOS_SIMULATOR_CACHE_KEY_PREFIX : IOS_DEVICE_CACHE_KEY_PREFIX;
+    }
+    return ANDROID_CACHE_KEY_PREFIX;
+}
 exports.PUBLIC_CACHE_KEY_PREFIX_BY_PLATFORM = {
     [eas_build_job_1.Platform.ANDROID]: PUBLIC_ANDROID_CACHE_KEY_PREFIX,
     [eas_build_job_1.Platform.IOS]: PUBLIC_IOS_CACHE_KEY_PREFIX,
@@ -68,14 +72,14 @@ function getCcachePath(env) {
     (0, assert_1.default)(env.HOME, 'Failed to infer directory: $HOME environment variable is empty.');
     return path_1.default.join(env.HOME, PATH_BY_PLATFORM[os_1.default.platform()]);
 }
-async function generateDefaultBuildCacheKeyAsync(workingDirectory, platform) {
+async function generateDefaultBuildCacheKeyAsync(workingDirectory, target) {
     // This will resolve which package manager and use the relevant lock file
     // The lock file hash is the key and ensures cache is fresh
     const packagerRunDir = (0, packageManager_1.findPackagerRootDir)(workingDirectory);
     const manager = PackageManagerUtils.createForProject(packagerRunDir);
     const lockPath = path_1.default.join(packagerRunDir, manager.lockFile);
     try {
-        return `${exports.CACHE_KEY_PREFIX_BY_PLATFORM[platform]}${(0, steps_1.hashFiles)([lockPath])}`;
+        return `${getCcacheKeyPrefix(target)}${(0, steps_1.hashFiles)([lockPath])}`;
     }
     catch (err) {
         throw new Error(`Failed to read lockfile for cache key generation: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "22.0.0",
+  "version": "22.3.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -46,7 +46,7 @@
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "22.0.0",
+    "@expo/steps": "22.1.0",
     "@expo/template-file": "22.0.0",
     "@expo/turtle-spawn": "22.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -54,6 +54,7 @@
     "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",
     "bplist-parser": "0.3.2",
+    "content-disposition": "1.0.1",
     "fast-glob": "^3.3.2",
     "fast-xml-parser": "^4.4.1",
     "fs-extra": "^11.2.0",
@@ -77,7 +78,8 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@expo/repack-app": "~0.6.1",
+    "@expo/repack-app": "~0.9.0",
+    "@types/content-disposition": "0.5.9",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.4",
@@ -100,5 +102,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "b92a9cc5a718f133966e27b9fedcedb569f9cd17"
+  "gitHead": "70066fc8beedabdd31081f18c18928461d400806"
 }