@expo/build-tools 22.2.0 → 22.3.0

package/dist/builders/android.js

@@ -81,7 +81,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, restoreBuildCache_1.restoreCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform },
             env: ctx.env,
             secrets: ctx.job.secrets,
         });
@@ -203,7 +203,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, saveBuildCache_1.saveCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform },
             evictUsedBefore,
             env: ctx.env,
             secrets: ctx.job.secrets,

package/dist/builders/ios.js

@@ -97,7 +97,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
             await (0, restoreBuildCache_1.restoreCcacheAsync)({
                 logger: ctx.logger,
                 workingDirectory,
-                platform: ctx.job.platform,
+                target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
                 env: ctx.env,
                 secrets: ctx.job.secrets,
             });
@@ -224,7 +224,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, saveBuildCache_1.saveCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
             evictUsedBefore,
             env: ctx.env,
             secrets: ctx.job.secrets,

package/dist/steps/easFunctions.js

@@ -20,8 +20,10 @@ const generateGymfileFromTemplate_1 = require("./functions/generateGymfileFromTe
 const getCredentialsForBuildTriggeredByGitHubIntegration_1 = require("./functions/getCredentialsForBuildTriggeredByGitHubIntegration");
 const injectAndroidCredentials_1 = require("./functions/injectAndroidCredentials");
 const installMaestro_1 = require("./functions/installMaestro");
+const installBuild_1 = require("./functions/installBuild");
 const installNodeModules_1 = require("./functions/installNodeModules");
 const installPods_1 = require("./functions/installPods");
+const launchApplication_1 = require("./functions/launchApplication");
 const prebuild_1 = require("./functions/prebuild");
 const readAppConfig_1 = require("./functions/readAppConfig");
 const readIpaInfo_1 = require("./functions/readIpaInfo");
@@ -70,6 +72,8 @@ function getEasFunctions(ctx) {
         (0, prebuild_1.createPrebuildBuildFunction)(),
         (0, readIpaInfo_1.createReadIpaInfoBuildFunction)(),
         (0, downloadBuild_1.createDownloadBuildFunction)(ctx),
+        (0, installBuild_1.createInstallBuildFunction)(),
+        (0, launchApplication_1.createLaunchApplicationFunction)(),
         (0, export_1.createEasExportBuildFunction)(),
         (0, deploy_1.createEasDeployBuildFunction)(),
         (0, repack_1.createRepackBuildFunction)(),

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

@@ -2,13 +2,20 @@ import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { Client } from '@urql/core';
 import { CustomBuildContext } from '../../customBuildContext';
+type DownloadBuildSource = {
+    buildId: string;
+    applicationArchiveUrl?: never;
+} | {
+    buildId?: never;
+    applicationArchiveUrl: string;
+};
 export declare function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunction;
-export declare function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }: {
+export declare function downloadBuildAsync(params: DownloadBuildSource & {
     logger: bunyan;
-    buildId: string;
     graphqlClient: Client;
     robotAccessToken: string | null;
     extensions: string[];
 }): Promise<{
     artifactPath: string;
 }>;
+export {};

package/dist/steps/functions/downloadBuild.js

@@ -8,9 +8,11 @@ exports.downloadBuildAsync = downloadBuildAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
+const content_disposition_1 = __importDefault(require("content-disposition"));
 const fast_glob_1 = require("fast-glob");
 const gql_tada_1 = require("gql.tada");
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_assert_1 = __importDefault(require("node:assert"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -44,7 +46,12 @@ function createDownloadBuildFunction(ctx) {
         inputProviders: [
             steps_1.BuildStepInput.createProvider({
                 id: 'build_id',
-                required: true,
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'application_archive_url',
+                required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
             steps_1.BuildStepInput.createProvider({
@@ -64,11 +71,29 @@ function createDownloadBuildFunction(ctx) {
             const { logger } = stepsCtx;
             const extensions = zod_1.z.array(zod_1.z.string()).parse(inputs.extensions.value);
             logger.info(`Expected extensions: [${extensions.join(', ')}]`);
-            const buildId = zod_1.z.string().uuid().parse(inputs.build_id.value);
-            logger.info(`Downloading build ${buildId}...`);
+            const buildId = inputs.build_id.value
+                ? zod_1.z.string().uuid().parse(inputs.build_id.value)
+                : undefined;
+            const applicationArchiveUrl = inputs.application_archive_url.value
+                ? parseHttpApplicationArchiveUrl(inputs.application_archive_url.value)
+                : undefined;
+            let source;
+            if (buildId) {
+                if (applicationArchiveUrl) {
+                    throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass only one of build_id or application_archive_url.');
+                }
+                source = { buildId };
+            }
+            else {
+                if (!applicationArchiveUrl) {
+                    throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass build_id or application_archive_url.');
+                }
+                source = { applicationArchiveUrl };
+            }
+            logger.info(buildId ? `Downloading build ${buildId}...` : `Downloading application archive...`);
             const { artifactPath } = await downloadBuildAsync({
                 logger,
-                buildId,
+                ...source,
                 graphqlClient: ctx.graphqlClient,
                 robotAccessToken: stepsCtx.global.staticContext.job.secrets?.robotAccessToken ?? null,
                 extensions,
@@ -92,21 +117,32 @@ async function fetchApplicationArchiveUrlAsync({ buildId, graphqlClient, }) {
     }
     return applicationArchiveUrl;
 }
-async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }) {
+async function downloadBuildAsync(params) {
+    const { logger, graphqlClient, robotAccessToken, extensions } = params;
+    let downloadUrl;
+    let headers;
+    if (params.applicationArchiveUrl) {
+        if (params.buildId) {
+            throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass only one of buildId or applicationArchiveUrl.');
+        }
+        downloadUrl = parseHttpApplicationArchiveUrl(params.applicationArchiveUrl);
+        headers = undefined;
+    }
+    else if (params.buildId) {
+        const buildId = zod_1.z.string().uuid().parse(params.buildId);
+        downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
+        headers = robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined;
+    }
+    else {
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass buildId or applicationArchiveUrl.');
+    }
     const downloadDestinationDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'download_build-downloaded-'));
-    const downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
-    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(downloadUrl, {
-        headers: robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined,
-    });
+    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(downloadUrl, { headers });
     if (!response.ok) {
         const textResult = await (0, results_1.asyncResult)(response.text());
         throw new Error(`Unexpected response from server (${response.status}): ${textResult.value}`);
     }
-    // URL may contain percent-encoded characters, e.g. my%20file.apk
-    // this replaces all non-alphanumeric characters (excluding dot) with underscore
-    const archiveFilename = node_path_1.default
-        .basename(new URL(response.url).pathname)
-        .replace(/([^a-z0-9.-]+)/gi, '_');
+    const archiveFilename = resolveArchiveFilename({ response, extensions });
     const archivePath = node_path_1.default.join(downloadDestinationDirectory, archiveFilename);
     await streamPipeline(response.body, node_fs_1.default.createWriteStream(archivePath));
     const { size } = await node_fs_1.default.promises.stat(archivePath);
@@ -133,3 +169,36 @@ async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessT
     logger.info(`Found ${matchingFiles.length} matching ${(0, strings_1.pluralize)(matchingFiles.length, 'entry')}:\n${matchingFiles.map(f => `- ${node_path_1.default.relative(extractionDirectory, f)}`).join('\n')}`);
     return { artifactPath: matchingFiles[0] };
 }
+function parseHttpApplicationArchiveUrl(value) {
+    try {
+        const applicationArchiveUrl = zod_1.z.string().parse(value);
+        const parsedUrl = new URL(applicationArchiveUrl);
+        (0, node_assert_1.default)(parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:');
+        return applicationArchiveUrl;
+    }
+    catch {
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_APPLICATION_ARCHIVE_URL', 'application_archive_url must be a valid HTTP or HTTPS URL.');
+    }
+}
+function resolveArchiveFilename({ response, extensions, }) {
+    const contentDispositionHeader = response.headers.get('content-disposition');
+    let headerFilename;
+    if (contentDispositionHeader) {
+        try {
+            headerFilename = content_disposition_1.default.parse(contentDispositionHeader).parameters.filename;
+        }
+        catch {
+            // Ignore malformed Content-Disposition headers and fall back to the response URL.
+        }
+    }
+    const urlFilename = node_path_1.default.basename(new URL(response.url).pathname);
+    let archiveFilename = node_path_1.default.basename(headerFilename ?? urlFilename ?? '');
+    if (!archiveFilename || archiveFilename === '.' || archiveFilename === '..') {
+        archiveFilename = 'application';
+    }
+    if (!node_path_1.default.extname(archiveFilename) && extensions.length === 1) {
+        archiveFilename = `${archiveFilename}.${extensions[0]}`;
+    }
+    // URL and header filenames may contain percent-encoded or unsafe filesystem characters.
+    return archiveFilename.replace(/([^a-z0-9.-]+)/gi, '_');
+}

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

@@ -0,0 +1,12 @@
+import { bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
+export declare function createInstallBuildFunction(): BuildFunction;
+export declare function installBuildAsync({ artifactPath, runtimePlatform, env, logger, }: {
+    artifactPath: string;
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<{
+    applicationIdentifier: string;
+    activityName?: string;
+}>;

package/dist/steps/functions/installBuild.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstallBuildFunction = createInstallBuildFunction;
+exports.installBuildAsync = installBuildAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+function createInstallBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'install_build',
+        name: 'Install build',
+        __metricsId: 'eas/install_build',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'artifact_path',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'application_identifier',
+                required: true,
+            }),
+            steps_1.BuildStepOutput.createProvider({
+                id: 'activity_name',
+                required: false,
+            }),
+        ],
+        fn: async ({ global, logger }, { inputs, outputs, env }) => {
+            const artifactPath = zod_1.z.string().min(1).parse(inputs.artifact_path.value);
+            const { applicationIdentifier, activityName } = await installBuildAsync({
+                artifactPath,
+                runtimePlatform: global.runtimePlatform,
+                env,
+                logger,
+            });
+            outputs.application_identifier.set(applicationIdentifier);
+            if (activityName) {
+                outputs.activity_name.set(activityName);
+            }
+        },
+    });
+}
+async function installBuildAsync({ artifactPath, runtimePlatform, env, logger, }) {
+    const artifactStat = await node_fs_1.default.promises.stat(artifactPath).catch(err => {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', `Build artifact does not exist at ${artifactPath}.`, { cause: err });
+    });
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        if (node_path_1.default.extname(artifactPath) !== '.app' || !artifactStat.isDirectory()) {
+            throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', 'iOS Simulator sessions require a .app build artifact.');
+        }
+        const infoPlistPath = node_path_1.default.join(artifactPath, 'Info.plist');
+        const { stdout } = await (0, turtle_spawn_1.default)('plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', infoPlistPath], { stdio: 'pipe', env });
+        const applicationIdentifier = stdout.trim();
+        if (!applicationIdentifier) {
+            throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_MISSING_IDENTIFIER', `Could not read CFBundleIdentifier from ${infoPlistPath}.`);
+        }
+        logger.info(`Installing ${artifactPath} on the iOS Simulator.`);
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'install', 'booted', artifactPath], { env, logger });
+        return { applicationIdentifier };
+    }
+    if (node_path_1.default.extname(artifactPath) !== '.apk' || !artifactStat.isFile()) {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', 'Android Emulator sessions require an .apk build artifact.');
+    }
+    const { stdout } = await (0, turtle_spawn_1.default)('aapt2', ['dump', 'badging', artifactPath], {
+        stdio: 'pipe',
+        env,
+    });
+    const applicationIdentifier = stdout.match(/package: name='([^']+)'/)?.[1];
+    const activityName = stdout.match(/launchable-activity: name='([^']+)'/)?.[1];
+    if (!applicationIdentifier) {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_MISSING_IDENTIFIER', `Could not read an Android application identifier from ${artifactPath}.`);
+    }
+    logger.info(`Installing ${artifactPath} on the Android Emulator.`);
+    await (0, turtle_spawn_1.default)('adb', ['install', '-r', artifactPath], { env, logger });
+    return { applicationIdentifier, activityName };
+}

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

@@ -0,0 +1,10 @@
+import { bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
+export declare function createLaunchApplicationFunction(): BuildFunction;
+export declare function launchApplicationAsync({ applicationIdentifier, activityName, runtimePlatform, env, logger, }: {
+    applicationIdentifier: string;
+    activityName?: string;
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;

package/dist/steps/functions/launchApplication.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchApplicationFunction = createLaunchApplicationFunction;
+exports.launchApplicationAsync = launchApplicationAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+function createLaunchApplicationFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'launch_application',
+        name: 'Launch application',
+        __metricsId: 'eas/launch_application',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'application_identifier',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'activity_name',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async ({ global, logger }, { inputs, env }) => {
+            const applicationIdentifier = parseNonEmptyStringInput(inputs.application_identifier.value, 'application_identifier');
+            const activityName = inputs.activity_name.value === undefined
+                ? undefined
+                : parseNonEmptyStringInput(inputs.activity_name.value, 'activity_name');
+            await launchApplicationAsync({
+                applicationIdentifier,
+                activityName,
+                runtimePlatform: global.runtimePlatform,
+                env,
+                logger,
+            });
+        },
+    });
+}
+async function launchApplicationAsync({ applicationIdentifier, activityName, runtimePlatform, env, logger, }) {
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        logger.info(`Launching ${applicationIdentifier}.`);
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'launch', 'booted', applicationIdentifier], {
+            env,
+            logger,
+        });
+        return;
+    }
+    if (!activityName) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_MISSING_ACTIVITY', 'Launching an Android application requires activity_name.');
+    }
+    logger.info(`Launching ${applicationIdentifier}.`);
+    await (0, turtle_spawn_1.default)('adb', ['shell', 'am', 'start', '-n', `${applicationIdentifier}/${activityName}`], {
+        env,
+        logger,
+    });
+}
+function parseNonEmptyStringInput(value, inputName) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_INVALID_INPUT', `Input "${inputName}" must be a non-empty string. Pass the "${inputName}" output from eas/install_build.`);
+    }
+    return value;
+}

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

@@ -3,6 +3,7 @@ export type IpaInfo = {
     bundleIdentifier: string;
     bundleShortVersion: string;
     bundleVersion: string;
+    dtPlatformName: string | null;
 };
 export declare function createReadIpaInfoBuildFunction(): BuildFunction;
 export declare function readIpaInfoAsync(ipaPath: string): Promise<IpaInfo>;

package/dist/steps/functions/readIpaInfo.js

@@ -70,10 +70,12 @@ async function readIpaInfoAsync(ipaPath) {
         if (typeof bundleVersion !== 'string') {
             throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleVersion in Info.plist');
         }
+        const dtPlatformName = typeof infoPlist.DTPlatformName === 'string' ? infoPlist.DTPlatformName : null;
         return {
             bundleIdentifier,
             bundleShortVersion,
             bundleVersion,
+            dtPlatformName,
         };
     }
     catch (error) {

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

@@ -11,11 +11,14 @@ export declare function resolveAndroidSigningOptionsAsync({ job, tmpDir, }: {
     tmpDir: string;
 }): Promise<AndroidSigningOptions | undefined>;
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-export declare function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }: {
+export declare function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }: {
     job: Job;
     logger: bunyan;
+    backend?: 'fastlane' | 'zsign';
     useAppEntitlements?: boolean;
     entitlementsPath?: string;
+    tmpDir: string;
 }): Promise<IosSigningOptions | undefined>;

package/dist/steps/functions/repack.js

@@ -53,6 +53,12 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_backend',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                allowedValues: ['fastlane', 'zsign'],
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -123,8 +129,10 @@ function createRepackBuildFunction() {
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
+                            backend: inputs.ios_signing_backend.value,
                             useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value,
                             entitlementsPath: inputs.ios_signing_app_entitlements_path.value,
+                            tmpDir,
                         }),
                         logger: stepsCtx.logger,
                         spawnAsync: repackSpawnAsync,
@@ -234,14 +242,26 @@ async function resolveAndroidSigningOptionsAsync({ job, tmpDir, }) {
     };
 }
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }) {
+async function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }) {
     const iosJob = job;
     const buildCredentials = iosJob.secrets?.buildCredentials;
     if (iosJob.simulator || buildCredentials == null) {
         return undefined;
     }
+    const commonOptions = { buildCredentials, logger, useAppEntitlements, entitlementsPath };
+    return backend === 'zsign'
+        ? await createIosZsignOptionsAsync({ ...commonOptions, tmpDir })
+        : await createIosFastlaneOptionsAsync(commonOptions);
+}
+/**
+ * Creates signing options for the fastlane backend: certificates are imported
+ * into a temporary keychain and provisioning profiles are parsed with the
+ * macOS `security` tool.
+ */
+async function createIosFastlaneOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, }) {
     const credentialsManager = new manager_1.default(buildCredentials);
     const credentials = await credentialsManager.prepare(logger);
     const provisioningProfile = {};
@@ -256,3 +276,31 @@ async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements,
         entitlementsPath,
     };
 }
+/**
+ * Creates signing options for the zsign backend. The distribution certificate
+ * secret is already a PKCS#12 file, so it goes to disk as-is together with the
+ * provisioning profiles.
+ */
+async function createIosZsignOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, tmpDir, }) {
+    const targets = Object.entries(buildCredentials);
+    const [targetName, targetCredentials] = targets[0];
+    logger.info(`Using the distribution certificate from target '${targetName}' for zsign`);
+    const certificatePath = node_path_1.default.join(tmpDir, `dist-cert-${(0, node_crypto_1.randomUUID)()}.p12`);
+    await node_fs_1.default.promises.writeFile(certificatePath, new Uint8Array(Buffer.from(targetCredentials.distributionCertificate.dataBase64, 'base64')));
+    // zsign matches profiles to bundles by the app-id suffix itself, so the
+    // record keys are informational only.
+    const provisioningProfile = {};
+    for (const [target, credentials] of targets) {
+        const profilePath = node_path_1.default.join(tmpDir, `profile-${target}-${(0, node_crypto_1.randomUUID)()}.mobileprovision`);
+        await node_fs_1.default.promises.writeFile(profilePath, new Uint8Array(Buffer.from(credentials.provisioningProfileBase64, 'base64')));
+        provisioningProfile[target] = profilePath;
+    }
+    return {
+        backend: 'zsign',
+        certificatePath,
+        keyPassword: targetCredentials.distributionCertificate.password,
+        provisioningProfile,
+        useAppEntitlements,
+        entitlementsPath,
+    };
+}

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

@@ -1,12 +1,12 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createRestoreBuildCacheFunction(): BuildFunction;
 export declare function createCacheStatsBuildFunction(): BuildFunction;
-export declare function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }: {
+export declare function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     env: Record<string, string | undefined>;
     secrets?: {
         robotAccessToken?: string;

package/dist/steps/functions/restoreBuildCache.js

@@ -33,6 +33,11 @@ function createRestoreBuildCacheFunction() {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'simulator',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
         ],
         fn: async (stepCtx, { env, inputs }) => {
             const { logger } = stepCtx;
@@ -42,10 +47,18 @@ function createRestoreBuildCacheFunction() {
             if (!platform || ![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 target = platform === eas_build_job_1.Platform.IOS
+                ? {
+                    platform,
+                    simulator: inputs.simulator.value ??
+                        (stepCtx.global.staticContext.job.platform === eas_build_job_1.Platform.IOS &&
+                            stepCtx.global.staticContext.job.simulator === true),
+                }
+                : { platform };
             await restoreCcacheAsync({
                 logger,
                 workingDirectory,
-                platform,
+                target,
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
             });
@@ -80,7 +93,7 @@ function createCacheStatsBuildFunction() {
         },
     });
 }
-async function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }) {
+async function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }) {
     const enabled = env.EAS_RESTORE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_RESTORE_CACHE !== '0');
     if (!enabled) {
         return;
@@ -103,7 +116,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             env,
             stdio: 'pipe',
         }));
-        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, platform);
+        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, target);
         logger.info(`Restoring cache key: ${cacheKey}`);
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
@@ -113,8 +126,8 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             robotAccessToken,
             paths: [cachePath],
             key: cacheKey,
-            keyPrefixes: [cacheKey_1.CACHE_KEY_PREFIX_BY_PLATFORM[platform]],
-            platform,
+            keyPrefixes: [(0, cacheKey_1.getCcacheKeyPrefix)(target)],
+            platform: target.platform,
         });
         await (0, restoreCache_1.decompressCacheAsync)({
             archivePath,
@@ -139,7 +152,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
                     expoApiServerURL,
                     robotAccessToken,
                     paths: [cachePath],
-                    platform,
+                    platform: target.platform,
                 });
                 await (0, restoreCache_1.decompressCacheAsync)({
                     archivePath,

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

@@ -1,11 +1,11 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFunction;
-export declare function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBefore, env, secrets, }: {
+export declare function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     evictUsedBefore: Date;
     env: Record<string, string | undefined>;
     secrets?: {

package/dist/steps/functions/saveBuildCache.js

@@ -29,6 +29,11 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'simulator',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
         ],
         fn: async (stepCtx, { env, inputs }) => {
             const { logger } = stepCtx;
@@ -38,10 +43,18 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
             if (!platform || ![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 target = platform === eas_build_job_1.Platform.IOS
+                ? {
+                    platform,
+                    simulator: inputs.simulator.value ??
+                        (stepCtx.global.staticContext.job.platform === eas_build_job_1.Platform.IOS &&
+                            stepCtx.global.staticContext.job.simulator === true),
+                }
+                : { platform };
             await saveCcacheAsync({
                 logger,
                 workingDirectory,
-                platform,
+                target,
                 evictUsedBefore,
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
@@ -57,7 +70,7 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
         },
     });
 }
-async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBefore, env, secrets, }) {
+async function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }) {
     const enabled = env.EAS_SAVE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_SAVE_CACHE !== '0');
     if (!enabled) {
         return;
@@ -72,7 +85,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
         return;
     }
     try {
-        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, platform);
+        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, target);
         logger.info(`Saving 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');
@@ -104,7 +117,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
             key: cacheKey,
             paths: [cachePath],
             size,
-            platform,
+            platform: target.platform,
         });
     }
     catch (err) {

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -12,6 +12,11 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         __metricsId: 'eas/start_serve_sim_remote_session',
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
         inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'package_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'max_duration_seconds',
                 required: false,
@@ -22,6 +27,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const maxDurationSeconds = inputs.max_duration_seconds?.value;
+            const packageVersion = inputs.package_version?.value;
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
@@ -29,6 +35,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
+                packageVersion,
             });
             logger.info(`Preview URL: ${serveSim.previewUrl}`);
             try {

package/dist/steps/functions/uploadToAsc.js

@@ -141,15 +141,25 @@ function createUploadToAscBuildFunction() {
             const appResponse = await AscApiUtils_1.AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
             const ascAppBundleIdentifier = appResponse.data.attributes.bundleId;
             stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${ascAppBundleIdentifier})...`);
+            // Derive the App Store Connect platform from the IPA itself so tvOS (and
+            // other) binaries are uploaded to the correct version train instead of the
+            // iOS one. Falls back to `IOS` if the platform cannot be read.
+            const ipaInfoResult = await (0, results_1.asyncResult)((0, readIpaInfo_1.readIpaInfoAsync)(ipaPath));
+            const platform = ipaInfoResult.ok
+                ? AscApiUtils_1.AscApiUtils.ascPlatformFromDtPlatformName(ipaInfoResult.value.dtPlatformName)
+                : 'IOS';
+            stepsCtx.logger.info(`Detected App Store Connect platform: ${platform}`);
             stepsCtx.logger.info('Creating Build Upload...');
             const buildUploadResponse = await AscApiUtils_1.AscApiUtils.createBuildUploadAsync({
                 client,
                 appleAppIdentifier,
                 bundleShortVersion,
                 bundleVersion,
+                platform,
             });
             const buildUploadId = buildUploadResponse.data.id;
-            const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/ios/${buildUploadId}`;
+            const platformPathSegment = AscApiUtils_1.AscApiUtils.testFlightPlatformPathSegment(platform);
+            const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/${platformPathSegment}/${buildUploadId}`;
             outputs.build_upload_id.set(buildUploadId);
             outputs.build_upload_url.set(buildUploadUrl);
             stepsCtx.logger.info(`Build Upload initialized (ID: ${buildUploadId}). Preparing IPA upload...`);

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

@@ -92,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'>;
@@ -106,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

@@ -69,7 +69,7 @@ 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';
@@ -473,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',
@@ -540,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 {

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.2.0",
+  "version": "22.3.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -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": "5484dd607468c7711d915a2521df10531f8b9908"
+  "gitHead": "70066fc8beedabdd31081f18c18928461d400806"
 }