Merge branch 'main' into @evanbacon/cli/auto-bundle-id

- Wrap suggestion lookup in try-catch for non-interactive mode
- Add changelog entry for the new feature

Co-Authored-By: Claude Opus 4.5 <[email protected]>

CHANGELOG.md

@@ -8,73 +8,18 @@ This is the log of notable changes to EAS CLI and related packages.
 
 ### 🎉 New features
 
-### 🐛 Bug fixes
-
-### 🧹 Chores
-
-## [18.8.0](https://github.com/expo/eas-cli/releases/tag/v18.8.0) - 2026-04-22
-
-### 🎉 New features
-
-- [eas-cli] Support custom params in `observe:events` results. ([#3620](https://github.com/expo/eas-cli/pull/3620) by [@douglowder](https://github.com/douglowder))
-- [build-tools] Add `eas/deploy` function for EAS Hosting web deployments. ([#3598](https://github.com/expo/eas-cli/pull/3598) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Add `eas/export` function for Expo web exports. ([#3598](https://github.com/expo/eas-cli/pull/3598) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Add `eas update:insights <groupId>` command to display launch, crash, unique-user, and payload-size metrics for an update group. ([#3614](https://github.com/expo/eas-cli/pull/3614) by [@kadikraman](https://github.com/kadikraman))
-- [eas-cli] Add `--insights` flag to `eas update:view <groupId>` to append the same metrics below the existing output. ([#3614](https://github.com/expo/eas-cli/pull/3614) by [@kadikraman](https://github.com/kadikraman))
-- [eas-cli] Add `eas channel:insights --channel <name> --runtime-version <version>` command to display adoption and crash metrics for a channel + runtime version. ([#3614](https://github.com/expo/eas-cli/pull/3614) by [@kadikraman](https://github.com/kadikraman))
-
-### 🐛 Bug fixes
-
-- [eas-cli] Fix `metadata:push` not deleting video previews from App Store Connect when removed from config. ([#3603](https://github.com/expo/eas-cli/pull/3603) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Warn and skip unknown preview types in `metadata:push` with a helpful suggestion when the `APP_` screenshot prefix is mistakenly used. ([#3603](https://github.com/expo/eas-cli/pull/3603) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Delete all existing previews in a preview set before uploading to avoid Apple's "Too many app previews" error. ([#3603](https://github.com/expo/eas-cli/pull/3603) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Fixes for `observe` commands, including an issue for apps with many update IDs. ([#3609](https://github.com/expo/eas-cli/pull/3609) by [@douglowder](https://github.com/douglowder))
-- [eas-cli] Add existing capability identifiers. ([#3615](https://github.com/expo/eas-cli/pull/3615) by [@jakex7](https://github.com/jakex7))
-
-## [18.7.0](https://github.com/expo/eas-cli/releases/tag/v18.7.0) - 2026-04-14
-
-### 🎉 New features
-
-- [build-tools] Add `eas/read_package_json` and `eas/read_app_config` functions ([#3585](https://github.com/expo/eas-cli/pull/3585) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Add `--skip-bundler` to `eas build:dev` to install and run a development build without starting the local Expo/Metro server. ([#3604](https://github.com/expo/eas-cli/pull/3604) by [@mmichels-brex](https://github.com/mmichels-brex))
-
-## [18.6.0](https://github.com/expo/eas-cli/releases/tag/v18.6.0) - 2026-04-10
-
-### 🎉 New features
-
-- [eas-cli] Add missing Apple metadata attributes for age ratings and content descriptions. ([#3584](https://github.com/expo/eas-cli/pull/3584) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Add App Clip metadata support to `metadata:push` and `metadata:pull` (default experience action, per-locale subtitle and header image, App Store review invocation URLs). ([#3590](https://github.com/expo/eas-cli/pull/3590) by [@EvanBacon](https://github.com/EvanBacon))
-- [build-tools] Add `working_directory` input to `eas/build` function group for custom builds. ([#3582](https://github.com/expo/eas-cli/pull/3582) by [@szdziedzic](https://github.com/szdziedzic))
-
-### 🐛 Bug fixes
-
-- [steps] Coerce numeric env values to strings in workflow step configuration. ([#3583](https://github.com/expo/eas-cli/pull/3583) by [@szdziedzic](https://github.com/szdziedzic))
-- [build-tools][eas-cli] Detect iOS Development provisioning profiles and set correct code signing identity instead of treating them as Ad Hoc. ([#3496](https://github.com/expo/eas-cli/pull/3496) by [@qwertey6](https://github.com/qwertey6))
-- [build-tools] Prevent detecting Yarn Modern as Classic based on lockfile ([#3572](https://github.com/expo/eas-cli/pull/3572) by [@kitten](https://github.com/kitten))
-- [build-tools] Early stop `eas/start_android_emulator` when Android emulator host setup is invalid. ([#3580](https://github.com/expo/eas-cli/pull/3580) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Bump `@expo/apple-utils` to `2.1.18` to fix `metadata:push` failing on `ageRatingDeclarations` due to the removed `gamblingAndContests` attribute. ([#3588](https://github.com/expo/eas-cli/pull/3588) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Bump `@expo/apple-utils` to `2.1.19` to fix image and video uploads via `metadata:push` getting stuck in `AWAITING_UPLOAD` state. The asset client was inheriting Bearer token injection from the App Store Connect API client, which caused S3 presigned URL uploads to be silently mishandled by Apple's CDN. Fixes screenshots, previews, and App Clip header image uploads. ([#3590](https://github.com/expo/eas-cli/pull/3590) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] `metadata:pull` now preserves screenshot, video preview, and App Clip header image entries with placeholder paths when the asset is in an unrendered state, so users can recover broken records by replacing the file or removing the entry instead of having entries silently dropped from `store.config.json`. ([#3590](https://github.com/expo/eas-cli/pull/3590) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Surface hosting deployment's asset upload errors sooner ([#3600](https://github.com/expo/eas-cli/pull/3600) by [@kitten](https://github.com/kitten))
-
-## [18.5.0](https://github.com/expo/eas-cli/releases/tag/v18.5.0) - 2026-04-02
-
-### 🎉 New features
-
-- [eas-cli] Add screenshots and previews support to `metadata:push` and `metadata:pull`. ([#3301](https://github.com/expo/eas-cli/pull/3301) by [@EvanBacon](https://github.com/EvanBacon))
+- Auto-generate `ios.bundleIdentifier` and `android.package` in non-interactive mode when not set in app config. ([#3399](https://github.com/expo/eas-cli/pull/3399) by [@evanbacon](https://github.com/evanbacon))
+- Use authorization code flow with PKCE for browser-based login. ([#3398](https://github.com/expo/eas-cli/pull/3398) by [@byronkarlen](https://github.com/byronkarlen))
 - [eas-cli] Add `--non-interactive` flag to `metadata:push` and `metadata:pull` commands with ASC API Key auth support. ([#3548](https://github.com/expo/eas-cli/pull/3548) by [@EvanBacon](https://github.com/EvanBacon))
-- [eas-cli] Add `observe:metrics`, `observe:events`, and `observe:versions` commands. ([#3401](https://github.com/expo/eas-cli/pull/3401) by [@ubax](https://github.com/ubax)), [@douglowder](https://github.com/douglowder)
 
 ### 🐛 Bug fixes
 
 - [eas-cli] Fix workflow:logs for builds using built-in EAS build steps. ([#3523](https://github.com/expo/eas-cli/pull/3523) by [@douglowder](https://github.com/douglowder))
 - [build-tools][worker] Read Expo app config with `expo config` CLI invocation before falling back to `@expo/config` ([#3536](https://github.com/expo/eas-cli/pull/3536) by [@kitten](https://github.com/kitten))
-- Fix `hasIgnoredIosProjectAsync()` always returning `false` for ignored iOS projects. ([#3562](https://github.com/expo/eas-cli/pull/3562) by [@sjchmiela](https://github.com/sjchmiela))
 
 ### 🧹 Chores
 
 - Bump apple-utils. ([#3545](https://github.com/expo/eas-cli/pull/3545) by [@quinlanj](https://github.com/quinlanj))
-- [eas-cli][build-tools][worker] Bump `@expo/config` and `@expo/config-plugins`. ([#3527](https://github.com/expo/eas-cli/pull/3527) by [@quinlanj](https://github.com/quinlanj))
 
 ## [18.4.0](https://github.com/expo/eas-cli/releases/tag/v18.4.0) - 2026-03-16
 

lerna.json

@@ -1,5 +1,5 @@
 {
   "npmClient": "yarn",
-  "version": "18.8.0",
+  "version": "18.4.0",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

packages/build-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.8.0",
+  "version": "18.4.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -35,20 +35,19 @@
     "test": "yarn jest-unit"
   },
   "dependencies": {
-    "@expo/config": "55.0.10",
-    "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "18.5.0",
-    "@expo/eas-build-job": "18.8.0",
-    "@expo/eas-json": "18.8.0",
+    "@expo/config": "10.0.6",
+    "@expo/config-plugins": "9.0.12",
+    "@expo/downloader": "18.0.1",
+    "@expo/eas-build-job": "18.4.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "18.5.0",
+    "@expo/logger": "18.0.1",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "18.8.0",
-    "@expo/template-file": "18.5.0",
-    "@expo/turtle-spawn": "18.5.0",
+    "@expo/steps": "18.4.0",
+    "@expo/template-file": "18.0.1",
+    "@expo/turtle-spawn": "18.0.1",
     "@expo/xcpretty": "^4.3.1",
     "@google-cloud/storage": "^7.11.2",
     "@urql/core": "^6.0.1",

packages/build-tools/src/builders/ios.ts

@@ -16,7 +16,6 @@ import { runFastlaneGym, runFastlaneResign } from '../ios/fastlane';
 import { installPods } from '../ios/pod';
 import { downloadApplicationArchiveAsync } from '../ios/resign';
 import { resolveArtifactPath, resolveBuildConfiguration, resolveScheme } from '../ios/resolve';
-import { parseAndReportXcactivitylog } from '../steps/utils/ios/xcactivitylog';
 import { cacheStatsAsync, restoreCcacheAsync } from '../steps/functions/restoreBuildCache';
 import { saveCcacheAsync } from '../steps/functions/saveBuildCache';
 import { uploadApplicationArchive } from '../utils/artifacts';
@@ -52,7 +51,6 @@ async function buildAsync(ctx: BuildContext<Ios.Job>): Promise<void> {
   const evictUsedBefore = new Date();
   const credentialsManager = new CredentialsManager(ctx);
   const workingDirectory = ctx.getReactNativeProjectDirectory();
-  let fastlaneResult: { derivedDataPath: string; workspacePath: string } | undefined;
   try {
     const credentials = await ctx.runBuildPhase(BuildPhase.PREPARE_CREDENTIALS, async () => {
       return await credentialsManager.prepare();
@@ -148,10 +146,10 @@ async function buildAsync(ctx: BuildContext<Ios.Job>): Promise<void> {
       });
     }
 
-    fastlaneResult = await ctx.runBuildPhase(BuildPhase.RUN_FASTLANE, async () => {
+    await ctx.runBuildPhase(BuildPhase.RUN_FASTLANE, async () => {
       const scheme = resolveScheme(ctx);
       const entitlements = await readEntitlementsAsync(ctx, { scheme, buildConfiguration });
-      return await runFastlaneGym(ctx, {
+      await runFastlaneGym(ctx, {
         credentials,
         scheme,
         buildConfiguration,
@@ -173,18 +171,6 @@ async function buildAsync(ctx: BuildContext<Ios.Job>): Promise<void> {
     });
   }
 
-  if (ctx.env.EXPERIMENTAL_EAS_XCACTIVITYLOG === '1') {
-    const { derivedDataPath, workspacePath } = nullthrows(fastlaneResult);
-    await ctx.runBuildPhase(BuildPhase.PARSE_XCACTIVITYLOG, async () => {
-      await parseAndReportXcactivitylog({
-        derivedDataPath,
-        workspacePath,
-        logger: ctx.logger,
-        proxyBaseUrl: ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL,
-      });
-    });
-  }
-
   await ctx.runBuildPhase(BuildPhase.PRE_UPLOAD_ARTIFACTS_HOOK, async () => {
     await runHookIfPresent(ctx, Hook.PRE_UPLOAD_ARTIFACTS);
   });

packages/build-tools/src/common/__tests__/easBuildInternal.test.ts

@@ -1,72 +0,0 @@
-import { BuildJob } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
-
-import { resolveEnvFromBuildProfileAsync, runEasBuildInternalAsync } from '../easBuildInternal';
-import { resolveEasCommandPrefixAndEnvAsync } from '../../utils/easCli';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-jest.mock('../../utils/easCli', () => ({
-  ...jest.requireActual('../../utils/easCli'),
-  resolveEasCommandPrefixAndEnvAsync: jest.fn(),
-}));
-
-describe('easBuildInternal', () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-    jest.mocked(resolveEasCommandPrefixAndEnvAsync).mockResolvedValue({
-      cmd: 'npx',
-      args: ['-y', 'eas-cli@latest'],
-      extraEnv: {},
-    });
-  });
-
-  it('calls resolveEasCommandPrefixAndEnvAsync in runEasBuildInternalAsync', async () => {
-    const logger = {
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-      child: jest.fn(),
-    } as any;
-
-    const job = {
-      platform: 'android',
-      secrets: { robotAccessToken: 'token' },
-    } as unknown as BuildJob;
-
-    await expect(
-      runEasBuildInternalAsync({
-        job,
-        logger,
-        env: {},
-        cwd: '/tmp/project',
-      })
-    ).rejects.toThrow('build profile is missing in a build from git-based integration.');
-
-    expect(resolveEasCommandPrefixAndEnvAsync).toHaveBeenCalledWith();
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('calls resolveEasCommandPrefixAndEnvAsync in resolveEnvFromBuildProfileAsync', async () => {
-    const logger = {
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-      child: jest.fn(),
-    } as any;
-    const ctx = {
-      logger,
-      env: {},
-      job: { platform: 'ios' },
-    } as any;
-
-    await expect(resolveEnvFromBuildProfileAsync(ctx, { cwd: '/tmp/project' })).rejects.toThrow(
-      'build profile is missing in a build from git-based integration.'
-    );
-
-    expect(resolveEasCommandPrefixAndEnvAsync).toHaveBeenCalledWith();
-    expect(spawn).not.toHaveBeenCalled();
-  });
-});

packages/build-tools/src/common/easBuildInternal.ts

@@ -1,4 +1,11 @@
-import { BuildJob, Env, Metadata, sanitizeBuildJob, sanitizeMetadata } from '@expo/eas-build-job';
+import {
+  BuildJob,
+  EasCliNpmTags,
+  Env,
+  Metadata,
+  sanitizeBuildJob,
+  sanitizeMetadata,
+} from '@expo/eas-build-job';
 import { PipeMode, bunyan } from '@expo/logger';
 import { BuildStepEnv } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
@@ -7,7 +14,7 @@ import Joi from 'joi';
 import nullthrows from 'nullthrows';
 
 import { BuildContext } from '../context';
-import { resolveEasCommandPrefixAndEnvAsync } from '../utils/easCli';
+import { isAtLeastNpm7Async } from '../utils/packageManager';
 
 const EasBuildInternalResultSchema = Joi.object<{ job: object; metadata: object }>({
   job: Joi.object().unknown(),
@@ -114,6 +121,33 @@ export async function resolveEnvFromBuildProfileAsync<TJob extends BuildJob>(
   return env;
 }
 
+async function resolveEasCommandPrefixAndEnvAsync(): Promise<{
+  cmd: string;
+  args: string[];
+  extraEnv: Env;
+}> {
+  const npxArgsPrefix = (await isAtLeastNpm7Async()) ? ['-y'] : [];
+  if (process.env.ENVIRONMENT === 'development') {
+    return {
+      cmd: 'npx',
+      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.STAGING}`],
+      extraEnv: {},
+    };
+  } else if (process.env.ENVIRONMENT === 'staging') {
+    return {
+      cmd: 'npx',
+      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.STAGING}`],
+      extraEnv: { EXPO_STAGING: '1' },
+    };
+  } else {
+    return {
+      cmd: 'npx',
+      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.PRODUCTION}`],
+      extraEnv: {},
+    };
+  }
+}
+
 function validateEasBuildInternalResult<TJob extends BuildJob>({
   oldJob,
   result,

packages/build-tools/src/common/setup.ts

@@ -26,7 +26,7 @@ import {
   shouldUseFrozenLockfile,
 } from '../utils/packageManager';
 import { getParentAndDescendantProcessPidsAsync } from '../utils/processes';
-import { readAndLogPackageJson, readEasJsonContents } from '../utils/project';
+import { readEasJsonContents, readPackageJson } from '../utils/project';
 import { retryAsync } from '../utils/retry';
 
 const MAX_EXPO_DOCTOR_TIMEOUT_MS = 30 * 1000;
@@ -82,7 +82,10 @@ export async function setupAsync<TJob extends BuildJob>(ctx: BuildContext<TJob>)
   });
 
   const packageJson = await ctx.runBuildPhase(BuildPhase.READ_PACKAGE_JSON, async () => {
-    return readAndLogPackageJson(ctx.logger, ctx.getReactNativeProjectDirectory());
+    ctx.logger.info('Using package.json:');
+    const packageJson = readPackageJson(ctx.getReactNativeProjectDirectory());
+    ctx.logger.info(JSON.stringify(packageJson, null, 2));
+    return packageJson;
   });
 
   await ctx.runBuildPhase(BuildPhase.INSTALL_DEPENDENCIES, async () => {

packages/build-tools/src/context.ts

@@ -173,9 +173,7 @@ export class BuildContext<TJob extends Job = Job> {
     return path.join(this.workingdir, 'env');
   }
   public get packageManager(): PackageManager {
-    return resolvePackageManager(this.getReactNativeProjectDirectory(), {
-      env: this.env,
-    });
+    return resolvePackageManager(this.getReactNativeProjectDirectory());
   }
   public get appConfig(): Promise<ExpoConfig> {
     if (!this._appConfig) {

packages/build-tools/src/index.ts

@@ -19,5 +19,12 @@ export { PackageManager } from './utils/packageManager';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';
 
 export { Hook, runHookIfPresent } from './utils/hooks';
+export {
+  maybeStartPreparingPrecompiledModules,
+  PRECOMPILED_MODULES_PATH,
+  shouldUsePrecompiledDependencies,
+  startPreparingPrecompiledDependencies,
+  waitForPrecompiledModulesPreparationAsync,
+} from './utils/precompiledModules';
 
 export * from './generic';

packages/build-tools/src/ios/__tests__/__snapshots__/gymfile.test.ts.snap

@@ -22,10 +22,6 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain /Users/expo/Library/Keychains
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
 
-derived_data_path("./build")
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
-
 output_directory("/tmp/output")
 "
 `;
@@ -49,10 +45,6 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain /tmp/keychain\\""
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
 
-derived_data_path("./build")
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
-
 output_directory("/tmp/output")
 "
 `;
@@ -78,10 +70,6 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain /tmp/keychain\\""
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
 
-derived_data_path("./build")
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
-
 output_directory("/tmp/output")
 "
 `;
@@ -109,10 +97,6 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain /tmp/keychain\\""
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
 
-derived_data_path("./build")
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
-
 output_directory("/tmp/output")
 "
 `;
@@ -133,9 +117,6 @@ destination("generic/platform=iOS Simulator")
 
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
-
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
 "
 `;
 
@@ -153,9 +134,6 @@ destination("platform=iOS Simulator,name=iPhone 15")
 
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
-
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
 "
 `;
 
@@ -175,8 +153,5 @@ destination("generic/platform=tvOS Simulator")
 
 disable_xcpretty(true)
 buildlog_path("/tmp/logs")
-
-result_bundle(true)
-result_bundle_path("./build/result-bundle.xcresult")
 "
 `;

packages/build-tools/src/ios/__tests__/configure.test.ts

@@ -165,52 +165,6 @@ describe(configureXcodeProject, () => {
       'Info.plist application target'
     );
   });
-  it('configures credentials with Apple Development identity for development profile', async () => {
-    vol.fromJSON(
-      {
-        'ios/testapp.xcodeproj/project.pbxproj': originalFs.readFileSync(
-          path.join(__dirname, 'fixtures/simple-project.pbxproj'),
-          'utf-8'
-        ),
-        'ios/testapp/AppDelegate.m': 'placeholder',
-      },
-      '/app'
-    );
-    const options = {
-      credentials: {
-        keychainPath: 'fake/path',
-        targetProvisioningProfiles: {
-          testapp: {
-            path: 'fake/path.mobileprovision',
-            target: 'testapp',
-            bundleIdentifier: 'abc',
-            teamId: 'ABCDEFGH',
-            uuid: 'abc',
-            name: 'profile name',
-            developerCertificate: Buffer.from('test'),
-            certificateCommonName: 'Apple Development: Test User',
-            distributionType: DistributionType.DEVELOPMENT,
-          },
-        },
-        distributionType: DistributionType.DEVELOPMENT,
-        teamId: 'ABCDEFGH',
-        applicationTargetProvisioningProfile: {} as ProvisioningProfile<Ios.Job>,
-      },
-      buildConfiguration: 'Release',
-    };
-    const ctx = {
-      getReactNativeProjectDirectory: () => '/app',
-      logger: { info: jest.fn() },
-      job: {},
-    };
-    await configureXcodeProject(ctx as any, options);
-    const pbxproj = vol.readFileSync(
-      '/app/ios/testapp.xcodeproj/project.pbxproj',
-      'utf-8'
-    ) as string;
-    expect(pbxproj).toContain('CODE_SIGN_IDENTITY = "Apple Development: Test User"');
-    expect(pbxproj).not.toContain('"iPhone Distribution"');
-  });
   it('configures credentials and versions for multi target project', async () => {
     vol.fromJSON(
       {

packages/build-tools/src/ios/__tests__/fastlane.test.ts

@@ -1,128 +0,0 @@
-import { Ios } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
-import { vol } from 'memfs';
-import path from 'path';
-
-import { createTestIosJob } from '../../__tests__/utils/job';
-import { createMockLogger } from '../../__tests__/utils/logger';
-import { BuildContext } from '../../context';
-import { Credentials } from '../credentials/manager';
-import { DistributionType } from '../credentials/provisioningProfile';
-import { runFastlaneGym } from '../fastlane';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn().mockResolvedValue(undefined),
-}));
-
-jest.mock('../tvos', () => ({
-  isTVOS: jest.fn().mockResolvedValue(false),
-}));
-
-const WORKING_DIR = '/workingdir';
-// BuildContext.getReactNativeProjectDirectory() nests the RN project under `${workingdir}/build`.
-const IOS_DIR = path.join(WORKING_DIR, 'build', 'ios');
-
-function makeIosBuildContext({ simulator }: { simulator: boolean }): BuildContext<Ios.Job> {
-  const job: Ios.Job = { ...createTestIosJob(), simulator };
-  return new BuildContext(job, {
-    workingdir: WORKING_DIR,
-    logger: createMockLogger(),
-    logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
-    env: { __API_SERVER_URL: 'http://api.expo.test' },
-    uploadArtifact: jest.fn(),
-  });
-}
-
-const ARCHIVE_CREDENTIALS: Credentials = {
-  keychainPath: '/Users/expo/Library/Keychains/login.keychain',
-  distributionType: DistributionType.APP_STORE,
-  teamId: 'TEAM123',
-  applicationTargetProvisioningProfile: {} as any,
-  targetProvisioningProfiles: {
-    'com.example.app': {
-      bundleIdentifier: 'com.example.app',
-      uuid: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
-      path: '/path/to/profile1.mobileprovision',
-      target: 'com.example.app',
-      teamId: 'TEAM123',
-      name: 'Main App Profile',
-      developerCertificate: Buffer.from('cert'),
-      certificateCommonName: 'iPhone Distribution',
-      distributionType: DistributionType.APP_STORE,
-    },
-  },
-};
-
-function readDerivedDataPathFromGymfile(gymfileContent: string, workspacePath: string): string {
-  const match = gymfileContent.match(/derived_data_path\("([^"]+)"\)/);
-  if (!match) {
-    throw new Error(
-      `Gymfile did not contain derived_data_path("..."). Content:\n${gymfileContent}`
-    );
-  }
-  return path.resolve(workspacePath, match[1]);
-}
-
-describe(runFastlaneGym, () => {
-  beforeEach(() => {
-    vol.reset();
-    vol.fromJSON({ [path.join(IOS_DIR, '.keep')]: '' });
-    (spawn as jest.Mock).mockClear();
-  });
-
-  describe.each([
-    {
-      name: 'archive',
-      simulator: false,
-      credentials: ARCHIVE_CREDENTIALS,
-      buildConfiguration: 'Release',
-    },
-    {
-      name: 'simulator',
-      simulator: true,
-      credentials: null,
-      buildConfiguration: 'Debug',
-    },
-  ])('$name build', ({ simulator, credentials, buildConfiguration }) => {
-    it('returns paths that match the generated Gymfile template', async () => {
-      const ctx = makeIosBuildContext({ simulator });
-
-      const result = await runFastlaneGym(ctx, {
-        scheme: 'App',
-        buildConfiguration,
-        credentials,
-        entitlements: null,
-      });
-
-      expect(result).toEqual({
-        derivedDataPath: path.join(IOS_DIR, 'build'),
-        workspacePath: IOS_DIR,
-      });
-
-      const gymfileContent = vol.readFileSync(path.join(IOS_DIR, 'Gymfile'), 'utf8') as string;
-      expect(readDerivedDataPathFromGymfile(gymfileContent, result.workspacePath)).toBe(
-        result.derivedDataPath
-      );
-    });
-  });
-
-  it('still returns EAS-convention paths when a pre-existing ios/Gymfile is present', async () => {
-    vol.fromJSON({
-      [path.join(IOS_DIR, 'Gymfile')]: '# user-supplied Gymfile\n',
-    });
-
-    const ctx = makeIosBuildContext({ simulator: false });
-
-    const result = await runFastlaneGym(ctx, {
-      scheme: 'App',
-      credentials: ARCHIVE_CREDENTIALS,
-      entitlements: null,
-    });
-
-    expect(result).toEqual({
-      derivedDataPath: path.join(IOS_DIR, 'build'),
-      workspacePath: IOS_DIR,
-    });
-  });
-});

packages/build-tools/src/ios/__tests__/gymfile.test.ts

@@ -58,8 +58,6 @@ describe('gymfile', () => {
         scheme: 'MyApp',
         buildConfiguration: 'Release',
         outputDirectory: '/tmp/output',
-        derivedDataPath: './build',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: true,
         logsDirectory: '/tmp/logs',
       });
@@ -96,8 +94,6 @@ describe('gymfile', () => {
         credentials: mockCredentials,
         scheme: 'TestScheme',
         outputDirectory: '/tmp/output',
-        derivedDataPath: './build',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: false,
         logsDirectory: '/tmp/logs',
       });
@@ -135,8 +131,6 @@ describe('gymfile', () => {
         scheme: 'MyApp',
         buildConfiguration: 'Release',
         outputDirectory: '/tmp/output',
-        derivedDataPath: './build',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: true,
         logsDirectory: '/tmp/logs',
         entitlements: {
@@ -198,8 +192,6 @@ describe('gymfile', () => {
         credentials: mockCredentials,
         scheme: 'MyApp',
         outputDirectory: '/tmp/output',
-        derivedDataPath: './build',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: true,
         logsDirectory: '/tmp/logs',
       });
@@ -218,7 +210,6 @@ describe('gymfile', () => {
         scheme: 'MyApp',
         buildConfiguration: 'Debug',
         derivedDataPath: '/tmp/derived-data',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: true,
         logsDirectory: '/tmp/logs',
         simulatorDestination: 'generic/platform=iOS Simulator',
@@ -235,7 +226,6 @@ describe('gymfile', () => {
         outputFile,
         scheme: 'TestApp',
         derivedDataPath: '/tmp/derived',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: false,
         logsDirectory: '/tmp/logs',
         simulatorDestination: 'platform=iOS Simulator,name=iPhone 15',
@@ -253,7 +243,6 @@ describe('gymfile', () => {
         scheme: 'MyTVApp',
         buildConfiguration: 'Debug',
         derivedDataPath: '/tmp/derived',
-        resultBundlePath: './build/result-bundle.xcresult',
         clean: true,
         logsDirectory: '/tmp/logs',
         simulatorDestination: 'generic/platform=tvOS Simulator',

packages/build-tools/src/ios/__tests__/pod.test.ts

@@ -0,0 +1,127 @@
+import downloadFile from '@expo/downloader';
+import spawn from '@expo/turtle-spawn';
+import { mkdirp, mkdtemp, move, remove } from 'fs-extra';
+import StreamZip from 'node-stream-zip';
+
+import { createTestIosJob } from '../../__tests__/utils/job';
+import { createMockLogger } from '../../__tests__/utils/logger';
+import { BuildContext } from '../../context';
+import {
+  startPreparingPrecompiledDependencies,
+  PRECOMPILED_MODULES_PATH,
+} from '../../utils/precompiledModules';
+import { installPods } from '../pod';
+
+jest.mock('@expo/downloader');
+jest.mock('fs-extra');
+jest.mock('@expo/turtle-spawn');
+jest.mock('node-stream-zip', () => ({
+  __esModule: true,
+  default: {
+    async: jest.fn(),
+  },
+}));
+
+describe(installPods.name, () => {
+  const extract = jest.fn();
+  const close = jest.fn();
+
+  beforeEach(() => {
+    jest.mocked(remove).mockImplementation(async () => undefined as any);
+    jest.mocked(mkdirp).mockImplementation(async () => undefined as any);
+    jest.mocked(move).mockImplementation(async () => undefined as any);
+    let mkdtempCallCount = 0;
+    jest.mocked(mkdtemp).mockImplementation(async () => {
+      mkdtempCallCount += 1;
+      return mkdtempCallCount === 1
+        ? ('/tmp/precompiled-modules-archive' as any)
+        : ('/tmp/precompiled-modules-staging' as any);
+    });
+    extract.mockReset().mockResolvedValue(undefined);
+    close.mockReset().mockResolvedValue(undefined);
+    jest.mocked(StreamZip.async).mockImplementation(
+      () =>
+        ({
+          extract,
+          close,
+        }) as any
+    );
+  });
+
+  it('waits for precompiled dependencies before running pod install', async () => {
+    let resolvePreparation: (() => void) | undefined;
+    const preparationPromise = new Promise<void>(resolve => {
+      resolvePreparation = resolve;
+    });
+    jest.mocked(downloadFile).mockReturnValue(preparationPromise);
+    const ctx = new BuildContext(
+      createTestIosJob({
+        buildCredentials: undefined,
+      }),
+      {
+        workingdir: '/workingdir',
+        logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
+        logger: createMockLogger(),
+        env: {
+          __API_SERVER_URL: 'http://api.expo.test',
+        },
+        uploadArtifact: jest.fn(),
+      }
+    );
+    startPreparingPrecompiledDependencies(ctx, [
+      'https://example.com/precompiled-modules-0.zip',
+      'https://example.com/precompiled-modules-1.zip',
+    ]);
+
+    jest.mocked(spawn).mockResolvedValue({} as any);
+
+    const installPodsPromise = installPods(ctx, {});
+    await Promise.resolve();
+
+    expect(spawn).not.toHaveBeenCalled();
+
+    resolvePreparation?.();
+    await installPodsPromise;
+
+    expect(spawn).toHaveBeenCalledWith(
+      'pod',
+      ['install'],
+      expect.objectContaining({
+        cwd: '/workingdir/build/ios',
+      })
+    );
+    expect(mkdirp).toHaveBeenCalledWith(PRECOMPILED_MODULES_PATH);
+  });
+
+  it('continues with pod install when precompiled dependencies preparation fails', async () => {
+    jest.mocked(downloadFile).mockRejectedValue(new Error('download failed'));
+    const ctx = new BuildContext(
+      createTestIosJob({
+        buildCredentials: undefined,
+      }),
+      {
+        workingdir: '/workingdir',
+        logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
+        logger: createMockLogger(),
+        env: {
+          __API_SERVER_URL: 'http://api.expo.test',
+        },
+        uploadArtifact: jest.fn(),
+      }
+    );
+    startPreparingPrecompiledDependencies(ctx, ['https://example.com/precompiled-modules-0.zip']);
+
+    jest.mocked(spawn).mockResolvedValue({} as any);
+
+    await expect(installPods(ctx, {})).resolves.toEqual({
+      spawnPromise: expect.any(Promise),
+    });
+    expect(spawn).toHaveBeenCalledWith(
+      'pod',
+      ['install'],
+      expect.objectContaining({
+        cwd: '/workingdir/build/ios',
+      })
+    );
+  });
+});

packages/build-tools/src/ios/configure.ts

@@ -6,7 +6,6 @@ import uniq from 'lodash/uniq';
 import path from 'path';
 
 import { Credentials } from './credentials/manager';
-import { DistributionType } from './credentials/provisioningProfile';
 import { BuildContext } from '../context';
 
 async function configureXcodeProject(
@@ -57,9 +56,6 @@ async function configureCredentialsAsync(
         profileName: profile.name,
         appleTeamId: profile.teamId,
         buildConfiguration,
-        ...(credentials.distributionType === DistributionType.DEVELOPMENT && {
-          codeSignIdentity: profile.certificateCommonName,
-        }),
       }
     );
   }

packages/build-tools/src/ios/credentials/provisioningProfile.ts

@@ -24,7 +24,6 @@ export interface ProvisioningProfileData {
 export enum DistributionType {
   AD_HOC = 'ad-hoc',
   APP_STORE = 'app-store',
-  DEVELOPMENT = 'development',
   ENTERPRISE = 'enterprise',
 }
 
@@ -138,10 +137,6 @@ export default class ProvisioningProfile<TJob extends Ios.Job> {
     if (plistData.ProvisionsAllDevices) {
       return DistributionType.ENTERPRISE;
     } else if (plistData.ProvisionedDevices) {
-      const entitlements = plistData.Entitlements as plist.PlistObject | undefined;
-      if (entitlements?.['get-task-allow']) {
-        return DistributionType.DEVELOPMENT;
-      }
       return DistributionType.AD_HOC;
     } else {
       return DistributionType.APP_STORE;

packages/build-tools/src/ios/fastlane.ts

@@ -3,7 +3,6 @@ import { bunyan } from '@expo/logger';
 import spawn, { SpawnResult } from '@expo/turtle-spawn';
 import fs from 'fs-extra';
 import nullthrows from 'nullthrows';
-import os from 'os';
 import path from 'path';
 
 import type { Credentials } from './credentials/manager';
@@ -29,13 +28,7 @@ export async function runFastlaneGym<TJob extends Ios.Job>(
     entitlements: object | null;
     extraEnv?: Env;
   }
-): Promise<{
-  derivedDataPath: string;
-  workspacePath: string;
-}> {
-  const workspacePath = path.join(ctx.getReactNativeProjectDirectory(), 'ios');
-  const derivedDataPath = path.join(workspacePath, 'build');
-
+): Promise<void> {
   await ensureGymfileExists(ctx, {
     scheme,
     buildConfiguration,
@@ -50,15 +43,13 @@ export async function runFastlaneGym<TJob extends Ios.Job>(
   void buildLogger.watchLogFiles(ctx.buildLogsDirectory);
   try {
     await runFastlane(['gym'], {
-      cwd: workspacePath,
+      cwd: path.join(ctx.getReactNativeProjectDirectory(), 'ios'),
       logger: ctx.logger,
       env: { ...ctx.env, ...extraEnv },
     });
   } finally {
     await buildLogger.flush();
   }
-
-  return { derivedDataPath, workspacePath };
 }
 
 export async function runFastlaneResign<TJob extends Ios.Job>(
@@ -131,8 +122,6 @@ async function ensureGymfileExists<TJob extends Ios.Job>(
   }
 
   ctx.logger.info('Creating Gymfile');
-  const resultBundlePath = path.join(os.tmpdir(), `result-bundle-${Date.now()}.xcresult`);
-
   if (ctx.job.simulator) {
     const isTV = await isTVOS(ctx);
     const simulatorDestination = `generic/platform=${isTV ? 'tvOS' : 'iOS'} Simulator`;
@@ -142,7 +131,6 @@ async function ensureGymfileExists<TJob extends Ios.Job>(
       scheme,
       buildConfiguration: buildConfiguration ?? 'release',
       derivedDataPath: './build',
-      resultBundlePath,
       clean: false,
       logsDirectory,
       simulatorDestination,
@@ -154,8 +142,6 @@ async function ensureGymfileExists<TJob extends Ios.Job>(
       scheme,
       buildConfiguration,
       outputDirectory: './build',
-      derivedDataPath: './build',
-      resultBundlePath,
       clean: false,
       logsDirectory,
       entitlements: entitlements ?? undefined,

packages/build-tools/src/ios/gymfile.ts

@@ -11,8 +11,6 @@ interface ArchiveBuildOptions {
   scheme: string;
   buildConfiguration?: string;
   outputDirectory: string;
-  derivedDataPath: string;
-  resultBundlePath: string;
   clean: boolean;
   logsDirectory: string;
   entitlements?: object;
@@ -23,7 +21,6 @@ interface SimulatorBuildOptions {
   scheme: string;
   buildConfiguration?: string;
   derivedDataPath: string;
-  resultBundlePath: string;
   clean: boolean;
   logsDirectory: string;
   simulatorDestination: string;
@@ -37,8 +34,6 @@ export async function createGymfileForArchiveBuild({
   buildConfiguration,
   entitlements,
   outputDirectory,
-  derivedDataPath,
-  resultBundlePath,
   logsDirectory,
 }: ArchiveBuildOptions): Promise<void> {
   const PROFILES: { BUNDLE_ID: string; UUID: string }[] = [];
@@ -64,8 +59,6 @@ export async function createGymfileForArchiveBuild({
       SCHEME: scheme,
       SCHEME_BUILD_CONFIGURATION: buildConfiguration,
       OUTPUT_DIRECTORY: outputDirectory,
-      DERIVED_DATA_PATH: derivedDataPath,
-      RESULT_BUNDLE_PATH: resultBundlePath,
       EXPORT_METHOD: credentials.distributionType,
       CLEAN: String(clean),
       LOGS_DIRECTORY: logsDirectory,
@@ -81,7 +74,6 @@ export async function createGymfileForSimulatorBuild({
   scheme,
   buildConfiguration,
   derivedDataPath,
-  resultBundlePath,
   logsDirectory,
   simulatorDestination,
 }: SimulatorBuildOptions): Promise<void> {
@@ -94,7 +86,6 @@ export async function createGymfileForSimulatorBuild({
       SCHEME_BUILD_CONFIGURATION: buildConfiguration,
       SCHEME_SIMULATOR_DESTINATION: simulatorDestination,
       DERIVED_DATA_PATH: derivedDataPath,
-      RESULT_BUNDLE_PATH: resultBundlePath,
       CLEAN: String(clean),
       LOGS_DIRECTORY: logsDirectory,
     },

packages/build-tools/src/ios/pod.ts

@@ -3,11 +3,21 @@ import spawn, { SpawnOptions, SpawnPromise, SpawnResult } from '@expo/turtle-spa
 import path from 'path';
 
 import { BuildContext } from '../context';
+import { waitForPrecompiledModulesPreparationAsync } from '../utils/precompiledModules';
 
 export async function installPods<TJob extends Ios.Job>(
   ctx: BuildContext<TJob>,
   { infoCallbackFn }: SpawnOptions
 ): Promise<{ spawnPromise: SpawnPromise<SpawnResult> }> {
+  try {
+    await waitForPrecompiledModulesPreparationAsync();
+  } catch (err) {
+    ctx.logger.warn(
+      { err },
+      'Precompiled dependencies were not prepared successfully, continuing with pod install'
+    );
+  }
+
   const iosDir = path.join(ctx.getReactNativeProjectDirectory(), 'ios');
 
   const verboseFlag = ctx.env['EAS_VERBOSE'] === '1' ? ['--verbose'] : [];

packages/build-tools/src/steps/__tests__/easFunctionGroups.test.ts

@@ -1,27 +0,0 @@
-import { getEasFunctionGroups } from '../easFunctionGroups';
-
-describe(getEasFunctionGroups, () => {
-  it('includes eas/maestro_test for non-build jobs', () => {
-    const ctx = {
-      hasBuildJob: () => false,
-      job: {},
-    } as unknown as Parameters<typeof getEasFunctionGroups>[0];
-
-    const functionGroupIds = getEasFunctionGroups(ctx).map(functionGroup =>
-      functionGroup.getFullId()
-    );
-    expect(functionGroupIds).toEqual(['eas/maestro_test']);
-  });
-
-  it('includes eas/build for build jobs', () => {
-    const ctx = {
-      hasBuildJob: () => true,
-      job: {},
-    } as unknown as Parameters<typeof getEasFunctionGroups>[0];
-
-    const functionGroupIds = getEasFunctionGroups(ctx).map(functionGroup =>
-      functionGroup.getFullId()
-    );
-    expect(functionGroupIds).toEqual(expect.arrayContaining(['eas/build', 'eas/maestro_test']));
-  });
-});

packages/build-tools/src/steps/easFunctions.ts

@@ -9,8 +9,6 @@ import { configureIosVersionFunction } from './functions/configureIosVersion';
 import { createSubmissionEntityFunction } from './functions/createSubmissionEntity';
 import { createDownloadArtifactFunction } from './functions/downloadArtifact';
 import { createDownloadBuildFunction } from './functions/downloadBuild';
-import { createEasDeployBuildFunction } from './functions/deploy';
-import { createEasExportBuildFunction } from './functions/export';
 import { eagerBundleBuildFunction } from './functions/eagerBundle';
 import { createFindAndUploadBuildArtifactsBuildFunction } from './functions/findAndUploadBuildArtifacts';
 import { generateGymfileFromTemplateFunction } from './functions/generateGymfileFromTemplate';
@@ -19,21 +17,18 @@ import { injectAndroidCredentialsFunction } from './functions/injectAndroidCrede
 import { createInstallMaestroBuildFunction } from './functions/installMaestro';
 import { createInstallNodeModulesBuildFunction } from './functions/installNodeModules';
 import { createInstallPodsBuildFunction } from './functions/installPods';
+import { createInternalEasMaestroTestFunction } from './functions/internalMaestroTest';
 import { createPrebuildBuildFunction } from './functions/prebuild';
-import { createReadAppConfigBuildFunction } from './functions/readAppConfig';
 import { createReadIpaInfoBuildFunction } from './functions/readIpaInfo';
-import { createReadPackageJsonBuildFunction } from './functions/readPackageJson';
 import { createRepackBuildFunction } from './functions/repack';
 import { createReportMaestroTestResultsFunction } from './functions/reportMaestroTestResults';
 import { resolveAppleTeamIdFromCredentialsFunction } from './functions/resolveAppleTeamIdFromCredentials';
 import { createResolveBuildConfigBuildFunction } from './functions/resolveBuildConfig';
-import { createResolveSubmitConfigBuildFunction } from './functions/resolveSubmitConfig';
 import {
   createCacheStatsBuildFunction,
   createRestoreBuildCacheFunction,
 } from './functions/restoreBuildCache';
 import { createRestoreCacheFunction } from './functions/restoreCache';
-import { parseXcactivitylogFunction } from './functions/parseXcactivitylog';
 import { runFastlaneFunction } from './functions/runFastlane';
 import { runGradleFunction } from './functions/runGradle';
 import { createSaveBuildCacheFunction } from './functions/saveBuildCache';
@@ -53,14 +48,10 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     createDownloadArtifactFunction(),
     createUploadArtifactBuildFunction(ctx),
     createSetUpNpmrcBuildFunction(),
-    createReadPackageJsonBuildFunction(),
-    createReadAppConfigBuildFunction(),
     createInstallNodeModulesBuildFunction(),
     createPrebuildBuildFunction(),
     createReadIpaInfoBuildFunction(),
     createDownloadBuildFunction(),
-    createEasExportBuildFunction(),
-    createEasDeployBuildFunction(),
     createRepackBuildFunction(),
     createRestoreCacheFunction(),
     createRestoreBuildCacheFunction(),
@@ -77,7 +68,6 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     configureIosVersionFunction(),
     generateGymfileFromTemplateFunction(),
     runFastlaneFunction(),
-    parseXcactivitylogFunction(),
     createStartAndroidEmulatorBuildFunction(),
     createStartCuttlefishDeviceBuildFunction(),
     createStartIosSimulatorBuildFunction(),
@@ -89,9 +79,10 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     calculateEASUpdateRuntimeVersionFunction(),
 
     createSubmissionEntityFunction(),
-    createResolveSubmitConfigBuildFunction(ctx),
     createUploadToAscBuildFunction(),
 
+    createInternalEasMaestroTestFunction(ctx),
+
     createReportMaestroTestResultsFunction(ctx),
   ];
 

packages/build-tools/src/steps/functionGroups/__tests__/build.test.ts

@@ -1,200 +0,0 @@
-import { BuildJob, Platform } from '@expo/eas-build-job';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { CustomBuildContext } from '../../../customBuildContext';
-import { createEasBuildBuildFunctionGroup } from '../build';
-
-function createMockBuildToolsContext(
-  overrides: Partial<{
-    platform: Platform;
-    simulator: boolean;
-    buildCredentials: Record<string, unknown>;
-  }> = {}
-): CustomBuildContext<BuildJob> {
-  return {
-    job: {
-      platform: overrides.platform ?? Platform.ANDROID,
-      simulator: overrides.simulator ?? false,
-      secrets: overrides.buildCredentials
-        ? { buildCredentials: overrides.buildCredentials }
-        : undefined,
-    },
-  } as unknown as CustomBuildContext<BuildJob>;
-}
-
-describe(createEasBuildBuildFunctionGroup, () => {
-  describe('working_directory input', () => {
-    it('does not set working directory on steps when not provided (Android)', () => {
-      const buildToolsContext = createMockBuildToolsContext({ platform: Platform.ANDROID });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx);
-
-      for (const step of steps) {
-        // Without working_directory, only installPods would have a relative dir (iOS only).
-        // On Android, no step should have a relative working directory.
-        expect(step.ctx.relativeWorkingDirectory).toBeUndefined();
-      }
-    });
-
-    it('sets working directory on all steps except checkout (Android)', () => {
-      const buildToolsContext = createMockBuildToolsContext({ platform: Platform.ANDROID });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const checkoutStep = steps.find(s => s.displayName === 'Checkout');
-      expect(checkoutStep).toBeDefined();
-      expect(checkoutStep!.ctx.relativeWorkingDirectory).toBeUndefined();
-
-      const nonCheckoutSteps = steps.filter(s => s.displayName !== 'Checkout');
-      expect(nonCheckoutSteps.length).toBeGreaterThan(0);
-      for (const step of nonCheckoutSteps) {
-        expect(step.ctx.relativeWorkingDirectory).toBe('./my-app');
-      }
-    });
-
-    it('sets working directory on all steps except checkout (iOS simulator)', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        simulator: true,
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const checkoutStep = steps.find(s => s.displayName === 'Checkout');
-      expect(checkoutStep).toBeDefined();
-      expect(checkoutStep!.ctx.relativeWorkingDirectory).toBeUndefined();
-
-      const nonCheckoutSteps = steps.filter(s => s.displayName !== 'Checkout');
-      expect(nonCheckoutSteps.length).toBeGreaterThan(0);
-      for (const step of nonCheckoutSteps) {
-        expect(step.ctx.relativeWorkingDirectory).toBeDefined();
-        expect(step.ctx.relativeWorkingDirectory).toContain('my-app');
-      }
-    });
-
-    it('sets working directory on all steps except checkout (iOS with credentials)', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        buildCredentials: { test: {} },
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const checkoutStep = steps.find(s => s.displayName === 'Checkout');
-      expect(checkoutStep).toBeDefined();
-      expect(checkoutStep!.ctx.relativeWorkingDirectory).toBeUndefined();
-
-      const nonCheckoutSteps = steps.filter(s => s.displayName !== 'Checkout');
-      expect(nonCheckoutSteps.length).toBeGreaterThan(0);
-      for (const step of nonCheckoutSteps) {
-        expect(step.ctx.relativeWorkingDirectory).toBeDefined();
-        expect(step.ctx.relativeWorkingDirectory).toContain('my-app');
-      }
-    });
-
-    it('wires configure_ios_credentials target_names into configure_ios_version', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        buildCredentials: { test: {} },
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const configureIosVersionStep = steps.find(s => s.displayName === 'Configure iOS version');
-      const targetNamesInput = configureIosVersionStep?.inputs?.find(
-        input => input.id === 'target_names'
-      );
-
-      expect(configureIosVersionStep).toBeDefined();
-      expect(targetNamesInput?.rawValue).toBe(
-        '${{ steps.configure_ios_credentials.outputs.target_names }}'
-      );
-    });
-
-    it('composes working directory with installPods step-level ./ios dir (iOS)', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        simulator: true,
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const installPodsStep = steps.find(s => s.displayName === 'Install Pods');
-      expect(installPodsStep).toBeDefined();
-      expect(installPodsStep!.ctx.relativeWorkingDirectory).toBe('my-app/ios');
-    });
-
-    it('uses ./ios for installPods when no working_directory provided (iOS)', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        simulator: true,
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx);
-
-      const installPodsStep = steps.find(s => s.displayName === 'Install Pods');
-      expect(installPodsStep).toBeDefined();
-      expect(installPodsStep!.ctx.relativeWorkingDirectory).toBe('./ios');
-    });
-
-    it('sets working directory on all steps except checkout (Android with credentials)', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.ANDROID,
-        buildCredentials: { test: {} },
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx, {
-        callInputs: { working_directory: './my-app' },
-      });
-
-      const checkoutStep = steps.find(s => s.displayName === 'Checkout');
-      expect(checkoutStep).toBeDefined();
-      expect(checkoutStep!.ctx.relativeWorkingDirectory).toBeUndefined();
-
-      const nonCheckoutSteps = steps.filter(s => s.displayName !== 'Checkout');
-      expect(nonCheckoutSteps.length).toBeGreaterThan(0);
-      for (const step of nonCheckoutSteps) {
-        expect(step.ctx.relativeWorkingDirectory).toBe('./my-app');
-      }
-    });
-  });
-
-  it('throws for generic jobs (no platform)', () => {
-    const buildToolsContext = {
-      job: { platform: undefined },
-    } as unknown as CustomBuildContext<BuildJob>;
-    const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-    const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-    expect(() => functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx)).toThrow(
-      'Build function group is not supported in generic jobs.'
-    );
-  });
-});

packages/build-tools/src/steps/functionGroups/build.ts

@@ -1,12 +1,5 @@
 import { BuildJob, Platform } from '@expo/eas-build-job';
-import {
-  BuildFunctionGroup,
-  BuildStep,
-  BuildStepGlobalContext,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
-import path from 'path';
+import { BuildFunctionGroup, BuildStep, BuildStepGlobalContext } from '@expo/steps';
 
 import { shouldUseEagerBundle } from '../../common/eagerBundle';
 import { CustomBuildContext } from '../../customBuildContext';
@@ -37,7 +30,6 @@ import { createSetUpNpmrcBuildFunction } from '../functions/useNpmToken';
 interface HelperFunctionsInput {
   globalCtx: BuildStepGlobalContext;
   buildToolsContext: CustomBuildContext<BuildJob>;
-  workingDirectory?: string;
 }
 
 export function createEasBuildBuildFunctionGroup(
@@ -46,30 +38,17 @@ export function createEasBuildBuildFunctionGroup(
   return new BuildFunctionGroup({
     namespace: 'eas',
     id: 'build',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'working_directory',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-    ],
-    createBuildStepsFromFunctionGroupCall: (globalCtx, { inputs }) => {
-      const workingDirectory = inputs.working_directory?.getValue({
-        interpolationContext: globalCtx.getInterpolationContext(),
-      }) as string | undefined;
-
+    createBuildStepsFromFunctionGroupCall: globalCtx => {
       if (buildToolsContext.job.platform === Platform.IOS) {
         if (buildToolsContext.job.simulator) {
           return createStepsForIosSimulatorBuild({
             globalCtx,
             buildToolsContext,
-            workingDirectory,
           });
         } else {
           return createStepsForIosBuildWithCredentials({
             globalCtx,
             buildToolsContext,
-            workingDirectory,
           });
         }
       } else if (buildToolsContext.job.platform === Platform.ANDROID) {
@@ -77,13 +56,11 @@ export function createEasBuildBuildFunctionGroup(
           return createStepsForAndroidBuildWithoutCredentials({
             globalCtx,
             buildToolsContext,
-            workingDirectory,
           });
         } else {
           return createStepsForAndroidBuildWithCredentials({
             globalCtx,
             buildToolsContext,
-            workingDirectory,
           });
         }
       }
@@ -96,19 +73,16 @@ export function createEasBuildBuildFunctionGroup(
 function createStepsForIosSimulatorBuild({
   globalCtx,
   buildToolsContext,
-  workingDirectory,
 }: HelperFunctionsInput): BuildStep[] {
   const calculateEASUpdateRuntimeVersion =
     calculateEASUpdateRuntimeVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
       id: 'calculate_eas_update_runtime_version',
-      workingDirectory,
     });
   const installPods = createInstallPodsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-    workingDirectory: workingDirectory ? path.join(workingDirectory, './ios') : './ios',
+    workingDirectory: './ios',
   });
   const configureEASUpdate =
     configureEASUpdateIfInstalledFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
       callInputs: {
         throw_if_not_configured: false,
         resolved_eas_update_runtime_version:
@@ -117,7 +91,6 @@ function createStepsForIosSimulatorBuild({
     });
   const runFastlane = runFastlaneFunction().createBuildStepFromFunctionCall(globalCtx, {
     id: 'run_fastlane',
-    workingDirectory,
     callInputs: {
       resolved_eas_update_runtime_version:
         '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -125,26 +98,18 @@ function createStepsForIosSimulatorBuild({
   });
   return [
     createCheckoutBuildFunction().createBuildStepFromFunctionCall(globalCtx),
-    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
-    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx),
+    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     createResolveBuildConfigBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
-      globalCtx,
-      { workingDirectory }
+      globalCtx
     ),
-    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     calculateEASUpdateRuntimeVersion,
     installPods,
     configureEASUpdate,
     ...(shouldUseEagerBundle(globalCtx.staticContext.metadata)
       ? [
           eagerBundleBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-            workingDirectory,
             callInputs: {
               resolved_eas_update_runtime_version:
                 '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -152,35 +117,29 @@ function createStepsForIosSimulatorBuild({
           }),
         ]
       : []),
-    generateGymfileFromTemplateFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    generateGymfileFromTemplateFunction().createBuildStepFromFunctionCall(globalCtx),
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx),
   ];
 }
 
 function createStepsForIosBuildWithCredentials({
   globalCtx,
   buildToolsContext,
-  workingDirectory,
 }: HelperFunctionsInput): BuildStep[] {
   const evictUsedBefore = new Date();
 
   const resolveAppleTeamIdFromCredentials =
     resolveAppleTeamIdFromCredentialsFunction().createBuildStepFromFunctionCall(globalCtx, {
       id: 'resolve_apple_team_id_from_credentials',
-      workingDirectory,
     });
   const calculateEASUpdateRuntimeVersion =
     calculateEASUpdateRuntimeVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
       id: 'calculate_eas_update_runtime_version',
-      workingDirectory,
     });
   const prebuildStep = createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-    workingDirectory,
     callInputs: {
       apple_team_id: '${ steps.resolve_apple_team_id_from_credentials.apple_team_id }',
     },
@@ -188,18 +147,16 @@ function createStepsForIosBuildWithCredentials({
   const restoreCache = createRestoreBuildCacheFunction().createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.IOS,
       },
     }
   );
   const installPods = createInstallPodsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-    workingDirectory: workingDirectory ? path.join(workingDirectory, './ios') : './ios',
+    workingDirectory: './ios',
   });
   const configureEASUpdate =
     configureEASUpdateIfInstalledFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
       callInputs: {
         throw_if_not_configured: false,
         resolved_eas_update_runtime_version:
@@ -209,7 +166,6 @@ function createStepsForIosBuildWithCredentials({
   const generateGymfile = generateGymfileFromTemplateFunction().createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         credentials: '${ eas.job.secrets.buildCredentials }',
       },
@@ -217,7 +173,6 @@ function createStepsForIosBuildWithCredentials({
   );
   const runFastlane = runFastlaneFunction().createBuildStepFromFunctionCall(globalCtx, {
     id: 'run_fastlane',
-    workingDirectory,
     callInputs: {
       resolved_eas_update_runtime_version:
         '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -226,7 +181,6 @@ function createStepsForIosBuildWithCredentials({
   const saveCache = createSaveBuildCacheFunction(evictUsedBefore).createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.IOS,
       },
@@ -234,15 +188,10 @@ function createStepsForIosBuildWithCredentials({
   );
   return [
     createCheckoutBuildFunction().createBuildStepFromFunctionCall(globalCtx),
-    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
-    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx),
+    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     createResolveBuildConfigBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
-      globalCtx,
-      { workingDirectory }
+      globalCtx
     ),
     resolveAppleTeamIdFromCredentials,
     prebuildStep,
@@ -250,20 +199,11 @@ function createStepsForIosBuildWithCredentials({
     calculateEASUpdateRuntimeVersion,
     installPods,
     configureEASUpdate,
-    configureIosCredentialsFunction().createBuildStepFromFunctionCall(globalCtx, {
-      id: 'configure_ios_credentials',
-      workingDirectory,
-    }),
-    configureIosVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-      callInputs: {
-        target_names: '${{ steps.configure_ios_credentials.outputs.target_names }}',
-      },
-    }),
+    configureIosCredentialsFunction().createBuildStepFromFunctionCall(globalCtx),
+    configureIosVersionFunction().createBuildStepFromFunctionCall(globalCtx),
     ...(shouldUseEagerBundle(globalCtx.staticContext.metadata)
       ? [
           eagerBundleBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-            workingDirectory,
             callInputs: {
               resolved_eas_update_runtime_version:
                 '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -275,29 +215,24 @@ function createStepsForIosBuildWithCredentials({
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx),
     saveCache,
-    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx),
   ];
 }
 
 function createStepsForAndroidBuildWithoutCredentials({
   globalCtx,
   buildToolsContext,
-  workingDirectory,
 }: HelperFunctionsInput): BuildStep[] {
   const evictUsedBefore = new Date();
 
   const calculateEASUpdateRuntimeVersion =
     calculateEASUpdateRuntimeVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
       id: 'calculate_eas_update_runtime_version',
-      workingDirectory,
     });
   const configureEASUpdate =
     configureEASUpdateIfInstalledFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
       callInputs: {
         throw_if_not_configured: false,
         resolved_eas_update_runtime_version:
@@ -307,7 +242,6 @@ function createStepsForAndroidBuildWithoutCredentials({
   const restoreCache = createRestoreBuildCacheFunction().createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.ANDROID,
       },
@@ -315,7 +249,6 @@ function createStepsForAndroidBuildWithoutCredentials({
   );
   const runGradle = runGradleFunction().createBuildStepFromFunctionCall(globalCtx, {
     id: 'run_gradle',
-    workingDirectory,
     callInputs: {
       resolved_eas_update_runtime_version:
         '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -324,7 +257,6 @@ function createStepsForAndroidBuildWithoutCredentials({
   const saveCache = createSaveBuildCacheFunction(evictUsedBefore).createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.ANDROID,
       },
@@ -332,26 +264,18 @@ function createStepsForAndroidBuildWithoutCredentials({
   );
   return [
     createCheckoutBuildFunction().createBuildStepFromFunctionCall(globalCtx),
-    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
-    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx),
+    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     createResolveBuildConfigBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
-      globalCtx,
-      { workingDirectory }
+      globalCtx
     ),
-    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     restoreCache,
     calculateEASUpdateRuntimeVersion,
     configureEASUpdate,
     ...(shouldUseEagerBundle(globalCtx.staticContext.metadata)
       ? [
           eagerBundleBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-            workingDirectory,
             callInputs: {
               resolved_eas_update_runtime_version:
                 '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -362,29 +286,24 @@ function createStepsForAndroidBuildWithoutCredentials({
     runGradle,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx),
     saveCache,
-    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx),
   ];
 }
 
 function createStepsForAndroidBuildWithCredentials({
   globalCtx,
   buildToolsContext,
-  workingDirectory,
 }: HelperFunctionsInput): BuildStep[] {
   const evictUsedBefore = new Date();
 
   const calculateEASUpdateRuntimeVersion =
     calculateEASUpdateRuntimeVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
       id: 'calculate_eas_update_runtime_version',
-      workingDirectory,
     });
   const configureEASUpdate =
     configureEASUpdateIfInstalledFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
       callInputs: {
         throw_if_not_configured: false,
         resolved_eas_update_runtime_version:
@@ -394,7 +313,6 @@ function createStepsForAndroidBuildWithCredentials({
   const restoreCache = createRestoreBuildCacheFunction().createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.ANDROID,
       },
@@ -402,7 +320,6 @@ function createStepsForAndroidBuildWithCredentials({
   );
   const runGradle = runGradleFunction().createBuildStepFromFunctionCall(globalCtx, {
     id: 'run_gradle',
-    workingDirectory,
     callInputs: {
       resolved_eas_update_runtime_version:
         '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -411,7 +328,6 @@ function createStepsForAndroidBuildWithCredentials({
   const saveCache = createSaveBuildCacheFunction(evictUsedBefore).createBuildStepFromFunctionCall(
     globalCtx,
     {
-      workingDirectory,
       callInputs: {
         platform: Platform.ANDROID,
       },
@@ -419,33 +335,21 @@ function createStepsForAndroidBuildWithCredentials({
   );
   return [
     createCheckoutBuildFunction().createBuildStepFromFunctionCall(globalCtx),
-    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
-    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx),
+    createInstallNodeModulesBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     createResolveBuildConfigBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
-      globalCtx,
-      { workingDirectory }
+      globalCtx
     ),
-    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx),
     restoreCache,
     calculateEASUpdateRuntimeVersion,
     configureEASUpdate,
-    injectAndroidCredentialsFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
-    configureAndroidVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    injectAndroidCredentialsFunction().createBuildStepFromFunctionCall(globalCtx),
+    configureAndroidVersionFunction().createBuildStepFromFunctionCall(globalCtx),
     runGradle,
     ...(shouldUseEagerBundle(globalCtx.staticContext.metadata)
       ? [
           eagerBundleBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-            workingDirectory,
             callInputs: {
               resolved_eas_update_runtime_version:
                 '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
@@ -455,10 +359,8 @@ function createStepsForAndroidBuildWithCredentials({
       : []),
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx),
     saveCache,
-    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
+    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx),
   ];
 }

packages/build-tools/src/steps/functions/__tests__/configureIosCredentials.test.ts

@@ -1,81 +0,0 @@
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createTestIosJob } from '../../../__tests__/utils/job';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { configureCredentialsAsync } from '../../utils/ios/configure';
-import IosCredentialsManager, { type Credentials } from '../../utils/ios/credentials/manager';
-import { DistributionType } from '../../utils/ios/credentials/provisioningProfile';
-import { configureIosCredentialsFunction } from '../configureIosCredentials';
-
-jest.mock('../../utils/ios/configure');
-jest.mock('../../utils/ios/credentials/manager');
-
-function createCredentials({
-  targetNames = ['app', 'share-extension'],
-}: {
-  targetNames?: string[];
-} = {}): Credentials {
-  return {
-    applicationTargetProvisioningProfile: {} as Credentials['applicationTargetProvisioningProfile'],
-    keychainPath: '/tmp/keychain',
-    targetProvisioningProfiles: Object.fromEntries(
-      targetNames.map(targetName => [
-        targetName,
-        {
-          path: `/tmp/${targetName}.mobileprovision`,
-          target: targetName,
-          bundleIdentifier: `com.example.${targetName}`,
-          teamId: 'TEAMID123',
-          uuid: `${targetName}-uuid`,
-          name: `${targetName} profile`,
-          distributionType: DistributionType.AD_HOC,
-          developerCertificate: Buffer.from('certificate'),
-          certificateCommonName: `${targetName} cert`,
-        },
-      ])
-    ),
-    distributionType: DistributionType.AD_HOC,
-    teamId: 'TEAMID123',
-  };
-}
-
-function createRawCredentials() {
-  return {
-    app: {
-      provisioningProfileBase64: 'cHJvZmlsZQ==',
-      distributionCertificate: {
-        dataBase64: 'Y2VydA==',
-        password: '',
-      },
-    },
-  };
-}
-
-describe(configureIosCredentialsFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-    jest.mocked(configureCredentialsAsync).mockResolvedValue(undefined);
-  });
-
-  it('exports target_names from prepared credentials', async () => {
-    jest
-      .spyOn(IosCredentialsManager.prototype, 'prepare')
-      .mockResolvedValue(createCredentials({ targetNames: ['app', 'widget'] }));
-
-    const buildStep = configureIosCredentialsFunction().createBuildStepFromFunctionCall(
-      createGlobalContextMock({
-        logger: createMockLogger(),
-        staticContextContent: { job: createTestIosJob() },
-      }),
-      {
-        callInputs: {
-          credentials: createRawCredentials(),
-        },
-      }
-    );
-
-    await buildStep.executeAsync();
-
-    expect(configureCredentialsAsync).toHaveBeenCalled();
-    expect(buildStep.outputById.target_names.value).toBe(JSON.stringify(['app', 'widget']));
-  });
-});

packages/build-tools/src/steps/functions/__tests__/configureIosVersion.test.ts

@@ -1,286 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import { BuildWorkflow } from '@expo/steps';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createTestIosJob } from '../../../__tests__/utils/job';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { updateVersionsAsync } from '../../utils/ios/configure';
-import IosCredentialsManager, { type Credentials } from '../../utils/ios/credentials/manager';
-import { DistributionType } from '../../utils/ios/credentials/provisioningProfile';
-import { configureIosCredentialsFunction } from '../configureIosCredentials';
-import { configureIosVersionFunction } from '../configureIosVersion';
-
-jest.mock('../../utils/ios/configure');
-jest.mock('../../utils/ios/credentials/manager');
-
-function createCredentials({
-  targetNames = ['app', 'share-extension'],
-}: {
-  targetNames?: string[];
-} = {}): Credentials {
-  return {
-    applicationTargetProvisioningProfile: {} as Credentials['applicationTargetProvisioningProfile'],
-    keychainPath: '/tmp/keychain',
-    targetProvisioningProfiles: Object.fromEntries(
-      targetNames.map(targetName => [
-        targetName,
-        {
-          path: `/tmp/${targetName}.mobileprovision`,
-          target: targetName,
-          bundleIdentifier: `com.example.${targetName}`,
-          teamId: 'TEAMID123',
-          uuid: `${targetName}-uuid`,
-          name: `${targetName} profile`,
-          distributionType: DistributionType.AD_HOC,
-          developerCertificate: Buffer.from('certificate'),
-          certificateCommonName: `${targetName} cert`,
-        },
-      ])
-    ),
-    distributionType: DistributionType.AD_HOC,
-    teamId: 'TEAMID123',
-  };
-}
-
-function createRawCredentials() {
-  return {
-    app: {
-      provisioningProfileBase64: 'cHJvZmlsZQ==',
-      distributionCertificate: {
-        dataBase64: 'Y2VydA==',
-        password: '',
-      },
-    },
-  };
-}
-
-function createBuildStep({
-  callInputs = {},
-  job = createTestIosJob(),
-}: {
-  callInputs?: Record<string, unknown>;
-  job?: ReturnType<typeof createTestIosJob>;
-} = {}) {
-  return configureIosVersionFunction().createBuildStepFromFunctionCall(
-    createGlobalContextMock({
-      logger: createMockLogger(),
-      staticContextContent: { job },
-    }),
-    { callInputs }
-  );
-}
-
-describe(configureIosVersionFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-    jest.mocked(updateVersionsAsync).mockResolvedValue(undefined);
-  });
-
-  it('uses target_names without an explicit credentials input', async () => {
-    const buildStep = createBuildStep({
-      callInputs: {
-        target_names: ['app', 'widget'],
-        build_number: '42',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      buildStep.ctx.workingDirectory,
-      {
-        buildNumber: '42',
-        appVersion: undefined,
-      },
-      {
-        targetNames: ['app', 'widget'],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('uses credentials only to preserve the existing fallback path', async () => {
-    jest
-      .spyOn(IosCredentialsManager.prototype, 'prepare')
-      .mockResolvedValue(createCredentials({ targetNames: ['app', 'widget'] }));
-    const buildStep = createBuildStep({
-      callInputs: {
-        credentials: createRawCredentials(),
-        app_version: '1.2.3',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(IosCredentialsManager.prototype.prepare).toHaveBeenCalledTimes(1);
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      buildStep.ctx.workingDirectory,
-      {
-        buildNumber: undefined,
-        appVersion: '1.2.3',
-      },
-      {
-        targetNames: ['app', 'widget'],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('uses the implicit credentials default fallback from the job secrets', async () => {
-    const prepareSpy = jest
-      .spyOn(IosCredentialsManager.prototype, 'prepare')
-      .mockResolvedValue(createCredentials({ targetNames: ['app', 'widget'] }));
-    const buildStep = createBuildStep({
-      job: createTestIosJob({ buildCredentials: createRawCredentials() }),
-      callInputs: {
-        app_version: '1.2.3',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(prepareSpy).toHaveBeenCalledTimes(1);
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      buildStep.ctx.workingDirectory,
-      {
-        buildNumber: undefined,
-        appVersion: '1.2.3',
-      },
-      {
-        targetNames: ['app', 'widget'],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('prefers target_names when both target_names and credentials are provided', async () => {
-    const prepareSpy = jest
-      .spyOn(IosCredentialsManager.prototype, 'prepare')
-      .mockResolvedValue(createCredentials({ targetNames: ['credentials-target'] }));
-    const buildStep = createBuildStep({
-      callInputs: {
-        target_names: ['input-target'],
-        credentials: createRawCredentials(),
-        app_version: '1.2.3',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(prepareSpy).not.toHaveBeenCalled();
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      buildStep.ctx.workingDirectory,
-      {
-        buildNumber: undefined,
-        appVersion: '1.2.3',
-      },
-      {
-        targetNames: ['input-target'],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('parses target_names exported by configure_ios_credentials through workflow interpolation', async () => {
-    const prepareSpy = jest
-      .spyOn(IosCredentialsManager.prototype, 'prepare')
-      .mockResolvedValue(createCredentials({ targetNames: ['app', 'widget'] }));
-    const globalCtx = createGlobalContextMock({
-      logger: createMockLogger(),
-      staticContextContent: {
-        job: createTestIosJob({ buildCredentials: createRawCredentials() }),
-      },
-    });
-    const configureIosCredentialsStep =
-      configureIosCredentialsFunction().createBuildStepFromFunctionCall(globalCtx, {
-        id: 'configure_ios_credentials',
-      });
-    const configureIosVersionStep = configureIosVersionFunction().createBuildStepFromFunctionCall(
-      globalCtx,
-      {
-        callInputs: {
-          target_names: '${{ steps.configure_ios_credentials.outputs.target_names }}',
-          app_version: '1.2.3',
-        },
-      }
-    );
-
-    await new BuildWorkflow(globalCtx, {
-      buildSteps: [configureIosCredentialsStep, configureIosVersionStep],
-      buildFunctions: {},
-    }).executeAsync();
-
-    expect(prepareSpy).toHaveBeenCalledTimes(1);
-    expect(configureIosCredentialsStep.outputById.target_names.value).toBe(
-      JSON.stringify(['app', 'widget'])
-    );
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      configureIosVersionStep.ctx.workingDirectory,
-      {
-        buildNumber: undefined,
-        appVersion: '1.2.3',
-      },
-      {
-        targetNames: ['app', 'widget'],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('accepts an empty target_names array without crashing', async () => {
-    const prepareSpy = jest.spyOn(IosCredentialsManager.prototype, 'prepare');
-    const buildStep = createBuildStep({
-      callInputs: {
-        target_names: [],
-        app_version: '1.2.3',
-      },
-    });
-
-    await expect(buildStep.executeAsync()).resolves.toBeUndefined();
-
-    expect(prepareSpy).not.toHaveBeenCalled();
-    expect(updateVersionsAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      buildStep.ctx.workingDirectory,
-      {
-        buildNumber: undefined,
-        appVersion: '1.2.3',
-      },
-      {
-        targetNames: [],
-        buildConfiguration: 'Release',
-      }
-    );
-  });
-
-  it('rejects invalid target_names', async () => {
-    const buildStep = createBuildStep({
-      callInputs: {
-        target_names: ['app', 123],
-        app_version: '1.2.3',
-      },
-    });
-
-    const promise = buildStep.executeAsync();
-    await expect(promise).rejects.toBeInstanceOf(UserError);
-    await expect(promise).rejects.toThrow('"target_names" input must be an array of strings.');
-  });
-
-  it('uses the corrected App version error text', async () => {
-    const buildStep = createBuildStep({
-      callInputs: {
-        target_names: ['app'],
-        app_version: 'invalid-semver',
-      },
-    });
-
-    await expect(buildStep.executeAsync()).rejects.toThrow(
-      'App version provided by the "app_version" input is not a valid semver version: invalid-semver'
-    );
-  });
-});

packages/build-tools/src/steps/functions/__tests__/deploy.test.ts

@@ -1,290 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { runEasCliCommand } from '../../../utils/easCli';
-import { createEasDeployBuildFunction } from '../deploy';
-
-jest.mock('../../../utils/easCli', () => ({
-  runEasCliCommand: jest.fn(),
-}));
-
-const mockDeployStdout = JSON.stringify({
-  url: 'https://example.dev',
-  production: { url: 'https://example.prod' },
-  aliases: [{ url: 'https://example.alias' }],
-  identifier: 'abc',
-  dashboardUrl: 'https://expo.dev/dashboard',
-});
-
-describe(createEasDeployBuildFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('passes deploy flags from function inputs and sets deploy_json output', async () => {
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(mockDeployStdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: {
-        alias: 'preview-link',
-        prod: true,
-        source_maps: false,
-      },
-      env: { HOME: '/tmp/home' },
-    });
-    await buildStep.executeAsync();
-
-    expect(buildStep.ctx.logger.info).toHaveBeenCalledWith(
-      'Running deploy command: eas deploy --non-interactive --json --export-dir dist --alias preview-link --prod'
-    );
-    expect(runEasCliCommand).toHaveBeenCalledWith({
-      args: [
-        'deploy',
-        '--non-interactive',
-        '--json',
-        '--export-dir',
-        'dist',
-        '--alias',
-        'preview-link',
-        '--prod',
-      ],
-      options: expect.objectContaining({
-        cwd: buildStep.ctx.workingDirectory,
-        env: expect.objectContaining({ HOME: '/tmp/home' }),
-        logger: buildStep.ctx.logger,
-      }),
-    });
-    expect(buildStep.outputById.deploy_json.value).toBe(mockDeployStdout);
-    expect(buildStep.outputById.deploy_url.value).toBe('https://example.prod');
-    expect(buildStep.outputById.deploy_deployment_url.value).toBe('https://example.dev');
-    expect(buildStep.outputById.deploy_identifier.value).toBe('abc');
-    expect(buildStep.outputById.deploy_dashboard_url.value).toBe('https://expo.dev/dashboard');
-    expect(buildStep.outputById.deploy_alias_url.value).toBe('https://example.alias');
-  });
-
-  it('forwards workflow step env to the eas deploy process', async () => {
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(mockDeployStdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { source_maps: true },
-      env: { HOME: '/tmp/home', EXAMPLE_WORKFLOW_ENV: 'from-workflow' },
-    });
-    await buildStep.executeAsync();
-
-    expect(runEasCliCommand).toHaveBeenCalledWith(
-      expect.objectContaining({
-        args: expect.arrayContaining(['--source-maps']),
-      })
-    );
-    expect(runEasCliCommand).toHaveBeenCalledWith(
-      expect.objectContaining({
-        options: expect.objectContaining({
-          env: expect.objectContaining({
-            HOME: '/tmp/home',
-            EXAMPLE_WORKFLOW_ENV: 'from-workflow',
-          }),
-        }),
-      })
-    );
-  });
-
-  it('throws an actionable error message when deploy command fails', async () => {
-    jest.mocked(runEasCliCommand).mockRejectedValue(new Error('deploy failed'));
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-
-    let errorMessage = '';
-    try {
-      await buildStep.executeAsync();
-    } catch (error) {
-      errorMessage = error instanceof Error ? error.message : String(error);
-    }
-
-    expect(errorMessage).toContain('Deploy command failed.');
-    expect(errorMessage).toContain('This can happen when deploy inputs are invalid');
-    expect(errorMessage).toContain(
-      'Check the deploy step logs, verify your deploy configuration and exported files, then retry.'
-    );
-    expect(errorMessage).toContain('Original error: deploy failed');
-  });
-
-  it('passes custom export_dir to eas deploy', async () => {
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(mockDeployStdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { export_dir: 'web-build' },
-    });
-    await buildStep.executeAsync();
-
-    expect(runEasCliCommand).toHaveBeenCalledWith(
-      expect.objectContaining({
-        args: expect.arrayContaining(['--export-dir', 'web-build']),
-      })
-    );
-  });
-
-  it('does not pass --source-maps when source_maps is false', async () => {
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(mockDeployStdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { source_maps: false },
-    });
-    await buildStep.executeAsync();
-
-    const { args } = jest.mocked(runEasCliCommand).mock.calls[0][0];
-    expect(args).not.toContain('--source-maps');
-  });
-
-  it('sets deploy_json and skips optional outputs when stdout is not valid JSON', async () => {
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from('not-json'),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-    await buildStep.executeAsync();
-
-    expect(buildStep.outputById.deploy_json.value).toBe('not-json');
-    expect(buildStep.ctx.logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.anything() }),
-      expect.stringContaining('Failed to parse')
-    );
-    expect(buildStep.outputById.deploy_url.value).toBeUndefined();
-  });
-
-  it('sets outputs from partial deploy JSON and leaves missing fields undefined', async () => {
-    const partialDeployStdout = JSON.stringify({
-      url: 'https://example.dev-only',
-      dashboardUrl: 'https://expo.dev/dashboard-only',
-    });
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(partialDeployStdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-    await buildStep.executeAsync();
-
-    expect(buildStep.outputById.deploy_json.value).toBe(partialDeployStdout);
-    expect(buildStep.outputById.deploy_url.value).toBe('https://example.dev-only');
-    expect(buildStep.outputById.deploy_deployment_url.value).toBe('https://example.dev-only');
-    expect(buildStep.outputById.deploy_dashboard_url.value).toBe('https://expo.dev/dashboard-only');
-    expect(buildStep.outputById.deploy_identifier.value).toBeUndefined();
-    expect(buildStep.outputById.deploy_alias_url.value).toBeUndefined();
-  });
-
-  it('sets deploy_url from aliases[0].url when production is absent but aliases exist', async () => {
-    const stdout = JSON.stringify({
-      url: 'https://example.deployment',
-      aliases: [{ url: 'https://example.alias-first' }],
-      identifier: 'partial-alias',
-    });
-    jest.mocked(runEasCliCommand).mockResolvedValue({
-      stdout: Buffer.from(stdout),
-      stderr: Buffer.from(''),
-      pid: 1,
-      output: [],
-      status: 0,
-      signal: null,
-      error: null,
-    } as any);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasDeployBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-    await buildStep.executeAsync();
-
-    expect(buildStep.outputById.deploy_url.value).toBe('https://example.alias-first');
-    expect(buildStep.outputById.deploy_deployment_url.value).toBe('https://example.deployment');
-    expect(buildStep.outputById.deploy_alias_url.value).toBe('https://example.alias-first');
-    expect(buildStep.outputById.deploy_identifier.value).toBe('partial-alias');
-  });
-});

packages/build-tools/src/steps/functions/__tests__/export.test.ts

@@ -1,122 +0,0 @@
-jest.mock('../../../utils/project', () => ({
-  runExpoCliCommand: jest.fn().mockResolvedValue({}),
-}));
-
-jest.mock('../../../utils/packageManager', () => ({
-  ...jest.requireActual('../../../utils/packageManager'),
-  resolvePackageManager: jest.fn(),
-}));
-
-import { BuildRuntimePlatform } from '@expo/steps';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { PackageManager, resolvePackageManager } from '../../../utils/packageManager';
-import { runExpoCliCommand } from '../../../utils/project';
-import { createEasExportBuildFunction } from '../export';
-
-describe(createEasExportBuildFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-    jest.mocked(resolvePackageManager).mockReturnValue(PackageManager.NPM);
-    jest.mocked(runExpoCliCommand).mockResolvedValue({} as any);
-  });
-
-  it('runs expo export via runExpoCliCommand with default output_dir and platform web', async () => {
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasExportBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      env: { HOME: '/tmp/home' },
-    });
-    await buildStep.executeAsync();
-
-    expect(buildStep.ctx.logger.info).toHaveBeenCalledWith(
-      'Running export command: expo export --output-dir dist --platform web'
-    );
-    expect(runExpoCliCommand).toHaveBeenCalledWith({
-      packageManager: PackageManager.NPM,
-      args: ['export', '--output-dir', 'dist', '--platform', 'web'],
-      options: {
-        cwd: buildStep.ctx.workingDirectory,
-        env: expect.objectContaining({ HOME: '/tmp/home' }),
-        logger: buildStep.ctx.logger,
-        stdio: 'pipe',
-      },
-    });
-    expect(buildStep.outputById.export_dir.value).toBe('dist');
-  });
-
-  it('passes optional flags matching expo export CLI', async () => {
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasExportBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: {
-        output_dir: 'web-out',
-        dev: true,
-        minify: false,
-        dump_assetmap: true,
-        ssg: false,
-        api_only: true,
-        platform: 'web',
-      },
-    });
-    await buildStep.executeAsync();
-
-    expect(runExpoCliCommand).toHaveBeenCalledWith(
-      expect.objectContaining({
-        args: [
-          'export',
-          '--output-dir',
-          'web-out',
-          '--platform',
-          'web',
-          '--dev',
-          '--no-minify',
-          '--dump-assetmap',
-          '--no-ssg',
-          '--api-only',
-        ],
-      })
-    );
-    expect(buildStep.outputById.export_dir.value).toBe('web-out');
-  });
-
-  it('uses resolved package manager (e.g. yarn)', async () => {
-    jest.mocked(resolvePackageManager).mockReturnValue(PackageManager.YARN);
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasExportBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-    await buildStep.executeAsync();
-
-    expect(runExpoCliCommand).toHaveBeenCalledWith(
-      expect.objectContaining({ packageManager: PackageManager.YARN })
-    );
-  });
-
-  it('throws when export command fails', async () => {
-    jest.mocked(runExpoCliCommand).mockRejectedValue(new Error('export failed'));
-
-    const logger = createMockLogger();
-    const globalCtx = createGlobalContextMock({
-      logger,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-    });
-
-    const buildStep = createEasExportBuildFunction().createBuildStepFromFunctionCall(globalCtx, {});
-
-    await expect(buildStep.executeAsync()).rejects.toThrow('Export command failed: export failed');
-  });
-});

packages/build-tools/src/steps/functions/__tests__/installPods.test.ts

@@ -0,0 +1,59 @@
+import spawn from '@expo/turtle-spawn';
+
+import { createGlobalContextMock } from '../../../__tests__/utils/context';
+import { waitForPrecompiledModulesPreparationAsync } from '../../../utils/precompiledModules';
+import { createInstallPodsBuildFunction } from '../installPods';
+
+jest.mock('@expo/turtle-spawn');
+jest.mock('../../../utils/precompiledModules', () => ({
+  ...jest.requireActual('../../../utils/precompiledModules'),
+  waitForPrecompiledModulesPreparationAsync: jest.fn(),
+}));
+
+describe(createInstallPodsBuildFunction, () => {
+  it('waits for precompiled dependencies before running pod install', async () => {
+    jest.mocked(spawn).mockResolvedValue({} as any);
+    jest.mocked(waitForPrecompiledModulesPreparationAsync).mockResolvedValue(undefined);
+
+    const installPods = createInstallPodsBuildFunction();
+    const globalContext = createGlobalContextMock({});
+    const buildStep = installPods.createBuildStepFromFunctionCall(globalContext, {
+      callInputs: {},
+    });
+
+    await buildStep.executeAsync();
+
+    expect(waitForPrecompiledModulesPreparationAsync).toHaveBeenCalled();
+    expect(spawn).toHaveBeenCalledWith(
+      'pod',
+      ['install'],
+      expect.objectContaining({
+        cwd: globalContext.defaultWorkingDirectory,
+      })
+    );
+  });
+
+  it('continues with pod install when precompiled dependencies preparation fails', async () => {
+    jest.mocked(spawn).mockResolvedValue({} as any);
+    jest
+      .mocked(waitForPrecompiledModulesPreparationAsync)
+      .mockRejectedValue(new Error('precompiled dependencies failed'));
+
+    const installPods = createInstallPodsBuildFunction();
+    const globalContext = createGlobalContextMock({});
+    const buildStep = installPods.createBuildStepFromFunctionCall(globalContext, {
+      callInputs: {},
+    });
+
+    await expect(buildStep.executeAsync()).resolves.toBeUndefined();
+
+    expect(waitForPrecompiledModulesPreparationAsync).toHaveBeenCalled();
+    expect(spawn).toHaveBeenCalledWith(
+      'pod',
+      ['install'],
+      expect.objectContaining({
+        cwd: globalContext.defaultWorkingDirectory,
+      })
+    );
+  });
+});

packages/build-tools/src/steps/functions/__tests__/internalMaestroTest.test.ts

@@ -0,0 +1,238 @@
+import { spawnAsync } from '@expo/steps';
+import spawn from '@expo/turtle-spawn';
+import { vol } from 'memfs';
+import os from 'os';
+
+import { createGlobalContextMock } from '../../../__tests__/utils/context';
+import { createMockLogger } from '../../../__tests__/utils/logger';
+import { AndroidEmulatorUtils } from '../../../utils/AndroidEmulatorUtils';
+import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
+import { findMaestroPathsFlowsToExecuteAsync } from '../../../utils/findMaestroPathsFlowsToExecuteAsync';
+import { retryAsync } from '../../../utils/retry';
+import { createInternalEasMaestroTestFunction } from '../internalMaestroTest';
+
+jest.mock('@expo/steps', () => ({
+  ...jest.requireActual('@expo/steps'),
+  spawnAsync: jest.fn(),
+}));
+
+jest.mock('@expo/turtle-spawn', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+jest.mock('../../../utils/IosSimulatorUtils');
+jest.mock('../../../utils/AndroidEmulatorUtils');
+jest.mock('../../../utils/findMaestroPathsFlowsToExecuteAsync');
+jest.mock('../../../utils/retry', () => ({
+  retryAsync: jest.fn(),
+}));
+
+const mockedSpawnAsync = jest.mocked(spawnAsync);
+const mockedSpawn = jest.mocked(spawn);
+const mockedRetryAsync = jest.mocked(retryAsync);
+const mockedAndroidUtils = jest.mocked(AndroidEmulatorUtils);
+const mockedIosUtils = jest.mocked(IosSimulatorUtils);
+const mockedFindFlows = jest.mocked(findMaestroPathsFlowsToExecuteAsync);
+
+describe(createInternalEasMaestroTestFunction, () => {
+  const mockUploadArtifact = jest.fn();
+
+  beforeEach(() => {
+    vol.mkdirSync(os.tmpdir(), { recursive: true });
+
+    mockedSpawnAsync.mockResolvedValue(undefined as any);
+    mockedSpawn.mockResolvedValue({ stdout: 'source-emulator\n', stderr: '' } as any);
+    mockUploadArtifact.mockResolvedValue({ artifactId: null });
+
+    mockedRetryAsync.mockImplementation(async (fn, { retryOptions }) => {
+      let lastErr: unknown;
+      for (let attemptCount = 0; attemptCount <= retryOptions.retries; attemptCount++) {
+        try {
+          return await fn(attemptCount);
+        } catch (err) {
+          lastErr = err;
+        }
+      }
+      throw lastErr;
+    });
+
+    mockedIosUtils.getAvailableDevicesAsync.mockResolvedValue([
+      { name: 'iPhone 15', udid: 'test-udid-123' } as any,
+    ]);
+    mockedIosUtils.cloneAsync.mockResolvedValue(undefined as any);
+    mockedIosUtils.startAsync.mockResolvedValue({ udid: 'cloned-udid' } as any);
+    mockedIosUtils.waitForReadyAsync.mockResolvedValue(undefined as any);
+    mockedIosUtils.collectLogsAsync.mockResolvedValue({ outputPath: '/tmp/logs.txt' } as any);
+    mockedIosUtils.deleteAsync.mockResolvedValue(undefined as any);
+
+    mockedAndroidUtils.getAttachedDevicesAsync.mockResolvedValue([
+      { serialId: 'emulator-5554', state: 'device' } as any,
+    ]);
+    mockedAndroidUtils.cloneAsync.mockResolvedValue(undefined as any);
+    mockedAndroidUtils.startAsync.mockResolvedValue({
+      serialId: 'emulator-5556',
+      emulatorPromise: Promise.resolve({}),
+    } as any);
+    mockedAndroidUtils.waitForReadyAsync.mockResolvedValue(undefined as any);
+    mockedAndroidUtils.collectLogsAsync.mockResolvedValue({ outputPath: '/tmp/logs.txt' } as any);
+    mockedAndroidUtils.deleteAsync.mockResolvedValue(undefined as any);
+
+    mockedFindFlows.mockResolvedValue(['/project/.maestro/home.yml']);
+  });
+
+  function createStep(overrides?: { callInputs?: Record<string, unknown> }) {
+    const ctx = {
+      runtimeApi: { uploadArtifact: mockUploadArtifact },
+    };
+    const fn = createInternalEasMaestroTestFunction(ctx as any);
+    return fn.createBuildStepFromFunctionCall(
+      createGlobalContextMock({
+        logger: createMockLogger(),
+      }),
+      {
+        callInputs: {
+          platform: 'ios',
+          flow_paths: JSON.stringify(['.maestro']),
+          ...overrides?.callInputs,
+        },
+      }
+    );
+  }
+
+  it('sets junit_report_directory output when output_format is junit', async () => {
+    const step = createStep({
+      callInputs: { output_format: 'junit' },
+    });
+    await step.executeAsync();
+
+    const junitDir = step.getOutputValueByName('junit_report_directory');
+    expect(junitDir).toMatch(/maestro-reports-/);
+  });
+
+  it('does not set junit_report_directory output when output_format is not junit', async () => {
+    const step = createStep();
+    await step.executeAsync();
+
+    const junitDir = step.getOutputValueByName('junit_report_directory');
+    expect(junitDir).toBeUndefined();
+  });
+
+  it('does not set junit_report_directory when function throws before reaching output code', async () => {
+    mockedIosUtils.getAvailableDevicesAsync.mockResolvedValue([]);
+
+    const step = createStep({
+      callInputs: { output_format: 'junit' },
+    });
+
+    try {
+      await step.executeAsync();
+    } catch {
+      // Expected - no booted device found
+    }
+
+    const junitDir = step.getOutputValueByName('junit_report_directory');
+    expect(junitDir).toBeUndefined();
+  });
+
+  it('retries Android clone startup with increasing timeouts', async () => {
+    mockedAndroidUtils.startAsync
+      .mockResolvedValueOnce({
+        serialId: 'emulator-attempt-1',
+        emulatorPromise: Promise.resolve({}),
+      } as any)
+      .mockResolvedValueOnce({
+        serialId: 'emulator-attempt-2',
+        emulatorPromise: Promise.resolve({}),
+      } as any);
+    mockedAndroidUtils.waitForReadyAsync
+      .mockRejectedValueOnce(new Error('network unavailable'))
+      .mockResolvedValueOnce(undefined);
+
+    const step = createStep({
+      callInputs: { platform: 'android' },
+    });
+
+    await step.executeAsync();
+
+    expect(mockedAndroidUtils.waitForReadyAsync).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        serialId: 'emulator-attempt-1',
+        timeoutMs: 60_000,
+      })
+    );
+    expect(mockedAndroidUtils.waitForReadyAsync).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        serialId: 'emulator-attempt-2',
+        timeoutMs: 120_000,
+      })
+    );
+    expect(mockedAndroidUtils.deleteAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        serialId: 'emulator-attempt-1',
+        deviceName: 'eas-simulator-0-0',
+      })
+    );
+  });
+
+  it('generates per-attempt report filenames when retrying', async () => {
+    // Mock sequence:
+    // 1. xcrun simctl shutdown → succeeds (beforeEach default is fine)
+    // 2. maestro test attempt 0 → fails (triggers retry)
+    // 3. maestro test attempt 1 → succeeds (beforeEach default)
+    mockedSpawnAsync
+      .mockResolvedValueOnce(undefined as any) // xcrun simctl shutdown
+      .mockRejectedValueOnce(new Error('Maestro test failed')); // maestro attempt 0
+    // Attempt 1 falls through to beforeEach's mockResolvedValue default
+
+    const step = createStep({
+      callInputs: { output_format: 'junit', retries: 2 },
+    });
+    await step.executeAsync();
+
+    // Filter to just the maestro test command calls (skip xcrun simctl shutdown)
+    const maestroCalls = mockedSpawnAsync.mock.calls.filter(([cmd]) => cmd === 'maestro');
+    expect(maestroCalls).toHaveLength(2);
+
+    // Extract --output paths from maestro calls
+    const outputArgs = maestroCalls.map(([, args]) => args[args.indexOf('--output') + 1]);
+
+    expect(outputArgs[0]).toContain('attempt-0');
+    expect(outputArgs[1]).toContain('attempt-1');
+    // Filenames must be unique (not overwriting)
+    expect(outputArgs[0]).not.toBe(outputArgs[1]);
+  });
+
+  it('fails Android flow when clone startup exhausts all attempts', async () => {
+    mockedAndroidUtils.startAsync
+      .mockResolvedValueOnce({
+        serialId: 'emulator-attempt-1',
+        emulatorPromise: Promise.resolve({}),
+      } as any)
+      .mockResolvedValueOnce({
+        serialId: 'emulator-attempt-2',
+        emulatorPromise: Promise.resolve({}),
+      } as any)
+      .mockResolvedValueOnce({
+        serialId: 'emulator-attempt-3',
+        emulatorPromise: Promise.resolve({}),
+      } as any);
+    mockedAndroidUtils.waitForReadyAsync.mockRejectedValue(new Error('network unavailable'));
+
+    const step = createStep({
+      callInputs: { platform: 'android' },
+    });
+
+    await expect(step.executeAsync()).rejects.toThrow('network unavailable');
+
+    expect(mockedAndroidUtils.waitForReadyAsync).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        serialId: 'emulator-attempt-3',
+        timeoutMs: 180_000,
+      })
+    );
+  });
+});

packages/build-tools/src/steps/functions/__tests__/parseXcactivitylog.test.ts

@@ -1,81 +0,0 @@
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { parseAndReportXcactivitylog } from '../../utils/ios/xcactivitylog';
-import { parseXcactivitylogFunction } from '../parseXcactivitylog';
-
-jest.mock('../../utils/ios/xcactivitylog');
-
-describe(parseXcactivitylogFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('passes proxyBaseUrl from env into parseAndReportXcactivitylog', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-    globalContext.updateEnv({ EAS_BUILD_COCOAPODS_CACHE_URL: 'https://cache.example.com' });
-
-    const buildStep = parseXcactivitylogFunction().createBuildStepFromFunctionCall(globalContext);
-
-    await buildStep.executeAsync();
-
-    expect(parseAndReportXcactivitylog).toHaveBeenCalledWith(
-      expect.objectContaining({
-        proxyBaseUrl: 'https://cache.example.com',
-      })
-    );
-  });
-
-  it('passes xclogparserVersion as undefined when the input is not provided', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-
-    const buildStep = parseXcactivitylogFunction().createBuildStepFromFunctionCall(globalContext);
-
-    await buildStep.executeAsync();
-
-    expect(parseAndReportXcactivitylog).toHaveBeenCalledWith(
-      expect.objectContaining({
-        xclogparserVersion: undefined,
-      })
-    );
-  });
-
-  it('resolves derived_data_path and workspace_path inputs against stepCtx.workingDirectory', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-
-    const buildStep = parseXcactivitylogFunction().createBuildStepFromFunctionCall(globalContext, {
-      callInputs: {
-        derived_data_path: 'my-app/ios/Build',
-        workspace_path: 'my-app/ios',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(parseAndReportXcactivitylog).toHaveBeenCalledWith(
-      expect.objectContaining({
-        derivedDataPath: expect.stringMatching(/\/my-app\/ios\/Build$/),
-        workspacePath: expect.stringMatching(/\/my-app\/ios$/),
-      })
-    );
-  });
-
-  it('accepts absolute paths for derived_data_path and workspace_path', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-
-    const buildStep = parseXcactivitylogFunction().createBuildStepFromFunctionCall(globalContext, {
-      callInputs: {
-        derived_data_path: '/abs/derived',
-        workspace_path: '/abs/workspace',
-      },
-    });
-
-    await buildStep.executeAsync();
-
-    expect(parseAndReportXcactivitylog).toHaveBeenCalledWith(
-      expect.objectContaining({
-        derivedDataPath: '/abs/derived',
-        workspacePath: '/abs/workspace',
-      })
-    );
-  });
-});

packages/build-tools/src/steps/functions/__tests__/readAppConfig.test.ts

@@ -1,77 +0,0 @@
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { readAppConfig } from '../../../utils/appConfig';
-import { createReadAppConfigBuildFunction } from '../readAppConfig';
-
-jest.mock('../../../utils/appConfig');
-
-describe(createReadAppConfigBuildFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('reads and logs app configuration', async () => {
-    const stepLogger = createMockLogger();
-    const logger = createMockLogger();
-    logger.child = jest.fn().mockReturnValue(stepLogger);
-    const globalContext = createGlobalContextMock({
-      logger,
-      staticContextContent: { metadata: { sdkVersion: '54.0.0' } },
-    });
-    globalContext.updateEnv({ EXPO_PUBLIC_TEST: '1' });
-    const buildStep =
-      createReadAppConfigBuildFunction().createBuildStepFromFunctionCall(globalContext);
-    jest
-      .mocked(readAppConfig)
-      .mockResolvedValue({ exp: { name: 'my-app', slug: 'my-app-slug', version: '1.2.3' } } as any);
-
-    await buildStep.executeAsync();
-
-    expect(readAppConfig).toHaveBeenCalledWith(
-      expect.objectContaining({
-        projectDir: globalContext.defaultWorkingDirectory,
-        env: expect.objectContaining({ EXPO_PUBLIC_TEST: '1' }),
-        logger: stepLogger,
-        sdkVersion: '54.0.0',
-      })
-    );
-    expect(stepLogger.info).toHaveBeenCalledWith('Using app configuration:');
-    expect(stepLogger.info).toHaveBeenCalledWith(
-      JSON.stringify({ name: 'my-app', slug: 'my-app-slug', version: '1.2.3' }, null, 2)
-    );
-    const firstOutput = buildStep.outputById.app_config.value;
-    expect(firstOutput).toBeDefined();
-    expect(JSON.parse(firstOutput!)).toEqual({
-      name: 'my-app',
-      slug: 'my-app-slug',
-      version: '1.2.3',
-    });
-  });
-
-  it('does not throw if reading app config fails', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-    const buildStep =
-      createReadAppConfigBuildFunction().createBuildStepFromFunctionCall(globalContext);
-    jest.mocked(readAppConfig).mockRejectedValue(new Error('failed to read app config'));
-
-    await expect(buildStep.executeAsync()).resolves.toBeUndefined();
-  });
-
-  it('exports app fields as returned by app config', async () => {
-    const globalContext = createGlobalContextMock({ logger: createMockLogger() });
-    const buildStep =
-      createReadAppConfigBuildFunction().createBuildStepFromFunctionCall(globalContext);
-    jest
-      .mocked(readAppConfig)
-      .mockResolvedValue({ exp: { name: 'my-app', slug: 123, version: undefined } } as any);
-
-    await buildStep.executeAsync();
-
-    const secondOutput = buildStep.outputById.app_config.value;
-    expect(secondOutput).toBeDefined();
-    expect(JSON.parse(secondOutput!)).toEqual({
-      name: 'my-app',
-      slug: 123,
-    });
-  });
-});

packages/build-tools/src/steps/functions/__tests__/readPackageJson.test.ts

@@ -1,50 +0,0 @@
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { readAndLogPackageJson } from '../../../utils/project';
-import { createReadPackageJsonBuildFunction } from '../readPackageJson';
-
-jest.mock('../../../utils/project');
-
-describe(createReadPackageJsonBuildFunction, () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('logs package.json contents', async () => {
-    const stepLogger = createMockLogger();
-    const logger = createMockLogger();
-    logger.child = jest.fn().mockReturnValue(stepLogger);
-    const globalContext = createGlobalContextMock({ logger });
-    const buildStep =
-      createReadPackageJsonBuildFunction().createBuildStepFromFunctionCall(globalContext);
-    jest.mocked(readAndLogPackageJson).mockReturnValue({ name: 'app', version: '1.0.0' });
-
-    await buildStep.executeAsync();
-
-    expect(readAndLogPackageJson).toHaveBeenCalledWith(
-      stepLogger,
-      globalContext.defaultWorkingDirectory
-    );
-    expect(buildStep.outputById.package_json.value).toBe(
-      JSON.stringify({ name: 'app', version: '1.0.0' })
-    );
-  });
-
-  it('does not throw if reading package.json fails', async () => {
-    const stepLogger = createMockLogger();
-    const logger = createMockLogger();
-    logger.child = jest.fn().mockReturnValue(stepLogger);
-    const globalContext = createGlobalContextMock({ logger });
-    const buildStep =
-      createReadPackageJsonBuildFunction().createBuildStepFromFunctionCall(globalContext);
-    jest.mocked(readAndLogPackageJson).mockImplementation(() => {
-      throw new Error('failed to read package.json');
-    });
-
-    await expect(buildStep.executeAsync()).resolves.toBeUndefined();
-    expect(stepLogger.error).toHaveBeenCalledWith({
-      err: expect.any(Error),
-    });
-    expect(buildStep.outputById.package_json.value).toBeUndefined();
-  });
-});

packages/build-tools/src/steps/functions/__tests__/startAndroidEmulator.test.ts

@@ -34,6 +34,7 @@ jest.mock('../../../utils/AndroidEmulatorUtils', () => ({
 const mockedSpawn = jest.mocked(spawn);
 const mockedRetryAsync = jest.mocked(retryAsync);
 const mockedAndroidUtils = jest.mocked(AndroidEmulatorUtils);
+
 function createStep(callInputs?: Record<string, unknown>, envOverrides?: NodeJS.ProcessEnv) {
   const logger = createMockLogger();
   const fn = createStartAndroidEmulatorBuildFunction();
@@ -211,64 +212,4 @@ describe(createStartAndroidEmulatorBuildFunction, () => {
 
     expect(mockedAndroidUtils.disableWindowAndTransitionAnimationsAsync).not.toHaveBeenCalled();
   });
-
-  it('fails early on Linux when emulator host support check fails', async () => {
-    mockedSpawn.mockRejectedValueOnce(new Error('accel check failed') as any);
-
-    const step = createStep();
-    await expect(step.executeAsync()).rejects.toThrow(/nested virtualization/i);
-
-    expect(mockedSpawn).toHaveBeenCalledWith('/android/home/emulator/emulator', ['-accel-check'], {
-      env: expect.any(Object),
-    });
-    expect(mockedSpawn.mock.calls.some(([command]) => command === 'sdkmanager')).toBe(false);
-  });
-
-  it('continues startup on Linux when emulator host support check succeeds', async () => {
-    await createStep().executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith('/android/home/emulator/emulator', ['-accel-check'], {
-      env: expect.any(Object),
-    });
-    expect(mockedSpawn.mock.calls.some(([command]) => command === 'sdkmanager')).toBe(true);
-  });
-
-  it('skips emulator host support check when opt out env var is enabled', async () => {
-    const step = createStep(undefined, {
-      EAS_NO_EMULATOR_HOST_SUPPORT_CHECK: '1',
-    });
-
-    await step.executeAsync();
-
-    expect(mockedSpawn.mock.calls.some(([command]) => command.includes('/emulator/emulator'))).toBe(
-      false
-    );
-    expect(mockedSpawn.mock.calls.some(([command]) => command === 'sdkmanager')).toBe(true);
-  });
-
-  it('falls back to empty SDK path when Android SDK path env vars are missing', async () => {
-    await createStep(undefined, {
-      ANDROID_HOME: undefined,
-      ANDROID_SDK_ROOT: undefined,
-    }).executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith('/emulator/emulator', ['-accel-check'], {
-      env: expect.any(Object),
-    });
-  });
-
-  it('uses ANDROID_SDK_ROOT when ANDROID_HOME is missing', async () => {
-    await createStep(undefined, {
-      ANDROID_HOME: undefined,
-      ANDROID_SDK_ROOT: '/android/sdk/root',
-    }).executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      '/android/sdk/root/emulator/emulator',
-      ['-accel-check'],
-      {
-        env: expect.any(Object),
-      }
-    );
-  });
 });

packages/build-tools/src/steps/functions/configureIosCredentials.ts

@@ -1,10 +1,5 @@
 import { Ios } from '@expo/eas-build-job';
-import {
-  BuildFunction,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-  BuildStepOutput,
-} from '@expo/steps';
+import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@expo/steps';
 import assert from 'assert';
 
 import { configureCredentialsAsync } from '../utils/ios/configure';
@@ -31,14 +26,9 @@ export function configureIosCredentialsFunction(): BuildFunction {
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
     ],
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'target_names',
-        required: true,
-      }),
-    ],
-    fn: async (stepCtx, { inputs, outputs }) => {
-      const { value, error } = IosBuildCredentialsSchema.validate(inputs.credentials.value, {
+    fn: async (stepCtx, { inputs }) => {
+      const rawCredentialsInput = inputs.credentials.value as Record<string, any>;
+      const { value, error } = IosBuildCredentialsSchema.validate(rawCredentialsInput, {
         stripUnknown: true,
         convert: true,
         abortEarly: false,
@@ -60,7 +50,6 @@ export function configureIosCredentialsFunction(): BuildFunction {
           inputs.build_configuration.value as string | undefined
         ),
       });
-      outputs.target_names.set(JSON.stringify(Object.keys(credentials.targetProvisioningProfiles)));
 
       stepCtx.logger.info('Successfully configured iOS credentials');
     },

packages/build-tools/src/steps/functions/configureIosVersion.ts

@@ -1,8 +1,7 @@
-import { Ios, UserError } from '@expo/eas-build-job';
+import { Ios } from '@expo/eas-build-job';
 import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@expo/steps';
 import assert from 'assert';
 import semver from 'semver';
-import { z } from 'zod';
 
 import { updateVersionsAsync } from '../utils/ios/configure';
 import { IosBuildCredentialsSchema } from '../utils/ios/credentials/credentials';
@@ -18,15 +17,10 @@ export function configureIosVersionFunction(): BuildFunction {
     inputProviders: [
       BuildStepInput.createProvider({
         id: 'credentials',
-        required: false,
+        required: true,
         allowedValueTypeName: BuildStepInputValueTypeName.JSON,
         defaultValue: '${ eas.job.secrets.buildCredentials }',
       }),
-      BuildStepInput.createProvider({
-        id: 'target_names',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-      }),
       BuildStepInput.createProvider({
         id: 'build_configuration',
         required: false,
@@ -44,6 +38,19 @@ export function configureIosVersionFunction(): BuildFunction {
       }),
     ],
     fn: async (stepCtx, { inputs }) => {
+      const rawCredentialsInput = inputs.credentials.value as Record<string, any>;
+      const { value, error } = IosBuildCredentialsSchema.validate(rawCredentialsInput, {
+        stripUnknown: true,
+        convert: true,
+        abortEarly: false,
+      });
+      if (error) {
+        throw error;
+      }
+
+      const credentialsManager = new IosCredentialsManager(value);
+      const credentials = await credentialsManager.prepare(stepCtx.logger);
+
       assert(stepCtx.global.staticContext.job, 'Job is not defined');
       const job = stepCtx.global.staticContext.job as Ios.Job;
 
@@ -52,9 +59,8 @@ export function configureIosVersionFunction(): BuildFunction {
       const appVersion =
         (inputs.app_version.value as string | undefined) ?? job.version?.appVersion;
       if (appVersion && !semver.valid(appVersion)) {
-        throw new UserError(
-          'EAS_CONFIGURE_IOS_VERSION_INVALID_APP_VERSION',
-          `App version provided by the "app_version" input is not a valid semver version: ${appVersion}`
+        throw new Error(
+          `App verrsion provided by the "app_version" input is not a valid semver version: ${appVersion}`
         );
       }
 
@@ -65,33 +71,6 @@ export function configureIosVersionFunction(): BuildFunction {
         return;
       }
 
-      const targetNamesInput = inputs.target_names.value;
-      let targetNames: string[];
-      if (targetNamesInput !== undefined) {
-        const parsed = z.array(z.string()).safeParse(targetNamesInput);
-        if (!parsed.success) {
-          throw new UserError(
-            'EAS_CONFIGURE_IOS_VERSION_INVALID_TARGET_NAMES',
-            '"target_names" input must be an array of strings.',
-            { cause: parsed.error }
-          );
-        }
-        targetNames = parsed.data;
-      } else {
-        const { value, error } = IosBuildCredentialsSchema.validate(inputs.credentials.value, {
-          stripUnknown: true,
-          convert: true,
-          abortEarly: false,
-        });
-        if (error) {
-          throw error;
-        }
-
-        const credentialsManager = new IosCredentialsManager(value);
-        const credentials = await credentialsManager.prepare(stepCtx.logger);
-        targetNames = Object.keys(credentials.targetProvisioningProfiles);
-      }
-
       stepCtx.logger.info('Setting iOS version...');
       if (buildNumber) {
         stepCtx.logger.info(`Build number: ${buildNumber}`);
@@ -108,7 +87,7 @@ export function configureIosVersionFunction(): BuildFunction {
           appVersion,
         },
         {
-          targetNames,
+          targetNames: Object.keys(credentials.targetProvisioningProfiles),
           buildConfiguration: resolveBuildConfiguration(
             job,
             inputs.build_configuration.value as string | undefined

packages/build-tools/src/steps/functions/deploy.ts

@@ -1,167 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import { PipeMode, bunyan } from '@expo/logger';
-import {
-  BuildFunction,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-  BuildStepOutput,
-} from '@expo/steps';
-
-import { runEasCliCommand } from '../../utils/easCli';
-
-export function createEasDeployBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'deploy',
-    name: 'Deploy',
-    __metricsId: 'eas/deploy',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'alias',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'prod',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'source_maps',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      // Match eas/export default `output_dir`
-      BuildStepInput.createProvider({
-        id: 'export_dir',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-        required: false,
-        defaultValue: 'dist',
-      }),
-    ],
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'deploy_json',
-        required: true,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'deploy_url',
-        required: false,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'deploy_deployment_url',
-        required: false,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'deploy_identifier',
-        required: false,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'deploy_dashboard_url',
-        required: false,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'deploy_alias_url',
-        required: false,
-      }),
-    ],
-    fn: async (stepsCtx, { inputs, outputs, env }) => {
-      const alias = inputs.alias.value as string | undefined;
-      const prod = inputs.prod.value as boolean | undefined;
-      const sourceMaps = inputs.source_maps.value as boolean | undefined;
-      const exportDir = inputs.export_dir.value as string;
-
-      const deployCommand = getDeployCommand({
-        exportDir,
-        alias,
-        prod,
-        sourceMaps,
-      });
-      stepsCtx.logger.info(`Running deploy command: eas ${deployCommand.join(' ')}`);
-
-      try {
-        const result = await runEasCliCommand({
-          args: deployCommand,
-          options: {
-            cwd: stepsCtx.workingDirectory,
-            env,
-            logger: stepsCtx.logger,
-            mode: PipeMode.STDERR_ONLY_AS_STDOUT,
-          },
-        });
-
-        const deployJson = result.stdout.toString();
-        outputs.deploy_json.set(deployJson);
-        const parsedDeploymentOutput = parseDeploymentOutput({
-          deployJson,
-          logger: stepsCtx.logger,
-        });
-        outputs.deploy_url.set(parsedDeploymentOutput.deploy_url);
-        outputs.deploy_deployment_url.set(parsedDeploymentOutput.deploy_deployment_url);
-        outputs.deploy_identifier.set(parsedDeploymentOutput.deploy_identifier);
-        outputs.deploy_dashboard_url.set(parsedDeploymentOutput.deploy_dashboard_url);
-        outputs.deploy_alias_url.set(parsedDeploymentOutput.deploy_alias_url);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'unknown error';
-        throw new UserError(
-          'EAS_DEPLOY_FAILED',
-          'Deploy command failed.\n\n' +
-            `This can happen when deploy inputs are invalid, the export directory "${exportDir}" is missing, or EAS CLI authentication/network checks fail.\n` +
-            'Check the deploy step logs, verify your deploy configuration and exported files, then retry.\n' +
-            `Original error: ${errorMessage}`,
-          { cause: error }
-        );
-      }
-    },
-  });
-}
-
-function getDeployCommand({
-  exportDir,
-  alias,
-  prod,
-  sourceMaps,
-}: {
-  exportDir: string;
-  alias?: string;
-  prod?: boolean;
-  sourceMaps?: boolean;
-}): string[] {
-  const deployCommand = ['deploy', '--non-interactive', '--json', '--export-dir', exportDir];
-  if (alias) {
-    deployCommand.push('--alias', alias);
-  }
-  if (prod) {
-    deployCommand.push('--prod');
-  }
-  if (sourceMaps) {
-    deployCommand.push('--source-maps');
-  }
-  return deployCommand;
-}
-
-function parseDeploymentOutput({ deployJson, logger }: { deployJson: string; logger: bunyan }): {
-  deploy_url?: string;
-  deploy_deployment_url?: string;
-  deploy_identifier?: string;
-  deploy_dashboard_url?: string;
-  deploy_alias_url?: string;
-} {
-  try {
-    const deployObject = JSON.parse(deployJson);
-    return {
-      deploy_url:
-        deployObject.production?.url || deployObject.aliases?.[0]?.url || deployObject.url,
-      deploy_deployment_url: deployObject.url,
-      deploy_identifier: deployObject.identifier,
-      deploy_dashboard_url: deployObject.dashboardUrl,
-      deploy_alias_url: deployObject.aliases?.[0]?.url,
-    };
-  } catch (error: unknown) {
-    logger.warn(
-      { err: error },
-      'Failed to parse "eas deploy" JSON output. Some outputs expected from this step will be undefined.'
-    );
-    return {};
-  }
-}

packages/build-tools/src/steps/functions/eagerBundle.ts

@@ -29,7 +29,7 @@ export function eagerBundleBuildFunction(): BuildFunction {
         throw new Error('Eager bundle is not supported for SDK version < 52');
       }
 
-      const packageManager = resolvePackageManager(stepsCtx.workingDirectory, { env });
+      const packageManager = resolvePackageManager(stepsCtx.workingDirectory);
       const resolvedEASUpdateRuntimeVersion = inputs.resolved_eas_update_runtime_version.value as
         | string
         | undefined;

packages/build-tools/src/steps/functions/export.ts

@@ -1,140 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import {
-  BuildFunction,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-  BuildStepOutput,
-} from '@expo/steps';
-
-import { resolvePackageManager } from '../../utils/packageManager';
-import { runExpoCliCommand } from '../../utils/project';
-
-export function createEasExportBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'export',
-    name: 'Export',
-    __metricsId: 'eas/export',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'output_dir',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-        required: false,
-        defaultValue: 'dist',
-      }),
-      BuildStepInput.createProvider({
-        id: 'dev',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'minify',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'dump_assetmap',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'ssg',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'api_only',
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-        required: false,
-      }),
-      BuildStepInput.createProvider({
-        id: 'platform',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-        required: false,
-        defaultValue: 'web',
-      }),
-    ],
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'export_dir',
-        required: true,
-      }),
-    ],
-    fn: async (stepsCtx, { inputs, outputs, env }) => {
-      const outputDir = inputs.output_dir.value as string;
-      const dev = inputs.dev.value as boolean | undefined;
-      const minify = inputs.minify.value as boolean | undefined;
-      const dumpAssetmap = inputs.dump_assetmap.value as boolean | undefined;
-      const ssg = inputs.ssg.value as boolean | undefined;
-      const apiOnly = inputs.api_only.value as boolean | undefined;
-      const platform = inputs.platform.value as string;
-
-      const packageManager = resolvePackageManager(stepsCtx.workingDirectory, { env });
-      const exportCommand = getExportCommand({
-        outputDir,
-        dev,
-        minify,
-        dumpAssetmap,
-        ssg,
-        apiOnly,
-        platform,
-      });
-      stepsCtx.logger.info(`Running export command: expo ${exportCommand.join(' ')}`);
-
-      try {
-        await runExpoCliCommand({
-          packageManager,
-          args: exportCommand,
-          options: {
-            cwd: stepsCtx.workingDirectory,
-            env,
-            logger: stepsCtx.logger,
-            stdio: 'pipe',
-          },
-        });
-        outputs.export_dir.set(outputDir);
-      } catch (error) {
-        throw new UserError(
-          'EXPO_EXPORT_FAILED',
-          `Export command failed: ${error instanceof Error ? error.message : 'unknown error'}`
-        );
-      }
-    },
-  });
-}
-
-function getExportCommand({
-  outputDir,
-  dev,
-  minify,
-  dumpAssetmap,
-  ssg,
-  apiOnly,
-  platform,
-}: {
-  outputDir: string;
-  dev?: boolean;
-  minify?: boolean;
-  dumpAssetmap?: boolean;
-  ssg?: boolean;
-  apiOnly?: boolean;
-  platform: string;
-}): string[] {
-  const exportCommand = ['export', '--output-dir', outputDir, '--platform', platform];
-  if (dev) {
-    exportCommand.push('--dev');
-  }
-  if (minify === false) {
-    exportCommand.push('--no-minify');
-  }
-  if (dumpAssetmap) {
-    exportCommand.push('--dump-assetmap');
-  }
-  if (ssg === false) {
-    exportCommand.push('--no-ssg');
-  }
-  if (apiOnly) {
-    exportCommand.push('--api-only');
-  }
-  return exportCommand;
-}

packages/build-tools/src/steps/functions/generateGymfileFromTemplate.ts

@@ -6,7 +6,6 @@ import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@exp
 import { templateString } from '@expo/template-file';
 import assert from 'assert';
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
 
 import { IosBuildCredentialsSchema } from '../utils/ios/credentials/credentials';
@@ -37,10 +36,6 @@ const DEFAULT_CREDENTIALS_TEMPLATE = `
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
 
-    derived_data_path("<%- DERIVED_DATA_PATH %>")
-    result_bundle(true)
-    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
-
     output_directory("<%- OUTPUT_DIRECTORY %>")
 `;
 
@@ -60,9 +55,6 @@ const DEFAULT_SIMULATOR_TEMPLATE = `
 
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
-
-    result_bundle(true)
-    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;
 
 export function generateGymfileFromTemplateFunction(): BuildFunction {
@@ -189,7 +181,6 @@ export function generateGymfileFromTemplateFunction(): BuildFunction {
           ICLOUD_CONTAINER_ENVIRONMENT,
           SCHEME_SIMULATOR_DESTINATION: simulatorDestination,
           DERIVED_DATA_PATH: './build',
-          RESULT_BUNDLE_PATH: path.join(os.tmpdir(), `result-bundle-${Date.now()}.xcresult`),
           ...(PROFILES ? { PROFILES } : {}),
           ...(credentials
             ? {

packages/build-tools/src/steps/functions/installNodeModules.ts

@@ -27,7 +27,7 @@ export async function installNodeModules(
   env: BuildStepEnv
 ): Promise<void> {
   const { logger } = stepCtx;
-  const packageManager = resolvePackageManager(stepCtx.workingDirectory, { env });
+  const packageManager = resolvePackageManager(stepCtx.workingDirectory);
   const packagerRunDir = findPackagerRootDir(stepCtx.workingDirectory);
 
   if (packagerRunDir !== stepCtx.workingDirectory) {

packages/build-tools/src/steps/functions/installPods.ts

@@ -1,6 +1,8 @@
 import { BuildFunction } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 
+import { waitForPrecompiledModulesPreparationAsync } from '../../utils/precompiledModules';
+
 export function createInstallPodsBuildFunction(): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
@@ -8,6 +10,14 @@ export function createInstallPodsBuildFunction(): BuildFunction {
     name: 'Install Pods',
     __metricsId: 'eas/install_pods',
     fn: async (stepsCtx, { env }) => {
+      try {
+        await waitForPrecompiledModulesPreparationAsync();
+      } catch (err) {
+        stepsCtx.logger.warn(
+          { err },
+          'Precompiled dependencies were not prepared successfully, continuing with pod install'
+        );
+      }
       stepsCtx.logger.info('Installing pods');
       const verboseFlag = stepsCtx.global.env['EAS_VERBOSE'] === '1' ? ['--verbose'] : [];
       const cocoapodsDeploymentFlag =

packages/build-tools/src/steps/functions/internalMaestroTest.ts

@@ -0,0 +1,684 @@
+import { GenericArtifactType } from '@expo/eas-build-job';
+import { PipeMode, bunyan } from '@expo/logger';
+import { Result, asyncResult, result } from '@expo/results';
+import {
+  BuildFunction,
+  BuildStepEnv,
+  BuildStepInput,
+  BuildStepInputValueTypeName,
+  BuildStepOutput,
+  spawnAsync,
+} from '@expo/steps';
+import spawn, { SpawnPromise, SpawnResult } from '@expo/turtle-spawn';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { setTimeout } from 'node:timers/promises';
+import { z } from 'zod';
+
+import { CustomBuildContext } from '../../customBuildContext';
+import {
+  AndroidDeviceSerialId,
+  AndroidEmulatorUtils,
+  AndroidVirtualDeviceName,
+} from '../../utils/AndroidEmulatorUtils';
+import { IosSimulatorName, IosSimulatorUtils } from '../../utils/IosSimulatorUtils';
+import { findMaestroPathsFlowsToExecuteAsync } from '../../utils/findMaestroPathsFlowsToExecuteAsync';
+import { retryAsync } from '../../utils/retry';
+import { PlatformToProperNounMap } from '../../utils/strings';
+
+export function createInternalEasMaestroTestFunction(ctx: CustomBuildContext): BuildFunction {
+  return new BuildFunction({
+    namespace: 'eas',
+    id: '__maestro_test',
+    __metricsId: 'eas/__maestro_test',
+    inputProviders: [
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+        id: 'platform',
+        required: true,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
+        id: 'flow_paths',
+        required: true,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
+        id: 'retries',
+        defaultValue: 1,
+        required: false,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+        id: 'include_tags',
+        required: false,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+        id: 'exclude_tags',
+        required: false,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
+        id: 'shards',
+        defaultValue: 1,
+        required: false,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+        id: 'output_format',
+        required: false,
+      }),
+      BuildStepInput.createProvider({
+        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
+        id: 'record_screen',
+        defaultValue: false,
+        required: false,
+      }),
+    ],
+    outputProviders: [
+      BuildStepOutput.createProvider({
+        id: 'test_reports_artifact_id',
+        required: false,
+      }),
+      BuildStepOutput.createProvider({
+        id: 'junit_report_directory',
+        required: false,
+      }),
+    ],
+    fn: async (stepCtx, { inputs: _inputs, env, outputs }) => {
+      // inputs come in form of { value: unknown }. Here we parse them into a typed and validated object.
+      const {
+        platform,
+        flow_paths,
+        retries,
+        include_tags,
+        exclude_tags,
+        shards,
+        output_format,
+        record_screen,
+      } = z
+        .object({
+          platform: z.enum(['ios', 'android']),
+          flow_paths: z.array(z.string()),
+          retries: z.number().default(1),
+          include_tags: z.string().optional(),
+          exclude_tags: z.string().optional(),
+          shards: z.number().default(1),
+          output_format: z.string().optional(),
+          record_screen: z.boolean().default(false),
+        })
+        .parse(
+          Object.fromEntries(Object.entries(_inputs).map(([key, value]) => [key, value.value]))
+        );
+
+      const flowPathsToExecute: string[] = [];
+      for (const flowPath of flow_paths) {
+        const flowPaths = await findMaestroPathsFlowsToExecuteAsync({
+          workingDirectory: stepCtx.workingDirectory,
+          flowPath,
+          logger: stepCtx.logger,
+          includeTags: include_tags ? include_tags.split(',') : undefined,
+          excludeTags: exclude_tags ? exclude_tags.split(',') : undefined,
+        });
+        if (flowPaths.length === 0) {
+          stepCtx.logger.warn(`No flows to execute found in "${flowPath}".`);
+          continue;
+        }
+        stepCtx.logger.info(
+          `Marking for execution:\n- ${flowPaths
+            .map(flowPath => path.relative(stepCtx.workingDirectory, flowPath))
+            .join('\n- ')}`
+        );
+        stepCtx.logger.info('');
+        flowPathsToExecute.push(...flowPaths);
+      }
+
+      // TODO: Add support for shards. (Shouldn't be too difficult.)
+      if (shards > 1) {
+        stepCtx.logger.warn(
+          'Sharding support has been temporarily disabled. Running tests on a single shard.'
+        );
+      }
+
+      // eas/__maestro_test does not start devices, it expects a single device to be already running
+      // and configured with the app. Here we find the booted device and stop it.
+
+      let sourceDeviceIdentifier: IosSimulatorName | AndroidVirtualDeviceName;
+
+      switch (platform) {
+        case 'ios': {
+          const bootedDevices = await IosSimulatorUtils.getAvailableDevicesAsync({
+            env,
+            filter: 'booted',
+          });
+          if (bootedDevices.length === 0) {
+            throw new Error('No booted iOS Simulator found.');
+          } else if (bootedDevices.length > 1) {
+            throw new Error('Multiple booted iOS Simulators found.');
+          }
+
+          const device = bootedDevices[0];
+          stepCtx.logger.info(`Running tests on iOS Simulator: ${device.name}.`);
+
+          stepCtx.logger.info(`Preparing Simulator for tests...`);
+          await spawnAsync('xcrun', ['simctl', 'shutdown', device.udid], {
+            logger: stepCtx.logger,
+            stdio: 'pipe',
+          });
+
+          sourceDeviceIdentifier = device.name;
+          break;
+        }
+        case 'android': {
+          const connectedDevices = await AndroidEmulatorUtils.getAttachedDevicesAsync({ env });
+          if (connectedDevices.length === 0) {
+            throw new Error('No booted Android Emulator found.');
+          } else if (connectedDevices.length > 1) {
+            throw new Error('Multiple booted Android Emulators found.');
+          }
+
+          const { serialId } = connectedDevices[0];
+          const adbEmuAvdNameResult = await spawn('adb', ['-s', serialId, 'emu', 'avd', 'name'], {
+            mode: PipeMode.COMBINED,
+            env,
+          });
+          const avdName = adbEmuAvdNameResult.stdout
+            .replace(/\r\n/g, '\n')
+            .split('\n')[0] as AndroidVirtualDeviceName;
+          stepCtx.logger.info(`Running tests on Android Emulator: ${avdName}.`);
+
+          stepCtx.logger.info(`Preparing Emulator for tests...`);
+          await spawnAsync('adb', ['-s', serialId, 'emu', 'kill'], {
+            stdio: 'pipe',
+          });
+          // Waiting for emulator to get killed, see ANDROID_EMULATOR_WAIT_TIME_BEFORE_KILL.
+          await setTimeout(1000);
+
+          sourceDeviceIdentifier = avdName;
+          break;
+        }
+      }
+
+      // During tests we generate reports and device logs. We store them in temporary directories
+      // and upload them once all tests are done. When a test is retried, new reports overwrite
+      // the old ones. The files are named "flow-${index}" for easier identification.
+      const maestroReportsDir = await fs.promises.mkdtemp(
+        path.join(os.tmpdir(), 'maestro-reports-')
+      );
+      const deviceLogsDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'device-logs-'));
+
+      const failedFlows: string[] = [];
+
+      for (const [flowIndex, flowPath] of flowPathsToExecute.entries()) {
+        stepCtx.logger.info('');
+
+        for (let attemptCount = 0; attemptCount < retries; attemptCount++) {
+          // Generate unique report path per attempt (not overwritten on retry)
+          const outputPath = path.join(
+            maestroReportsDir,
+            [
+              `${output_format ? output_format + '-' : ''}report-flow-${flowIndex + 1}-attempt-${attemptCount}`,
+              MaestroOutputFormatToExtensionMap[output_format ?? 'noop'],
+            ]
+              .filter(Boolean)
+              .join('.')
+          );
+          const localDeviceName = `eas-simulator-${flowIndex}-${attemptCount}` as
+            | IosSimulatorName
+            | AndroidVirtualDeviceName;
+
+          // If the test passes, but the recording fails, we don't want to make the test fail,
+          // so we return two separate results.
+          const {
+            fnResult: { fnResult, recordingResult },
+            logsResult,
+          } = await withCleanDeviceAsync({
+            platform,
+            sourceDeviceIdentifier,
+            localDeviceName,
+            env,
+            logger: stepCtx.logger,
+            fn: async ({ deviceIdentifier }) => {
+              return await maybeWithScreenRecordingAsync({
+                shouldRecord: record_screen,
+                platform,
+                deviceIdentifier,
+                env,
+                logger: stepCtx.logger,
+                fn: async () => {
+                  stepCtx.logger.info('');
+
+                  const [command, ...args] = getMaestroTestCommand({
+                    flow_path: flowPath,
+                    output_format,
+                    output_path: outputPath,
+                  });
+
+                  try {
+                    await spawnAsync(command, args, {
+                      logger: stepCtx.logger,
+                      cwd: stepCtx.workingDirectory,
+                      env,
+                      stdio: 'pipe',
+                    });
+                  } finally {
+                    stepCtx.logger.info('');
+                  }
+                },
+              });
+            },
+          });
+
+          // Move device logs to the device logs directory.
+          if (logsResult?.ok) {
+            try {
+              const extension = path.extname(logsResult.value.outputPath);
+              const destinationPath = path.join(
+                deviceLogsDir,
+                `flow-${flowIndex}-attempt-${attemptCount}${extension}`
+              );
+
+              await fs.promises.rename(logsResult.value.outputPath, destinationPath);
+            } catch (err) {
+              stepCtx.logger.warn({ err }, 'Failed to prepare device logs for upload.');
+            }
+          } else if (logsResult?.reason) {
+            stepCtx.logger.error({ err: logsResult.reason }, 'Failed to collect device logs.');
+          }
+
+          const isLastAttempt = fnResult.ok || attemptCount === retries - 1;
+          if (isLastAttempt && recordingResult.value) {
+            try {
+              await ctx.runtimeApi.uploadArtifact({
+                logger: stepCtx.logger,
+                artifact: {
+                  // TODO(sjchmiela): Add metadata to artifacts so we don't need to encode flow path and attempt in the name.
+                  name: `Screen Recording (${flowIndex}-${path.basename(
+                    flowPath,
+                    path.extname(flowPath)
+                  )})`,
+                  paths: [recordingResult.value],
+                  type: GenericArtifactType.OTHER,
+                },
+              });
+            } catch (err) {
+              stepCtx.logger.warn({ err }, 'Failed to upload screen recording.');
+            }
+          }
+
+          if (fnResult.ok) {
+            stepCtx.logger.info(`Test passed.`);
+            // Break out of the retry loop.
+            break;
+          }
+
+          if (attemptCount < retries - 1) {
+            stepCtx.logger.info(`Retrying test...`);
+            stepCtx.logger.info('');
+            continue;
+          }
+
+          // fnResult.reason is not super interesting, but it does print out the full command so we can keep it for debugging purposes.
+          stepCtx.logger.error({ err: fnResult.reason }, 'Test errored.');
+          failedFlows.push(flowPath);
+        }
+      }
+
+      stepCtx.logger.info('');
+
+      // When all tests are done, we upload the reports and device logs.
+      const generatedMaestroReports = await fs.promises.readdir(maestroReportsDir);
+      if (generatedMaestroReports.length === 0) {
+        stepCtx.logger.warn('No reports were generated.');
+      } else {
+        stepCtx.logger.info(`Uploading reports...`);
+        try {
+          const { artifactId } = await ctx.runtimeApi.uploadArtifact({
+            logger: stepCtx.logger,
+            artifact: {
+              name: `${PlatformToProperNounMap[platform]} Maestro Test Reports (${output_format})`,
+              paths: [maestroReportsDir],
+              type: GenericArtifactType.OTHER,
+            },
+          });
+          if (artifactId) {
+            outputs.test_reports_artifact_id.set(artifactId);
+          }
+        } catch (err) {
+          stepCtx.logger.error({ err }, 'Failed to upload reports.');
+        }
+      }
+
+      if (output_format === 'junit') {
+        outputs.junit_report_directory.set(maestroReportsDir);
+      }
+
+      const generatedDeviceLogs = await fs.promises.readdir(deviceLogsDir);
+      if (generatedDeviceLogs.length === 0) {
+        stepCtx.logger.warn('No device logs were successfully collected.');
+      } else {
+        stepCtx.logger.info(`Uploading device logs...`);
+        try {
+          await ctx.runtimeApi.uploadArtifact({
+            logger: stepCtx.logger,
+            artifact: {
+              name: `Maestro Test Device Logs`,
+              paths: [deviceLogsDir],
+              type: GenericArtifactType.OTHER,
+            },
+          });
+        } catch (err) {
+          stepCtx.logger.error({ err }, 'Failed to upload device logs.');
+        }
+      }
+
+      stepCtx.logger.info('');
+
+      // If any tests failed, we throw an error to mark the step as failed.
+      if (failedFlows.length > 0) {
+        throw new Error(
+          `Some Maestro tests failed:\n- ${failedFlows
+            .map(flowPath => path.relative(stepCtx.workingDirectory, flowPath))
+            .join('\n- ')}`
+        );
+      } else {
+        stepCtx.logger.info('All Maestro tests passed.');
+      }
+    },
+  });
+}
+
+export function getMaestroTestCommand(params: {
+  flow_path: string;
+  output_format: string | undefined;
+  /** Unused if `output_format` is undefined */
+  output_path: string;
+}): [command: string, ...args: string[]] {
+  let outputFormatFlags: string[] = [];
+  if (params.output_format) {
+    outputFormatFlags = [`--format`, params.output_format, `--output`, params.output_path];
+  }
+
+  return ['maestro', 'test', ...outputFormatFlags, params.flow_path] as [
+    command: string,
+    ...args: string[],
+  ];
+}
+
+const MaestroOutputFormatToExtensionMap: Record<string, string | undefined> = {
+  junit: 'xml',
+  html: 'html',
+};
+
+const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
+const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
+
+async function withCleanDeviceAsync<TResult>({
+  platform,
+  sourceDeviceIdentifier,
+  localDeviceName,
+  env,
+  logger,
+  fn,
+}: {
+  env: BuildStepEnv;
+  logger: bunyan;
+  platform: 'ios' | 'android';
+  sourceDeviceIdentifier: IosSimulatorName | AndroidVirtualDeviceName;
+  localDeviceName: IosSimulatorName | AndroidVirtualDeviceName;
+  fn: ({
+    deviceIdentifier,
+  }: {
+    deviceIdentifier: IosSimulatorName | AndroidDeviceSerialId;
+  }) => Promise<TResult>;
+}): Promise<{ fnResult: TResult; logsResult: Result<{ outputPath: string }> | null }> {
+  // Clone and start the device
+
+  let localDeviceIdentifier: IosSimulatorName | AndroidDeviceSerialId | null = null;
+
+  switch (platform) {
+    case 'ios': {
+      logger.info(`Cloning iOS Simulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
+      await IosSimulatorUtils.cloneAsync({
+        sourceDeviceIdentifier: sourceDeviceIdentifier as IosSimulatorName,
+        destinationDeviceName: localDeviceName as IosSimulatorName,
+        env,
+      });
+      logger.info(`Starting iOS Simulator ${localDeviceName}...`);
+      const { udid } = await IosSimulatorUtils.startAsync({
+        deviceIdentifier: localDeviceName as IosSimulatorName,
+        env,
+      });
+      logger.info(`Waiting for iOS Simulator ${localDeviceName} to be ready...`);
+      await IosSimulatorUtils.waitForReadyAsync({
+        udid,
+        env,
+      });
+      localDeviceIdentifier = localDeviceName as IosSimulatorName;
+      break;
+    }
+    case 'android': {
+      await retryAsync(
+        async attemptCount => {
+          const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
+          const attempt = attemptCount + 1;
+          const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
+          let serialId: AndroidDeviceSerialId | null = null;
+          try {
+            logger.info(
+              `Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`
+            );
+            await AndroidEmulatorUtils.cloneAsync({
+              sourceDeviceName: sourceDeviceIdentifier as AndroidVirtualDeviceName,
+              destinationDeviceName: localDeviceName as AndroidVirtualDeviceName,
+              env,
+              logger,
+            });
+            logger.info(
+              `Starting Android Emulator ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`
+            );
+            const startResult = await AndroidEmulatorUtils.startAsync({
+              deviceName: localDeviceName as AndroidVirtualDeviceName,
+              env,
+            });
+            serialId = startResult.serialId;
+            logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
+            await AndroidEmulatorUtils.waitForReadyAsync({
+              serialId,
+              env,
+              timeoutMs,
+              logger,
+            });
+            localDeviceIdentifier = serialId;
+          } catch (err) {
+            logger.warn(
+              { err },
+              `Failed to start Android Emulator ${localDeviceName} on attempt ${attempt}/${maxAttempts}.`
+            );
+            try {
+              if (serialId) {
+                await AndroidEmulatorUtils.deleteAsync({
+                  serialId,
+                  deviceName: localDeviceName as AndroidVirtualDeviceName,
+                  env,
+                });
+              } else {
+                await AndroidEmulatorUtils.deleteAsync({
+                  deviceName: localDeviceName as AndroidVirtualDeviceName,
+                  env,
+                });
+              }
+            } catch (cleanupErr) {
+              logger.warn(
+                { err: cleanupErr },
+                `Failed to clean up Android Emulator ${localDeviceName}.`
+              );
+            }
+            throw err;
+          }
+        },
+        {
+          logger,
+          retryOptions: {
+            retries: ANDROID_STARTUP_RETRIES_COUNT,
+            retryIntervalMs: 1_000,
+          },
+        }
+      );
+      break;
+    }
+  }
+
+  if (!localDeviceIdentifier) {
+    throw new Error('Device did not return an identifier after startup.');
+  }
+
+  // Run the function
+
+  const fnResult = await asyncResult(fn({ deviceIdentifier: localDeviceIdentifier }));
+
+  // Stop the device
+
+  let logsResult: Result<{ outputPath: string }> | null = null;
+
+  try {
+    switch (platform) {
+      case 'ios': {
+        logger.info(`Collecting logs from ${localDeviceName}...`);
+        logsResult = await asyncResult(
+          IosSimulatorUtils.collectLogsAsync({
+            deviceIdentifier: localDeviceIdentifier as IosSimulatorName,
+            env,
+          })
+        );
+
+        logger.info(`Cleaning up ${localDeviceName}...`);
+        await IosSimulatorUtils.deleteAsync({
+          deviceIdentifier: localDeviceIdentifier as IosSimulatorName,
+          env,
+        });
+        break;
+      }
+      case 'android': {
+        logger.info(`Collecting logs from ${localDeviceName}...`);
+        logsResult = await asyncResult(
+          AndroidEmulatorUtils.collectLogsAsync({
+            serialId: localDeviceIdentifier as unknown as AndroidDeviceSerialId,
+            env,
+          })
+        );
+
+        logger.info(`Cleaning up ${localDeviceName}...`);
+        await AndroidEmulatorUtils.deleteAsync({
+          serialId: localDeviceIdentifier as unknown as AndroidDeviceSerialId,
+          env,
+        });
+        break;
+      }
+    }
+  } catch (err) {
+    logger.error(`Error cleaning up device: ${err}`);
+  }
+
+  return { fnResult: fnResult.enforceValue(), logsResult };
+}
+
+/** Runs provided `fn` function, optionally wrapping it with starting and stopping screen recording. */
+async function maybeWithScreenRecordingAsync<TResult>({
+  shouldRecord,
+  platform,
+  deviceIdentifier,
+  env,
+  logger,
+  fn,
+}: {
+  // As weird as it is, it's more convenient to have this function like `maybeWith...`
+  // than "withScreenRecordingAsync" and `withScreenRecordingAsync(fn)` vs `fn` in the caller.
+  shouldRecord: boolean;
+  platform: 'ios' | 'android';
+  deviceIdentifier: IosSimulatorName | AndroidDeviceSerialId;
+  env: BuildStepEnv;
+  logger: bunyan;
+  fn: () => Promise<TResult>;
+}): Promise<{ fnResult: Result<TResult>; recordingResult: Result<string | null> }> {
+  if (!shouldRecord) {
+    return { fnResult: await asyncResult(fn()), recordingResult: result(null) };
+  }
+
+  let recordingResult: Result<{
+    recordingSpawn: SpawnPromise<SpawnResult>;
+    outputPath?: string;
+  }>;
+
+  // Start screen recording
+
+  logger.info(`Starting screen recording on ${deviceIdentifier}...`);
+
+  switch (platform) {
+    case 'ios': {
+      recordingResult = await asyncResult(
+        IosSimulatorUtils.startScreenRecordingAsync({
+          deviceIdentifier: deviceIdentifier as IosSimulatorName,
+          env,
+        })
+      );
+      break;
+    }
+    case 'android': {
+      recordingResult = await asyncResult(
+        AndroidEmulatorUtils.startScreenRecordingAsync({
+          serialId: deviceIdentifier as AndroidDeviceSerialId,
+          env,
+        })
+      );
+      break;
+    }
+  }
+
+  if (!recordingResult.ok) {
+    logger.warn('Failed to start screen recording.', recordingResult.reason);
+  }
+
+  // Run the function
+
+  const fnResult = await asyncResult(fn());
+
+  // If recording failed there's nothing to stop, so we return the results
+
+  if (!recordingResult.ok) {
+    return { fnResult, recordingResult: result(recordingResult.reason) };
+  }
+
+  // If recording started, finish it
+
+  try {
+    logger.info(`Stopping screen recording on ${deviceIdentifier}...`);
+
+    switch (platform) {
+      case 'ios': {
+        await IosSimulatorUtils.stopScreenRecordingAsync({
+          recordingSpawn: recordingResult.value.recordingSpawn,
+        });
+        return {
+          fnResult,
+          // We know outputPath is defined, because startIosScreenRecording() should have filled it.
+          recordingResult: result(recordingResult.value.outputPath!),
+        };
+      }
+      case 'android': {
+        const { outputPath } = await AndroidEmulatorUtils.stopScreenRecordingAsync({
+          serialId: deviceIdentifier as AndroidDeviceSerialId,
+          recordingSpawn: recordingResult.value.recordingSpawn,
+          env,
+        });
+        return { fnResult, recordingResult: result(outputPath) };
+      }
+    }
+  } catch (err) {
+    logger.warn('Failed to stop screen recording.', err);
+
+    return { fnResult, recordingResult: result(err as Error) };
+  }
+}

packages/build-tools/src/steps/functions/parseXcactivitylog.ts

@@ -1,51 +0,0 @@
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
-import path from 'path';
-
-import { parseAndReportXcactivitylog } from '../utils/ios/xcactivitylog';
-
-export function parseXcactivitylogFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'parse_xcactivitylog',
-    name: 'Analyze build performance',
-    __metricsId: 'eas/parse_xcactivitylog',
-    supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'derived_data_path',
-        required: false,
-        defaultValue: 'ios/build',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'workspace_path',
-        required: false,
-        defaultValue: 'ios',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'xclogparser_version',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-    ],
-    fn: async (stepCtx, { inputs, env }) => {
-      const derivedDataPath = inputs.derived_data_path.value as string;
-      const workspacePath = inputs.workspace_path.value as string;
-      const version = inputs.xclogparser_version.value as string | undefined;
-
-      await parseAndReportXcactivitylog({
-        derivedDataPath: path.resolve(stepCtx.workingDirectory, derivedDataPath),
-        workspacePath: path.resolve(stepCtx.workingDirectory, workspacePath),
-        xclogparserVersion: version,
-        logger: stepCtx.logger,
-        proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
-      });
-    },
-  });
-}

packages/build-tools/src/steps/functions/prebuild.ts

@@ -32,7 +32,7 @@ export function createPrebuildBuildFunction(): BuildFunction {
     fn: async (stepCtx, { inputs, env }) => {
       const { logger } = stepCtx;
       const appleTeamId = inputs.apple_team_id.value as string | undefined;
-      const packageManager = resolvePackageManager(stepCtx.workingDirectory, { env });
+      const packageManager = resolvePackageManager(stepCtx.workingDirectory);
       const defaultPlatform = process.platform === 'darwin' ? 'ios' : 'android';
 
       const job = stepCtx.global.staticContext.job;

packages/build-tools/src/steps/functions/readAppConfig.ts

@@ -1,43 +0,0 @@
-import { Metadata } from '@expo/eas-build-job';
-import { BuildFunction, BuildStepOutput } from '@expo/steps';
-
-import { readAppConfig } from '../../utils/appConfig';
-
-export function createReadAppConfigBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'read_app_config',
-    name: 'Read app config',
-    __metricsId: 'eas/read_app_config',
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'app_config',
-        required: false,
-      }),
-    ],
-    fn: async (stepCtx, { env, outputs }) => {
-      const metadata = stepCtx.global.staticContext.metadata as Metadata | undefined;
-      try {
-        const appConfig = (
-          await readAppConfig({
-            projectDir: stepCtx.workingDirectory,
-            env: Object.keys(env).reduce(
-              (acc, key) => {
-                acc[key] = env[key] ?? '';
-                return acc;
-              },
-              {} as Record<string, string>
-            ),
-            logger: stepCtx.logger,
-            sdkVersion: metadata?.sdkVersion,
-          })
-        ).exp;
-        stepCtx.logger.info('Using app configuration:');
-        stepCtx.logger.info(JSON.stringify(appConfig, null, 2));
-        outputs.app_config.set(JSON.stringify(appConfig));
-      } catch {
-        // readAppConfig logs underlying failures.
-      }
-    },
-  });
-}

packages/build-tools/src/steps/functions/readPackageJson.ts

@@ -1,26 +0,0 @@
-import { BuildFunction, BuildStepOutput } from '@expo/steps';
-
-import { readAndLogPackageJson } from '../../utils/project';
-
-export function createReadPackageJsonBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'read_package_json',
-    name: 'Read package.json',
-    __metricsId: 'eas/read_package_json',
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'package_json',
-        required: false,
-      }),
-    ],
-    fn: async (stepCtx, { outputs }) => {
-      try {
-        const packageJson = readAndLogPackageJson(stepCtx.logger, stepCtx.workingDirectory);
-        outputs.package_json.set(JSON.stringify(packageJson));
-      } catch (err: unknown) {
-        stepCtx.logger.error({ err });
-      }
-    },
-  });
-}

packages/build-tools/src/steps/functions/resolveSubmitConfig/android.ts

@@ -1,182 +0,0 @@
-import { Platform, SubmissionConfig, SystemError, UserError } from '@expo/eas-build-job';
-import { AndroidReleaseStatus, SubmitProfile } from '@expo/eas-json';
-import { bunyan } from '@expo/logger';
-import { asyncResult } from '@expo/results';
-import spawn from '@expo/turtle-spawn';
-import { BuildStepEnv } from '@expo/steps';
-import fs from 'fs-extra';
-import { graphql } from 'gql.tada';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { BuildInfo, ResolvedSubmitConfig } from './common';
-import { CustomBuildContext } from '../../../customBuildContext';
-
-const ANDROID_APP_CREDENTIALS_QUERY = graphql(`
-  query ResolveSubmitConfigAndroidAppCredentials(
-    $appId: String!
-    $applicationIdentifier: String
-  ) {
-    app {
-      byId(appId: $appId) {
-        id
-        androidAppCredentials(filter: { applicationIdentifier: $applicationIdentifier }) {
-          id
-          googleServiceAccountKeyForSubmissions {
-            id
-            keyJson
-          }
-        }
-      }
-    }
-  }
-`);
-
-const AndroidReleaseStatusToSubmissionReleaseStatus: Record<
-  AndroidReleaseStatus,
-  SubmissionConfig.Android.ReleaseStatus
-> = {
-  [AndroidReleaseStatus.completed]: SubmissionConfig.Android.ReleaseStatus.COMPLETED,
-  [AndroidReleaseStatus.draft]: SubmissionConfig.Android.ReleaseStatus.DRAFT,
-  [AndroidReleaseStatus.halted]: SubmissionConfig.Android.ReleaseStatus.HALTED,
-  [AndroidReleaseStatus.inProgress]: SubmissionConfig.Android.ReleaseStatus.IN_PROGRESS,
-};
-
-export async function resolveAndroidSubmitConfigAsync({
-  artifactPath,
-  build,
-  ctx,
-  env,
-  logger,
-  profile,
-  workingDirectory,
-}: {
-  artifactPath: string;
-  build: BuildInfo;
-  ctx: CustomBuildContext;
-  env: BuildStepEnv;
-  logger: bunyan;
-  profile: SubmitProfile<Platform.ANDROID>;
-  workingDirectory: string;
-}): Promise<ResolvedSubmitConfig> {
-  const applicationId =
-    build.appIdentifier ??
-    profile.applicationId ??
-    (await readAndroidApplicationIdAsync(artifactPath, env, logger));
-  if (!applicationId) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_ANDROID_APPLICATION_ID_NOT_FOUND',
-      'Could not resolve Android applicationId from build metadata or artifact. Set applicationId in the Android submit profile, or pass an APK/AAB artifact with a readable package name.'
-    );
-  }
-
-  const googleServiceAccountKeyJson = profile.serviceAccountKeyPath
-    ? await fs.readFile(path.resolve(workingDirectory, profile.serviceAccountKeyPath), 'utf8')
-    : await getGoogleServiceAccountKeyJsonAsync({
-        applicationId,
-        appId: build.appId,
-        ctx,
-      });
-
-  const releaseStatus = AndroidReleaseStatusToSubmissionReleaseStatus[profile.releaseStatus];
-  const baseConfigInput = {
-    changesNotSentForReview: profile.changesNotSentForReview,
-    googleServiceAccountKeyJson,
-    track: profile.track,
-  };
-  const configInput: z.input<typeof SubmissionConfig.Android.SchemaZ> =
-    releaseStatus === SubmissionConfig.Android.ReleaseStatus.IN_PROGRESS
-      ? {
-          ...baseConfigInput,
-          releaseStatus,
-          rollout: profile.rollout,
-        }
-      : {
-          ...baseConfigInput,
-          releaseStatus,
-        };
-
-  return {
-    appIdentifier: applicationId,
-    config: SubmissionConfig.Android.SchemaZ.parse(configInput),
-    platform: Platform.ANDROID,
-  };
-}
-
-async function getGoogleServiceAccountKeyJsonAsync({
-  applicationId,
-  appId,
-  ctx,
-}: {
-  applicationId: string;
-  appId: string;
-  ctx: CustomBuildContext;
-}): Promise<string> {
-  const credentialsResult = await ctx.graphqlClient
-    .query(ANDROID_APP_CREDENTIALS_QUERY, {
-      appId,
-      applicationIdentifier: applicationId,
-    })
-    .toPromise();
-  if (credentialsResult.error) {
-    throw credentialsResult.error;
-  }
-
-  const key =
-    credentialsResult.data?.app.byId.androidAppCredentials[0]
-      ?.googleServiceAccountKeyForSubmissions;
-  if (!key) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_ANDROID_SERVICE_ACCOUNT_KEY_NOT_CONFIGURED',
-      `Google Service Account Key for submissions is not configured for ${applicationId}. Configure a Google Service Account Key for submissions in EAS credentials, or set serviceAccountKeyPath in the Android submit profile.`
-    );
-  }
-
-  if (!key.keyJson) {
-    throw new SystemError(`Google Service Account Key ${key.id} could not be resolved.`);
-  }
-  return key.keyJson;
-}
-
-async function readAndroidApplicationIdAsync(
-  artifactPath: string,
-  env: BuildStepEnv,
-  logger: bunyan
-): Promise<string | undefined> {
-  if (artifactPath.endsWith('.apk')) {
-    return await readAndroidApplicationIdFromApkAsync(artifactPath, env, logger);
-  } else if (artifactPath.endsWith('.aab')) {
-    return await readAndroidApplicationIdFromAabAsync(artifactPath, env, logger);
-  }
-  return undefined;
-}
-
-async function readAndroidApplicationIdFromApkAsync(
-  apkPath: string,
-  env: BuildStepEnv,
-  logger: bunyan
-): Promise<string | undefined> {
-  const aapt2Result = await asyncResult(spawn('aapt2', ['dump', 'packagename', apkPath], { env }));
-  if (aapt2Result.ok) {
-    return aapt2Result.value.stdout.trim();
-  }
-  logger.warn('Failed to read APK package name with aapt2.');
-  return undefined;
-}
-
-async function readAndroidApplicationIdFromAabAsync(
-  aabPath: string,
-  env: BuildStepEnv,
-  logger: bunyan
-): Promise<string | undefined> {
-  const result = await asyncResult(
-    spawn('bundletool', ['dump', 'manifest', `--bundle=${aabPath}`, '--xpath=/manifest/@package'], {
-      env,
-    })
-  );
-  if (!result.ok) {
-    logger.warn('Failed to read AAB package name with bundletool.');
-    return undefined;
-  }
-  return result.value.stdout.trim();
-}

packages/build-tools/src/steps/functions/resolveSubmitConfig/common.ts

@@ -1,84 +0,0 @@
-import { Platform, SubmissionConfig, UserError } from '@expo/eas-build-job';
-import { EasJsonAccessor, EasJsonUtils, SubmitProfile } from '@expo/eas-json';
-import { graphql } from 'gql.tada';
-
-import { CustomBuildContext } from '../../../customBuildContext';
-
-export type AppPlatform = 'ANDROID' | 'IOS';
-
-export const AppPlatformToPlatform: Record<AppPlatform, Platform> = {
-  ANDROID: Platform.ANDROID,
-  IOS: Platform.IOS,
-};
-
-export type BuildInfo = {
-  appIdentifier?: string | null;
-  appId: string;
-  buildId: string;
-  projectOwnerAccountId: string;
-  platform: Platform;
-};
-
-export type ResolvedSubmitConfig = {
-  appIdentifier?: string;
-  config: SubmissionConfig.Android | SubmissionConfig.Ios;
-  platform: Platform;
-};
-
-const BUILD_BY_ID_QUERY = graphql(`
-  query ResolveSubmitConfigBuildById($buildId: ID!) {
-    builds {
-      byId(buildId: $buildId) {
-        id
-        platform
-        appIdentifier
-        app {
-          id
-          ownerAccount {
-            id
-          }
-        }
-      }
-    }
-  }
-`);
-
-export async function getBuildInfoAsync(
-  ctx: CustomBuildContext,
-  buildId: string
-): Promise<BuildInfo> {
-  const result = await ctx.graphqlClient.query(BUILD_BY_ID_QUERY, { buildId }).toPromise();
-  if (result.error) {
-    throw result.error;
-  }
-  const build = result.data?.builds.byId;
-  if (!build) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_BUILD_NOT_FOUND',
-      `Could not find build ${buildId}.`
-    );
-  }
-  return {
-    appIdentifier: build.appIdentifier,
-    appId: build.app.id,
-    buildId: build.id,
-    projectOwnerAccountId: build.app.ownerAccount.id,
-    platform: AppPlatformToPlatform[build.platform],
-  };
-}
-
-export async function getSubmitProfileAsync<T extends Platform>({
-  platform,
-  profileName,
-  workingDirectory,
-}: {
-  platform: T;
-  profileName: string;
-  workingDirectory: string;
-}): Promise<SubmitProfile<T>> {
-  return await EasJsonUtils.getSubmitProfileAsync(
-    EasJsonAccessor.fromProjectPath(workingDirectory),
-    platform,
-    profileName
-  );
-}

packages/build-tools/src/steps/functions/resolveSubmitConfig/index.ts

@@ -1,139 +0,0 @@
-import { Platform, SystemError } from '@expo/eas-build-job';
-import { bunyan } from '@expo/logger';
-import {
-  BuildFunction,
-  BuildStepEnv,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-  BuildStepOutput,
-} from '@expo/steps';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { resolveAndroidSubmitConfigAsync } from './android';
-import { ResolvedSubmitConfig, getBuildInfoAsync, getSubmitProfileAsync } from './common';
-import { resolveIosSubmitConfigAsync } from './ios';
-import { CustomBuildContext } from '../../../customBuildContext';
-
-export function createResolveSubmitConfigBuildFunction(ctx: CustomBuildContext): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'resolve_submit_config',
-    name: 'Resolve submit config',
-    __metricsId: 'eas/resolve_submit_config',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'build_id',
-        required: true,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'profile',
-        required: true,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'artifact_path',
-        required: true,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-    ],
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'config_json',
-        required: true,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'platform',
-        required: true,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'app_identifier',
-        required: false,
-      }),
-    ],
-    fn: async (stepsCtx, { env, inputs, outputs }) => {
-      const buildId = z.string().uuid().parse(inputs.build_id.value);
-      const profileName = z.string().parse(inputs.profile.value);
-      const artifactPath = path.resolve(
-        stepsCtx.workingDirectory,
-        z.string().parse(inputs.artifact_path.value)
-      );
-
-      const { config, platform, appIdentifier } = await resolveSubmitConfigAsync({
-        artifactPath,
-        buildId,
-        ctx,
-        env,
-        logger: stepsCtx.logger,
-        profileName,
-        workingDirectory: stepsCtx.workingDirectory,
-      });
-
-      outputs.config_json.set(JSON.stringify(config));
-      outputs.platform.set(platform);
-      if (appIdentifier) {
-        outputs.app_identifier.set(appIdentifier);
-      }
-    },
-  });
-}
-
-export async function resolveSubmitConfigAsync({
-  artifactPath,
-  buildId,
-  ctx,
-  env,
-  logger,
-  profileName,
-  workingDirectory,
-}: {
-  artifactPath: string;
-  buildId: string;
-  ctx: CustomBuildContext;
-  env: BuildStepEnv;
-  logger: bunyan;
-  profileName: string;
-  workingDirectory: string;
-}): Promise<ResolvedSubmitConfig> {
-  logger.info('Resolving submit config...');
-  const build = await getBuildInfoAsync(ctx, buildId);
-
-  switch (build.platform) {
-    case Platform.ANDROID: {
-      const profile = await getSubmitProfileAsync({
-        platform: build.platform,
-        profileName,
-        workingDirectory,
-      });
-      return await resolveAndroidSubmitConfigAsync({
-        artifactPath,
-        build,
-        ctx,
-        env,
-        logger,
-        profile,
-        workingDirectory,
-      });
-    }
-    case Platform.IOS: {
-      const profile = await getSubmitProfileAsync({
-        platform: build.platform,
-        profileName,
-        workingDirectory,
-      });
-      return await resolveIosSubmitConfigAsync({
-        artifactPath,
-        appId: build.appId,
-        buildAppIdentifier: build.appIdentifier,
-        ctx,
-        env,
-        profile,
-        projectOwnerAccountId: build.projectOwnerAccountId,
-        workingDirectory,
-      });
-    }
-    default:
-      throw new SystemError(`Unsupported platform: ${build.platform}`);
-  }
-}

packages/build-tools/src/steps/functions/resolveSubmitConfig/ios.ts

@@ -1,214 +0,0 @@
-import { Platform, SubmissionConfig, UserError } from '@expo/eas-build-job';
-import { SubmitProfile } from '@expo/eas-json';
-import { BuildStepEnv } from '@expo/steps';
-import fs from 'fs-extra';
-import { graphql } from 'gql.tada';
-import path from 'node:path';
-import { z } from 'zod';
-
-import { readIpaInfoAsync } from '../readIpaInfo';
-import { ResolvedSubmitConfig } from './common';
-import { CustomBuildContext } from '../../../customBuildContext';
-
-const APPLE_APP_IDENTIFIER_QUERY = graphql(`
-  query ResolveSubmitConfigAppleAppIdentifier(
-    $accountId: String!
-    $bundleIdentifier: String!
-  ) {
-    account {
-      byId(accountId: $accountId) {
-        id
-        appleAppIdentifiers(bundleIdentifier: $bundleIdentifier) {
-          id
-          bundleIdentifier
-        }
-      }
-    }
-  }
-`);
-
-const IOS_APP_CREDENTIALS_QUERY = graphql(`
-  query ResolveSubmitConfigIosAppCredentials(
-    $appId: String!
-    $appleAppIdentifierId: String!
-  ) {
-    app {
-      byId(appId: $appId) {
-        id
-        iosAppCredentials(filter: { appleAppIdentifierId: $appleAppIdentifierId }) {
-          id
-          appStoreConnectApiKeyForSubmissions {
-            id
-            issuerIdentifier
-            keyIdentifier
-            keyP8
-          }
-        }
-      }
-    }
-  }
-`);
-
-export async function resolveIosSubmitConfigAsync({
-  appId,
-  artifactPath,
-  buildAppIdentifier,
-  ctx,
-  env,
-  profile,
-  projectOwnerAccountId,
-  workingDirectory,
-}: {
-  appId: string;
-  artifactPath: string;
-  buildAppIdentifier?: string | null;
-  ctx: CustomBuildContext;
-  env: BuildStepEnv;
-  profile: SubmitProfile<Platform.IOS>;
-  projectOwnerAccountId: string;
-  workingDirectory: string;
-}): Promise<ResolvedSubmitConfig> {
-  const bundleIdentifier =
-    buildAppIdentifier ??
-    profile.bundleIdentifier ??
-    (await readIpaInfoAsync(artifactPath)).bundleIdentifier;
-
-  if (!profile.ascAppId) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_ASC_APP_ID_NOT_CONFIGURED',
-      'Set ascAppId in the submit profile in eas.json.'
-    );
-  }
-
-  const appSpecificPassword = env.EXPO_APPLE_APP_SPECIFIC_PASSWORD;
-  const configInput: z.input<typeof SubmissionConfig.Ios.SchemaZ> = {
-    ascAppIdentifier: profile.ascAppId,
-    groups: profile.groups,
-    ...(appSpecificPassword
-      ? {
-          appleAppSpecificPassword: validateAppSpecificPassword(appSpecificPassword),
-          appleIdUsername: requireAppleIdUsername(profile.appleId ?? env.EXPO_APPLE_ID),
-        }
-      : {
-          ascApiJsonKey: await getAscApiJsonKeyAsync({
-            accountId: projectOwnerAccountId,
-            appId,
-            bundleIdentifier,
-            ctx,
-            profile,
-            workingDirectory,
-          }),
-        }),
-  };
-
-  return {
-    appIdentifier: bundleIdentifier,
-    config: SubmissionConfig.Ios.SchemaZ.parse(configInput),
-    platform: Platform.IOS,
-  };
-}
-
-async function getAscApiJsonKeyAsync({
-  accountId,
-  appId,
-  bundleIdentifier,
-  ctx,
-  profile,
-  workingDirectory,
-}: {
-  accountId: string;
-  appId: string;
-  bundleIdentifier?: string;
-  ctx: CustomBuildContext;
-  profile: SubmitProfile<Platform.IOS>;
-  workingDirectory: string;
-}): Promise<string> {
-  // Prefer explicit local ASC API key fields from eas.json when all are present.
-  if (profile.ascApiKeyPath && profile.ascApiKeyIssuerId && profile.ascApiKeyId) {
-    return JSON.stringify({
-      issuer_id: profile.ascApiKeyIssuerId,
-      key: await fs.readFile(path.resolve(workingDirectory, profile.ascApiKeyPath), 'utf8'),
-      key_id: profile.ascApiKeyId,
-    });
-  }
-
-  if (profile.ascApiKeyPath || profile.ascApiKeyIssuerId || profile.ascApiKeyId) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_ASC_API_KEY_INCOMPLETE',
-      'ascApiKeyPath, ascApiKeyIssuerId and ascApiKeyId must all be defined in eas.json.'
-    );
-  }
-
-  if (!bundleIdentifier) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_BUNDLE_IDENTIFIER_NOT_FOUND',
-      'Could not resolve iOS bundleIdentifier from build metadata or artifact. Set bundleIdentifier in the iOS submit profile, or pass an IPA artifact with a readable bundle identifier.'
-    );
-  }
-
-  // Server credentials are keyed by the Apple App Identifier, so first map the bundle id to it.
-  const appleAppIdentifierResult = await ctx.graphqlClient
-    .query(APPLE_APP_IDENTIFIER_QUERY, {
-      accountId,
-      bundleIdentifier,
-    })
-    .toPromise();
-  if (appleAppIdentifierResult.error) {
-    throw appleAppIdentifierResult.error;
-  }
-
-  const appleAppIdentifierId =
-    appleAppIdentifierResult.data?.account.byId.appleAppIdentifiers[0]?.id;
-  if (!appleAppIdentifierId) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_APP_IDENTIFIER_NOT_CONFIGURED',
-      `Apple App Identifier is not configured for ${bundleIdentifier}. Configure the bundle identifier in EAS credentials for this account.`
-    );
-  }
-
-  // The app credentials record points at the ASC API key selected for submissions.
-  const credentialsResult = await ctx.graphqlClient
-    .query(IOS_APP_CREDENTIALS_QUERY, {
-      appId,
-      appleAppIdentifierId,
-    })
-    .toPromise();
-  if (credentialsResult.error) {
-    throw credentialsResult.error;
-  }
-
-  const ascApiKey =
-    credentialsResult.data?.app.byId.iosAppCredentials[0]?.appStoreConnectApiKeyForSubmissions;
-  if (!ascApiKey) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_ASC_API_KEY_NOT_CONFIGURED',
-      `App Store Connect API Key for submissions is not configured for ${bundleIdentifier}. Configure an App Store Connect API Key for submissions in EAS credentials, or set ascApiKeyPath, ascApiKeyIssuerId, and ascApiKeyId in the iOS submit profile.`
-    );
-  }
-
-  return JSON.stringify({
-    issuer_id: ascApiKey.issuerIdentifier,
-    key: ascApiKey.keyP8,
-    key_id: ascApiKey.keyIdentifier,
-  });
-}
-
-function validateAppSpecificPassword(password: string): string {
-  if (!/^[a-z]{4}-[a-z]{4}-[a-z]{4}-[a-z]{4}$/.test(password)) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_APP_SPECIFIC_PASSWORD_INVALID',
-      'EXPO_APPLE_APP_SPECIFIC_PASSWORD must be in the format xxxx-xxxx-xxxx-xxxx, where x is a lowercase letter.'
-    );
-  }
-  return password;
-}
-
-function requireAppleIdUsername(appleIdUsername?: string): string {
-  if (!appleIdUsername) {
-    throw new UserError(
-      'EAS_RESOLVE_SUBMIT_CONFIG_IOS_APPLE_ID_NOT_CONFIGURED',
-      'Set appleId in the submit profile or EXPO_APPLE_ID when using EXPO_APPLE_APP_SPECIFIC_PASSWORD.'
-    );
-  }
-  return appleIdUsername;
-}

packages/build-tools/src/steps/functions/restoreBuildCache.ts

@@ -200,7 +200,7 @@ export async function restoreGradleCacheAsync({
   env: Record<string, string | undefined>;
   secrets?: { robotAccessToken?: string };
 }): Promise<void> {
-  if (env.EAS_GRADLE_CACHE !== '1') {
+  if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
     return;
   }
 

packages/build-tools/src/steps/functions/saveBuildCache.ts

@@ -161,7 +161,7 @@ export async function saveGradleCacheAsync({
   env: Record<string, string | undefined>;
   secrets?: { robotAccessToken?: string };
 }): Promise<void> {
-  if (env.EAS_GRADLE_CACHE !== '1') {
+  if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
     return;
   }
 

packages/build-tools/src/steps/functions/startAndroidEmulator.ts

@@ -1,11 +1,5 @@
-import { UserError } from '@expo/eas-build-job';
 import { asyncResult } from '@expo/results';
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
+import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 
 import {
@@ -50,14 +44,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
       }),
     ],
     fn: async ({ logger }, { inputs, env }) => {
-      if (env.EAS_NO_EMULATOR_HOST_SUPPORT_CHECK !== '1') {
-        await assertAndroidEmulatorHostSupportAsync({ env });
-      } else {
-        logger.info(
-          'Skipping Android emulator host support check because $EAS_NO_EMULATOR_HOST_SUPPORT_CHECK is enabled.'
-        );
-      }
-
       try {
         const availableDevices = await AndroidEmulatorUtils.getAvailableDevicesAsync({ env });
         logger.info(`Available Android devices:\n- ${availableDevices.join(`\n- `)}`);
@@ -267,32 +253,3 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
     },
   });
 }
-
-async function assertAndroidEmulatorHostSupportAsync({
-  env,
-}: {
-  env: NodeJS.ProcessEnv;
-}): Promise<void> {
-  const isAndroidEmulatorHostSupported = await isAndroidEmulatorHostSupportedAsync(env);
-  if (!isAndroidEmulatorHostSupported) {
-    throw new UserError(
-      'ANDROID_EMULATOR_ACCEL_CHECK_UNAVAILABLE',
-      'Could not start the Android emulator on this runner.\n\n' +
-        'Android emulator requires nested virtualization on Linux. This job does not have the required virtualization support.\n\n' +
-        'Update your workflow YAML to use a nested-virtualization Linux runner, for example:\n' +
-        '  runs_on: linux-medium-nested-virtualization\n' +
-        '  runs_on: linux-large-nested-virtualization\n\n' +
-        'See https://docs.expo.dev/eas/workflows/syntax/#jobsjob_idruns_on for more information.'
-    );
-  }
-}
-
-async function isAndroidEmulatorHostSupportedAsync(env: NodeJS.ProcessEnv): Promise<boolean> {
-  const androidSdkPath = env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? '';
-  try {
-    await spawn(`${androidSdkPath}/emulator/emulator`, ['-accel-check'], { env });
-    return true;
-  } catch {
-    return false;
-  }
-}

packages/build-tools/src/steps/utils/ios/__tests__/configure.test.ts

@@ -50,47 +50,6 @@ describe(configureCredentialsAsync, () => {
       vol.readFileSync('/app/ios/testapp.xcodeproj/project.pbxproj', 'utf-8')
     ).toMatchSnapshot();
   });
-  it('configures credentials with Apple Development identity for development profile', async () => {
-    vol.fromJSON(
-      {
-        'ios/testapp.xcodeproj/project.pbxproj': originalFs.readFileSync(
-          path.join(__dirname, 'fixtures/simple-project.pbxproj'),
-          'utf-8'
-        ),
-        'ios/testapp/AppDelegate.m': 'placeholder',
-      },
-      '/app'
-    );
-    const options = {
-      credentials: {
-        keychainPath: 'fake/path',
-        targetProvisioningProfiles: {
-          testapp: {
-            path: 'fake/path.mobileprovision',
-            target: 'testapp',
-            bundleIdentifier: 'abc',
-            teamId: 'ABCDEFGH',
-            uuid: 'abc',
-            name: 'profile name',
-            developerCertificate: Buffer.from('test'),
-            certificateCommonName: 'Apple Development: Test User',
-            distributionType: DistributionType.DEVELOPMENT,
-          },
-        },
-        distributionType: DistributionType.DEVELOPMENT,
-        teamId: 'ABCDEFGH',
-        applicationTargetProvisioningProfile: {} as ProvisioningProfile,
-      },
-      buildConfiguration: 'Release',
-    };
-    await configureCredentialsAsync({ info: jest.fn() } as any, '/app', options);
-    const pbxproj = vol.readFileSync(
-      '/app/ios/testapp.xcodeproj/project.pbxproj',
-      'utf-8'
-    ) as string;
-    expect(pbxproj).toContain('CODE_SIGN_IDENTITY = "Apple Development: Test User"');
-    expect(pbxproj).not.toContain('"iPhone Distribution"');
-  });
   it('configures credentials for multi target project', async () => {
     vol.fromJSON(
       {

packages/build-tools/src/steps/utils/ios/__tests__/xcactivitylog.test.ts

@@ -1,504 +0,0 @@
-import downloadFile from '@expo/downloader';
-import spawn from '@expo/turtle-spawn';
-import fs from 'fs-extra';
-import path from 'path';
-
-import { createMockLogger } from '../../../../__tests__/utils/logger';
-import {
-  buildTargetMetrics,
-  isCompileStep,
-  collectTopLevelCompileSteps,
-  formatReport,
-  parseAndReportXcactivitylog,
-} from '../xcactivitylog';
-
-jest.mock('@expo/downloader');
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-// Minimal fixture: two modules with compile steps
-const FIXTURE_TWO_MODULES = {
-  schema: { name: 'TestProject' },
-  subSteps: [
-    {
-      title: 'Build target ModuleA',
-      subSteps: [
-        {
-          detailStepType: 'cCompilation',
-          duration: 5.0,
-          startTimestamp: 100.0,
-          endTimestamp: 103.0,
-          signature: 'CompileC foo.c',
-          subSteps: [],
-        },
-        {
-          detailStepType: 'other',
-          signature: 'SwiftCompile normal bar.swift',
-          duration: 3.0,
-          startTimestamp: 101.0,
-          endTimestamp: 104.0,
-          subSteps: [],
-        },
-      ],
-    },
-    {
-      title: 'Build target ModuleB',
-      subSteps: [
-        {
-          detailStepType: 'compileAssetsCatalog',
-          duration: 2.0,
-          startTimestamp: 200.0,
-          endTimestamp: 202.0,
-          signature: 'CompileAssetCatalog',
-          subSteps: [],
-        },
-      ],
-    },
-    {
-      title: 'Build target TinyModule',
-      subSteps: [
-        {
-          detailStepType: 'cCompilation',
-          duration: 0.1,
-          startTimestamp: 300.0,
-          endTimestamp: 300.1,
-          signature: 'CompileC tiny.c',
-          subSteps: [],
-        },
-      ],
-    },
-  ],
-};
-
-// Fixture: empty data
-const FIXTURE_EMPTY = {
-  schema: { name: 'EmptyProject' },
-  subSteps: [],
-};
-
-// Fixture: no compile steps (only non-compile sub-steps)
-const FIXTURE_NO_COMPILE = {
-  schema: { name: 'NoCompileProject' },
-  subSteps: [
-    {
-      title: 'Build target SomeTarget',
-      subSteps: [
-        {
-          detailStepType: 'linkCommand',
-          duration: 5.0,
-          startTimestamp: 100.0,
-          endTimestamp: 105.0,
-          signature: 'Ld something',
-          subSteps: [],
-        },
-      ],
-    },
-  ],
-};
-
-// Fixture: missing timestamps
-const FIXTURE_MISSING_TIMESTAMPS = {
-  schema: { name: 'MissingTimestamps' },
-  subSteps: [
-    {
-      title: 'Build target PartialModule',
-      subSteps: [
-        {
-          detailStepType: 'cCompilation',
-          duration: 3.0,
-          signature: 'CompileC partial.c',
-          subSteps: [],
-          // no startTimestamp/endTimestamp
-        },
-      ],
-    },
-  ],
-};
-
-// Fixture: nested compile steps (compile step inside non-compile step)
-const FIXTURE_NESTED = {
-  schema: { name: 'NestedProject' },
-  subSteps: [
-    {
-      title: 'Build target NestedModule',
-      subSteps: [
-        {
-          detailStepType: 'scriptExecution',
-          duration: 10.0,
-          startTimestamp: 100.0,
-          endTimestamp: 110.0,
-          signature: 'PhaseScriptExecution',
-          subSteps: [
-            {
-              detailStepType: 'cCompilation',
-              duration: 2.0,
-              startTimestamp: 101.0,
-              endTimestamp: 103.0,
-              signature: 'CompileC nested.c',
-              subSteps: [],
-            },
-          ],
-        },
-      ],
-    },
-  ],
-};
-
-const mockedDownloadFile = jest.mocked(downloadFile);
-const mockedSpawn = jest.mocked(spawn);
-
-function mockFilesystem({
-  tempDir = '/tmp/xclogparser-123',
-  jsonOutput = JSON.stringify(FIXTURE_TWO_MODULES),
-}: {
-  tempDir?: string;
-  jsonOutput?: string;
-} = {}) {
-  jest.spyOn(fs, 'mkdtemp').mockImplementation(async () => tempDir);
-  jest.spyOn(fs, 'chmod').mockImplementation(async () => undefined);
-  jest.spyOn(fs, 'readFile').mockImplementation(async () => jsonOutput);
-  jest.spyOn(fs, 'rm').mockImplementation(async () => undefined);
-
-  return {
-    reportPath: path.join(tempDir, 'xcactivitylog.json'),
-    tempDir,
-  };
-}
-
-describe('parseAndReportXcactivitylog', () => {
-  beforeEach(() => {
-    mockedDownloadFile.mockReset();
-    mockedSpawn.mockReset();
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('downloads xclogparser from GCS and logs only the final report on success', async () => {
-    const logger = createMockLogger();
-    const { tempDir, reportPath } = mockFilesystem();
-
-    mockedDownloadFile.mockResolvedValue(undefined);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-
-    await parseAndReportXcactivitylog({
-      derivedDataPath: '/tmp/derived-data',
-      workspacePath: '/tmp/workspace',
-      logger,
-    });
-
-    expect(mockedDownloadFile).toHaveBeenCalledWith(
-      'https://storage.googleapis.com/turtle-v2/xclogparser/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      path.join(tempDir, 'XCLogParser-macOS-x86-64-arm64-v0.2.46.zip'),
-      { retry: 3, timeout: 20_000 }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      1,
-      'unzip',
-      ['-q', path.join(tempDir, 'XCLogParser-macOS-x86-64-arm64-v0.2.46.zip'), '-d', tempDir],
-      { stdio: 'pipe' }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      2,
-      path.join(tempDir, 'xclogparser'),
-      [
-        'parse',
-        '--derived_data',
-        '/tmp/derived-data',
-        '--workspace',
-        '/tmp/workspace',
-        '--reporter',
-        'json',
-        '--output',
-        reportPath,
-      ],
-      { stdio: 'pipe' }
-    );
-    expect(fs.readFile).toHaveBeenCalledWith(reportPath, 'utf8');
-    expect(logger.info).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith(
-      expect.stringContaining('Xcode Build — Compile Metrics by Module')
-    );
-    expect(logger.debug).not.toHaveBeenCalled();
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-
-  it('tries the proxy URL first and falls back to the direct GCS URL', async () => {
-    const logger = createMockLogger();
-    mockFilesystem();
-
-    mockedDownloadFile
-      .mockRejectedValueOnce(new Error('proxy failed'))
-      .mockResolvedValueOnce(undefined);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-
-    await parseAndReportXcactivitylog({
-      derivedDataPath: '/tmp/derived-data',
-      workspacePath: '/tmp/workspace',
-      logger,
-      proxyBaseUrl: 'https://cache.example.com',
-    });
-
-    expect(mockedDownloadFile).toHaveBeenNthCalledWith(
-      1,
-      'https://cache.example.com/storage.googleapis.com/turtle-v2/xclogparser/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      '/tmp/xclogparser-123/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      { retry: 3, timeout: 20_000 }
-    );
-    expect(mockedDownloadFile).toHaveBeenNthCalledWith(
-      2,
-      'https://storage.googleapis.com/turtle-v2/xclogparser/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      '/tmp/xclogparser-123/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      { retry: 3, timeout: 20_000 }
-    );
-    expect(logger.debug).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      'Failed to prepare xclogparser via the proxy path; falling back to the direct URL'
-    );
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-
-  it('falls back to the direct GCS URL when the proxy download succeeds but unpacking fails', async () => {
-    const logger = createMockLogger();
-    mockFilesystem();
-
-    mockedDownloadFile.mockResolvedValue(undefined);
-    mockedSpawn
-      .mockRejectedValueOnce(new Error('invalid zip'))
-      .mockResolvedValueOnce({ stdout: '', stderr: '' } as any)
-      .mockResolvedValueOnce({ stdout: '', stderr: '' } as any);
-
-    await parseAndReportXcactivitylog({
-      derivedDataPath: '/tmp/derived-data',
-      workspacePath: '/tmp/workspace',
-      logger,
-      proxyBaseUrl: 'https://cache.example.com',
-    });
-
-    expect(mockedDownloadFile).toHaveBeenNthCalledWith(
-      1,
-      'https://cache.example.com/storage.googleapis.com/turtle-v2/xclogparser/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      '/tmp/xclogparser-123/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      { retry: 3, timeout: 20_000 }
-    );
-    expect(mockedDownloadFile).toHaveBeenNthCalledWith(
-      2,
-      'https://storage.googleapis.com/turtle-v2/xclogparser/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      '/tmp/xclogparser-123/XCLogParser-macOS-x86-64-arm64-v0.2.46.zip',
-      { retry: 3, timeout: 20_000 }
-    );
-    expect(logger.debug).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      'Failed to prepare xclogparser via the proxy path; falling back to the direct URL'
-    );
-    expect(logger.info).toHaveBeenCalledWith(
-      expect.stringContaining('Xcode Build — Compile Metrics by Module')
-    );
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-
-  it('skips reporting and logs debug when the JSON output is invalid', async () => {
-    const logger = createMockLogger();
-    mockFilesystem({ jsonOutput: '{not valid json' });
-
-    mockedDownloadFile.mockResolvedValue(undefined);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-
-    await expect(
-      parseAndReportXcactivitylog({
-        derivedDataPath: '/tmp/derived-data',
-        workspacePath: '/tmp/workspace',
-        logger,
-      })
-    ).resolves.toBeUndefined();
-
-    expect(logger.info).not.toHaveBeenCalled();
-    expect(logger.debug).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      'Failed to analyze build performance; continuing without a report'
-    );
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-
-  it('skips reporting and logs debug when the JSON output does not match the expected schema', async () => {
-    const logger = createMockLogger();
-    mockFilesystem({
-      jsonOutput: JSON.stringify({
-        schema: { name: 'BadProject' },
-        subSteps: [{ title: 123, subSteps: [] }],
-      }),
-    });
-
-    mockedDownloadFile.mockResolvedValue(undefined);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-
-    await expect(
-      parseAndReportXcactivitylog({
-        derivedDataPath: '/tmp/derived-data',
-        workspacePath: '/tmp/workspace',
-        logger,
-      })
-    ).resolves.toBeUndefined();
-
-    expect(logger.info).not.toHaveBeenCalled();
-    expect(logger.debug).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      'Failed to analyze build performance; continuing without a report'
-    );
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-
-  it('swallows cleanup failures without emitting additional logs', async () => {
-    const logger = createMockLogger();
-    mockFilesystem();
-    jest.spyOn(fs, 'rm').mockImplementation(async () => {
-      throw new Error('cleanup failed');
-    });
-
-    mockedDownloadFile.mockResolvedValue(undefined);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-
-    await expect(
-      parseAndReportXcactivitylog({
-        derivedDataPath: '/tmp/derived-data',
-        workspacePath: '/tmp/workspace',
-        logger,
-      })
-    ).resolves.toBeUndefined();
-
-    expect(logger.info).toHaveBeenCalledTimes(1);
-    expect(logger.debug).not.toHaveBeenCalled();
-    expect(logger.warn).not.toHaveBeenCalled();
-  });
-});
-
-describe('isCompileStep', () => {
-  it('identifies cCompilation', () => {
-    expect(isCompileStep({ detailStepType: 'cCompilation', signature: '' })).toBe(true);
-  });
-
-  it('identifies compileAssetsCatalog', () => {
-    expect(isCompileStep({ detailStepType: 'compileAssetsCatalog', signature: '' })).toBe(true);
-  });
-
-  it('identifies compileStoryboard', () => {
-    expect(isCompileStep({ detailStepType: 'compileStoryboard', signature: '' })).toBe(true);
-  });
-
-  it('identifies SwiftCompile by signature prefix', () => {
-    expect(
-      isCompileStep({ detailStepType: 'other', signature: 'SwiftCompile normal foo.swift' })
-    ).toBe(true);
-  });
-
-  it('identifies SwiftGeneratePch by signature prefix', () => {
-    expect(isCompileStep({ detailStepType: 'other', signature: 'SwiftGeneratePch normal' })).toBe(
-      true
-    );
-  });
-
-  it('rejects non-compile steps', () => {
-    expect(isCompileStep({ detailStepType: 'linkCommand', signature: 'Ld something' })).toBe(false);
-  });
-
-  it('handles missing fields gracefully', () => {
-    expect(isCompileStep({})).toBe(false);
-  });
-});
-
-describe('collectTopLevelCompileSteps', () => {
-  it('collects direct compile children', () => {
-    const target = FIXTURE_TWO_MODULES.subSteps[0]; // ModuleA
-    const result = collectTopLevelCompileSteps(target);
-    expect(result).toHaveLength(2);
-  });
-
-  it('finds nested compile steps through non-compile parents', () => {
-    const target = FIXTURE_NESTED.subSteps[0]; // NestedModule
-    const result = collectTopLevelCompileSteps(target);
-    expect(result).toHaveLength(1);
-    expect(result[0].detailStepType).toBe('cCompilation');
-  });
-
-  it('returns empty array when no compile steps', () => {
-    const target = FIXTURE_NO_COMPILE.subSteps[0];
-    const result = collectTopLevelCompileSteps(target);
-    expect(result).toHaveLength(0);
-  });
-});
-
-describe('buildTargetMetrics', () => {
-  it('returns metrics sorted by taskSeconds descending', () => {
-    const { results } = buildTargetMetrics(FIXTURE_TWO_MODULES);
-    expect(results.length).toBeGreaterThan(0);
-    for (let i = 1; i < results.length; i++) {
-      expect(results[i - 1].taskSeconds).toBeGreaterThanOrEqual(results[i].taskSeconds);
-    }
-  });
-
-  it('computes correct taskSeconds for ModuleA', () => {
-    const { results } = buildTargetMetrics(FIXTURE_TWO_MODULES);
-    const moduleA = results.find(r => r.moduleName === 'ModuleA');
-    expect(moduleA).toBeDefined();
-    expect(moduleA!.taskSeconds).toBeCloseTo(8.0); // 5.0 + 3.0
-  });
-
-  it('computes correct wallSpan for ModuleA with overlapping intervals', () => {
-    const { results } = buildTargetMetrics(FIXTURE_TWO_MODULES);
-    const moduleA = results.find(r => r.moduleName === 'ModuleA');
-    expect(moduleA).toBeDefined();
-    // intervals: [100, 103] and [101, 104] → wall span = 104 - 100 = 4.0
-    expect(moduleA!.wallSpan).toBeCloseTo(4.0);
-  });
-
-  it('filters out modules below minTaskSeconds threshold', () => {
-    const { results } = buildTargetMetrics(FIXTURE_TWO_MODULES);
-    const tinyModule = results.find(r => r.moduleName === 'TinyModule');
-    expect(tinyModule).toBeUndefined(); // 0.1s < 0.5s default threshold
-  });
-
-  it('allows custom minTaskSeconds threshold', () => {
-    const { results } = buildTargetMetrics(FIXTURE_TWO_MODULES, { minTaskSeconds: 0 });
-    const tinyModule = results.find(r => r.moduleName === 'TinyModule');
-    expect(tinyModule).toBeDefined();
-  });
-
-  it('returns empty results for empty data', () => {
-    const { results, totalTaskSeconds } = buildTargetMetrics(FIXTURE_EMPTY);
-    expect(results).toHaveLength(0);
-    expect(totalTaskSeconds).toBe(0);
-  });
-
-  it('handles missing timestamps gracefully', () => {
-    const { results } = buildTargetMetrics(FIXTURE_MISSING_TIMESTAMPS);
-    const mod = results.find(r => r.moduleName === 'PartialModule');
-    expect(mod).toBeDefined();
-    expect(mod!.taskSeconds).toBeCloseTo(3.0);
-    expect(mod!.wallSpan).toBe(0); // no valid intervals
-  });
-});
-
-describe('formatReport', () => {
-  it('produces table with header and module rows', () => {
-    const report = formatReport(FIXTURE_TWO_MODULES);
-    expect(report).toContain('Xcode Build — Compile Metrics by Module');
-    expect(report).toContain('ModuleA');
-    expect(report).toContain('ModuleB');
-    expect(report).toContain('TOTAL');
-    expect(report).toContain('% Task');
-  });
-
-  it('does not include modules below threshold', () => {
-    const report = formatReport(FIXTURE_TWO_MODULES);
-    expect(report).not.toContain('TinyModule');
-  });
-
-  it('handles empty data without crashing', () => {
-    const report = formatReport(FIXTURE_EMPTY);
-    expect(report).toContain('Xcode Build — Compile Metrics by Module');
-    expect(report).toContain('TOTAL');
-  });
-});

packages/build-tools/src/steps/utils/ios/configure.ts

@@ -6,7 +6,6 @@ import uniq from 'lodash/uniq';
 import path from 'path';
 
 import { Credentials } from './credentials/manager';
-import { DistributionType } from './credentials/provisioningProfile';
 
 export async function configureCredentialsAsync(
   logger: bunyan,
@@ -30,9 +29,6 @@ export async function configureCredentialsAsync(
       profileName: profile.name,
       appleTeamId: profile.teamId,
       buildConfiguration,
-      ...(credentials.distributionType === DistributionType.DEVELOPMENT && {
-        codeSignIdentity: profile.certificateCommonName,
-      }),
     });
   }
 }

packages/build-tools/src/steps/utils/ios/credentials/provisioningProfile.ts

@@ -23,7 +23,6 @@ export interface ProvisioningProfileData {
 export enum DistributionType {
   AD_HOC = 'ad-hoc',
   APP_STORE = 'app-store',
-  DEVELOPMENT = 'development',
   ENTERPRISE = 'enterprise',
 }
 
@@ -134,10 +133,6 @@ export default class ProvisioningProfile {
     if (plistData.ProvisionsAllDevices) {
       return DistributionType.ENTERPRISE;
     } else if (plistData.ProvisionedDevices) {
-      const entitlements = plistData.Entitlements as plist.PlistObject | undefined;
-      if (entitlements?.['get-task-allow']) {
-        return DistributionType.DEVELOPMENT;
-      }
       return DistributionType.AD_HOC;
     } else {
       return DistributionType.APP_STORE;

packages/build-tools/src/steps/utils/ios/xcactivitylog.ts

@@ -1,418 +0,0 @@
-import downloadFile from '@expo/downloader';
-import { bunyan } from '@expo/logger';
-import { asyncResult } from '@expo/results';
-import spawn from '@expo/turtle-spawn';
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { z } from 'zod';
-
-const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.46';
-const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclogparser';
-const XCLOGPARSER_DOWNLOAD_TIMEOUT_MS = 20_000;
-const XCLOGPARSER_OUTPUT_FILENAME = 'xcactivitylog.json';
-
-/**
- * Download xclogparser, parse xcactivitylog from derived data, and log a
- * compile metrics report. Never throws — all errors are logged at debug level.
- *
- * Can be called from both the step-based flow (BuildFunction) and the
- * traditional builder flow (runBuildPhase).
- */
-export async function parseAndReportXcactivitylog({
-  derivedDataPath,
-  workspacePath,
-  xclogparserVersion = DEFAULT_XCLOGPARSER_VERSION,
-  logger,
-  proxyBaseUrl,
-}: {
-  derivedDataPath: string;
-  workspacePath: string;
-  xclogparserVersion?: string;
-  logger: bunyan;
-  proxyBaseUrl?: string;
-}): Promise<void> {
-  let tempDir: string | undefined;
-  try {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'xclogparser-'));
-    const xclogparserPath = await downloadXclogparser(
-      tempDir,
-      xclogparserVersion,
-      logger,
-      proxyBaseUrl
-    );
-    const jsonOutputPath = await runXclogparser({
-      binaryPath: xclogparserPath,
-      derivedDataPath,
-      workspacePath,
-      outputDir: tempDir,
-    });
-    const data = XcactivitylogDataSchemaZ.parse(
-      JSON.parse(await fs.readFile(jsonOutputPath, 'utf8'))
-    );
-    logger.info(formatReport(data));
-  } catch (err: unknown) {
-    logger.debug({ err }, 'Failed to analyze build performance; continuing without a report');
-  } finally {
-    if (tempDir) {
-      await asyncResult(fs.rm(tempDir, { force: true, recursive: true }));
-    }
-  }
-}
-
-async function downloadXclogparser(
-  tempDir: string,
-  version: string,
-  logger: bunyan,
-  proxyBaseUrl?: string
-): Promise<string> {
-  const zipName = getXclogparserZipName(version);
-  const zipPath = path.join(tempDir, zipName);
-  const directUrl = `${XCLOGPARSER_DOWNLOAD_URL}/${zipName}`;
-  const proxiedUrl = getProxiedDownloadUrl({ directUrl, proxyBaseUrl });
-
-  if (proxiedUrl) {
-    const proxiedDownloadResult = await asyncResult(
-      downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl: proxiedUrl })
-    );
-    if (!proxiedDownloadResult.ok) {
-      logger.debug(
-        { err: proxiedDownloadResult.reason },
-        'Failed to prepare xclogparser via the proxy path; falling back to the direct URL'
-      );
-      await cleanupXclogparserArtifacts({ tempDir, zipPath });
-    } else {
-      return proxiedDownloadResult.value;
-    }
-  }
-
-  return await downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl: directUrl });
-}
-
-async function downloadAndUnpackXclogparser({
-  tempDir,
-  zipPath,
-  sourceUrl,
-}: {
-  tempDir: string;
-  zipPath: string;
-  sourceUrl: string;
-}): Promise<string> {
-  await downloadFile(sourceUrl, zipPath, { retry: 3, timeout: XCLOGPARSER_DOWNLOAD_TIMEOUT_MS });
-
-  return await unpackXclogparser({ tempDir, zipPath });
-}
-
-async function unpackXclogparser({
-  tempDir,
-  zipPath,
-}: {
-  tempDir: string;
-  zipPath: string;
-}): Promise<string> {
-  await spawn('unzip', ['-q', zipPath, '-d', tempDir], { stdio: 'pipe' });
-
-  const binaryPath = path.join(tempDir, 'xclogparser');
-  await fs.chmod(binaryPath, 0o755);
-  return binaryPath;
-}
-
-async function cleanupXclogparserArtifacts({
-  tempDir,
-  zipPath,
-}: {
-  tempDir: string;
-  zipPath: string;
-}): Promise<void> {
-  await asyncResult(fs.rm(zipPath, { force: true }));
-  await asyncResult(fs.rm(path.join(tempDir, 'xclogparser'), { force: true }));
-}
-
-async function runXclogparser({
-  binaryPath,
-  derivedDataPath,
-  workspacePath,
-  outputDir,
-}: {
-  binaryPath: string;
-  derivedDataPath: string;
-  workspacePath: string;
-  outputDir: string;
-}): Promise<string> {
-  const outputPath = path.join(outputDir, XCLOGPARSER_OUTPUT_FILENAME);
-
-  await spawn(
-    binaryPath,
-    [
-      'parse',
-      '--derived_data',
-      derivedDataPath,
-      '--workspace',
-      workspacePath,
-      '--reporter',
-      'json',
-      '--output',
-      outputPath,
-    ],
-    { stdio: 'pipe' }
-  );
-
-  return outputPath;
-}
-
-const XcactivitylogStepSchemaZ = z.object({
-  title: z.string().optional(),
-  detailStepType: z.string().optional(),
-  signature: z.string().optional(),
-  duration: z.number().optional(),
-  startTimestamp: z.number().optional(),
-  endTimestamp: z.number().optional(),
-  get subSteps() {
-    return z.array(XcactivitylogStepSchemaZ).optional();
-  },
-});
-
-const XcactivitylogDataSchemaZ = z.object({
-  schema: z.union([z.string(), z.object({ name: z.string().optional() })]).optional(),
-  subSteps: z.array(XcactivitylogStepSchemaZ).optional(),
-});
-
-type XcactivitylogStep = z.infer<typeof XcactivitylogStepSchemaZ>;
-type XcactivitylogData = z.infer<typeof XcactivitylogDataSchemaZ>;
-
-interface TargetMetric {
-  moduleName: string;
-  taskSeconds: number;
-  wallSpan: number;
-  activeWallTime: number;
-}
-
-interface Interval {
-  start: number;
-  end: number;
-}
-
-const COMPILE_DETAIL_TYPES = new Set(['cCompilation', 'compileAssetsCatalog', 'compileStoryboard']);
-
-const COMPILE_SIGNATURE_PREFIXES = ['SwiftCompile ', 'SwiftGeneratePch '];
-
-function getXclogparserZipName(version: string): string {
-  return `XCLogParser-macOS-x86-64-arm64-${version}.zip`;
-}
-
-function getProxiedDownloadUrl({
-  directUrl,
-  proxyBaseUrl,
-}: {
-  directUrl: string;
-  proxyBaseUrl?: string;
-}): string | null {
-  if (!proxyBaseUrl) {
-    return null;
-  }
-
-  const parsedUrl = new URL(directUrl);
-  return directUrl.replace(
-    `${parsedUrl.protocol}//${parsedUrl.host}`,
-    `${proxyBaseUrl}/${parsedUrl.host}`
-  );
-}
-
-export function isCompileStep(step: Partial<XcactivitylogStep>): boolean {
-  const detailStepType = step.detailStepType ?? '';
-  const signature = step.signature ?? '';
-
-  if (COMPILE_DETAIL_TYPES.has(detailStepType)) {
-    return true;
-  }
-
-  return COMPILE_SIGNATURE_PREFIXES.some(prefix => signature.startsWith(prefix));
-}
-
-export function collectTopLevelCompileSteps(
-  step: XcactivitylogStep,
-  results: XcactivitylogStep[] = []
-): XcactivitylogStep[] {
-  for (const child of step.subSteps ?? []) {
-    if (isCompileStep(child)) {
-      results.push(child);
-      continue;
-    }
-    collectTopLevelCompileSteps(child, results);
-  }
-  return results;
-}
-
-function intervalFromStep(step: XcactivitylogStep): Interval | null {
-  if (typeof step.startTimestamp !== 'number' || typeof step.endTimestamp !== 'number') {
-    return null;
-  }
-  return { start: step.startTimestamp, end: step.endTimestamp };
-}
-
-function computeActiveWallTime(intervals: Interval[]): number {
-  if (intervals.length === 0) {
-    return 0;
-  }
-
-  const sorted = [...intervals].sort((a, b) => a.start - b.start);
-  let activeWallTime = 0;
-  let currentStart = sorted[0].start;
-  let currentEnd = sorted[0].end;
-
-  for (const interval of sorted.slice(1)) {
-    if (interval.start <= currentEnd) {
-      currentEnd = Math.max(currentEnd, interval.end);
-      continue;
-    }
-    activeWallTime += currentEnd - currentStart;
-    currentStart = interval.start;
-    currentEnd = interval.end;
-  }
-
-  activeWallTime += currentEnd - currentStart;
-  return activeWallTime;
-}
-
-export function buildTargetMetrics(
-  data: XcactivitylogData,
-  { minTaskSeconds = 0.5 }: { minTaskSeconds?: number } = {}
-): { results: TargetMetric[]; totalTaskSeconds: number } {
-  const results: TargetMetric[] = [];
-
-  for (const step of data.subSteps ?? []) {
-    const title = step.title ?? '';
-    if (!title.startsWith('Build target ')) {
-      continue;
-    }
-
-    const moduleName = title.replace('Build target ', '');
-    const compileSteps = collectTopLevelCompileSteps(step);
-    const taskSeconds = compileSteps.reduce((sum, s) => sum + (s.duration ?? 0), 0);
-
-    if (taskSeconds < minTaskSeconds) {
-      continue;
-    }
-
-    const intervals = compileSteps.map(intervalFromStep).filter((i): i is Interval => i !== null);
-    const minStart = intervals.length > 0 ? Math.min(...intervals.map(i => i.start)) : 0;
-    const maxEnd = intervals.length > 0 ? Math.max(...intervals.map(i => i.end)) : 0;
-    const wallSpan = intervals.length > 0 ? maxEnd - minStart : 0;
-    const activeWallTime = computeActiveWallTime(intervals);
-
-    results.push({ moduleName, taskSeconds, wallSpan, activeWallTime });
-  }
-
-  results.sort((a, b) => {
-    if (b.taskSeconds !== a.taskSeconds) {
-      return b.taskSeconds - a.taskSeconds;
-    }
-    if (b.wallSpan !== a.wallSpan) {
-      return b.wallSpan - a.wallSpan;
-    }
-    return a.moduleName.localeCompare(b.moduleName);
-  });
-
-  const totalTaskSeconds = results.reduce((sum, r) => sum + r.taskSeconds, 0);
-
-  return { results, totalTaskSeconds };
-}
-
-function formatSeconds(value: number): string {
-  return `${value.toFixed(1)}s`;
-}
-
-export function formatReport(data: XcactivitylogData): string {
-  const { results, totalTaskSeconds } = buildTargetMetrics(data);
-
-  const nameWidth = Math.max(6, ...results.map(r => r.moduleName.length)) + 2;
-  const taskWidth = 10;
-  const pctWidth = 8;
-  const wallWidth = 10;
-  const barMaxWidth = 20;
-  const maxTaskSeconds = results[0]?.taskSeconds ?? 1;
-
-  const header =
-    '┌─' +
-    '─'.repeat(nameWidth) +
-    '─┬────────────┬──────────┬────────────┬─' +
-    '─'.repeat(barMaxWidth) +
-    '─┐';
-  const divider =
-    '├─' +
-    '─'.repeat(nameWidth) +
-    '─┼────────────┼──────────┼────────────┼─' +
-    '─'.repeat(barMaxWidth) +
-    '─┤';
-  const footer =
-    '└─' +
-    '─'.repeat(nameWidth) +
-    '─┴────────────┴──────────┴────────────┴─' +
-    '─'.repeat(barMaxWidth) +
-    '─┘';
-
-  const lines: string[] = [];
-
-  lines.push('');
-  lines.push('Xcode Build — Compile Metrics by Module');
-  lines.push(
-    `Schema: ${typeof data.schema === 'string' ? data.schema : (data.schema?.name ?? 'unknown')}`
-  );
-  lines.push('% Task = share of total Compile Task Seconds');
-  lines.push('Wall = first compile start to last compile end');
-  lines.push('');
-  lines.push(header);
-  lines.push(
-    '│ ' +
-      'Module'.padEnd(nameWidth) +
-      ' │ ' +
-      'Task'.padStart(taskWidth) +
-      ' │ ' +
-      '% Task'.padStart(pctWidth) +
-      ' │ ' +
-      'Wall'.padStart(wallWidth) +
-      ' │ ' +
-      ' '.repeat(barMaxWidth) +
-      ' │'
-  );
-  lines.push(divider);
-
-  for (const result of results) {
-    const pct = totalTaskSeconds === 0 ? 0 : (result.taskSeconds / totalTaskSeconds) * 100;
-    const barLength = Math.round((result.taskSeconds / maxTaskSeconds) * barMaxWidth);
-    const bar = '█'.repeat(barLength) + '░'.repeat(barMaxWidth - barLength);
-
-    lines.push(
-      '│ ' +
-        result.moduleName.padEnd(nameWidth) +
-        ' │ ' +
-        formatSeconds(result.taskSeconds).padStart(taskWidth) +
-        ' │ ' +
-        `${pct.toFixed(1)}%`.padStart(pctWidth) +
-        ' │ ' +
-        formatSeconds(result.wallSpan).padStart(wallWidth) +
-        ' │ ' +
-        bar +
-        ' │'
-    );
-  }
-
-  lines.push(divider);
-  lines.push(
-    '│ ' +
-      'TOTAL'.padEnd(nameWidth) +
-      ' │ ' +
-      formatSeconds(totalTaskSeconds).padStart(taskWidth) +
-      ' │ ' +
-      '100.0%'.padStart(pctWidth) +
-      ' │ ' +
-      'n/a'.padStart(wallWidth) +
-      ' │ ' +
-      ' '.repeat(barMaxWidth) +
-      ' │'
-  );
-  lines.push(footer);
-  lines.push('');
-
-  return lines.join('\n');
-}

packages/build-tools/src/templates/GymfileArchive.ts

@@ -20,9 +20,5 @@ export_xcargs "OTHER_CODE_SIGN_FLAGS=\\"--keychain <%- KEYCHAIN_PATH %>\\""
 disable_xcpretty(true)
 buildlog_path("<%- LOGS_DIRECTORY %>")
 
-derived_data_path("<%- DERIVED_DATA_PATH %>")
-result_bundle(true)
-result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
-
 output_directory("<%- OUTPUT_DIRECTORY %>")
 `;

packages/build-tools/src/templates/GymfileSimulator.ts

@@ -13,7 +13,4 @@ destination("<%- SCHEME_SIMULATOR_DESTINATION %>")
 
 disable_xcpretty(true)
 buildlog_path("<%- LOGS_DIRECTORY %>")
-
-result_bundle(true)
-result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;

packages/build-tools/src/utils/__integration-tests__/findMaestroPathsFlowsToExecuteAsync.test.ts

@@ -0,0 +1,400 @@
+import spawnAsync from '@expo/spawn-async';
+import bunyan from 'bunyan';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+
+import { createMockLogger } from '../../__tests__/utils/logger';
+import { findMaestroPathsFlowsToExecuteAsync } from '../findMaestroPathsFlowsToExecuteAsync';
+
+// We use node:fs
+jest.unmock('node:fs');
+// and fg uses fs.
+jest.unmock('fs');
+jest.setTimeout(15000);
+
+/**
+ *
+ * You need to have a Simulator running to run these tests.
+ *
+ */
+
+describe('findMaestroPathsFlowsToExecuteAsync', () => {
+  const fixturesDir = path.join(__dirname, 'fixtures', 'maestro-flows');
+  const singleFileDir = path.join(__dirname, 'fixtures', 'single-file');
+  const configFlowsDir = path.join(__dirname, 'fixtures', 'config-flows');
+  const noConfigFlowsDir = path.join(__dirname, 'fixtures', 'no-config-flows');
+
+  let logger: bunyan;
+
+  beforeAll(() => {
+    logger = createMockLogger();
+  });
+
+  // Helper function to run maestro test and determine which flows it executed
+  // by parsing the output
+  async function getMaestroFlowList(
+    flowPath: string,
+    includeTags: string[] = [],
+    excludeTags: string[] = []
+  ): Promise<string[]> {
+    const args = ['test', flowPath, '--no-ansi'];
+
+    if (includeTags.length > 0) {
+      args.push('--include-tags', includeTags.join(','));
+    }
+
+    if (excludeTags.length > 0) {
+      args.push('--exclude-tags', excludeTags.join(','));
+    }
+
+    try {
+      const result = await spawnAsync('maestro', args, {
+        stdio: 'pipe',
+      });
+
+      return parseMaestroExecutedFlows(result.stdout + result.stderr);
+    } catch (error: any) {
+      const output = (error.stdout || '') + (error.stderr || '') + (error.message || '');
+      return parseMaestroExecutedFlows(output);
+    }
+  }
+
+  function parseMaestroExecutedFlows(output: string): string[] {
+    return output
+      .split('\n')
+      .filter(line => line.includes('[Passed]') || line.includes('> Flow'))
+      .map(line => {
+        if (line.includes('[Passed]')) {
+          return line.split('[Passed]')[1].trim().split(' ')[0];
+        }
+        return line.split('> Flow')[1].trim();
+      })
+      .sort();
+  }
+
+  // Helper function to run our implementation
+  async function getOurFlowList(
+    flowPath: string,
+    includeTags: string[] = [],
+    excludeTags: string[] = []
+  ): Promise<string[]> {
+    const result = await findMaestroPathsFlowsToExecuteAsync({
+      workingDirectory: process.cwd(),
+      flowPath: path.relative(process.cwd(), flowPath),
+      includeTags,
+      excludeTags,
+      logger,
+    });
+
+    return result.map(filePath => path.basename(filePath, path.extname(filePath))).sort();
+  }
+
+  describe('Directory-based flow discovery', () => {
+    it('should discover all flows when no tags are specified', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir);
+      const ourFlows = await getOurFlowList(fixturesDir);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should filter flows by include tags', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, ['auth']);
+      const ourFlows = await getOurFlowList(fixturesDir, ['auth']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should filter flows by exclude tags', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, [], ['slow']);
+      const ourFlows = await getOurFlowList(fixturesDir, [], ['slow']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should filter flows by both include and exclude tags', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, ['smoke'], ['regression']);
+      const ourFlows = await getOurFlowList(fixturesDir, ['smoke'], ['regression']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should handle multiple include tags', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, ['auth', 'smoke']);
+      const ourFlows = await getOurFlowList(fixturesDir, ['auth', 'smoke']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should handle multiple exclude tags', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, [], ['slow', 'regression']);
+      const ourFlows = await getOurFlowList(fixturesDir, [], ['slow', 'regression']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should not include nested flows in subdirectories', async () => {
+      const maestroFlows = await getMaestroFlowList(fixturesDir, ['nested']);
+      const ourFlows = await getOurFlowList(fixturesDir, ['nested']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+    });
+
+    it('should exclude config files from flow discovery', async () => {
+      const ourFlows = await getOurFlowList(fixturesDir);
+
+      expect(ourFlows.every(flow => !flow.endsWith('config.yaml'))).toBe(true);
+      expect(ourFlows.every(flow => !flow.endsWith('config.yml'))).toBe(true);
+    });
+
+    it('should exclude non-YAML files from flow discovery', async () => {
+      const ourFlows = await getOurFlowList(fixturesDir);
+
+      expect(ourFlows).not.toContain('non-flow-file');
+    });
+  });
+
+  describe('Single file scenarios', () => {
+    it('should handle single file input', async () => {
+      const singleFile = path.join(singleFileDir, 'standalone-flow.yaml');
+
+      const maestroFlows = await getMaestroFlowList(singleFile);
+      const ourFlows = await getOurFlowList(singleFile);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      expect(ourFlows).toHaveLength(1);
+      expect(ourFlows[0]).toBe(path.basename(singleFile, path.extname(singleFile)));
+    });
+
+    it('should handle single file with tag filtering (include)', async () => {
+      const singleFile = path.join(singleFileDir, 'standalone-flow.yaml');
+
+      // This file has 'smoke' tag, so should be included
+      const maestroFlows = await getMaestroFlowList(singleFile, ['smoke']);
+      const ourFlows = await getOurFlowList(singleFile, ['smoke']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      expect(ourFlows).toHaveLength(1);
+    });
+
+    it('should handle single file with tag filtering (exclude)', async () => {
+      const singleFile = path.join(singleFileDir, 'standalone-flow.yaml');
+
+      // This file has 'smoke' tag, so should be excluded
+      const maestroFlows = await getMaestroFlowList(singleFile, [], ['smoke']);
+      const ourFlows = await getOurFlowList(singleFile, [], ['smoke']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      expect(ourFlows).toHaveLength(1);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle non-existent paths gracefully', async () => {
+      const nonExistentPath = '/path/that/does/not/exist';
+
+      // Our implementation should return empty array for non-existent paths
+      await expect(getOurFlowList(nonExistentPath)).rejects.toThrow('ENOENT');
+    });
+
+    it('should handle empty directories', async () => {
+      const emptyDir = path.join(__dirname, 'fixtures', 'empty-dir');
+      await fs.mkdir(emptyDir, { recursive: true });
+
+      try {
+        const ourFlows = await getOurFlowList(emptyDir);
+        expect(ourFlows).toEqual([]);
+      } finally {
+        await fs.rmdir(emptyDir);
+      }
+    });
+
+    it('should handle flows that cannot be parsed', async () => {
+      // The invalid-flow.yaml has extra fields that might cause parsing issues
+      // but should still be discovered if tag filtering passes
+      const ourFlows = await getOurFlowList(fixturesDir, ['invalid']);
+
+      // Should either include the file (if parsing is lenient) or exclude it (if parsing fails)
+      // The important thing is that it doesn't crash
+      expect(Array.isArray(ourFlows)).toBe(true);
+    });
+  });
+
+  describe('Performance comparison', () => {
+    it('should complete discovery in reasonable time', async () => {
+      const startTime = Date.now();
+
+      await getOurFlowList(fixturesDir);
+
+      const duration = Date.now() - startTime;
+      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
+    });
+  });
+
+  describe('Detailed flow content verification', () => {
+    it('should correctly identify flows with specific tag combinations', async () => {
+      // Test complex tag filtering scenarios
+      const authFlows = await getOurFlowList(fixturesDir, ['auth']);
+      const smokeFlows = await getOurFlowList(fixturesDir, ['smoke']);
+      const criticalFlows = await getOurFlowList(fixturesDir, ['critical']);
+
+      // Verify specific files are included/excluded correctly
+      expect(authFlows).toContain('tagged-flow-auth');
+      expect(authFlows).not.toContain('nested-flow'); // Subdirectory flows excluded by default
+      expect(smokeFlows).toContain('tagged-flow-smoke');
+      expect(criticalFlows).toContain('tagged-flow-smoke');
+    });
+
+    it('should handle flows without tags correctly', async () => {
+      // When no filters are applied, flows without tags should be included
+      const allFlows = await getOurFlowList(fixturesDir);
+      expect(allFlows).toContain('no-tags-flow');
+      expect(allFlows).toContain('basic-flow');
+
+      // When include tags are specified, flows without tags should be excluded
+      const taggedFlows = await getOurFlowList(fixturesDir, ['auth']);
+      expect(taggedFlows).not.toContain('no-tags-flow');
+      expect(taggedFlows).not.toContain('basic-flow');
+    });
+  });
+
+  describe('config.yaml flow patterns', () => {
+    it('should discover flows using config.yaml patterns', async () => {
+      const maestroFlows = await getMaestroFlowList(configFlowsDir);
+      const ourFlows = await getOurFlowList(configFlowsDir);
+
+      expect(ourFlows).toEqual(maestroFlows);
+
+      // Verify specific files are included based on config patterns
+      expect(ourFlows).toContain('login'); // features/auth/login.yaml
+      expect(ourFlows).toContain('logout'); // features/auth/logout.yaml
+      expect(ourFlows).toContain('navigation'); // features/core/navigation.yaml
+      expect(ourFlows).toContain('api.spec'); // specs/api.spec.yaml
+      expect(ourFlows).toContain('ui.spec'); // specs/ui.spec.yaml
+
+      // Verify top-level file is excluded (not matching patterns)
+      expect(ourFlows).not.toContain('ignored-top-level');
+    });
+
+    it('should handle tag filtering with config.yaml patterns', async () => {
+      const authFlows = await getOurFlowList(configFlowsDir, ['auth']);
+      const maestroAuthFlows = await getMaestroFlowList(configFlowsDir, ['auth']);
+
+      expect(authFlows).toEqual(maestroAuthFlows);
+      expect(authFlows).toContain('login');
+      expect(authFlows).toContain('logout');
+      expect(authFlows).not.toContain('navigation');
+      expect(authFlows).not.toContain('api.spec');
+    });
+
+    it('should handle exclude tags with config.yaml patterns', async () => {
+      const nonSmokeFlows = await getOurFlowList(configFlowsDir, [], ['smoke']);
+      const maestroNonSmokeFlows = await getMaestroFlowList(configFlowsDir, [], ['smoke']);
+
+      expect(nonSmokeFlows).toEqual(maestroNonSmokeFlows);
+      expect(nonSmokeFlows).not.toContain('login'); // has smoke tag
+      expect(nonSmokeFlows).not.toContain('navigation'); // has smoke tag
+      expect(nonSmokeFlows).toContain('logout'); // no smoke tag
+      expect(nonSmokeFlows).toContain('api.spec'); // no smoke tag
+    });
+
+    it('should handle multiple include tags with config.yaml patterns', async () => {
+      const multiTagFlows = await getOurFlowList(configFlowsDir, ['auth', 'integration']);
+      const maestroMultiTagFlows = await getMaestroFlowList(configFlowsDir, [
+        'auth',
+        'integration',
+      ]);
+
+      expect(multiTagFlows).toEqual(maestroMultiTagFlows);
+      expect(multiTagFlows).toContain('login'); // auth tag
+      expect(multiTagFlows).toContain('logout'); // auth tag
+      expect(multiTagFlows).toContain('api.spec'); // integration tag
+      expect(multiTagFlows).toContain('ui.spec'); // integration tag
+      expect(multiTagFlows).not.toContain('navigation'); // only core/smoke tags
+    });
+  });
+
+  describe('config.yaml includeTags/excludeTags merging', () => {
+    const configTagsDir = path.join(__dirname, 'fixtures', 'config-tags');
+
+    it('should respect includeTags/excludeTags from config.yaml when no CLI tags provided', async () => {
+      const maestroFlows = await getMaestroFlowList(configTagsDir);
+      const ourFlows = await getOurFlowList(configTagsDir);
+
+      expect(ourFlows).toEqual(maestroFlows);
+
+      // Based on fixtures, only flows matching config includeTags and not matching excludeTags should be included
+      expect(ourFlows).toContain('flow-inc-only');
+      expect(ourFlows).not.toContain('flow-exc-only');
+      expect(ourFlows).not.toContain('flow-inc-and-exc');
+      expect(ourFlows).not.toContain('flow-neutral');
+      expect(ourFlows).not.toContain('flow-cli-exclude');
+      expect(ourFlows).not.toContain('flow-cli-include');
+    });
+
+    it('should merge CLI includeTags with config includeTags', async () => {
+      const maestroFlows = await getMaestroFlowList(configTagsDir, ['cliInclude']);
+      const ourFlows = await getOurFlowList(configTagsDir, ['cliInclude']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      // Now flows with either cfgInclude or cliInclude should be included, minus excluded ones
+      expect(ourFlows).toContain('flow-inc-only');
+      expect(ourFlows).toContain('flow-cli-include');
+      expect(ourFlows).not.toContain('flow-exc-only');
+      expect(ourFlows).not.toContain('flow-inc-and-exc');
+      expect(ourFlows).not.toContain('flow-cli-exclude');
+    });
+
+    it('should merge CLI excludeTags with config excludeTags', async () => {
+      const maestroFlows = await getMaestroFlowList(configTagsDir, [], ['cliExclude']);
+      const ourFlows = await getOurFlowList(configTagsDir, [], ['cliExclude']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      // Exclude both cfgExclude and cliExclude
+      expect(ourFlows).toContain('flow-inc-only');
+      expect(ourFlows).not.toContain('flow-exc-only');
+      expect(ourFlows).not.toContain('flow-cli-exclude');
+      expect(ourFlows).not.toContain('flow-inc-and-exc');
+    });
+
+    it('should apply both merged include and exclude tags correctly', async () => {
+      const maestroFlows = await getMaestroFlowList(configTagsDir, ['cfgInclude'], ['cfgExclude']);
+      const ourFlows = await getOurFlowList(configTagsDir, ['cfgInclude'], ['cfgExclude']);
+
+      expect(ourFlows).toEqual(maestroFlows);
+      expect(ourFlows).toContain('flow-inc-only');
+      expect(ourFlows).not.toContain('flow-exc-only');
+      expect(ourFlows).not.toContain('flow-inc-and-exc');
+      expect(ourFlows).not.toContain('flow-neutral');
+    });
+  });
+
+  describe('backward compatibility (no config.yaml)', () => {
+    it('should use default "*" pattern when no config.yaml exists', async () => {
+      const maestroFlows = await getMaestroFlowList(noConfigFlowsDir);
+      const ourFlows = await getOurFlowList(noConfigFlowsDir);
+
+      expect(ourFlows).toEqual(maestroFlows);
+
+      // Should include top-level files
+      expect(ourFlows).toContain('top-level-flow');
+
+      // Should exclude subdirectory files (default "*" behavior)
+      expect(ourFlows).not.toContain('nested-flow');
+    });
+
+    it('should handle tag filtering without config.yaml', async () => {
+      const basicFlows = await getOurFlowList(noConfigFlowsDir, ['basic']);
+      const maestroBasicFlows = await getMaestroFlowList(noConfigFlowsDir, ['basic']);
+
+      expect(basicFlows).toEqual(maestroBasicFlows);
+      expect(basicFlows).toContain('top-level-flow');
+
+      const noIncludeTagsFlows = await getOurFlowList(noConfigFlowsDir, []);
+      const maestroNoIncludeTagsFlows = await getMaestroFlowList(noConfigFlowsDir, []);
+
+      expect(noIncludeTagsFlows).toEqual(maestroNoIncludeTagsFlows);
+      expect(noIncludeTagsFlows).toContain('top-level-flow');
+      expect(noIncludeTagsFlows).not.toContain('nested-flow');
+    });
+  });
+});

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/config.yaml

@@ -0,0 +1,3 @@
+flows:
+  - 'features/**/*.yaml'
+  - 'specs/*.spec.yaml'

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/features/auth/login.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "login"
+tags: ["auth", "smoke"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/features/auth/logout.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "logout"
+tags: ["auth"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/features/core/navigation.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "navigation"
+tags: ["core", "smoke"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/ignored-top-level.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "ignored-top-level"
+tags: ["ignored"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/specs/api.spec.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "api.spec"
+tags: ["api", "integration"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/config-flows/specs/ui.spec.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "ui.spec"
+tags: ["ui", "integration"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/basic-flow.yaml

@@ -0,0 +1,4 @@
+appId: com.example.app
+name: "basic-flow"
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/invalid-flow.yaml

@@ -0,0 +1,6 @@
+appId: com.example.app
+name: "invalid-flow"
+tags:
+  - invalid
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/no-tags-flow.yaml

@@ -0,0 +1,4 @@
+appId: com.example.app
+name: "no-tags-flow"
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/non-flow-file.txt

@@ -0,0 +1 @@
+This is not a YAML file and should be ignored by flow discovery.

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/subdir/nested-flow.yaml

@@ -0,0 +1,7 @@
+appId: com.example.app
+name: "nested-flow"
+tags:
+  - nested
+  - auth
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/tagged-flow-auth.yaml

@@ -0,0 +1,7 @@
+appId: com.example.app
+name: "tagged-flow-auth"
+tags:
+  - auth
+  - login
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/tagged-flow-regression.yaml

@@ -0,0 +1,7 @@
+appId: com.example.app
+name: "tagged-flow-regression"
+tags:
+  - regression
+  - slow
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/maestro-flows/tagged-flow-smoke.yaml

@@ -0,0 +1,7 @@
+appId: com.example.app
+name: "tagged-flow-smoke"
+tags:
+  - smoke
+  - critical
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/no-config-flows/subdir/nested-flow.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "nested-flow"
+tags: ["nested"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/no-config-flows/top-level-flow.yaml

@@ -0,0 +1,5 @@
+appId: com.example.app
+name: "top-level-flow"
+tags: ["basic"]
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/fixtures/single-file/standalone-flow.yaml

@@ -0,0 +1,7 @@
+appId: com.example.app
+name: "standalone-flow"
+tags:
+  - standalone
+  - smoke
+---
+- assertTrue: true

packages/build-tools/src/utils/__integration-tests__/precompiledModules.test.ts

@@ -0,0 +1,120 @@
+import fs from 'fs-extra';
+import nock from 'nock';
+import os from 'os';
+import path from 'path';
+
+import { createMockLogger } from '../../__tests__/utils/logger';
+
+jest.unmock('fs');
+jest.unmock('node:fs');
+jest.unmock('fs/promises');
+jest.unmock('node:fs/promises');
+
+describe('precompiledModules integration', () => {
+  beforeAll(() => {
+    nock.disableNetConnect();
+  });
+
+  afterAll(() => {
+    nock.enableNetConnect();
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('merges the extracted debug and release xcframework trees', async () => {
+    const homeDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'precompiled-modules-home-'));
+    const previousHome = process.env.HOME;
+    process.env.HOME = homeDirectory;
+
+    try {
+      const fixturesDirectory = path.join(__dirname, 'fixtures', 'precompiledModules');
+      const debugArchive = await fs.readFile(
+        path.join(fixturesDirectory, 'xcframeworks-Debug.zip')
+      );
+      const releaseArchive = await fs.readFile(
+        path.join(fixturesDirectory, 'xcframeworks-Release.zip')
+      );
+
+      nock('https://fixtures.expo.test')
+        .get('/xcframeworks-Debug.zip')
+        .reply(200, debugArchive, { 'Content-Type': 'application/zip' })
+        .get('/xcframeworks-Release.zip')
+        .reply(200, releaseArchive, { 'Content-Type': 'application/zip' });
+
+      jest.resetModules();
+      jest.doMock('os', () => ({
+        ...jest.requireActual('os'),
+        homedir: () => homeDirectory,
+      }));
+      const {
+        PRECOMPILED_MODULES_PATH,
+        startPreparingPrecompiledDependencies,
+        waitForPrecompiledModulesPreparationAsync,
+      } = await import('../precompiledModules');
+
+      startPreparingPrecompiledDependencies(
+        {
+          logger: createMockLogger(),
+          env: {},
+        } as any,
+        [
+          'https://fixtures.expo.test/xcframeworks-Debug.zip',
+          'https://fixtures.expo.test/xcframeworks-Release.zip',
+        ]
+      );
+      await waitForPrecompiledModulesPreparationAsync();
+
+      expect(PRECOMPILED_MODULES_PATH).toBe(
+        path.join(homeDirectory, '.expo', 'precompiled-modules')
+      );
+
+      await expect(
+        fs.readFile(
+          path.join(
+            PRECOMPILED_MODULES_PATH,
+            'expo-modules-core/output/debug/xcframeworks/ExpoModulesCore.tar.gz'
+          ),
+          'utf8'
+        )
+      ).resolves.toBe('debug expo-modules-core fixture\n');
+      await expect(
+        fs.readFile(
+          path.join(
+            PRECOMPILED_MODULES_PATH,
+            'expo-modules-core/output/release/xcframeworks/ExpoModulesCore.tar.gz'
+          ),
+          'utf8'
+        )
+      ).resolves.toBe('release expo-modules-core fixture\n');
+      await expect(
+        fs.readFile(
+          path.join(
+            PRECOMPILED_MODULES_PATH,
+            'expo-camera/output/debug/xcframeworks/ExpoCamera.tar.gz'
+          ),
+          'utf8'
+        )
+      ).resolves.toBe('debug expo-camera fixture\n');
+      await expect(
+        fs.readFile(
+          path.join(
+            PRECOMPILED_MODULES_PATH,
+            'expo-application/output/release/xcframeworks/EXApplication.tar.gz'
+          ),
+          'utf8'
+        )
+      ).resolves.toBe('release expo-application fixture\n');
+    } finally {
+      jest.dontMock('os');
+      jest.resetModules();
+      if (previousHome === undefined) {
+        delete process.env.HOME;
+      } else {
+        process.env.HOME = previousHome;
+      }
+      await fs.remove(homeDirectory);
+    }
+  });
+});

packages/build-tools/src/utils/__tests__/easCli.test.ts

@@ -1,139 +0,0 @@
-import { EasCliNpmTags } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
-
-import { resolveEasCommandPrefixAndEnvAsync, runEasCliCommand } from '../easCli';
-import { isAtLeastNpm7Async } from '../packageManager';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-jest.mock('../packageManager', () => ({
-  ...jest.requireActual('../packageManager'),
-  isAtLeastNpm7Async: jest.fn(async () => true),
-}));
-
-describe(resolveEasCommandPrefixAndEnvAsync, () => {
-  const originalEnvironment = process.env.ENVIRONMENT;
-
-  beforeEach(() => {
-    jest.mocked(spawn).mockReset();
-  });
-
-  afterEach(() => {
-    process.env.ENVIRONMENT = originalEnvironment;
-  });
-
-  it('resolves easd in development when easd --help succeeds', async () => {
-    process.env.ENVIRONMENT = 'development';
-    jest.mocked(spawn).mockResolvedValueOnce({ status: 0 } as any);
-
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-
-    expect(result).toEqual({
-      cmd: 'easd',
-      args: [],
-      extraEnv: {},
-    });
-    expect(spawn).toHaveBeenCalledWith(
-      'easd',
-      ['--help'],
-      expect.objectContaining({ stdio: ['ignore', 'pipe', 'pipe'] })
-    );
-  });
-
-  it('resolves staging tag in development when easd --help fails', async () => {
-    process.env.ENVIRONMENT = 'development';
-    jest.mocked(spawn).mockResolvedValueOnce({ status: 1 } as any);
-
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-
-    expect(result).toEqual({
-      cmd: 'npx',
-      args: ['-y', `eas-cli@${EasCliNpmTags.STAGING}`],
-      extraEnv: {},
-    });
-  });
-
-  it('resolves staging tag in development when easd probe throws', async () => {
-    process.env.ENVIRONMENT = 'development';
-    jest.mocked(spawn).mockRejectedValueOnce(new Error('easd not installed') as any);
-
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-
-    expect(result).toEqual({
-      cmd: 'npx',
-      args: ['-y', `eas-cli@${EasCliNpmTags.STAGING}`],
-      extraEnv: {},
-    });
-  });
-
-  it('resolves staging tag and EXPO_STAGING env in staging environment', async () => {
-    process.env.ENVIRONMENT = 'staging';
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-    expect(result).toEqual({
-      cmd: 'npx',
-      args: ['-y', `eas-cli@${EasCliNpmTags.STAGING}`],
-      extraEnv: { EXPO_STAGING: '1' },
-    });
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('resolves production tag by default', async () => {
-    process.env.ENVIRONMENT = 'production';
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-    expect(result).toEqual({
-      cmd: 'npx',
-      args: ['-y', `eas-cli@${EasCliNpmTags.PRODUCTION}`],
-      extraEnv: {},
-    });
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('omits -y when npm is older than v7', async () => {
-    jest.mocked(isAtLeastNpm7Async).mockResolvedValueOnce(false);
-    process.env.ENVIRONMENT = 'production';
-    const result = await resolveEasCommandPrefixAndEnvAsync();
-    expect(result).toEqual({
-      cmd: 'npx',
-      args: [`eas-cli@${EasCliNpmTags.PRODUCTION}`],
-      extraEnv: {},
-    });
-  });
-});
-
-describe(runEasCliCommand, () => {
-  const originalEnvironment = process.env.ENVIRONMENT;
-
-  beforeEach(() => {
-    jest.mocked(spawn).mockReset();
-  });
-
-  afterEach(() => {
-    process.env.ENVIRONMENT = originalEnvironment;
-  });
-
-  it('merges caller env with resolved extra env', async () => {
-    process.env.ENVIRONMENT = 'staging';
-
-    await runEasCliCommand({
-      args: ['deploy', '--json'],
-      options: {
-        cwd: '/tmp/project',
-        env: { FOO: 'bar' },
-      },
-    });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'npx',
-      expect.arrayContaining([`eas-cli@${EasCliNpmTags.STAGING}`, 'deploy', '--json']),
-      expect.objectContaining({
-        cwd: '/tmp/project',
-        env: expect.objectContaining({
-          FOO: 'bar',
-          EXPO_STAGING: '1',
-        }),
-      })
-    );
-  });
-});

packages/build-tools/src/utils/__tests__/packageManager.test.ts

@@ -1,4 +1,3 @@
-import { errors } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
 import fs from 'fs-extra';
 import { vol } from 'memfs';
@@ -6,7 +5,6 @@ import path from 'path';
 import semver from 'semver';
 
 import {
-  PackageManager,
   findPackagerRootDir,
   getPackageVersionFromPackageJson,
   resolvePackageManager,
@@ -25,23 +23,23 @@ describe(resolvePackageManager, () => {
   });
 
   it('returns yarn when no lockfiles exist', async () => {
-    expect(resolvePackageManager(rootDir, { env: {} })).toBe('yarn');
+    expect(resolvePackageManager(rootDir)).toBe('yarn');
   });
 
   it('returns npm when only package-json.lock exist', async () => {
     await fs.writeFile(path.join(rootDir, 'package-lock.json'), 'content');
-    expect(resolvePackageManager(rootDir, { env: {} })).toBe('npm');
+    expect(resolvePackageManager(rootDir)).toBe('npm');
   });
 
   it('returns yarn when only yarn.lock exists', async () => {
     await fs.writeFile(path.join(rootDir, 'yarn.lock'), 'content');
-    expect(resolvePackageManager(rootDir, { env: {} })).toBe('yarn');
+    expect(resolvePackageManager(rootDir)).toBe('yarn');
   });
 
   it('returns yarn when both lockfiles exists', async () => {
     await fs.writeFile(path.join(rootDir, 'yarn.lock'), 'content');
     await fs.writeFile(path.join(rootDir, 'package-lock.json'), 'content');
-    expect(resolvePackageManager(rootDir, { env: {} })).toBe('yarn');
+    expect(resolvePackageManager(rootDir)).toBe('yarn');
   });
 
   it('returns npm within a monorepo', async () => {
@@ -57,7 +55,7 @@ describe(resolvePackageManager, () => {
       name: '@monorepo/expo-app',
     });
 
-    expect(resolvePackageManager(nestedDir, { env: {} })).toBe('npm');
+    expect(resolvePackageManager(nestedDir)).toBe('npm');
   });
 
   it('returns yarn with an invalid monorepo', async () => {
@@ -69,51 +67,7 @@ describe(resolvePackageManager, () => {
     await fs.mkdirp(nestedDir);
     await fs.writeFile(path.join(nestedDir, 'package.json'), 'content');
 
-    expect(resolvePackageManager(nestedDir, { env: {} })).toBe('yarn');
-  });
-
-  it('returns yarn when no lockfile and env var is an empty string', () => {
-    expect(
-      resolvePackageManager(rootDir, {
-        env: { EAS_FALLBACK_PACKAGE_MANAGER: '' },
-      })
-    ).toBe(PackageManager.YARN);
-  });
-
-  it('returns bun from EAS_FALLBACK_PACKAGE_MANAGER when no lockfile', () => {
-    expect(resolvePackageManager(rootDir, { env: { EAS_FALLBACK_PACKAGE_MANAGER: 'bun' } })).toBe(
-      PackageManager.BUN
-    );
-  });
-
-  it('returns pnpm from EAS_FALLBACK_PACKAGE_MANAGER when no lockfile', () => {
-    expect(resolvePackageManager(rootDir, { env: { EAS_FALLBACK_PACKAGE_MANAGER: 'pnpm' } })).toBe(
-      PackageManager.PNPM
-    );
-  });
-
-  it('ignores EAS_FALLBACK_PACKAGE_MANAGER when a lockfile exists', async () => {
-    await fs.writeFile(path.join(rootDir, 'package-lock.json'), 'content');
-    expect(
-      resolvePackageManager(rootDir, {
-        env: { EAS_FALLBACK_PACKAGE_MANAGER: 'bunn' }, // invalid, but should not even be read
-      })
-    ).toBe(PackageManager.NPM);
-  });
-
-  it('throws a UserError on unsupported EAS_FALLBACK_PACKAGE_MANAGER value', () => {
-    expect(() =>
-      resolvePackageManager(rootDir, { env: { EAS_FALLBACK_PACKAGE_MANAGER: 'bunn' } })
-    ).toThrow(errors.UserError);
-    try {
-      resolvePackageManager(rootDir, { env: { EAS_FALLBACK_PACKAGE_MANAGER: 'bunn' } });
-    } catch (e) {
-      expect(e).toBeInstanceOf(errors.UserError);
-      const error = e as errors.UserError;
-      expect(error.errorCode).toBe('EAS_INVALID_FALLBACK_PACKAGE_MANAGER');
-      expect(error.message).toContain('bunn');
-      expect(error.message).toContain('yarn, npm, pnpm, bun');
-    }
+    expect(resolvePackageManager(nestedDir)).toBe('yarn');
   });
 });
 

packages/build-tools/src/utils/__tests__/precompiledModules.test.ts

@@ -0,0 +1,168 @@
+import downloadFile from '@expo/downloader';
+import { mkdirp, mkdtemp, move, remove } from 'fs-extra';
+import StreamZip from 'node-stream-zip';
+
+import {
+  PRECOMPILED_MODULES_PATH,
+  startPreparingPrecompiledDependencies,
+  waitForPrecompiledModulesPreparationAsync,
+} from '../precompiledModules';
+import { createMockLogger } from '../../__tests__/utils/logger';
+import { BuildContext } from '../../context';
+
+jest.mock('@expo/downloader');
+jest.mock('fs-extra');
+jest.mock('node-stream-zip', () => ({
+  __esModule: true,
+  default: {
+    async: jest.fn(),
+  },
+}));
+
+describe('precompiledModules', () => {
+  const extract = jest.fn();
+  const close = jest.fn();
+  const getMkdtempPath = jest.fn();
+
+  const createCtx = (env: Record<string, string | undefined> = {}): BuildContext =>
+    ({
+      logger: createMockLogger(),
+      env,
+    }) as unknown as BuildContext;
+
+  beforeEach(() => {
+    jest.mocked(remove).mockImplementation(async () => undefined as any);
+    jest.mocked(mkdirp).mockImplementation(async () => undefined as any);
+    jest.mocked(move).mockImplementation(async () => undefined as any);
+    getMkdtempPath.mockReset();
+    getMkdtempPath
+      .mockReturnValueOnce('/tmp/precompiled-modules-archive')
+      .mockReturnValueOnce('/tmp/precompiled-modules-staging');
+    jest.mocked(mkdtemp).mockImplementation(async () => getMkdtempPath() as any);
+    jest.mocked(downloadFile).mockReset();
+    extract.mockReset().mockResolvedValue(undefined);
+    close.mockReset().mockResolvedValue(undefined);
+    jest.mocked(StreamZip.async).mockImplementation(
+      () =>
+        ({
+          extract,
+          close,
+        }) as any
+    );
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('downloads through CocoaPods proxy when enabled', async () => {
+    jest.mocked(downloadFile).mockResolvedValue(undefined);
+
+    startPreparingPrecompiledDependencies(
+      createCtx({ EAS_BUILD_COCOAPODS_CACHE_URL: 'http://localhost:9001' }),
+      [
+        'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      ]
+    );
+
+    await waitForPrecompiledModulesPreparationAsync();
+
+    expect(downloadFile).toHaveBeenCalledWith(
+      'http://localhost:9001/storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      '/tmp/precompiled-modules-archive/precompiled-modules-0.zip',
+      { retry: 3 }
+    );
+  });
+
+  it('falls back to the direct url when CocoaPods proxy download fails', async () => {
+    jest
+      .mocked(downloadFile)
+      .mockRejectedValueOnce(new Error('proxy failed'))
+      .mockResolvedValueOnce(undefined);
+
+    startPreparingPrecompiledDependencies(
+      createCtx({ EAS_BUILD_COCOAPODS_CACHE_URL: 'http://localhost:9001' }),
+      [
+        'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      ]
+    );
+
+    await waitForPrecompiledModulesPreparationAsync();
+
+    expect(downloadFile).toHaveBeenNthCalledWith(
+      1,
+      'http://localhost:9001/storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      '/tmp/precompiled-modules-archive/precompiled-modules-0.zip',
+      { retry: 3 }
+    );
+    expect(downloadFile).toHaveBeenNthCalledWith(
+      2,
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      '/tmp/precompiled-modules-archive/precompiled-modules-0.zip',
+      { retry: 3 }
+    );
+  });
+
+  it('extracts all configured archives into the well-known destination path', async () => {
+    jest.mocked(downloadFile).mockResolvedValue(undefined);
+
+    startPreparingPrecompiledDependencies(createCtx(), [
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-1.zip',
+    ]);
+
+    await waitForPrecompiledModulesPreparationAsync();
+
+    expect(mkdirp).toHaveBeenCalledWith(PRECOMPILED_MODULES_PATH);
+    expect(downloadFile).toHaveBeenNthCalledWith(
+      1,
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+      '/tmp/precompiled-modules-archive/precompiled-modules-0.zip',
+      { retry: 3 }
+    );
+    expect(downloadFile).toHaveBeenNthCalledWith(
+      2,
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-1.zip',
+      '/tmp/precompiled-modules-archive/precompiled-modules-1.zip',
+      { retry: 3 }
+    );
+    expect(extract).toHaveBeenNthCalledWith(1, null, '/tmp/precompiled-modules-staging');
+    expect(extract).toHaveBeenNthCalledWith(2, null, '/tmp/precompiled-modules-staging');
+    expect(move).toHaveBeenCalledWith('/tmp/precompiled-modules-staging', PRECOMPILED_MODULES_PATH);
+  });
+
+  it('leaves the destination empty when preparation fails', async () => {
+    jest.mocked(downloadFile).mockResolvedValue(undefined);
+    extract.mockRejectedValueOnce(new Error('extract failed'));
+
+    startPreparingPrecompiledDependencies(createCtx(), [
+      'https://storage.googleapis.com/eas-build-precompiled-modules-production/ios/precompiled-modules-0.zip',
+    ]);
+
+    await expect(waitForPrecompiledModulesPreparationAsync()).rejects.toThrow('extract failed');
+
+    expect(move).not.toHaveBeenCalled();
+    expect(remove).toHaveBeenCalledWith('/tmp/precompiled-modules-staging');
+    expect(remove).toHaveBeenCalledWith(PRECOMPILED_MODULES_PATH);
+    expect(mkdirp).toHaveBeenCalledWith(PRECOMPILED_MODULES_PATH);
+  });
+
+  it('throws when precompiled dependencies are still not ready after 30 seconds', async () => {
+    jest.useFakeTimers();
+    jest.mocked(downloadFile).mockImplementation(() => new Promise<void>(() => {}) as any);
+
+    startPreparingPrecompiledDependencies(createCtx(), [
+      'https://example.com/xcframeworks-Debug.zip',
+    ]);
+
+    const waitPromise = waitForPrecompiledModulesPreparationAsync();
+    const waitExpectation = expect(waitPromise).rejects.toThrow(
+      'Timed out waiting for precompiled dependencies after 30 seconds'
+    );
+
+    await Promise.resolve();
+
+    await jest.advanceTimersByTimeAsync(30_000);
+    await waitExpectation;
+  });
+});

packages/build-tools/src/utils/__tests__/project.test.ts

@@ -2,29 +2,18 @@ import { ExpoConfig } from '@expo/config';
 import { Android } from '@expo/eas-build-job';
 import spawn from '@expo/turtle-spawn';
 import fs from 'fs-extra';
-import { vol } from 'memfs';
 import path from 'path';
-import { Readable } from 'stream';
 import { instance, mock, when } from 'ts-mockito';
 
 import { BuildContext } from '../../context';
-import { PackageManager, findPackagerRootDir } from '../packageManager';
-import {
-  isUsingModernYarnVersion,
-  readAndLogPackageJson,
-  readEasJsonContents,
-  runExpoCliCommand,
-} from '../project';
+import { PackageManager } from '../packageManager';
+import { readEasJsonContents, runExpoCliCommand } from '../project';
 
 jest.mock('fs');
 jest.mock('@expo/turtle-spawn', () => ({
   __esModule: true,
   default: jest.fn(),
 }));
-jest.mock('../packageManager', () => ({
-  ...jest.requireActual('../packageManager'),
-  findPackagerRootDir: jest.fn((dir: string) => dir),
-}));
 
 describe(runExpoCliCommand, () => {
   describe('Expo SDK >= 46', () => {
@@ -86,61 +75,6 @@ describe(runExpoCliCommand, () => {
   });
 });
 
-describe(isUsingModernYarnVersion, () => {
-  const projectDir = '/project';
-  const mockedFindPackagerRootDir = findPackagerRootDir as jest.MockedFunction<
-    typeof findPackagerRootDir
-  >;
-
-  beforeEach(() => {
-    mockedFindPackagerRootDir.mockReturnValue(projectDir);
-    jest.spyOn(fs, 'createReadStream').mockImplementation(((
-      filePath: string,
-      options?: { start?: number; end?: number }
-    ) => {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const start = options?.start ?? 0;
-      const end = options?.end != null ? options.end + 1 : content.length;
-      return Readable.from(Buffer.from(content.slice(start, end)));
-    }) as any);
-  });
-
-  it('returns true when .yarnrc.yml exists in project directory', async () => {
-    vol.fromJSON({ [path.join(projectDir, '.yarnrc.yml')]: '' });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(true);
-  });
-
-  it('returns true when .yarnrc.yml exists in workspace root directory', async () => {
-    const workspaceRoot = '/workspace-root';
-    mockedFindPackagerRootDir.mockReturnValue(workspaceRoot);
-    vol.fromJSON({ [path.join(workspaceRoot, '.yarnrc.yml')]: '' });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(true);
-  });
-
-  it('returns false when no .yarnrc.yml and no yarn.lock exist', async () => {
-    vol.fromJSON({ [projectDir]: null });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(false);
-  });
-
-  it('returns false when yarn.lock contains classic v1 header', async () => {
-    vol.fromJSON({ [path.join(projectDir, 'yarn.lock')]: '# yarn lockfile v1\n' });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(false);
-  });
-
-  it('returns true when yarn.lock does not contain classic v1 header', async () => {
-    vol.fromJSON({ [path.join(projectDir, 'yarn.lock')]: '__metadata:\n  version: 8\n' });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(true);
-  });
-
-  it('returns true when .yarnrc.yml exists even with classic yarn.lock', async () => {
-    vol.fromJSON({
-      [path.join(projectDir, '.yarnrc.yml')]: '',
-      [path.join(projectDir, 'yarn.lock')]: '# yarn lockfile v1\n',
-    });
-    expect(await isUsingModernYarnVersion(projectDir)).toBe(true);
-  });
-});
-
 describe(readEasJsonContents, () => {
   it('returns the raw eas.json contents even when it is not valid JSON', async () => {
     const projectDir = '/project';
@@ -153,23 +87,3 @@ describe(readEasJsonContents, () => {
     expect(readEasJsonContents(projectDir)).toBe(contents);
   });
 });
-
-describe(readAndLogPackageJson, () => {
-  beforeEach(() => {
-    vol.reset();
-  });
-
-  it('reads package.json, logs it, and returns parsed contents', async () => {
-    const projectDir = '/project';
-    const packageJsonPath = path.join(projectDir, 'package.json');
-    const packageJson = { name: 'app', version: '1.0.0' };
-    const logger = { info: jest.fn() };
-
-    await fs.mkdirp(projectDir);
-    await fs.writeJson(packageJsonPath, packageJson);
-
-    expect(readAndLogPackageJson(logger, projectDir)).toEqual(packageJson);
-    expect(logger.info).toHaveBeenNthCalledWith(1, 'Using package.json:');
-    expect(logger.info).toHaveBeenNthCalledWith(2, JSON.stringify(packageJson, null, 2));
-  });
-});

packages/build-tools/src/utils/easCli.ts

@@ -1,61 +0,0 @@
-import spawn, { SpawnOptions, SpawnResult } from '@expo/turtle-spawn';
-import { EasCliNpmTags, Env } from '@expo/eas-build-job';
-
-import { isAtLeastNpm7Async } from './packageManager';
-
-async function probeEasdAsync(): Promise<boolean> {
-  try {
-    const result = await spawn('easd', ['--help'], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    return result.status === 0;
-  } catch {
-    return false;
-  }
-}
-
-export async function resolveEasCommandPrefixAndEnvAsync(): Promise<{
-  cmd: string;
-  args: string[];
-  extraEnv: Env;
-}> {
-  const npxArgsPrefix = (await isAtLeastNpm7Async()) ? ['-y'] : [];
-  if (process.env.ENVIRONMENT === 'development') {
-    if (await probeEasdAsync()) {
-      return { cmd: 'easd', args: [], extraEnv: {} };
-    }
-    return {
-      cmd: 'npx',
-      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.STAGING}`],
-      extraEnv: {},
-    };
-  } else if (process.env.ENVIRONMENT === 'staging') {
-    return {
-      cmd: 'npx',
-      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.STAGING}`],
-      extraEnv: { EXPO_STAGING: '1' },
-    };
-  } else {
-    return {
-      cmd: 'npx',
-      args: [...npxArgsPrefix, `eas-cli@${EasCliNpmTags.PRODUCTION}`],
-      extraEnv: {},
-    };
-  }
-}
-
-export async function runEasCliCommand({
-  args,
-  options,
-}: {
-  args: string[];
-  options: SpawnOptions;
-}): Promise<SpawnResult> {
-  const { logger, ...spawnOptions } = options;
-  const { cmd, args: commandPrefixArgs, extraEnv } = await resolveEasCommandPrefixAndEnvAsync();
-  return await spawn(cmd, [...commandPrefixArgs, ...args], {
-    ...spawnOptions,
-    logger,
-    env: { ...spawnOptions.env, ...extraEnv },
-  });
-}

packages/build-tools/src/utils/findMaestroPathsFlowsToExecuteAsync.ts

@@ -0,0 +1,230 @@
+import { bunyan } from '@expo/logger';
+import { asyncResult } from '@expo/results';
+import fg from 'fast-glob';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as yaml from 'yaml';
+import { z } from 'zod';
+
+const FlowConfigSchema = z.object({
+  name: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+const WorkspaceConfigSchema = z.object({
+  flows: z.array(z.string()).optional(),
+  executionOrder: z.record(z.string(), z.unknown()).optional(),
+  includeTags: z.array(z.string()).optional(),
+  excludeTags: z.array(z.string()).optional(),
+});
+
+type FlowConfig = z.infer<typeof FlowConfigSchema>;
+type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+
+export async function findMaestroPathsFlowsToExecuteAsync({
+  workingDirectory,
+  flowPath,
+  includeTags: _includeTags,
+  excludeTags: _excludeTags,
+  logger,
+}: {
+  workingDirectory: string;
+  flowPath: string;
+  includeTags: string[] | undefined;
+  excludeTags: string[] | undefined;
+  logger: bunyan;
+}): Promise<string[]> {
+  const absoluteFlowPath = path.resolve(workingDirectory, flowPath);
+  // If it's a file, just return it (no validation needed)
+  const stat = await fs.stat(absoluteFlowPath);
+
+  if (stat.isFile()) {
+    logger.info(`Found a file: ${path.relative(workingDirectory, absoluteFlowPath)}`);
+    return [absoluteFlowPath];
+  }
+
+  // It's a directory - discover flow files
+  logger.info(`Found a directory: ${path.relative(workingDirectory, absoluteFlowPath)}`);
+
+  // Check for workspace config
+  logger.info(`Searching for workspace config...`);
+  const workspaceConfig = await findAndParseWorkspaceConfigAsync({
+    dirPath: absoluteFlowPath,
+    workingDirectory,
+    logger,
+  });
+  logger.info(`Using workspace config: ${JSON.stringify(workspaceConfig)}`);
+
+  if (workspaceConfig?.executionOrder) {
+    logger.warn(`Execution order is not supported yet. Ignoring.`);
+  }
+
+  logger.info(`Searching for flow files...`);
+  const { flows } = await findAndParseFlowFilesAsync({
+    dirPath: absoluteFlowPath,
+    workingDirectory,
+    workspaceConfig,
+    logger,
+  });
+
+  if (flows.length === 0) {
+    logger.info(
+      `No valid flow files found in: ${path.relative(workingDirectory, absoluteFlowPath)}`
+    );
+    return [];
+  }
+
+  const includeTags = [...(_includeTags ?? []), ...(workspaceConfig?.includeTags ?? [])];
+  const excludeTags = [...(_excludeTags ?? []), ...(workspaceConfig?.excludeTags ?? [])];
+
+  if (includeTags.length === 0 && excludeTags.length === 0) {
+    logger.info(`No tags provided, returning all flows.`);
+    return flows.map(({ path }) => path);
+  }
+
+  logger.info(
+    `Filtering flows by tags. Tags to include: ${JSON.stringify(includeTags)}. Tags to exclude: ${
+      JSON.stringify(excludeTags) ?? 'none'
+    }.`
+  );
+  return flows
+    .filter(({ config, path: flowPath }) => {
+      const shouldInclude = matchesTags({
+        flowTags: config?.tags ?? [],
+        includeTags,
+        excludeTags,
+      });
+
+      logger.info(
+        shouldInclude
+          ? `- ${path.relative(workingDirectory, flowPath)} matches tags, including.`
+          : `- ${path.relative(workingDirectory, flowPath)} does not match tags, excluding.`
+      );
+
+      return shouldInclude;
+    })
+    .map(({ path }) => path);
+}
+
+async function findAndParseWorkspaceConfigAsync({
+  dirPath,
+  workingDirectory,
+  logger,
+}: {
+  dirPath: string;
+  workingDirectory: string;
+  logger: bunyan;
+}): Promise<WorkspaceConfig | null> {
+  const configPaths = await fg(['config.yaml', 'config.yml'], {
+    cwd: dirPath,
+    absolute: true,
+  });
+
+  if (configPaths.length === 0) {
+    logger.info(`No workspace config found in: ${path.relative(workingDirectory, dirPath)}`);
+    return null;
+  }
+
+  for (const configPath of configPaths) {
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      const configDoc = yaml.parse(content);
+      if (!configDoc) {
+        logger.warn(
+          `No content found in workspace config: ${path.relative(workingDirectory, configPath)}`
+        );
+        continue;
+      }
+      logger.info(`Using workspace config from: ${path.relative(workingDirectory, configPath)}`);
+      return WorkspaceConfigSchema.parse(configDoc);
+    } catch (err) {
+      logger.warn(
+        { err },
+        `Failed to parse workspace config: ${path.relative(workingDirectory, configPath)}`
+      );
+      continue;
+    }
+  }
+
+  logger.info(`No valid workspace config found in: ${path.relative(workingDirectory, dirPath)}`);
+  return null;
+}
+
+async function findAndParseFlowFilesAsync({
+  workingDirectory,
+  dirPath,
+  workspaceConfig,
+  logger,
+}: {
+  workingDirectory: string;
+  dirPath: string;
+  workspaceConfig: WorkspaceConfig | null;
+  logger: bunyan;
+}): Promise<{ flows: { config: FlowConfig; path: string }[] }> {
+  const flows: { config: FlowConfig; path: string }[] = [];
+
+  // Determine flow patterns from config or use default
+  const flowPatterns = workspaceConfig?.flows ?? ['*'];
+  logger.info(`Using flow patterns: ${JSON.stringify(flowPatterns)}`);
+
+  // Use fast-glob to find matching files
+  const matchedFiles = await fg(flowPatterns, {
+    cwd: dirPath,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ['*/config.yaml', '*/config.yml'], // Skip workspace config files
+  });
+
+  logger.info(`Found ${matchedFiles.length} potential flow files`);
+
+  // Parse each matched file
+  for (const filePath of matchedFiles) {
+    // Skip non-YAML files
+    const ext = path.extname(filePath);
+    if (ext !== '.yaml' && ext !== '.yml') {
+      logger.info(`Skipping non-YAML file: ${path.relative(workingDirectory, filePath)}`);
+      continue;
+    }
+
+    const result = await asyncResult(parseFlowFile(filePath));
+    if (result.ok) {
+      logger.info(`Found flow file: ${path.relative(workingDirectory, filePath)}`);
+      flows.push({ config: result.value, path: filePath });
+    } else {
+      logger.info(
+        { err: result.reason },
+        `Skipping flow file: ${path.relative(workingDirectory, filePath)}`
+      );
+    }
+  }
+
+  return { flows };
+}
+
+async function parseFlowFile(filePath: string): Promise<FlowConfig> {
+  const content = await fs.readFile(filePath, 'utf-8');
+  const documents = yaml.parseAllDocuments(content);
+  const configDoc = documents[0];
+  if (!configDoc) {
+    throw new Error(`No config section found in ${filePath}`);
+  }
+  return FlowConfigSchema.parse(configDoc.toJS());
+}
+
+function matchesTags({
+  flowTags,
+  includeTags,
+  excludeTags,
+}: {
+  flowTags: string[];
+  includeTags: string[];
+  excludeTags: string[];
+}): boolean {
+  // Include logic: if includeTags is empty OR flow has any of the include tags
+  const includeMatch = includeTags.length === 0 || includeTags.some(tag => flowTags.includes(tag));
+
+  // Exclude logic: if excludeTags is empty OR flow has none of the exclude tags
+  const excludeMatch = excludeTags.length === 0 || !excludeTags.some(tag => flowTags.includes(tag));
+
+  return includeMatch && excludeMatch;
+}

packages/build-tools/src/utils/packageManager.ts

@@ -1,7 +1,5 @@
-import { errors } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
 import * as PackageManagerUtils from '@expo/package-manager';
-import { type BuildStepEnv } from '@expo/steps';
 import spawnAsync from '@expo/turtle-spawn';
 import semver from 'semver';
 import { z } from 'zod';
@@ -13,10 +11,7 @@ export enum PackageManager {
   BUN = 'bun',
 }
 
-export function resolvePackageManager(
-  directory: string,
-  { env }: { env: BuildStepEnv }
-): PackageManager {
+export function resolvePackageManager(directory: string): PackageManager {
   try {
     const manager = PackageManagerUtils.resolvePackageManager(directory);
     if (manager === 'npm') {
@@ -25,24 +20,12 @@ export function resolvePackageManager(
       return PackageManager.PNPM;
     } else if (manager === 'bun') {
       return PackageManager.BUN;
-    } else if (manager === 'yarn') {
+    } else {
       return PackageManager.YARN;
     }
-  } catch {}
-
-  const fallback = env.EAS_FALLBACK_PACKAGE_MANAGER;
-  if (fallback) {
-    const parsed = z.enum(PackageManager).safeParse(fallback);
-    if (parsed.success) {
-      return parsed.data;
-    }
-    const allowed = Object.values(PackageManager).join(', ');
-    throw new errors.UserError(
-      'EAS_INVALID_FALLBACK_PACKAGE_MANAGER',
-      `Invalid EAS_FALLBACK_PACKAGE_MANAGER value "${fallback}" (expected one of: ${allowed}).`
-    );
+  } catch {
+    return PackageManager.YARN;
   }
-  return PackageManager.YARN;
 }
 
 /**

packages/build-tools/src/utils/precompiledModules.ts

@@ -0,0 +1,174 @@
+import downloadFile from '@expo/downloader';
+import { bunyan } from '@expo/logger';
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import StreamZip from 'node-stream-zip';
+
+import { BuildContext } from '../context';
+
+let precompiledModulesPreparationPromise: Promise<void> | null = null;
+const PRECOMPILED_MODULES_WAIT_TIMEOUT_MS = 30_000;
+export const PRECOMPILED_MODULES_PATH = path.join(os.homedir(), '.expo', 'precompiled-modules');
+
+export function shouldUsePrecompiledDependencies(env: Record<string, string | undefined>): boolean {
+  return env.EAS_USE_PRECOMPILED_MODULES === '1';
+}
+
+export function maybeStartPreparingPrecompiledModules(
+  ctx: BuildContext,
+  config: { precompiledModulesUrls: string[] }
+): void {
+  if (!shouldUsePrecompiledDependencies(ctx.env)) {
+    return;
+  }
+
+  startPreparingPrecompiledDependencies(ctx, config.precompiledModulesUrls);
+}
+
+export function startPreparingPrecompiledDependencies(ctx: BuildContext, urls: string[]): void {
+  precompiledModulesPreparationPromise = preparePrecompiledDependenciesAsync({
+    logger: ctx.logger,
+    urls,
+    destinationDirectory: PRECOMPILED_MODULES_PATH,
+    cocoapodsProxyUrl: ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL,
+  });
+}
+
+export async function waitForPrecompiledModulesPreparationAsync(): Promise<void> {
+  if (!precompiledModulesPreparationPromise) {
+    return;
+  }
+
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      precompiledModulesPreparationPromise,
+      new Promise<void>((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(
+            new Error(
+              `Timed out waiting for precompiled dependencies after ${PRECOMPILED_MODULES_WAIT_TIMEOUT_MS / 1000} seconds`
+            )
+          );
+        }, PRECOMPILED_MODULES_WAIT_TIMEOUT_MS);
+        timeoutHandle.unref?.();
+      }),
+    ]);
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+  }
+}
+
+async function preparePrecompiledDependenciesAsync({
+  logger,
+  urls,
+  destinationDirectory,
+  cocoapodsProxyUrl,
+}: {
+  logger: bunyan;
+  urls: string[];
+  destinationDirectory: string;
+  cocoapodsProxyUrl?: string;
+}): Promise<void> {
+  const archiveDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'precompiled-modules-'));
+  const destinationParentDirectory = path.dirname(destinationDirectory);
+  await fs.mkdirp(destinationParentDirectory);
+  const stagingDirectory = await fs.mkdtemp(
+    path.join(destinationParentDirectory, `${path.basename(destinationDirectory)}-staging-`)
+  );
+
+  logger.info('');
+  logger.info(
+    {
+      destinationDirectory,
+      urls,
+    },
+    'Starting precompiled dependencies download'
+  );
+
+  await fs.remove(destinationDirectory);
+  await fs.mkdirp(destinationDirectory);
+
+  try {
+    const archives = urls.map((url, index) => ({
+      archiveName: path.basename(new URL(url).pathname),
+      url,
+      archivePath: path.join(archiveDirectory, `precompiled-modules-${index}.zip`),
+    }));
+
+    await Promise.all(
+      archives.map(async ({ url, archivePath }) => {
+        await downloadPrecompiledModulesAsync({
+          url,
+          archivePath,
+          cocoapodsProxyUrl,
+          logger,
+        });
+      })
+    );
+
+    for (const { archiveName, url, archivePath } of archives) {
+      logger.info({ archivePath, url }, `Downloaded ${archiveName}, extracting archive`);
+      await extractZipAsync(archivePath, stagingDirectory);
+      logger.info(
+        { destinationDirectory: stagingDirectory },
+        `Extracted ${archiveName} into staging precompiled dependencies directory`
+      );
+    }
+
+    await fs.remove(destinationDirectory);
+    await fs.move(stagingDirectory, destinationDirectory);
+    logger.info({ destinationDirectory }, `Precompiled modules ready in ${destinationDirectory}`);
+  } catch (error) {
+    await fs.remove(stagingDirectory);
+    await fs.remove(destinationDirectory);
+    await fs.mkdirp(destinationDirectory);
+    throw error;
+  } finally {
+    await fs.remove(archiveDirectory);
+  }
+}
+
+async function downloadPrecompiledModulesAsync({
+  url,
+  archivePath,
+  cocoapodsProxyUrl,
+  logger,
+}: {
+  url: string;
+  archivePath: string;
+  cocoapodsProxyUrl?: string;
+  logger: bunyan;
+}): Promise<void> {
+  const proxiedUrl = cocoapodsProxyUrl
+    ? (() => {
+        const parsedUrl = new URL(url);
+        return `${cocoapodsProxyUrl}/${parsedUrl.hostname}${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`;
+      })()
+    : null;
+  if (proxiedUrl) {
+    try {
+      await downloadFile(proxiedUrl, archivePath, { retry: 3 });
+      return;
+    } catch (err) {
+      logger.warn(
+        { err, proxiedUrl },
+        'Failed to download through CocoaPods proxy, retrying directly'
+      );
+    }
+  }
+
+  await downloadFile(url, archivePath, { retry: 3 });
+}
+
+async function extractZipAsync(archivePath: string, destinationDirectory: string): Promise<void> {
+  const zip = new StreamZip.async({ file: archivePath });
+  try {
+    await zip.extract(null, destinationDirectory);
+  } finally {
+    await zip.close();
+  }
+}

packages/build-tools/src/utils/project.ts

@@ -4,43 +4,13 @@ import path from 'path';
 
 import { PackageManager, findPackagerRootDir } from '../utils/packageManager';
 
-async function readFirstChars(filePath: string, chars: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Uint8Array[] = [];
-    const stream = fs.createReadStream(filePath, {
-      start: 0,
-      end: chars - 1,
-    });
-    stream.on('error', reject);
-    stream.on('data', chunk => {
-      chunks.push(chunk as Uint8Array);
-    });
-    stream.on('end', () => {
-      resolve(Buffer.concat(chunks).toString('utf8'));
-    });
-  });
-}
-
 /**
- * check if .yarnrc.yml exists in the project dir or in the workspace root dir,
- * or if the `yarn.lock` file is classic one, not a modern one
+ * check if .yarnrc.yml exists in the project dir or in the workspace root dir
  */
 export async function isUsingModernYarnVersion(projectDir: string): Promise<boolean> {
-  const rootDir = findPackagerRootDir(projectDir);
   const yarnrcPath = path.join(projectDir, '.yarnrc.yml');
   const yarnrcRootPath = path.join(findPackagerRootDir(projectDir), '.yarnrc.yml');
-  if ((await fs.pathExists(yarnrcPath)) || (await fs.pathExists(yarnrcRootPath))) {
-    return true;
-  }
-
-  const yarnlockPath = path.join(rootDir, 'yarn.lock');
-  if (!(await fs.pathExists(yarnlockPath))) {
-    return false;
-  }
-
-  // The yarn.lock file is for Yarn Classic, not Modern, if it contains "# yarn lockfile v1"
-  const startOfLockfile = await readFirstChars(yarnlockPath, 100);
-  return !/yarn lockfile v1/i.test(startOfLockfile);
+  return (await fs.pathExists(yarnrcPath)) || (await fs.pathExists(yarnrcRootPath));
 }
 
 export function runExpoCliCommand({
@@ -78,16 +48,6 @@ export function readPackageJson(projectDir: string): any {
   }
 }
 
-export function readAndLogPackageJson(
-  logger: { info: (message: string) => void },
-  projectDir: string
-): any {
-  logger.info('Using package.json:');
-  const packageJson = readPackageJson(projectDir);
-  logger.info(JSON.stringify(packageJson, null, 2));
-  return packageJson;
-}
-
 export function readEasJsonContents(projectDir: string): string {
   const easJsonPath = path.join(projectDir, 'eas.json');
   if (!fs.pathExistsSync(easJsonPath)) {

packages/build-tools/tsconfig.json

@@ -11,7 +11,6 @@
     "composite": true,
     "rootDir": "./src",
     "outDir": "./dist",
-    "types": ["jest", "node"],
     "plugins": [
       {
         "name": "gql.tada/ts-plugin",

packages/create-eas-build-function/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-eas-build-function",
-  "version": "18.8.0",
+  "version": "18.4.0",
   "description": "Create functions for use in EAS Build custom builds.",
   "keywords": [
     "expo",
@@ -35,7 +35,7 @@
     "clean": "rimraf ./build/ \"*.tsbuildinfo\""
   },
   "dependencies": {
-    "@expo/steps": "18.8.0"
+    "@expo/steps": "18.4.0"
   },
   "devDependencies": {
     "@expo/package-manager": "1.9.10",

packages/downloader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/downloader",
-  "version": "18.5.0",
+  "version": "18.0.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",

packages/eas-build-cache-provider/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eas-build-cache-provider",
-  "version": "18.5.0",
+  "version": "18.0.2",
   "description": "A build cache provider plugin for the Expo CLI",
   "homepage": "https://github.com/expo/eas-cli",
   "bugs": "https://github.com/expo/eas-cli/issues",

packages/eas-build-job/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/eas-build-job",
-  "version": "18.8.0",
+  "version": "18.4.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "MIT",
   "author": "Expo <[email protected]>",
@@ -25,7 +25,7 @@
     "clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
   },
   "dependencies": {
-    "@expo/logger": "18.5.0",
+    "@expo/logger": "18.0.1",
     "joi": "^17.13.1",
     "semver": "^7.6.2",
     "zod": "^4.3.5"

packages/eas-build-job/src/__tests__/common.test.ts

@@ -24,428 +24,6 @@ describe('StaticWorkflowInterpolationContextZ', () => {
     expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
   });
 
-  it('accepts app_store_connect context', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        build_upload: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'processing',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('accepts app_store_connect build_upload with cf_bundle_version', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        build_upload: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'processing',
-          cf_bundle_version: '42',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('accepts app_store_connect build_upload with build.id', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        build_upload: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'complete',
-          build: {
-            id: 'build-abc123',
-          },
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('accepts app_store_connect build_upload with both cf_bundle_version and build.id', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        build_upload: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'complete',
-          cf_bundle_version: '42',
-          build: {
-            id: 'build-abc123',
-          },
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('accepts app_store_connect context without build_upload', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('accepts app_store_connect context with app_version', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        app_version: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'ready_for_review',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('rejects invalid app_store_connect app_version state', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        app_version: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'invalid-state',
-        },
-      },
-    };
-
-    expect(() => StaticWorkflowInterpolationContextZ.parse(context)).toThrow();
-  });
-
-  it('accepts app_store_connect context with external_beta', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        external_beta: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'beta_approved',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('rejects invalid app_store_connect external_beta state', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        external_beta: {
-          id: '123e4567-e89b-42d3-a456-426614174000',
-          state: 'invalid-state',
-        },
-      },
-    };
-
-    expect(() => StaticWorkflowInterpolationContextZ.parse(context)).toThrow();
-  });
-
-  it('accepts app_store_connect context with beta_feedback', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        beta_feedback: {
-          id: 'AD8JvKbr0BK0Cj9OnM6WO6I',
-          type: 'screenshot',
-          url: 'https://api.appstoreconnect.apple.com/v1/betaFeedbackScreenshotSubmissions/AD8JvKbr0BK0Cj9OnM6WO6I',
-        },
-      },
-    };
-
-    expect(StaticWorkflowInterpolationContextZ.parse(context)).toEqual(context);
-  });
-
-  it('rejects app_store_connect beta_feedback without url', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        beta_feedback: {
-          id: 'AD8JvKbr0BK0Cj9OnM6WO6I',
-          type: 'crash',
-        },
-      },
-    };
-
-    expect(() => StaticWorkflowInterpolationContextZ.parse(context)).toThrow();
-  });
-
-  it('rejects invalid app_store_connect beta_feedback type', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        beta_feedback: {
-          id: 'AD8JvKbr0BK0Cj9OnM6WO6I',
-          type: 'invalid-type',
-          url: 'https://api.appstoreconnect.apple.com/v1/betaFeedbackScreenshotSubmissions/AD8JvKbr0BK0Cj9OnM6WO6I',
-        },
-      },
-    };
-
-    expect(() => StaticWorkflowInterpolationContextZ.parse(context)).toThrow();
-  });
-
-  it('rejects invalid app_store_connect build_upload context', () => {
-    const context = {
-      after: {},
-      needs: {},
-      workflow: {
-        id: 'workflow-id',
-        name: 'workflow-name',
-        filename: 'workflow.yml',
-        url: 'https://expo.dev/accounts/example/workflows/workflow-id',
-      },
-      app: {
-        id: 'app-id',
-        slug: 'app-slug',
-      },
-      account: {
-        id: 'account-id',
-        name: 'account-name',
-      },
-      app_store_connect: {
-        app: {
-          id: '1234567890',
-        },
-        build_upload: {
-          id: 'not-a-uuid',
-          state: 'invalid-state',
-        },
-      },
-    };
-
-    expect(() => StaticWorkflowInterpolationContextZ.parse(context)).toThrow();
-  });
-
   it('rejects invalid app and account context', () => {
     const context = {
       after: {},

packages/eas-build-job/src/__tests__/ios.test.ts

@@ -403,7 +403,6 @@ describe('Ios.JobSchema', () => {
     );
     expect(value).not.toMatchObject(managedJob);
   });
-
   test('validates channel', () => {
     const managedJob = {
       secrets: {

packages/eas-build-job/src/common.ts

@@ -226,72 +226,6 @@ const GitHubContextZ = z.object({
     .optional(),
 });
 
-const AppStoreConnectContextZ = z.looseObject({
-  app: z.looseObject({
-    id: z.string(),
-  }),
-  app_version: z
-    .looseObject({
-      id: z.string(),
-      state: z.enum([
-        'accepted',
-        'developer_rejected',
-        'in_review',
-        'invalid_binary',
-        'metadata_rejected',
-        'pending_apple_release',
-        'pending_developer_release',
-        'prepare_for_submission',
-        'processing_for_distribution',
-        'ready_for_distribution',
-        'ready_for_review',
-        'rejected',
-        'replaced_with_new_version',
-        'waiting_for_export_compliance',
-        'waiting_for_review',
-      ]),
-    })
-    .optional(),
-  build_upload: z
-    .looseObject({
-      id: z.string(),
-      state: z.enum(['awaiting_upload', 'processing', 'failed', 'complete']),
-      cf_bundle_version: z.string().optional(),
-      build: z
-        .looseObject({
-          id: z.string(),
-        })
-        .optional(),
-    })
-    .optional(),
-  external_beta: z
-    .looseObject({
-      id: z.string(),
-      state: z.enum([
-        'processing',
-        'processing_exception',
-        'missing_export_compliance',
-        'ready_for_beta_testing',
-        'in_beta_testing',
-        'expired',
-        'ready_for_beta_submission',
-        'in_export_compliance_review',
-        'waiting_for_beta_review',
-        'in_beta_review',
-        'beta_rejected',
-        'beta_approved',
-      ]),
-    })
-    .optional(),
-  beta_feedback: z
-    .looseObject({
-      id: z.string(),
-      type: z.enum(['crash', 'screenshot']),
-      url: z.string(),
-    })
-    .optional(),
-});
-
 export const StaticWorkflowInterpolationContextZ = z.object({
   after: z.record(
     z.string(),
@@ -325,8 +259,6 @@ export const StaticWorkflowInterpolationContextZ = z.object({
     id: z.string(),
     name: z.string(),
   }),
-  // We need to .optional() to support jobs that are not triggered by an App Store Connect event.
-  app_store_connect: AppStoreConnectContextZ.optional(),
 });
 
 export type StaticWorkflowInterpolationContext = z.infer<

packages/eas-build-job/src/logs.ts

@@ -41,7 +41,6 @@ export enum BuildPhase {
   INSTALL_PODS = 'INSTALL_PODS',
   CONFIGURE_XCODE_PROJECT = 'CONFIGURE_XCODE_PROJECT',
   RUN_FASTLANE = 'RUN_FASTLANE',
-  PARSE_XCACTIVITYLOG = 'PARSE_XCACTIVITYLOG',
 
   // HOOKS
   PRE_INSTALL_HOOK = 'PRE_INSTALL_HOOK',
@@ -109,7 +108,6 @@ export const buildPhaseDisplayName: Record<BuildPhase, string> = {
   [BuildPhase.INSTALL_PODS]: 'Install pods',
   [BuildPhase.CONFIGURE_XCODE_PROJECT]: 'Configure Xcode project',
   [BuildPhase.RUN_FASTLANE]: 'Run fastlane',
-  [BuildPhase.PARSE_XCACTIVITYLOG]: 'Analyze build performance',
 
   // HOOKS
   [BuildPhase.PRE_INSTALL_HOOK]: 'Pre-install hook',
@@ -174,7 +172,6 @@ export const buildPhaseWebsiteId: Record<BuildPhase, string> = {
   [BuildPhase.INSTALL_PODS]: 'install-pods',
   [BuildPhase.CONFIGURE_XCODE_PROJECT]: 'configure-xcode-project',
   [BuildPhase.RUN_FASTLANE]: 'run-fastlane',
-  [BuildPhase.PARSE_XCACTIVITYLOG]: 'parse-xcactivitylog',
 
   // HOOKS
   [BuildPhase.PRE_INSTALL_HOOK]: 'pre-install-hook',