v27.4.1

* [simulator-launcher] Wait for startup before claiming a session

* [simulator-launcher] Report startup wait progress in job logs

* [build-tools] Log warm Simulator claim waits directly

CHANGELOG.md

@@ -2,6 +2,31 @@
 
 This is the log of notable changes to EAS CLI and related packages.
 
+## [27.4.1](https://github.com/expo/eas-cli/releases/tag/v27.4.1) - 2026-11-04
+
+### 🐛 Bug fixes
+
+- [simulator-launcher][build-tools] Wait for a starting warm Simulator launcher before claiming its session, instead of falling back to a cold start. ([#4810](https://github.com/expo/eas-cli/pull/4810) by [@gwdp](https://github.com/gwdp))
+
+## [27.4.0](https://github.com/expo/eas-cli/releases/tag/v27.4.0) - 2026-11-03
+
+### 🎉 New features
+
+- [simulator-launcher][build-tools] Add `eas/start_warm_appium_remote_session`, which runs the Appium session on the warm Simulator, or starts cold. An `appium` claim stops the unused tools first, so WDA does not share the Simulator with the agent-device runner. ([#4735](https://github.com/expo/eas-cli/pull/4735) by [@gwdp](https://github.com/gwdp))
+- [build-tools] Add warm iOS session steps (`eas/start_warm_serve_sim_remote_session`, `eas/start_warm_agent_device_session`, `eas/start_warm_argent_remote_session`). They run the existing session on the warm Simulator, or start cold. `eas/start_agent_device_session` also accepts `install_app_path` and `launch_app_identifier`. ([#4723](https://github.com/expo/eas-cli/pull/4723) by [@gwdp](https://github.com/gwdp))
+- [build-tools] Update the app version and build number from the final application archive, so the build shows the values the native build resolved. ([#3499](https://github.com/expo/eas-cli/pull/3499) by [@kadikraman](https://github.com/kadikraman))
+
+### 🐛 Bug fixes
+
+- [build-tools] Upload the final agent-device session artifacts before stopping the daemon, including sessions that reuse a warm Simulator. ([#4750](https://github.com/expo/eas-cli/pull/4750) by [@gwdp](https://github.com/gwdp))
+- [build-tools] Add internal helpers that claim the warm Simulator through the launcher and adopt it on the warm serve-sim. Skip the Expo Go install when the warm Simulator already has the same Expo Go version. ([#4724](https://github.com/expo/eas-cli/pull/4724) by [@gwdp](https://github.com/gwdp))
+- [build-tools] Recover warm Simulator recordings when their MP4 exists before the shutdown manifest is ready. ([#4789](https://github.com/expo/eas-cli/pull/4789) by [@gwdp](https://github.com/gwdp))
+- [eas-cli] Show the Expo Simulators hint after a successful build from November 10 instead of November 5. ([#4801](https://github.com/expo/eas-cli/pull/4801) by [@williamgrosset](https://github.com/williamgrosset))
+
+### 🧹 Chores
+
+- [build-tools] Move iOS Simulator startup behind a shared session host contract. ([#4752](https://github.com/expo/eas-cli/pull/4752) by [@gwdp](https://github.com/gwdp))
+
 ## [27.3.0](https://github.com/expo/eas-cli/releases/tag/v27.3.0) - 2026-11-02
 
 ### 🎉 New features

cli-versions.json

@@ -1,4 +1,4 @@
 {
-  "STAGING": "27.2.0",
-  "PRODUCTION": "27.2.0"
+  "STAGING": "27.4.0",
+  "PRODUCTION": "27.4.0"
 }

lerna.json

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

packages/build-tools/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @expo/build-tools
 
+## 27.4.1
+
+### Patch Changes
+
+- Wait for a starting warm Simulator launcher before claiming its session, instead of falling back to a cold start. ([#4810](https://github.com/expo/eas-cli/pull/4810) by [@gwdp](https://github.com/gwdp))
+
+## 27.4.0
+
+### Minor Changes
+
+- Add `eas/start_warm_appium_remote_session`, which runs the Appium session on the warm Simulator, or starts cold. An `appium` claim stops the unused tools first, so WDA does not share the Simulator with the agent-device runner. ([#4735](https://github.com/expo/eas-cli/pull/4735) by [@gwdp](https://github.com/gwdp))
+- Add warm iOS session steps (`eas/start_warm_serve_sim_remote_session`, `eas/start_warm_agent_device_session`, `eas/start_warm_argent_remote_session`). They run the existing session on the warm Simulator, or start cold. `eas/start_agent_device_session` also accepts `install_app_path` and `launch_app_identifier`. ([#4723](https://github.com/expo/eas-cli/pull/4723) by [@gwdp](https://github.com/gwdp))
+- Update the app version and build number from the final application archive, so the build shows the values the native build resolved. ([#3499](https://github.com/expo/eas-cli/pull/3499) by [@kadikraman](https://github.com/kadikraman))
+
+### Patch Changes
+
+- Upload the final agent-device session artifacts before stopping the daemon, including sessions that reuse a warm Simulator. ([#4750](https://github.com/expo/eas-cli/pull/4750) by [@gwdp](https://github.com/gwdp))
+- Add internal helpers that claim the warm Simulator through the launcher and adopt it on the warm serve-sim. Skip the Expo Go install when the warm Simulator already has the same Expo Go version. ([#4724](https://github.com/expo/eas-cli/pull/4724) by [@gwdp](https://github.com/gwdp))
+- Recover warm Simulator recordings when their MP4 exists before the shutdown manifest is ready. ([#4789](https://github.com/expo/eas-cli/pull/4789) by [@gwdp](https://github.com/gwdp))
+
 ## 27.3.0
 
 ### Patch Changes

packages/build-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -42,17 +42,17 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "27.3.0",
-    "@expo/eas-build-job": "27.3.0",
+    "@expo/downloader": "27.4.1",
+    "@expo/eas-build-job": "27.4.1",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "27.3.0",
+    "@expo/logger": "27.4.1",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "27.3.0",
-    "@expo/template-file": "27.3.0",
-    "@expo/turtle-spawn": "27.3.0",
+    "@expo/steps": "27.4.1",
+    "@expo/template-file": "27.4.1",
+    "@expo/turtle-spawn": "27.4.1",
     "@expo/xcpretty": "^4.4.7",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",

packages/build-tools/src/builders/__tests__/android.test.ts

@@ -53,7 +53,7 @@ jest.mock('../../steps/utils/android/gradleConfig', () => ({
   injectCredentialsGradleConfig: jest.fn(),
 }));
 jest.mock('../../utils/artifacts', () => ({
-  uploadApplicationArchive: jest.fn(),
+  uploadApplicationArchive: jest.fn(async () => []),
 }));
 jest.mock('../../utils/expoUpdates', () => ({
   configureExpoUpdatesIfInstalledAsync: jest.fn(),

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

@@ -17,6 +17,10 @@ import { eagerBundleAsync, shouldUseEagerBundle } from '../common/eagerBundle';
 import { prebuildAsync } from '../common/prebuild';
 import { JobHooksRef, setupAsync } from '../common/setup';
 import { Artifacts, BuildContext, SkipNativeBuildError } from '../context';
+import {
+  extractAndroidVersionAsync,
+  updateResolvedVersionAsync,
+} from '../steps/functions/updateResolvedVersion';
 import {
   cacheStatsAsync,
   restoreCcacheAsync,
@@ -220,11 +224,30 @@ async function buildInnerAsync(
   });
 
   await ctx.runBuildPhase(BuildPhase.UPLOAD_APPLICATION_ARCHIVE, async () => {
-    await uploadApplicationArchive(ctx, {
+    const [archivePath] = await uploadApplicationArchive(ctx, {
       patternOrPath: resolveArtifactPath(ctx.job),
       rootDir: ctx.getReactNativeProjectDirectory(),
       logger: ctx.logger,
     });
+    const buildId = ctx.env.EAS_BUILD_ID;
+    if (!archivePath || !buildId) {
+      return;
+    }
+    try {
+      const { appVersion, appBuildVersion } = await extractAndroidVersionAsync(archivePath);
+      if (appVersion || appBuildVersion) {
+        await updateResolvedVersionAsync(ctx.graphqlClient, buildId, {
+          appVersion,
+          appBuildVersion,
+        });
+        ctx.logger.info(
+          `Updated resolved version: ${appVersion ?? 'N/A'} (${appBuildVersion ?? 'N/A'})`
+        );
+      }
+    } catch (err: any) {
+      Sentry.capture('Failed to update resolved version', err);
+      ctx.logger.warn({ err }, 'Failed to update resolved version (non-fatal)');
+    }
   });
 
   if (shouldUploadEmbeddedBundle(ctx)) {

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

@@ -18,6 +18,10 @@ import { downloadApplicationArchiveAsync } from '../ios/resign';
 import { resolveArtifactPath, resolveBuildConfiguration, resolveScheme } from '../ios/resolve';
 import { Sentry } from '../sentry';
 import { parseAndReportXcactivitylog } from '../steps/utils/ios/xcactivitylog';
+import {
+  extractIosVersionAsync,
+  updateResolvedVersionAsync,
+} from '../steps/functions/updateResolvedVersion';
 import {
   cacheStatsAsync,
   restoreCcacheAsync,
@@ -236,11 +240,30 @@ async function buildInnerAsync(
   });
 
   await ctx.runBuildPhase(BuildPhase.UPLOAD_APPLICATION_ARCHIVE, async () => {
-    await uploadApplicationArchive(ctx, {
+    const [archivePath] = await uploadApplicationArchive(ctx, {
       patternOrPath: resolveArtifactPath(ctx.job),
       rootDir: ctx.getReactNativeProjectDirectory(),
       logger: ctx.logger,
     });
+    const buildId = ctx.env.EAS_BUILD_ID;
+    if (!archivePath || !buildId) {
+      return;
+    }
+    try {
+      const { appVersion, appBuildVersion } = await extractIosVersionAsync(archivePath);
+      if (appVersion || appBuildVersion) {
+        await updateResolvedVersionAsync(ctx.graphqlClient, buildId, {
+          appVersion,
+          appBuildVersion,
+        });
+        ctx.logger.info(
+          `Updated resolved version: ${appVersion ?? 'N/A'} (${appBuildVersion ?? 'N/A'})`
+        );
+      }
+    } catch (err: any) {
+      Sentry.capture('Failed to update resolved version', err);
+      ctx.logger.warn({ err }, 'Failed to update resolved version (non-fatal)');
+    }
   });
 
   if (shouldUploadEmbeddedBundle(ctx)) {

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

@@ -0,0 +1,18 @@
+import { type CustomBuildContext } from '../../customBuildContext';
+import { getEasFunctions } from '../easFunctions';
+
+it('registers opt-in session functions with the existing inputs', () => {
+  const functions = getEasFunctions({ hasBuildJob: () => false } as CustomBuildContext);
+  for (const name of ['serve_sim_remote', 'agent_device', 'argent_remote', 'appium_remote']) {
+    const existing = functions.find(fn => fn.id === `start_${name}_session`)!;
+    const warm = functions.find(fn => fn.id === `start_warm_${name}_session`)!;
+    expect(warm.getFullId()).toBe(`eas/start_warm_${name}_session`);
+    const warmInputs = warm.inputProviders!.map(input => input(undefined as never, 'warm').id);
+    const existingInputs = existing.inputProviders!.map(
+      input => input(undefined as never, 'existing').id
+    );
+    expect(warmInputs).toEqual(existingInputs);
+  }
+  const ids = functions.map(fn => fn.getFullId());
+  expect(new Set(ids).size).toBe(ids.length);
+});

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

@@ -33,6 +33,7 @@ import { createSubmitToGooglePlayBuildFunction } from './functions/submitToGoogl
 import { createReadPackageJsonBuildFunction } from './functions/readPackageJson';
 import { createRepackBuildFunction } from './functions/repack';
 import { createReportMaestroTestResultsFunction } from './functions/reportMaestroTestResults';
+import { createUpdateResolvedVersionBuildFunction } from './functions/updateResolvedVersion';
 import { resolveAppleTeamIdFromCredentialsFunction } from './functions/resolveAppleTeamIdFromCredentials';
 import { createResolveBuildConfigBuildFunction } from './functions/resolveBuildConfig';
 import {
@@ -111,8 +112,11 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     runFastlaneFunction(),
     parseXcactivitylogFunction(),
     createStartAgentDeviceSessionBuildFunction(ctx),
+    createStartAgentDeviceSessionBuildFunction(ctx, { warm: true }),
     createStartArgentRemoteSessionBuildFunction(ctx),
+    createStartArgentRemoteSessionBuildFunction(ctx, { warm: true }),
     createStartAppiumRemoteSessionBuildFunction(ctx),
+    createStartAppiumRemoteSessionBuildFunction(ctx, { warm: true }),
     createStartAndroidEmulatorBuildFunction(),
     createStartCuttlefishDeviceBuildFunction(),
     createStartIosSimulatorBuildFunction(),
@@ -121,6 +125,7 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     createFinishIosSimulatorRecordingsBuildFunction(),
     createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx),
     createStartWebPreviewRemoteSessionBuildFunction(ctx),
+    createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true }),
     createStartServeSimMetricsBuildFunction(),
     createStartServeSimLogsBuildFunction(),
     createCollectServeSimLogsBuildFunction(ctx),
@@ -154,6 +159,7 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     functions.push(
       ...[
         createFindAndUploadBuildArtifactsBuildFunction(ctx),
+        createUpdateResolvedVersionBuildFunction(ctx),
         createUploadEmbeddedBundleBuildFunction(ctx),
         createResolveBuildConfigBuildFunction(ctx),
         createGetCredentialsForBuildTriggeredByGithubIntegration(ctx),

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

@@ -130,6 +130,35 @@ describe(createEasBuildBuildFunctionGroup, () => {
       );
     });
 
+    it.each([
+      ['Android without credentials', { platform: Platform.ANDROID }],
+      ['Android with credentials', { platform: Platform.ANDROID, buildCredentials: { test: {} } }],
+      ['iOS simulator', { platform: Platform.IOS, simulator: true }],
+      ['iOS with credentials', { platform: Platform.IOS, buildCredentials: { test: {} } }],
+    ])('wires the uploaded archive path into the update step (%s)', (_label, overrides) => {
+      const buildToolsContext = createMockBuildToolsContext(overrides);
+      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
+      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
+
+      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx);
+
+      const updateStep = steps.find(s => s.displayName === 'Update resolved version');
+      const archivePathInput = updateStep?.inputs?.find(
+        input => input.id === 'application_archive_path'
+      );
+      expect(updateStep).toBeDefined();
+      expect(archivePathInput?.rawValue).toBe(
+        '${ steps.find_and_upload_build_artifacts.application_archive_path }'
+      );
+
+      // The step ID must be assigned explicitly: an auto-generated ID makes the input
+      // interpolation throw "Step ... does not exist" before the function body runs.
+      const uploadStepIndex = steps.findIndex(s => s.id === 'find_and_upload_build_artifacts');
+      expect(uploadStepIndex).toBeGreaterThan(-1);
+      expect(steps[uploadStepIndex].displayName).toBe('Find and upload build artifacts');
+      expect(uploadStepIndex).toBeLessThan(steps.indexOf(updateStep!));
+    });
+
     it('composes working directory with installPods step-level ./ios dir (iOS)', () => {
       const buildToolsContext = createMockBuildToolsContext({
         platform: Platform.IOS,

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

@@ -19,6 +19,7 @@ import { configureIosCredentialsFunction } from '../functions/configureIosCreden
 import { configureIosVersionFunction } from '../functions/configureIosVersion';
 import { eagerBundleBuildFunction } from '../functions/eagerBundle';
 import { createFindAndUploadBuildArtifactsBuildFunction } from '../functions/findAndUploadBuildArtifacts';
+import { createUpdateResolvedVersionBuildFunction } from '../functions/updateResolvedVersion';
 import { generateGymfileFromTemplateFunction } from '../functions/generateGymfileFromTemplate';
 import { injectAndroidCredentialsFunction } from '../functions/injectAndroidCredentials';
 import { createInstallNodeModulesBuildFunction } from '../functions/installNodeModules';
@@ -183,7 +184,20 @@ function createStepsForIosSimulatorBuild({
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx, {
+      id: 'find_and_upload_build_artifacts',
+      workingDirectory,
+    }),
+    createUpdateResolvedVersionBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
+      globalCtx,
+      {
+        workingDirectory,
+        callInputs: {
+          application_archive_path:
+            '${ steps.find_and_upload_build_artifacts.application_archive_path }',
+        },
+      }
+    ),
     saveCache,
     createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
       workingDirectory,
@@ -304,7 +318,10 @@ function createStepsForIosBuildWithCredentials({
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx, {
+      id: 'find_and_upload_build_artifacts',
+      workingDirectory,
+    }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -318,6 +335,16 @@ function createStepsForIosBuildWithCredentials({
           }),
         ]
       : []),
+    createUpdateResolvedVersionBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
+      globalCtx,
+      {
+        workingDirectory,
+        callInputs: {
+          application_archive_path:
+            '${ steps.find_and_upload_build_artifacts.application_archive_path }',
+        },
+      }
+    ),
     saveCache,
     createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
       workingDirectory,
@@ -404,7 +431,10 @@ function createStepsForAndroidBuildWithoutCredentials({
     runGradle,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx, {
+      id: 'find_and_upload_build_artifacts',
+      workingDirectory,
+    }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -418,6 +448,16 @@ function createStepsForAndroidBuildWithoutCredentials({
           }),
         ]
       : []),
+    createUpdateResolvedVersionBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
+      globalCtx,
+      {
+        workingDirectory,
+        callInputs: {
+          application_archive_path:
+            '${ steps.find_and_upload_build_artifacts.application_archive_path }',
+        },
+      }
+    ),
     saveCache,
     createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
       workingDirectory,
@@ -510,7 +550,10 @@ function createStepsForAndroidBuildWithCredentials({
       : []),
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+    ).createBuildStepFromFunctionCall(globalCtx, {
+      id: 'find_and_upload_build_artifacts',
+      workingDirectory,
+    }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -524,6 +567,16 @@ function createStepsForAndroidBuildWithCredentials({
           }),
         ]
       : []),
+    createUpdateResolvedVersionBuildFunction(buildToolsContext).createBuildStepFromFunctionCall(
+      globalCtx,
+      {
+        workingDirectory,
+        callInputs: {
+          application_archive_path:
+            '${ steps.find_and_upload_build_artifacts.application_archive_path }',
+        },
+      }
+    ),
     saveCache,
     createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
       workingDirectory,

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

@@ -6,6 +6,7 @@ import type { CustomBuildContext } from '../../../customBuildContext';
 import { Sentry } from '../../../sentry';
 import { AndroidEmulatorUtils } from '../../../utils/AndroidEmulatorUtils';
 import { turtleFetch } from '../../../utils/turtleFetch';
+import { pollAgentDeviceArtifactsForUploadAsync } from '../../utils/agentDeviceArtifacts';
 import { startAgentDeviceEventCollectionAsync } from '../../utils/agentDeviceEvents';
 import { startAppiumEventCollectionAsync } from '../../utils/appiumEvents';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
@@ -54,6 +55,7 @@ const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnTh
 
 beforeEach(() => {
   jest.clearAllMocks();
+  jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockResolvedValue();
   // The daemon package is external. No installation or daemon process runs in these tests.
   jest.spyOn(fs, 'existsSync').mockReturnValue(true);
   // Only the emulator logcat folder: the Appium step writes into its own temp folder.
@@ -145,7 +147,11 @@ describe.each([
 
   it('holds the host until session completion', async () => {
     await runAsync();
-    expect(openPreview).toHaveBeenCalledWith({ baseDomain: 'example.test', authtoken: 'token' });
+    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ preview: { baseDomain: 'example.test', authtoken: 'token' } })
+    );
+    expect(openPreview).toHaveBeenCalledWith();
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
       expect.objectContaining({
         remoteConfig: expect.objectContaining({
@@ -350,6 +356,10 @@ describe('Appium ffmpeg setup', () => {
   }
 
   function holdFfmpegInstall({ appiumError }: { appiumError?: Error } = {}) {
+    let markStarted!: () => void;
+    const started = new Promise<void>(resolve => {
+      markStarted = resolve;
+    });
     let finish!: (outcome: 'installed' | 'failed') => void;
     const install = new Promise((resolve, reject) => {
       finish = outcome =>
@@ -360,25 +370,26 @@ describe('Appium ffmpeg setup', () => {
         return Promise.reject(new Error('ffmpeg missing'));
       }
       if (args.includes('install') && args.includes('ffmpeg')) {
+        markStarted();
         return install;
       }
       return command === 'npm' && appiumError
         ? Promise.reject(appiumError)
         : Promise.resolve({ stdout: '{}' });
     }) as never);
-    return finish;
+    return { finish, started };
   }
 
   it.each(['installed', 'failed'] as const)(
     'starts Appium after the ffmpeg install settles (%s)',
     async outcome => {
-      const finishFfmpegInstall = holdFfmpegInstall();
+      const { finish, started } = holdFfmpegInstall();
 
       const run = runAppiumAsync();
-      await new Promise(resolve => setImmediate(resolve));
+      await started;
       expect(spawnDetached).not.toHaveBeenCalled();
 
-      finishFfmpegInstall(outcome);
+      finish(outcome);
       await run;
       expect(spawnDetached).toHaveBeenCalledTimes(1);
     }
@@ -386,16 +397,16 @@ describe('Appium ffmpeg setup', () => {
 
   it('waits for the ffmpeg install before failing on an Appium install error', async () => {
     const appiumError = new Error('npm failed');
-    const finishFfmpegInstall = holdFfmpegInstall({ appiumError });
+    const { finish, started } = holdFfmpegInstall({ appiumError });
 
     let settled = false;
     const run = runAppiumAsync().finally(() => {
       settled = true;
     });
-    await new Promise(resolve => setImmediate(resolve));
+    await started;
     expect(settled).toBe(false);
 
-    finishFfmpegInstall('installed');
+    finish('installed');
     await expect(run).rejects.toBe(appiumError);
   });
 });

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

@@ -51,6 +51,24 @@ describe(createFindAndUploadBuildArtifactsBuildFunction, () => {
     await expect(buildStep.executeAsync()).resolves.not.toThrow();
   });
 
+  it('sets application_archive_path output to first archive', async () => {
+    const globalContext = createGlobalContextMock({});
+    vol.fromJSON(
+      {
+        'ios/build/test.ipa': '',
+      },
+      globalContext.defaultWorkingDirectory
+    );
+    const buildStep = findAndUploadBuildArtifacts.createBuildStepFromFunctionCall(
+      globalContext,
+      {}
+    );
+
+    await buildStep.executeAsync();
+
+    expect(buildStep.outputById.application_archive_path.value).toMatch(/ios\/build\/test\.ipa$/);
+  });
+
   it('throws build artifacts error', async () => {
     const globalContext = createGlobalContextMock({});
     ctx.job.buildArtifactPaths = ['worker.log'];

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

@@ -7,6 +7,7 @@ import { type CustomBuildContext } from '../../../customBuildContext';
 import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { isProcessDescendantOfAsync } from '../../../utils/processes';
 import { turtleFetch } from '../../../utils/turtleFetch';
+import { pollAgentDeviceArtifactsForUploadAsync } from '../../utils/agentDeviceArtifacts';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
 import {
   monitorLocalEgressAsync,
@@ -124,6 +125,7 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
   }
   beforeEach(() => {
     jest.clearAllMocks();
+    jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockResolvedValue();
     lifetime = registerLocalEgressResources(stopEgress);
     stopEgress.mockResolvedValue(undefined);
     stopPreview.mockResolvedValue(undefined);

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

@@ -1,12 +1,15 @@
 import { BuildRuntimePlatform } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
+import fetch from 'node-fetch';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { Readable } from 'node:stream';
 
 import { type CustomBuildContext } from '../../../customBuildContext';
 import { pollAgentDeviceArtifactsForUploadAsync } from '../../utils/agentDeviceArtifacts';
 import { startAgentDeviceEventCollectionAsync } from '../../utils/agentDeviceEvents';
+import { uploadDeviceRunSessionArtifactAsync } from '../../utils/deviceRunSessionArtifacts';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
 import {
   getDeviceRunSessionIdOrThrow,
@@ -21,6 +24,8 @@ import {
 } from '../../utils/remoteDeviceRunSession';
 import { createProcessOutput } from '../../utils/processOutput';
 import { type StartupTasks, createStartupTasks } from '../../utils/startupTasks';
+import { createWarmDeviceSessionServer } from '../../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../../utils/warmIosSession';
 import { runAgentDeviceRemoteSessionAsync } from '../startAgentDeviceRemoteSession';
 
 // The daemon entry path and the state directory are resolved from the home directory when
@@ -38,10 +43,14 @@ jest.mock('../../../sentry');
 jest.mock('../../utils/agentDeviceArtifacts', () => ({
   pollAgentDeviceArtifactsForUploadAsync: jest.fn(),
 }));
+jest.mock('../../utils/deviceRunSessionArtifacts', () => ({
+  uploadDeviceRunSessionArtifactAsync: jest.fn(),
+}));
 jest.mock('../../utils/agentDeviceEvents', () => ({
   startAgentDeviceEventCollectionAsync: jest.fn(),
 }));
 jest.mock('../../utils/deviceSessionHost');
+jest.mock('../../utils/warmDeviceSessionHost');
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   getDeviceRunSessionIdOrThrow: jest.fn(),
@@ -74,10 +83,7 @@ const NO_CAPTURE: CaptureInputs = { networkCapture: false, networkCaptureFields:
 async function runAsync(
   logger: { info: jest.Mock; warn: jest.Mock; child: jest.Mock },
   runtimePlatform: BuildRuntimePlatform,
-  capture: CaptureInputs = NO_CAPTURE,
-  disableShare = false,
-  privatePreviewUrl?: string,
-  maxIdleTimeMinutes?: number
+  options: Partial<Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]> = {}
 ): Promise<void> {
   await runAgentDeviceRemoteSessionAsync(ctx, {
     env: {},
@@ -89,16 +95,15 @@ async function runAsync(
       ngrokAuthtoken: 'ngrok-token',
     },
     packageVersion: undefined,
-    maxIdleTimeMinutes,
+    maxIdleTimeMinutes: undefined,
     maxDurationSeconds: undefined,
-    capture,
-    disableShare,
-    privatePreviewUrl,
-    tasks: createStartupTasks(logger as never),
+    capture: NO_CAPTURE,
+    tasks: createStartupTasks(logger as never, options.signal),
     device:
       runtimePlatform === BuildRuntimePlatform.DARWIN
         ? { iosSimulatorUdid: 'selected-udid', application: Promise.resolve() }
         : { booted: Promise.resolve(), ready: Promise.resolve() },
+    ...options,
   });
 }
 
@@ -195,6 +200,213 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     expect(mockDaemonStopAsync).toHaveBeenCalledTimes(1);
   });
 
+  it('uses the warm daemon after adoption and starts no daemon of its own', async () => {
+    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
+    const warmServer = { port: 3200 } as never;
+    jest.mocked(createWarmDeviceSessionServer).mockReturnValue(warmServer);
+    const warm = {
+      agentDeviceStateDir: '/warm/agent',
+      tools: { pid: 20, port: 4310, token: 'warm-token' },
+    } as WarmIosSession;
+    await runAgentDeviceRemoteSessionAsync(ctx, {
+      env: {},
+      logger: logger as never,
+      runtimePlatform: BuildRuntimePlatform.DARWIN,
+      sessionEnv: {
+        deviceRunSessionId: 'device-run-session-id',
+        ngrokTunnelDomain: 'tunnel.example.com',
+        ngrokAuthtoken: 'ngrok-token',
+      },
+      packageVersion: undefined,
+      maxIdleTimeMinutes: undefined,
+      maxDurationSeconds: undefined,
+      capture: NO_CAPTURE,
+      tasks: createStartupTasks(logger as never),
+      warm,
+      device: { iosSimulatorUdid: 'UDID', application: Promise.resolve() },
+    });
+    expect(spawnDetached).not.toHaveBeenCalled();
+    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(ctx, expect.anything(), warmServer);
+    expect(startNgrokTunnelAsync).toHaveBeenCalledWith(expect.objectContaining({ port: 4310 }));
+    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        remoteConfig: expect.objectContaining({ agentDeviceRemoteSessionToken: 'warm-token' }),
+      })
+    );
+    expect(startAgentDeviceEventCollectionAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ stateDir: '/warm/agent' })
+    );
+    expect(mockEventCollectionStopAsync).toHaveBeenCalledTimes(1);
+    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([false, true])(
+    'finishes the final artifact upload before stopping its owner (warm=%s)',
+    async warm => {
+      const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
+      const { pollAgentDeviceArtifactsForUploadAsync: pollActual } = jest.requireActual<
+        typeof import('../../utils/agentDeviceArtifacts')
+      >('../../utils/agentDeviceArtifacts');
+      jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockImplementation(pollActual);
+      const { Response } = jest.requireActual<typeof import('node-fetch')>('node-fetch');
+      const artifacts: { id: string; filename: string }[] = [];
+      let releaseUpload = () => {};
+      const pendingUpload = new Promise<void>(resolve => {
+        releaseUpload = resolve;
+      });
+      let markUploadStarted = () => {};
+      const uploadStarted = new Promise<void>(resolve => {
+        markUploadStarted = resolve;
+      });
+      jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementationOnce(async () => {
+        markUploadStarted();
+        await pendingUpload;
+      });
+      let inventories = 0;
+      jest.mocked(fetch).mockImplementation(async url => {
+        if (String(url).endsWith('/artifacts')) {
+          inventories += 1;
+          return new Response(JSON.stringify({ artifacts }));
+        }
+        return new Response(Readable.from([Buffer.from('screenshot')]));
+      });
+      jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async () => {
+        while (inventories === 0) {
+          await new Promise(resolve => setTimeout(resolve, 5));
+        }
+        // The next periodic inventory is 5 seconds away, so only the final one can see this file.
+        artifacts.push({ id: 'late', filename: 'late.png' });
+      });
+
+      const running = runAsync(
+        logger,
+        warm ? BuildRuntimePlatform.DARWIN : BuildRuntimePlatform.LINUX,
+        {
+          warm: warm
+            ? ({
+                agentDeviceStateDir: '/warm/agent',
+                tools: { port: 4310, token: 'warm-token' },
+              } as WarmIosSession)
+            : undefined,
+        }
+      );
+      try {
+        await uploadStarted;
+        expect(mockDaemonStopAsync).not.toHaveBeenCalled();
+        if (warm) {
+          expect(mockPreviewStopAsync).not.toHaveBeenCalled();
+        }
+      } finally {
+        releaseUpload();
+        await running;
+      }
+
+      expect(uploadDeviceRunSessionArtifactAsync).toHaveBeenCalledWith(
+        ctx,
+        expect.objectContaining({ artifactId: 'late', filename: 'late.png' })
+      );
+      expect(inventories).toBe(2);
+      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
+      expect(mockDaemonStopAsync).toHaveBeenCalledTimes(warm ? 0 : 1);
+    }
+  );
+
+  it('stops the daemon when the final artifact drain fails', async () => {
+    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
+    const failure = new Error('drain failed');
+    jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockRejectedValue(failure);
+
+    await expect(runAsync(logger, BuildRuntimePlatform.LINUX)).rejects.toBe(failure);
+
+    expect(pollAgentDeviceArtifactsForUploadAsync).toHaveBeenCalledWith(
+      ctx,
+      expect.objectContaining({ stopPollingSignal: expect.any(AbortSignal) })
+    );
+    expect(mockDaemonStopAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([false, true])(
+    'stops the warm host after a failed drain (collector startup fails=%s)',
+    async startupFails => {
+      const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
+      const drainFailure = new Error('drain failed');
+      const startupFailure = new Error('event collector failed');
+      jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockRejectedValueOnce(drainFailure);
+      if (startupFails) {
+        jest.mocked(startAgentDeviceEventCollectionAsync).mockRejectedValueOnce(startupFailure);
+      }
+      await expect(
+        runAsync(logger, BuildRuntimePlatform.DARWIN, {
+          warm: {
+            agentDeviceStateDir: '/warm/agent',
+            tools: { port: 4310, token: 'warm-token' },
+          } as WarmIosSession,
+        })
+      ).rejects.toBe(startupFails ? startupFailure : drainFailure);
+      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
+      expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
+      expect(mockDaemonStopAsync).not.toHaveBeenCalled();
+      expect(logger.warn).toHaveBeenCalledWith(
+        { err: drainFailure },
+        'Could not stop the agent-device daemon during remote session teardown.'
+      );
+    }
+  );
+
+  it('cancels a warm upload and drains its poller before stopping the host', async () => {
+    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
+    const controller = new AbortController();
+    const cancellation = new Error('job cancelled');
+    const { pollAgentDeviceArtifactsForUploadAsync: pollActual } = jest.requireActual<
+      typeof import('../../utils/agentDeviceArtifacts')
+    >('../../utils/agentDeviceArtifacts');
+    const pollingFinished = jest.fn();
+    jest
+      .mocked(pollAgentDeviceArtifactsForUploadAsync)
+      .mockImplementation((...args) => pollActual(...args).finally(pollingFinished));
+    const { Response } = jest.requireActual<typeof import('node-fetch')>('node-fetch');
+    jest
+      .mocked(fetch)
+      .mockImplementation(async url =>
+        String(url).endsWith('/artifacts')
+          ? new Response(JSON.stringify({ artifacts: [{ id: 'active', filename: 'active.png' }] }))
+          : new Response(Readable.from(['png']))
+      );
+    let markUploadStarted = () => {};
+    const uploadStarted = new Promise<void>(resolve => {
+      markUploadStarted = resolve;
+    });
+    jest
+      .mocked(uploadDeviceRunSessionArtifactAsync)
+      .mockImplementationOnce(async (_ctx, { signal }) => {
+        markUploadStarted();
+        await new Promise<void>((_resolve, reject) => {
+          signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
+        });
+      });
+    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementationOnce(async () => {
+      await uploadStarted;
+      controller.abort(cancellation);
+      throw cancellation;
+    });
+    await expect(
+      runAsync(logger, BuildRuntimePlatform.DARWIN, {
+        signal: controller.signal,
+        warm: {
+          agentDeviceStateDir: '/warm/agent',
+          tools: { port: 4310, token: 'warm-token' },
+        } as WarmIosSession,
+      })
+    ).rejects.toBe(cancellation);
+    expect(pollingFinished).toHaveBeenCalledTimes(1);
+    expect(pollingFinished.mock.invocationCallOrder[0]).toBeLessThan(
+      mockPreviewStopAsync.mock.invocationCallOrder[0]
+    );
+    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
+    expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
+    expect(mockDaemonStopAsync).not.toHaveBeenCalled();
+  });
+
   it('redacts learned daemon credentials in arbitrary output and retained diagnostics', async () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
     const token = 'daemon secret/+';
@@ -224,7 +436,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     } as never);
     jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(previewInputAt);
 
-    await runAsync(logger, BuildRuntimePlatform.LINUX, NO_CAPTURE, false, undefined, 5);
+    await runAsync(logger, BuildRuntimePlatform.LINUX, { maxIdleTimeMinutes: 5 });
 
     const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
     expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
@@ -235,8 +447,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
 
     await runAsync(logger, BuildRuntimePlatform.DARWIN, {
-      networkCapture: true,
-      networkCaptureFields: ['header'],
+      capture: { networkCapture: true, networkCaptureFields: ['header'] },
     });
 
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
@@ -247,13 +458,10 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
 
   it('hands a private preview choice to the session host', async () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    await runAsync(
-      logger,
-      BuildRuntimePlatform.DARWIN,
-      NO_CAPTURE,
-      true,
-      'https://expo.dev/private-preview'
-    );
+    await runAsync(logger, BuildRuntimePlatform.DARWIN, {
+      disableShare: true,
+      privatePreviewUrl: 'https://expo.dev/private-preview',
+    });
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
       ctx,
       expect.objectContaining({
@@ -615,10 +823,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
         ctx,
         {} as never
       );
-      const preview = await host.openPreviewAsync({
-        baseDomain: 'tunnel.example.com',
-        authtoken: 'ngrok-token',
-      });
+      const preview = await host.openPreviewAsync();
       jest.mocked(host.openPreviewAsync).mockImplementation(async () => {
         await previewReady.promise;
         return preview;

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

@@ -4,7 +4,6 @@ import spawn from '@expo/turtle-spawn';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
-import { DeviceRunSessionWorkerApi } from '../../utils/deviceRunSessionWorkerApi';
 import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { stopLocalEgressResourcesAsync } from '../../utils/localEgress';
 import {
@@ -20,6 +19,7 @@ import {
   getAgentDeviceRemoteSessionEnvOrThrow,
   runAgentDeviceRemoteSessionAsync,
 } from '../startAgentDeviceRemoteSession';
+import { runOnWarmIosSimulatorAsync } from '../../utils/warmDeviceSessionHost';
 import { createStartAgentDeviceSessionBuildFunction } from '../startAgentDeviceSession';
 import { startAndroidEmulatorAsync } from '../startAndroidEmulator';
 import { bootIosSimulatorAsync } from '../startIosSimulator';
@@ -42,6 +42,7 @@ jest.mock('../startIosSimulator', () => ({
   bootIosSimulatorAsync: jest.fn(),
 }));
 jest.mock('../startAndroidEmulator', () => ({ startAndroidEmulatorAsync: jest.fn() }));
+jest.mock('../../utils/warmDeviceSessionHost');
 jest.mock('../downloadBuild', () => ({ downloadBuildAsync: jest.fn() }));
 jest.mock('../installBuild', () => ({ installBuildAsync: jest.fn() }));
 jest.mock('../../utils/iosAppArtifact', () => ({
@@ -102,9 +103,10 @@ function runStep(
   runtimePlatform: BuildRuntimePlatform,
   inputValues: Record<string, unknown> = {},
   signal?: AbortSignal,
-  stepCtx: CustomBuildContext = ctx
+  stepCtx: CustomBuildContext = ctx,
+  warm = false
 ): Promise<void> {
-  const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx);
+  const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx, { warm });
   const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
   const inputs = Object.fromEntries(
     [
@@ -113,8 +115,10 @@ function runStep(
       'lcd_width',
       'lcd_height',
       'lcd_density',
+      'install_app_path',
       'build_id',
       'application_archive_url',
+      'launch_app_identifier',
       'launch_args',
       'open_url',
       'network_capture',
@@ -172,7 +176,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       emulatorPromise: Promise.resolve(),
       shouldAdjustAnimationScale: true,
     });
-    jest.mocked(downloadBuildAsync).mockResolvedValue({ artifactPath: '/tmp/App.app' });
     jest
       .mocked(installBuildAsync)
       .mockResolvedValue({ applicationIdentifier: 'dev.example.app', activityName: '.Main' });
@@ -188,7 +191,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     };
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(bootEnv);
     await runStep(BuildRuntimePlatform.DARWIN, {
-      build_id: 'build-id',
+      install_app_path: '/tmp/App.app',
       launch_args: ['-flag'],
       open_url: 'exp://example.test',
     });
@@ -202,14 +205,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       jest.mocked(runAgentDeviceRemoteSessionAsync).mock.invocationCallOrder[0]
     );
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        buildId: 'build-id',
-        extensions: ['app'],
-        graphqlClient,
-        robotAccessToken: 'robot-token',
-      })
-    );
+
     expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledTimes(1);
     const device = sessionDevice();
     expect(device).toEqual({
@@ -253,63 +249,21 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     );
   });
 
-  it('downloads build_id through the device run session worker API when the job has a session token', async () => {
-    const sessionCtx = {
-      graphqlClient,
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    } as unknown as CustomBuildContext;
-
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' }, undefined, sessionCtx);
-
-    expect(downloadBuildAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        buildId: 'build-id',
-        deviceRunSessionWorkerApi: expect.any(DeviceRunSessionWorkerApi),
-      })
-    );
-  });
-
-  it('does not use the worker API without a session token or for an archive URL', async () => {
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' });
-    expect(downloadBuildAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({ buildId: 'build-id', deviceRunSessionWorkerApi: null })
-    );
-
-    const sessionCtx = {
-      graphqlClient,
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    } as unknown as CustomBuildContext;
-    await runStep(
-      BuildRuntimePlatform.LINUX,
-      { application_archive_url: 'https://example.test/app.tar.gz' },
-      undefined,
-      sessionCtx
-    );
-    expect(downloadBuildAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        applicationArchiveUrl: 'https://example.test/app.tar.gz',
-        deviceRunSessionWorkerApi: null,
-      })
-    );
-  });
-
-  it('fails before download or host startup when guarded device shutdown fails', async () => {
+  it('fails before app installation or host startup when guarded device shutdown fails', async () => {
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
       SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
     });
     jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({ state: 'Booted' } as never);
     jest.mocked(spawn).mockRejectedValue(new Error('shutdown failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'shutdown failed'
-    );
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
+    await expect(
+      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app' })
+    ).rejects.toThrow('shutdown failed');
+
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
     expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
   });
 
-  it('provides Simulator preparation and downloaded startup options to the remote session', async () => {
+  it('provides Simulator preparation and local app startup options to the remote session', async () => {
     const hostReady = deferred();
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
       SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
@@ -324,7 +278,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     });
     const step = runStep(BuildRuntimePlatform.DARWIN, {
       device_identifier: 'iPhone 17',
-      build_id: 'build-id',
+      install_app_path: '/tmp/App.app',
       launch_args: ['-flag'],
       open_url: 'exp://example.test',
     });
@@ -334,7 +288,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       env: {},
     });
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).toHaveBeenCalledTimes(1);
+
     expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
       artifactPath: '/tmp/App.app',
       env: {},
@@ -352,15 +306,15 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     });
   });
 
-  it('fails a guarded session before download or host startup if its boot files are missing', async () => {
+  it('fails a guarded session before app installation or host startup if its boot files are missing', async () => {
     jest
       .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
       .mockRejectedValue(new Error('missing bin/egress-guard-check'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'missing bin/egress-guard-check'
-    );
+    await expect(
+      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app' })
+    ).rejects.toThrow('missing bin/egress-guard-check');
     expect(startLocalEgressGuardRelayAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
+
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
     expect(IosSimulatorUtils.getDeviceAsync).not.toHaveBeenCalled();
     expect(spawn).not.toHaveBeenCalled();
@@ -375,35 +329,18 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     jest
       .mocked(runAgentDeviceRemoteSessionAsync)
       .mockRejectedValueOnce(new Error('guard check failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'guard check failed'
-    );
+    await expect(
+      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app' })
+    ).rejects.toThrow('guard check failed');
     expect(startLocalEgressGuardRelayAsync).toHaveBeenCalledTimes(1);
     expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
     expect(installBuildAsync).not.toHaveBeenCalled();
     expect(launchApplicationAsync).not.toHaveBeenCalled();
   });
 
-  it('waits for the download before handing the app to the host', async () => {
-    const download = deferred<{ artifactPath: string }>();
-    jest.mocked(downloadBuildAsync).mockReturnValue(download.promise);
-
-    const step = runStep(BuildRuntimePlatform.DARWIN, {
-      application_archive_url: 'https://example.test/app.tar.gz',
-    });
-    await flushAsync();
-    expect(installBuildAsync).not.toHaveBeenCalled();
-
-    download.resolve({ artifactPath: '/tmp/App.app' });
-    await step;
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledTimes(1);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
   it('passes the selected Simulator to the host even when there is no app', async () => {
     await runStep(BuildRuntimePlatform.DARWIN);
 
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
     expect(installBuildAsync).not.toHaveBeenCalled();
     expect(launchApplicationAsync).not.toHaveBeenCalled();
     expect(sessionDevice()).toEqual({
@@ -420,7 +357,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       lcd_width: 720,
       lcd_height: 1600,
       lcd_density: 300,
-      build_id: 'build-id',
+      install_app_path: '/tmp/App.app',
     });
 
     expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
@@ -433,131 +370,33 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
         lcdDensity: 300,
       })
     );
-    expect(downloadBuildAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ extensions: ['apk'] })
-    );
+
     expect(launchApplicationAsync).toHaveBeenCalledWith(
       expect.objectContaining({ applicationIdentifier: 'dev.example.app', activityName: '.Main' })
     );
   });
 
-  it('fails the session when the download fails, without an unhandled rejection', async () => {
-    jest.mocked(downloadBuildAsync).mockRejectedValue(new Error('download failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'download failed'
-    );
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
-  /** A download that runs until its abort signal fires, like a stalled one. */
-  function mockStalledDownload(): { aborted: () => boolean; settled: () => boolean } {
-    let aborted = false;
-    let settled = false;
-    jest.mocked(downloadBuildAsync).mockImplementation(
-      ({ signal }) =>
-        new Promise((_resolve, reject) => {
-          signal!.addEventListener('abort', () => {
-            aborted = true;
-            // Settles a bit later, like a request that winds down.
-            setImmediate(() => {
-              settled = true;
-              reject(new Error('The user aborted a request.'));
-            });
-          });
-        })
-    );
-    return { aborted: () => aborted, settled: () => settled };
-  }
-
-  /** Runs the session like the real one: fails with the daemon, then waits for every part. */
-  function mockSessionWithFailingDaemon(beforeFailure?: () => Promise<void>): void {
-    jest
-      .mocked(runAgentDeviceRemoteSessionAsync)
-      .mockImplementation(async (_ctx, { tasks, device }) => {
-        const ready = runDevicePreparationAsync(device);
-        await beforeFailure?.();
-        const daemon = tasks.run('agent-device daemon', async () => {
-          throw new Error('daemon failed');
-        });
-        try {
-          await Promise.all([daemon, ready]);
-        } finally {
-          await Promise.allSettled([daemon, ready]);
-        }
-      });
-  }
-
-  it('stops the download and waits for it when Android boot fails', async () => {
-    const download = mockStalledDownload();
-    jest.mocked(startAndroidEmulatorAsync).mockRejectedValue(new Error('boot failed'));
-
-    await expect(runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' })).rejects.toThrow(
-      'boot failed'
-    );
-
-    expect(download.aborted()).toBe(true);
-    // The step returned only after the download stopped.
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
-  it('stops a stalled download and does not install when the daemon fails', async () => {
-    const download = mockStalledDownload();
-    mockSessionWithFailingDaemon();
-
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'daemon failed'
-    );
-
-    expect(download.aborted()).toBe(true);
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-  });
-
-  it('drains the download when host startup fails before app preparation', async () => {
-    const download = mockStalledDownload();
-    jest.mocked(runAgentDeviceRemoteSessionAsync).mockRejectedValue(new Error('host failed'));
-
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'host failed'
-    );
-    expect(download.aborted()).toBe(true);
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
   it('does not start work for an already cancelled step', async () => {
     const controller = new AbortController();
     controller.abort(new Error('cancelled'));
 
     await expect(
-      runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal)
+      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app' }, controller.signal)
     ).rejects.toThrow('cancelled');
     expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
+
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
 
-  it('cancels and drains a pending download through the external signal', async () => {
-    const controller = new AbortController();
-    const download = mockStalledDownload();
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal);
-    const failure = expect(step).rejects.toThrow('cancelled');
-    await flushAsync();
-    controller.abort(new Error('cancelled'));
-
-    await failure;
-    expect(download.aborted()).toBe(true);
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
-  it('does not start device or download work after cancellation during Xcode selection', async () => {
+  it('does not start device or app work after cancellation during Xcode selection', async () => {
     const controller = new AbortController();
     const selected = deferred();
     jest.mocked(selectXcodeDeveloperDirectoryAsync).mockReturnValue(selected.promise);
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal);
+    const step = runStep(
+      BuildRuntimePlatform.DARWIN,
+      { install_app_path: '/tmp/App.app' },
+      controller.signal
+    );
     const failure = expect(step).rejects.toThrow('cancelled');
     await flushAsync();
     controller.abort(new Error('cancelled'));
@@ -566,42 +405,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     await failure;
     expect(IosSimulatorUtils.resolveUdidAsync).not.toHaveBeenCalled();
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
 
-  it('drains app preparation when the daemon fails', async () => {
-    const metadata = deferred<string>();
-    const metadataStarted = deferred();
-    jest.mocked(readIosApplicationIdentifierAsync).mockImplementation(() => {
-      metadataStarted.resolve();
-      return metadata.promise;
-    });
-    mockSessionWithFailingDaemon(async () => {
-      await metadataStarted.promise;
-      setImmediate(() => metadata.resolve('dev.example.app'));
-    });
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'daemon failed'
-    );
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledTimes(1);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-    expect(deviceLaunch).toBeUndefined();
-  });
-
-  it('rejects conflicting application inputs before it boots anything', async () => {
-    await expect(
-      runStep(BuildRuntimePlatform.DARWIN, {
-        build_id: 'build-id',
-        application_archive_url: 'https://example.test/app.tar.gz',
-      })
-    ).rejects.toThrow('Pass only one of build_id or application_archive_url.');
-    await expect(
-      runStep(BuildRuntimePlatform.DARWIN, { open_url: 'exp://example.test' })
-    ).rejects.toThrow('launch_args and open_url need an application');
-
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
 
@@ -617,8 +421,10 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       'lcd_width',
       'lcd_height',
       'lcd_density',
+      'install_app_path',
       'build_id',
       'application_archive_url',
+      'launch_app_identifier',
       'launch_args',
       'open_url',
       'network_capture',
@@ -678,12 +484,15 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     ['NUL URL', { open_url: 'example:\u0000screen' }],
     ['URL length', { open_url: `example://${'a'.repeat(8192)}` }],
   ])('rejects iOS launch %s before startup work', async (_name, inputs) => {
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id', ...inputs });
+    const step = runStep(BuildRuntimePlatform.DARWIN, {
+      install_app_path: '/tmp/App.app',
+      ...inputs,
+    });
     await expect(step).rejects.toBeInstanceOf(UserError);
     expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
     expect(IosSimulatorUtils.resolveUdidAsync).not.toHaveBeenCalled();
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
+
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
 
@@ -692,16 +501,22 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     ['command length', { launch_args: ['--es', 'quotes', "'".repeat(20_000)] }],
     ['NUL URL', { open_url: 'example:\u0000screen' }],
   ])('rejects Android launch %s before startup work', async (_name, inputs) => {
-    const step = runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', ...inputs });
+    const step = runStep(BuildRuntimePlatform.LINUX, {
+      install_app_path: '/tmp/App.app',
+      ...inputs,
+    });
     await expect(step).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT' });
     expect(startAndroidEmulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
+
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
 
   it('keeps Android launch inputs on its existing direct path', async () => {
     const launchArgs = ['a'.repeat(9000)];
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', launch_args: launchArgs });
+    await runStep(BuildRuntimePlatform.LINUX, {
+      install_app_path: '/tmp/App.app',
+      launch_args: launchArgs,
+    });
     expect(launchApplicationAsync).toHaveBeenCalledWith(
       expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX, launchArgs })
     );
@@ -728,4 +543,170 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     expect(startAndroidEmulatorAsync).not.toHaveBeenCalled();
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
+  it('requires an application for launch options before starting the device', async () => {
+    await expect(
+      runStep(BuildRuntimePlatform.DARWIN, { open_url: 'fixture://route' })
+    ).rejects.toThrow('pass install_app_path or launch_app_identifier');
+    expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
+    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
+  });
+
+  it('launches an installed iOS application without reading an app artifact', async () => {
+    await runStep(BuildRuntimePlatform.DARWIN, {
+      launch_app_identifier: 'dev.installed.app',
+      launch_args: ['--test'],
+      open_url: 'fixture://route',
+    });
+    expect(readIosApplicationIdentifierAsync).not.toHaveBeenCalled();
+    expect(deviceLaunch).toEqual({
+      installAppPath: undefined,
+      launchAppIdentifier: 'dev.installed.app',
+      launchArgs: ['--test'],
+      openUrl: 'fixture://route',
+    });
+  });
+
+  it('keeps explicit application identifier launch iOS-only', async () => {
+    await expect(
+      runStep(BuildRuntimePlatform.LINUX, { launch_app_identifier: 'dev.app' })
+    ).rejects.toThrow('Pass install_app_path for Android');
+    expect(startAndroidEmulatorAsync).not.toHaveBeenCalled();
+  });
+
+  it('still downloads a build_id app and launches it on iOS', async () => {
+    jest.mocked(downloadBuildAsync).mockResolvedValue({ artifactPath: '/tmp/Downloaded.app' });
+    await runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id', launch_args: ['-flag'] });
+    expect(downloadBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ buildId: 'build-id', extensions: ['app'] })
+    );
+    expect(deviceLaunch).toEqual({
+      installAppPath: '/tmp/Downloaded.app',
+      launchAppIdentifier: 'dev.example.app',
+      launchArgs: ['-flag'],
+      openUrl: undefined,
+    });
+  });
+
+  it('still downloads an application_archive_url app and installs it on Android', async () => {
+    jest.mocked(downloadBuildAsync).mockResolvedValue({ artifactPath: '/tmp/Downloaded.apk' });
+    await runStep(BuildRuntimePlatform.LINUX, {
+      application_archive_url: 'https://example.test/app.tar.gz',
+    });
+    expect(downloadBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        applicationArchiveUrl: 'https://example.test/app.tar.gz',
+        extensions: ['apk'],
+      })
+    );
+    expect(installBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ artifactPath: '/tmp/Downloaded.apk' })
+    );
+    expect(launchApplicationAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it('runs the warm step on the warm Simulator for a local app only', async () => {
+    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation((_claim, run) => run());
+    const runWarm = (inputs: Record<string, unknown>) =>
+      runStep(BuildRuntimePlatform.DARWIN, inputs, undefined, ctx, true);
+    await runWarm({ install_app_path: '/tmp/App.app', device_identifier: 'iPhone 17' });
+    expect(runOnWarmIosSimulatorAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ engine: 'agent-device', requestedDevice: 'iPhone 17' }),
+      expect.any(Function)
+    );
+    jest.mocked(runOnWarmIosSimulatorAsync).mockClear();
+    jest.mocked(downloadBuildAsync).mockResolvedValue({ artifactPath: '/tmp/Downloaded.app' });
+    await runWarm({ build_id: 'build-id' });
+    expect(runOnWarmIosSimulatorAsync).not.toHaveBeenCalled();
+    expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledTimes(2);
+  });
+
+  it('accepts only one application source', async () => {
+    await expect(
+      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app', build_id: 'id' })
+    ).rejects.toThrow('Pass only one of install_app_path, build_id or application_archive_url.');
+    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
+  });
+
+  it('waits for Android boot before installing the supplied local APK', async () => {
+    const boot = deferred();
+    jest.mocked(startAndroidEmulatorAsync).mockReturnValue(boot.promise as never);
+    const step = runStep(BuildRuntimePlatform.LINUX, { install_app_path: '/tmp/App.apk' });
+    await flushAsync();
+    expect(installBuildAsync).not.toHaveBeenCalled();
+    boot.resolve();
+    await step;
+    expect(installBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ artifactPath: '/tmp/App.apk' })
+    );
+    expect(launchApplicationAsync).toHaveBeenCalledTimes(1);
+  });
+
+  it('drains an in-flight Android install on cancellation and never launches it', async () => {
+    const controller = new AbortController();
+    const installation = deferred<{ applicationIdentifier: string; activityName: string }>();
+    jest.mocked(installBuildAsync).mockReturnValue(installation.promise);
+    const step = runStep(
+      BuildRuntimePlatform.LINUX,
+      { install_app_path: '/tmp/App.apk' },
+      controller.signal
+    );
+    let settled = false;
+    void step.then(
+      () => (settled = true),
+      () => (settled = true)
+    );
+    const failure = expect(step).rejects.toThrow('cancelled');
+    await flushAsync();
+    expect(installBuildAsync).toHaveBeenCalledTimes(1);
+    controller.abort(new Error('cancelled'));
+    await flushAsync();
+    expect(settled).toBe(false);
+    installation.resolve({ applicationIdentifier: 'dev.app', activityName: '.Main' });
+    await failure;
+    expect(launchApplicationAsync).not.toHaveBeenCalled();
+  });
+
+  it('drains an in-flight Android install when session startup fails', async () => {
+    const entered = deferred();
+    const installation = deferred<{ applicationIdentifier: string; activityName: string }>();
+    jest.mocked(installBuildAsync).mockImplementation(() => {
+      entered.resolve();
+      return installation.promise;
+    });
+    jest.mocked(runAgentDeviceRemoteSessionAsync).mockImplementation(async () => {
+      await entered.promise;
+      throw new Error('session startup failed');
+    });
+    const step = runStep(BuildRuntimePlatform.LINUX, { install_app_path: '/tmp/App.apk' });
+    let settled = false;
+    void step.then(
+      () => (settled = true),
+      () => (settled = true)
+    );
+    const failure = expect(step).rejects.toThrow('session startup failed');
+    await entered.promise;
+    await flushAsync();
+    expect(settled).toBe(false);
+    installation.resolve({ applicationIdentifier: 'dev.app', activityName: '.Main' });
+    await failure;
+    expect(launchApplicationAsync).not.toHaveBeenCalled();
+  });
+
+  it('drains iOS metadata reading on cancellation without starting the session', async () => {
+    const controller = new AbortController();
+    const metadata = deferred<string>();
+    jest.mocked(readIosApplicationIdentifierAsync).mockReturnValue(metadata.promise);
+    const step = runStep(
+      BuildRuntimePlatform.DARWIN,
+      { install_app_path: '/tmp/App.app' },
+      controller.signal
+    );
+    const failure = expect(step).rejects.toThrow('cancelled');
+    await flushAsync();
+    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledTimes(1);
+    controller.abort(new Error('cancelled'));
+    metadata.resolve('dev.app');
+    await failure;
+    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
+  });
 });

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

@@ -13,6 +13,11 @@ import { turtleFetch } from '../../../utils/turtleFetch';
 import { startAppiumEventCollectionAsync } from '../../utils/appiumEvents';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
 import { preparePreinstalledWdaAsync } from '../../utils/preinstalledWda';
+import {
+  WarmSessionAdoptionError,
+  runOnWarmIosSimulatorAsync,
+} from '../../utils/warmDeviceSessionHost';
+import * as warmIosSession from '../../utils/warmIosSession';
 import {
   ensureFfmpegInstalledOnceAsync,
   selectXcodeDeveloperDirectoryAsync,
@@ -58,6 +63,14 @@ jest.mock('../../../utils/turtleFetch', () => ({
 }));
 jest.mock('../../utils/appiumEvents', () => ({ startAppiumEventCollectionAsync: jest.fn() }));
 jest.mock('../../utils/deviceSessionHost');
+jest.mock('../../utils/warmDeviceSessionHost', () => ({
+  ...jest.createMockFromModule<typeof import('../../utils/warmDeviceSessionHost')>(
+    '../../utils/warmDeviceSessionHost'
+  ),
+  WarmSessionAdoptionError: jest.requireActual<typeof import('../../utils/warmDeviceSessionHost')>(
+    '../../utils/warmDeviceSessionHost'
+  ).WarmSessionAdoptionError,
+}));
 jest.mock('../../utils/preinstalledWda', () => ({ preparePreinstalledWdaAsync: jest.fn() }));
 jest.mock('../../utils/iosAppArtifact', () => ({
   ...jest.requireActual('../../utils/iosAppArtifact'),
@@ -275,6 +288,36 @@ describe('createStartAppiumRemoteSessionBuildFunction', () => {
     });
   });
 
+  it('claims the warm Simulator for Appium without its package version', async () => {
+    jest.mocked(runOnWarmIosSimulatorAsync).mockResolvedValue(undefined);
+    const buildFunction = createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext, {
+      warm: true,
+    });
+    expect(buildFunction.id).toBe('start_warm_appium_remote_session');
+    await buildFunction.fn!(
+      {
+        logger: { info: jest.fn(), warn: jest.fn() },
+        global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
+      } as unknown as BuildStepContext,
+      {
+        inputs: {
+          package_version: { value: '3.5.0' },
+          max_idle_time_minutes: { value: undefined },
+          device_identifier: { value: 'iPhone 17' },
+        },
+        outputs: {},
+        env: {
+          DEVICE_RUN_SESSION_ID: 'session',
+          EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN: 'tunnel.example',
+          NGROK_AUTHTOKEN: 'ngrok-token',
+        },
+      } as never
+    );
+    const [claim] = jest.mocked(runOnWarmIosSimulatorAsync).mock.calls[0];
+    expect(claim).toMatchObject({ engine: 'appium', requestedDevice: 'iPhone 17' });
+    expect(claim).not.toHaveProperty('packageVersion');
+  });
+
   it('declares the launch inputs so serve-sim can launch the app', () => {
     const ctx = {} as unknown as CustomBuildContext;
     const buildFunction = createStartAppiumRemoteSessionBuildFunction(ctx);
@@ -298,6 +341,7 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
   const stopError = new Error('Process output drain timed out after 5000ms.');
   const stopAppium = jest.fn();
   const stopEventCollection = jest.fn();
+  const finishHost = jest.fn();
 
   beforeEach(() => {
     jest.mocked(ensureFfmpegInstalledOnceAsync).mockResolvedValue(undefined);
@@ -331,6 +375,7 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
       subdomainId: 'appium-abc',
       stopAsync: jest.fn(),
     });
+    finishHost.mockResolvedValue(undefined);
     jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: jest.fn().mockResolvedValue({
         previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
@@ -338,7 +383,7 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
         closeAsync: jest.fn(),
       }),
       getLastPreviewActivityAt: jest.fn(),
-      finishAsync: jest.fn(),
+      finishAsync: finishHost,
     });
   });
 
@@ -350,9 +395,10 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     logger: { info: jest.Mock; warn: jest.Mock },
     maxIdleTimeMinutes?: number,
     runtimePlatform = BuildRuntimePlatform.LINUX,
-    startupInputs: Record<string, { value: unknown }> = {}
+    startupInputs: Record<string, { value: unknown }> = {},
+    warm = false
   ): Promise<void> {
-    await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
+    await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext, { warm }).fn!(
       {
         logger,
         global: { runtimePlatform },
@@ -405,6 +451,187 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     expect(options.iosSimulatorUdid).toBeUndefined();
   });
 
+  function mockWarmSession(): jest.Mock {
+    const stopWarm = jest.fn().mockResolvedValue(undefined);
+    const warm: warmIosSession.WarmIosSession = {
+      device: { udid: 'CHOSEN-IOS-UDID', name: 'iPhone 17' },
+      server: { pid: 100, port: 3200, token: 'warm-token' },
+      agentDeviceStateDir: '/warm/agent-device',
+      argentEventLogPath: '/warm/argent-events',
+      prepareToolsAsync: jest.fn(),
+      process: {
+        pid: 100,
+        getOutput: () => '',
+        getExitError: () => undefined,
+        stopAsync: stopWarm,
+      },
+    };
+    jest.spyOn(warmIosSession, 'tryClaimWarmIosSessionAsync').mockResolvedValue(warm);
+    jest
+      .mocked(runOnWarmIosSimulatorAsync)
+      .mockImplementation(
+        jest.requireActual<typeof import('../../utils/warmDeviceSessionHost')>(
+          '../../utils/warmDeviceSessionHost'
+        ).runOnWarmIosSimulatorAsync
+      );
+    return stopWarm;
+  }
+
+  it.each(['event collection', 'Appium process'])(
+    'waits for warm %s teardown before finishing the session host',
+    async stage => {
+      mockWarmSession();
+      stopAppium.mockResolvedValue(undefined);
+      let finishTeardown = () => {};
+      const teardownGate = new Promise<void>(resolve => {
+        finishTeardown = resolve;
+      });
+      let startedTeardown = () => {};
+      const teardownStarted = new Promise<void>(resolve => {
+        startedTeardown = resolve;
+      });
+      const stop = async () => {
+        startedTeardown();
+        await teardownGate;
+      };
+      (stage === 'event collection' ? stopEventCollection : stopAppium).mockImplementationOnce(
+        stop
+      );
+
+      const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {}, true);
+      try {
+        await teardownStarted;
+        await Promise.resolve();
+        expect(finishHost).not.toHaveBeenCalled();
+        if (stage === 'event collection') {
+          expect(stopAppium).not.toHaveBeenCalled();
+        }
+      } finally {
+        finishTeardown();
+        await running;
+      }
+      expect(finishHost).toHaveBeenCalledTimes(1);
+      expect(stopAppium.mock.invocationCallOrder[0]).toBeLessThan(
+        finishHost.mock.invocationCallOrder[0]
+      );
+      const home = jest.mocked(spawnDetached).mock.calls[0][0].env.APPIUM_HOME;
+      expect(fs.existsSync(home ?? '')).toBe(false);
+    }
+  );
+
+  it.each(['event collection', 'Appium process'])(
+    'finishes the warm host after %s teardown fails',
+    async stage => {
+      const stopWarm = mockWarmSession();
+      stopAppium.mockResolvedValue(undefined);
+      const error = new Error(`${stage} stop failed`);
+      (stage === 'event collection' ? stopEventCollection : stopAppium).mockRejectedValueOnce(
+        error
+      );
+
+      await expect(
+        runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {}, true)
+      ).rejects.toBe(error);
+
+      expect(stopAppium).toHaveBeenCalledTimes(1);
+      expect(finishHost).toHaveBeenCalledTimes(1);
+      expect(stopWarm).toHaveBeenCalledTimes(1);
+      expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it.each([false, true])(
+    'finishes a cold host while Appium is still stopping (warm step: %s)',
+    async warm => {
+      if (warm) {
+        jest.mocked(runOnWarmIosSimulatorAsync).mockImplementationOnce((_claim, run) => run());
+      }
+      let finishAppium = () => {};
+      const appiumGate = new Promise<void>(resolve => {
+        finishAppium = resolve;
+      });
+      let startedAppiumStop = () => {};
+      const appiumStopping = new Promise<void>(resolve => {
+        startedAppiumStop = resolve;
+      });
+      stopAppium.mockImplementationOnce(async () => {
+        startedAppiumStop();
+        await appiumGate;
+      });
+      let startedHostFinish = () => {};
+      const hostFinishing = new Promise<void>(resolve => {
+        startedHostFinish = resolve;
+      });
+      finishHost.mockImplementationOnce(async () => startedHostFinish());
+
+      const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {}, warm);
+      try {
+        await appiumStopping;
+        await Promise.resolve();
+        expect(finishHost).toHaveBeenCalledTimes(1);
+        await hostFinishing;
+      } finally {
+        finishAppium();
+        await running;
+      }
+    }
+  );
+
+  it.each(['stopped', 'process stop failed', 'home cleanup failed'])(
+    'retries a failed warm adoption only after Appium stops (%s)',
+    async cleanup => {
+      const stopFails = cleanup === 'process stop failed';
+      const adoptionError = new WarmSessionAdoptionError();
+      const stopWarm = mockWarmSession();
+      let failHost: (error: Error) => void = () => {};
+      jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
+        new Promise((_resolve, reject) => {
+          failHost = reject;
+        })
+      );
+      jest.mocked(spawnDetached).mockImplementationOnce(() => {
+        failHost(adoptionError);
+        return {
+          pid: 4242,
+          getOutput: () => '',
+          getExitError: () => undefined,
+          stopAsync: stopAppium,
+        };
+      });
+      if (!stopFails) {
+        stopAppium.mockResolvedValue(undefined);
+      }
+      if (cleanup === 'home cleanup failed') {
+        jest.spyOn(fs.promises, 'rm').mockRejectedValueOnce(new Error('home cleanup failed'));
+      }
+
+      const running = runSessionAsync(
+        { info: jest.fn(), warn: jest.fn() },
+        undefined,
+        BuildRuntimePlatform.DARWIN,
+        { boot_simulator: { value: true }, device_identifier: { value: 'iPhone 17' } },
+        true
+      );
+
+      if (stopFails) {
+        await expect(running).rejects.toMatchObject({ errors: [adoptionError, stopError] });
+        expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
+        expect(stopWarm).toHaveBeenCalledTimes(1);
+      } else {
+        await expect(running).resolves.toBeUndefined();
+        expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(2);
+        expect(stopWarm).toHaveBeenCalledTimes(1);
+      }
+      expect(stopAppium).toHaveBeenCalledTimes(stopFails ? 1 : 2);
+      if (cleanup === 'home cleanup failed') {
+        const home = jest.mocked(spawnDetached).mock.calls[0][0].env.APPIUM_HOME;
+        if (home) {
+          await fs.promises.rm(home, { recursive: true, force: true });
+        }
+      }
+    }
+  );
+
   it.each([false, true])(
     'preserves preview settings with Simulator startup %s',
     async bootSimulator => {

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

@@ -24,6 +24,11 @@ import {
   uploadRemoteSessionConfigAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
+import {
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../../utils/warmIosSession';
 import { createStartArgentRemoteSessionBuildFunction } from '../startArgentRemoteSession';
 import { readIosApplicationIdentifierAsync } from '../../utils/iosAppArtifact';
 
@@ -50,6 +55,7 @@ jest.mock('../../utils/argentEvents', () => ({
   startArgentEventCollectionAsync: jest.fn(),
 }));
 jest.mock('../../utils/deviceSessionHost');
+jest.mock('../../utils/warmDeviceSessionHost');
 jest.mock('../../utils/iosAppArtifact', () => ({
   ...jest.requireActual('../../utils/iosAppArtifact'),
   readIosApplicationIdentifierAsync: jest.fn().mockResolvedValue('dev.example.app'),
@@ -605,6 +611,72 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     expect(JSON.stringify(logger.info.mock.calls)).not.toContain('secret');
   });
 
+  it('uses the warm Argent server and drains its artifacts before stopping the host', async () => {
+    const ctx = {} as unknown as CustomBuildContext;
+    const warmServer = { port: 3200 } as never;
+    const warm = {
+      device: { udid: 'WARM-UDID', name: 'iPhone 17' },
+      argentEventLogPath: '/warm/argent-events',
+      tools: { pid: 30, port: 3201, token: 'warm-token' },
+    } as WarmIosSession;
+    jest.mocked(createWarmDeviceSessionServer).mockReturnValue(warmServer);
+    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation((_claim, run) => run(warm));
+    let releaseArtifacts = () => {};
+    const artifactsDrained = new Promise<void>(resolve => {
+      releaseArtifacts = resolve;
+    });
+    let pollingStarted = () => {};
+    const polling = new Promise<void>(resolve => {
+      pollingStarted = resolve;
+    });
+    jest.mocked(pollArgentArtifactsForUploadAsync).mockImplementationOnce(async () => {
+      pollingStarted();
+      await artifactsDrained;
+    });
+    const buildFunction = createStartArgentRemoteSessionBuildFunction(ctx, { warm: true });
+    expect(buildFunction.id).toBe('start_warm_argent_remote_session');
+    if (!buildFunction.fn) {
+      throw new Error('Expected the Argent session function.');
+    }
+    const running = buildFunction.fn(
+      {
+        logger: { info: jest.fn(), warn: jest.fn() },
+        global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
+      } as unknown as BuildStepContext,
+      {
+        inputs: {
+          package_version: { value: undefined },
+          max_idle_time_minutes: { value: undefined },
+          max_duration_seconds: { value: undefined },
+        },
+        outputs: {},
+        env: {},
+      } as never
+    );
+    try {
+      await polling;
+      await new Promise<void>(resolve => setImmediate(resolve));
+      expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalled();
+      expect(mockPreviewStopAsync).not.toHaveBeenCalled();
+    } finally {
+      releaseArtifacts();
+      await running;
+    }
+    expect(spawn).not.toHaveBeenCalled();
+    expect(spawnDetached).not.toHaveBeenCalled();
+    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(ctx, expect.anything(), warmServer);
+    expect(startNgrokTunnelAsync).toHaveBeenCalledWith(expect.objectContaining({ port: 3201 }));
+    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        remoteConfig: expect.objectContaining({ toolsAuthToken: 'warm-token' }),
+      })
+    );
+    expect(startArgentEventCollectionAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ eventLogPath: '/warm/argent-events' })
+    );
+    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
+  });
+
   it('hands the launch inputs to serve-sim and announces them on an iOS session', async () => {
     const ctx = {} as unknown as CustomBuildContext;
     const logger = { info: jest.fn(), warn: jest.fn() };

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

@@ -1,4 +1,3 @@
-import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -6,79 +5,12 @@ import path from 'node:path';
 
 import { Sentry } from '../../../sentry';
 import {
-  MIN_ARGENT_REMOTE_SESSION_VERSION,
   stopArgentEventCollectionSafelyAsync,
   waitForArgentToolServerStateAsync,
-  warnIfArgentPackageVersionCannotBeVerified,
 } from '../startArgentRemoteSession';
 
 jest.mock('../../../sentry');
 
-describe(warnIfArgentPackageVersionCannotBeVerified, () => {
-  const warn = jest.fn();
-  const logger = { warn } as unknown as bunyan;
-  const supportedVersion = '999.0.0';
-  const oldVersion = '0.0.0';
-
-  beforeEach(() => {
-    warn.mockClear();
-  });
-
-  it('allows the default latest package version', () => {
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: undefined, logger })
-    ).not.toThrow();
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: 'latest', logger })
-    ).not.toThrow();
-    expect(warn).not.toHaveBeenCalled();
-  });
-
-  it('allows exact supported semver versions', () => {
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({
-        packageVersion: MIN_ARGENT_REMOTE_SESSION_VERSION,
-        logger,
-      })
-    ).not.toThrow();
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: supportedVersion, logger })
-    ).not.toThrow();
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({
-        packageVersion: `v${supportedVersion}`,
-        logger,
-      })
-    ).not.toThrow();
-    expect(warn).not.toHaveBeenCalled();
-  });
-
-  it('rejects exact semver versions that are too old', () => {
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: oldVersion, logger })
-    ).toThrow(SystemError);
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: oldVersion, logger })
-    ).toThrow(`Use "latest" or pass an exact version >= ${MIN_ARGENT_REMOTE_SESSION_VERSION}`);
-  });
-
-  it('warns for package tags or ranges that cannot be verified', () => {
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion: 'next', logger })
-    ).not.toThrow();
-    expect(() =>
-      warnIfArgentPackageVersionCannotBeVerified({
-        packageVersion: `^${MIN_ARGENT_REMOTE_SESSION_VERSION}`,
-        logger,
-      })
-    ).not.toThrow();
-    expect(warn).toHaveBeenCalledTimes(2);
-    expect(warn).toHaveBeenCalledWith(
-      expect.stringContaining('Continuing and letting the package manager resolve it.')
-    );
-  });
-});
-
 describe(waitForArgentToolServerStateAsync, () => {
   let stateDir: string;
 

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

@@ -12,9 +12,15 @@ import {
   uploadRemoteSessionConfigAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
+import {
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../../utils/warmIosSession';
 import { createStartWebPreviewRemoteSessionBuildFunction } from '../startWebPreviewRemoteSession';
 
 jest.mock('../../utils/deviceSessionHost');
+jest.mock('../../utils/warmDeviceSessionHost');
 jest.mock('../../../utils/IosSimulatorUtils', () => ({
   IosSimulatorUtils: {
     resolveUdidAsync: jest.fn().mockResolvedValue('selected-ios-udid'),
@@ -89,6 +95,28 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     stopAsync.mockResolvedValue(undefined);
   });
 
+  it('adopts the claimed warm Simulator when the warm step runs', async () => {
+    const warmServer = { port: 3200 } as never;
+    const warm = { device: { udid: 'SELECTED-IOS-UDID', name: 'iPhone 17' } } as WarmIosSession;
+    jest.mocked(createWarmDeviceSessionServer).mockReturnValue(warmServer);
+    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation((_claim, run) => run(warm));
+    const buildFunction = createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true });
+    expect(buildFunction.id).toBe('start_warm_serve_sim_remote_session');
+    await buildFunction.fn!(
+      { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
+      { inputs: { device_identifier: { value: 'iPhone 17' } }, outputs: {}, env } as never
+    );
+    expect(runOnWarmIosSimulatorAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ engine: 'serve-sim', requestedDevice: 'iPhone 17' }),
+      expect.any(Function)
+    );
+    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
+      ctx,
+      expect.objectContaining({ iosSimulatorUdid: 'SELECTED-IOS-UDID' }),
+      warmServer
+    );
+  });
+
   it('uses preview activity to reset the configured idle timeout', async () => {
     await runAsync(BuildRuntimePlatform.DARWIN, { max_idle_time_minutes: { value: 5 } });
     const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
@@ -246,6 +274,7 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       env: childEnv,
       logger,
       timeoutMs: 60_000,
+      preview: { baseDomain: 'tunnel.example.com', authtoken: 'ngrok-token' },
       signal: undefined,
       ...(selectsXcode
         ? {
@@ -265,10 +294,7 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       networkCaptureFields: [],
     });
     const host = await jest.mocked(startDeviceSessionHostAsync).mock.results[0].value;
-    expect(host.openPreviewAsync).toHaveBeenCalledWith({
-      baseDomain: 'tunnel.example.com',
-      authtoken: 'ngrok-token',
-    });
+    expect(host.openPreviewAsync).toHaveBeenCalledWith();
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith({
       ctx,
       deviceRunSessionId: 'device-run-session-id',

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

@@ -0,0 +1,407 @@
+import { BuildStep, spawnAsync } from '@expo/steps';
+import fs from 'node:fs';
+import path from 'node:path';
+
+jest.unmock('fs');
+jest.unmock('node:fs');
+jest.unmock('fs/promises');
+jest.unmock('node:fs/promises');
+
+jest.mock('@expo/steps', () => ({
+  ...jest.requireActual('@expo/steps'),
+  spawnAsync: jest.fn(),
+}));
+
+const mockedSpawnAsync = jest.mocked(spawnAsync);
+
+import { createGlobalContextMock } from '../../../__tests__/utils/context';
+import { createTestAndroidJob } from '../../../__tests__/utils/job';
+import { createMockLogger } from '../../../__tests__/utils/logger';
+import { BuildContext } from '../../../context';
+import { CustomBuildContext } from '../../../customBuildContext';
+import { parseInfoPlistBuffer } from '../readIpaInfo';
+import {
+  createUpdateResolvedVersionBuildFunction,
+  extractAndroidVersionAsync,
+  extractIosVersionAsync,
+  parseAaptOutput,
+  parseManifestXml,
+} from '../updateResolvedVersion';
+
+describe(parseAaptOutput, () => {
+  it('extracts versionName and versionCode from aapt2 output', () => {
+    const output = `package: name='com.example.app' versionCode='42' versionName='2.5.0' platformBuildVersionName='14' platformBuildVersionCode='34' compileSdkVersion='34' compileSdkVersionCodename='14'
+sdkVersion:'21'
+targetSdkVersion:'34'
+uses-permission: name='android.permission.INTERNET'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: '2.5.0',
+      appBuildVersion: '42',
+    });
+  });
+
+  it('handles output with no version info', () => {
+    expect(parseAaptOutput('some unrelated output')).toEqual({
+      appVersion: undefined,
+      appBuildVersion: undefined,
+    });
+  });
+
+  it('handles versionName with prerelease suffix', () => {
+    const output = `package: name='com.example' versionCode='1' versionName='1.0.0-beta.1'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: '1.0.0-beta.1',
+      appBuildVersion: '1',
+    });
+  });
+
+  it('keeps an unescaped apostrophe in versionName', () => {
+    const output = `package: name='com.example' versionCode='1' versionName='1.0-O'Brien' platformBuildVersionName='14' platformBuildVersionCode='34' compileSdkVersion='34'
+sdkVersion:'21'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: "1.0-O'Brien",
+      appBuildVersion: '1',
+    });
+  });
+
+  it('keeps a versionName that contains a quote and an equals sign', () => {
+    const output = `package: name='com.example' versionCode='1' versionName='1.0' build=beta'
+sdkVersion:'21'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: "1.0' build=beta",
+      appBuildVersion: '1',
+    });
+  });
+
+  it('stops versionName at the split field of a split APK', () => {
+    const output = `package: name='com.example' versionCode='42' versionName='2.5.0' split='feature' platformBuildVersionName='14' platformBuildVersionCode='34' compileSdkVersion='34'
+sdkVersion:'21'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: '2.5.0',
+      appBuildVersion: '42',
+    });
+  });
+
+  it('treats an empty versionName as missing', () => {
+    const output = `package: name='com.example' versionCode='42' versionName='' platformBuildVersionName='14' platformBuildVersionCode='34' compileSdkVersion='34'
+sdkVersion:'21'`;
+
+    expect(parseAaptOutput(output)).toEqual({
+      appVersion: undefined,
+      appBuildVersion: '42',
+    });
+  });
+});
+
+describe(parseManifestXml, () => {
+  it('extracts versionName and versionCode from bundletool manifest XML', () => {
+    const xml = `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    android:versionCode="10"
+    android:versionName="3.1.0"
+    package="com.example.app">
+    <uses-sdk android:minSdkVersion="21" android:targetSdkVersion="34" />
+</manifest>`;
+
+    expect(parseManifestXml(xml)).toEqual({
+      appVersion: '3.1.0',
+      appBuildVersion: '10',
+    });
+  });
+
+  it('handles XML with no version attributes', () => {
+    const xml = `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.app">
+</manifest>`;
+
+    expect(parseManifestXml(xml)).toEqual({
+      appVersion: undefined,
+      appBuildVersion: undefined,
+    });
+  });
+});
+
+describe('simulator .app Info.plist parsing', () => {
+  const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+  const SIMULATOR_APP_DIR = path.join(FIXTURES_DIR, 'TestSimulator.app');
+  const INFO_PLIST_PATH = path.join(SIMULATOR_APP_DIR, 'Info.plist');
+
+  beforeAll(async () => {
+    // Create a minimal XML Info.plist fixture
+    await fs.promises.mkdir(SIMULATOR_APP_DIR, { recursive: true });
+    await fs.promises.writeFile(
+      INFO_PLIST_PATH,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>com.example.test</string>
+  <key>CFBundleShortVersionString</key>
+  <string>4.2.0</string>
+  <key>CFBundleVersion</key>
+  <string>99</string>
+</dict>
+</plist>`
+    );
+  });
+
+  afterAll(async () => {
+    await fs.promises.rm(SIMULATOR_APP_DIR, { recursive: true, force: true });
+  });
+
+  it('reads version from a .app Info.plist', async () => {
+    const buffer = await fs.promises.readFile(INFO_PLIST_PATH);
+    const infoPlist = parseInfoPlistBuffer(buffer);
+
+    expect(infoPlist.CFBundleShortVersionString).toBe('4.2.0');
+    expect(infoPlist.CFBundleVersion).toBe('99');
+  });
+});
+
+describe(extractIosVersionAsync, () => {
+  const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+  const SIMULATOR_APP_DIR = path.join(FIXTURES_DIR, 'ExtractVersion.app');
+  const INFO_PLIST_PATH = path.join(SIMULATOR_APP_DIR, 'Info.plist');
+  const IPA_FIXTURE_PATH = path.join(FIXTURES_DIR, 'SmallestAppExample.ipa');
+
+  beforeAll(async () => {
+    await fs.promises.mkdir(SIMULATOR_APP_DIR, { recursive: true });
+    await fs.promises.writeFile(
+      INFO_PLIST_PATH,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleShortVersionString</key>
+  <string>2.0.1</string>
+  <key>CFBundleVersion</key>
+  <string>55</string>
+</dict>
+</plist>`
+    );
+  });
+
+  afterAll(async () => {
+    await fs.promises.rm(SIMULATOR_APP_DIR, { recursive: true, force: true });
+  });
+
+  it('extracts version from a .app directory', async () => {
+    const result = await extractIosVersionAsync(SIMULATOR_APP_DIR);
+
+    expect(result).toEqual({
+      appVersion: '2.0.1',
+      appBuildVersion: '55',
+    });
+  });
+
+  it('extracts version from an .ipa file', async () => {
+    const result = await extractIosVersionAsync(IPA_FIXTURE_PATH);
+
+    expect(result).toEqual({
+      appVersion: '1.0',
+      appBuildVersion: '1',
+    });
+  });
+});
+
+describe(extractAndroidVersionAsync, () => {
+  afterEach(() => {
+    mockedSpawnAsync.mockReset();
+  });
+
+  it('extracts version from an .apk via aapt2', async () => {
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `package: name='com.example.app' versionCode='42' versionName='2.5.0'`,
+      stderr: '',
+    } as any);
+
+    const result = await extractAndroidVersionAsync('/path/to/app.apk');
+
+    expect(mockedSpawnAsync).toHaveBeenCalledWith(
+      'aapt2',
+      ['dump', 'badging', '/path/to/app.apk'],
+      {
+        stdio: 'pipe',
+      }
+    );
+    expect(result).toEqual({
+      appVersion: '2.5.0',
+      appBuildVersion: '42',
+    });
+  });
+
+  it('extracts version from an .aab via bundletool', async () => {
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    android:versionCode="10"
+    android:versionName="3.1.0"
+    package="com.example.app">
+</manifest>`,
+      stderr: '',
+    } as any);
+
+    const result = await extractAndroidVersionAsync('/path/to/app.aab');
+
+    expect(mockedSpawnAsync).toHaveBeenCalledWith(
+      'bundletool',
+      ['dump', 'manifest', '--bundle', '/path/to/app.aab'],
+      { stdio: 'pipe' }
+    );
+    expect(result).toEqual({
+      appVersion: '3.1.0',
+      appBuildVersion: '10',
+    });
+  });
+
+  it('returns empty object for unknown extension', async () => {
+    const result = await extractAndroidVersionAsync('/path/to/archive.zip');
+
+    expect(mockedSpawnAsync).not.toHaveBeenCalled();
+    expect(result).toEqual({});
+  });
+});
+
+describe(createUpdateResolvedVersionBuildFunction, () => {
+  afterEach(() => {
+    mockedSpawnAsync.mockReset();
+  });
+
+  function createStep({
+    env,
+    archivePath,
+    workingDirectory,
+    mutationResult = { data: {}, error: undefined },
+  }: {
+    env: Record<string, string>;
+    archivePath?: string;
+    workingDirectory?: string;
+    mutationResult?: { data?: unknown; error?: Error };
+  }): { step: BuildStep; mutation: jest.Mock } {
+    const mutation = jest.fn(() => ({ toPromise: async () => mutationResult }));
+    const ctx = new BuildContext(createTestAndroidJob({}), {
+      env: { __API_SERVER_URL: 'http://api.expo.test', ...env },
+      logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
+      logger: createMockLogger(),
+      uploadArtifact: jest.fn(),
+      workingdir: '',
+    });
+    ctx.graphqlClient.mutation = mutation as any;
+    const step = createUpdateResolvedVersionBuildFunction(
+      new CustomBuildContext(ctx)
+    ).createBuildStepFromFunctionCall(createGlobalContextMock({}), {
+      callInputs: archivePath ? { application_archive_path: archivePath } : {},
+      workingDirectory,
+    });
+    return { step, mutation };
+  }
+
+  it('resolves a relative archive path against the step working directory', async () => {
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `package: name='com.example.app' versionCode='42' versionName='2.5.0'`,
+      stderr: '',
+    } as any);
+    const { step, mutation } = createStep({
+      env: { EAS_BUILD_ID: 'build-id' },
+      archivePath: 'android/app/build/outputs/apk/release/app-release.apk',
+      workingDirectory: './my-app',
+    });
+
+    await step.executeAsync();
+
+    const expectedPath = path.join(
+      step.ctx.workingDirectory,
+      'android/app/build/outputs/apk/release/app-release.apk'
+    );
+    expect(path.isAbsolute(expectedPath)).toBe(true);
+    expect(mockedSpawnAsync).toHaveBeenCalledWith('aapt2', ['dump', 'badging', expectedPath], {
+      stdio: 'pipe',
+    });
+    expect(mutation).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates the resolved versions for the build', async () => {
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `package: name='com.example.app' versionCode='42' versionName='2.5.0'`,
+      stderr: '',
+    } as any);
+    const { step, mutation } = createStep({
+      env: { EAS_BUILD_ID: 'build-id' },
+      archivePath: '/path/to/app.apk',
+    });
+
+    await step.executeAsync();
+
+    expect(mutation).toHaveBeenCalledTimes(1);
+    expect(mutation.mock.calls[0][1]).toEqual({
+      buildId: 'build-id',
+      appVersion: '2.5.0',
+      appBuildVersion: '42',
+    });
+  });
+
+  it('omits a missing value instead of sending null', async () => {
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `package: name='com.example.app' versionCode='42'`,
+      stderr: '',
+    } as any);
+    const { step, mutation } = createStep({
+      env: { EAS_BUILD_ID: 'build-id' },
+      archivePath: '/path/to/app.apk',
+    });
+
+    await step.executeAsync();
+
+    const variables = mutation.mock.calls[0][1];
+    expect(variables.appBuildVersion).toBe('42');
+    expect(variables.appVersion).toBeUndefined();
+    expect(variables.appVersion).not.toBeNull();
+  });
+
+  it('does nothing without a build ID', async () => {
+    const { step, mutation } = createStep({ env: {}, archivePath: '/path/to/app.apk' });
+
+    await step.executeAsync();
+
+    expect(mockedSpawnAsync).not.toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('does nothing without an archive path', async () => {
+    const { step, mutation } = createStep({ env: { EAS_BUILD_ID: 'build-id' } });
+
+    await step.executeAsync();
+
+    expect(mockedSpawnAsync).not.toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
+  });
+
+  it('does not fail the step when extraction or the mutation fails', async () => {
+    mockedSpawnAsync.mockRejectedValueOnce(new Error('aapt2: command not found'));
+    const failingExtraction = createStep({
+      env: { EAS_BUILD_ID: 'build-id' },
+      archivePath: '/path/to/app.apk',
+    });
+    await expect(failingExtraction.step.executeAsync()).resolves.not.toThrow();
+    expect(failingExtraction.mutation).not.toHaveBeenCalled();
+
+    mockedSpawnAsync.mockResolvedValue({
+      stdout: `package: name='com.example.app' versionCode='42' versionName='2.5.0'`,
+      stderr: '',
+    } as any);
+    const failingMutation = createStep({
+      env: { EAS_BUILD_ID: 'build-id' },
+      archivePath: '/path/to/app.apk',
+      mutationResult: { error: new Error('GraphQL error') },
+    });
+    await expect(failingMutation.step.executeAsync()).resolves.not.toThrow();
+    expect(failingMutation.mutation).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -1,5 +1,5 @@
 import { BuildJob, Ios, ManagedArtifactType, Platform } from '@expo/eas-build-job';
-import { BuildFunction, BuildStepContext } from '@expo/steps';
+import { BuildFunction, BuildStepContext, BuildStepOutput } from '@expo/steps';
 
 import { CustomBuildContext } from '../../customBuildContext';
 import { findXcodeBuildLogsPathAsync } from '../../ios/xcodeBuildLogs';
@@ -13,7 +13,13 @@ export function createFindAndUploadBuildArtifactsBuildFunction(
     id: 'find_and_upload_build_artifacts',
     name: 'Find and upload build artifacts',
     __metricsId: 'eas/find_and_upload_build_artifacts',
-    fn: async stepCtx => {
+    outputProviders: [
+      BuildStepOutput.createProvider({
+        id: 'application_archive_path',
+        required: false,
+      }),
+    ],
+    fn: async (stepCtx, { outputs }) => {
       // We want each upload to print logs on its own
       // and we don't want to interleave logs from different uploads
       // so we execute uploads consecutively.
@@ -24,7 +30,10 @@ export function createFindAndUploadBuildArtifactsBuildFunction(
       let firstError: any = null;
 
       try {
-        await uploadApplicationArchivesAsync({ ctx, stepCtx });
+        const [firstArchivePath] = await uploadApplicationArchivesAsync({ ctx, stepCtx });
+        if (firstArchivePath) {
+          outputs.application_archive_path.set(firstArchivePath);
+        }
       } catch (err: unknown) {
         stepCtx.logger.error({ err }, `Failed to upload application archives.`);
         firstError ||= err;
@@ -68,7 +77,7 @@ async function uploadApplicationArchivesAsync({
 }: {
   ctx: CustomBuildContext<BuildJob>;
   stepCtx: BuildStepContext;
-}): Promise<void> {
+}): Promise<string[]> {
   const applicationArchivePatternOrPath =
     ctx.job.platform === Platform.ANDROID
       ? (ctx.job.applicationArchivePath ?? 'android/app/build/outputs/**/*.{apk,aab}')
@@ -99,6 +108,8 @@ async function uploadApplicationArchivesAsync({
     logger,
   });
   logger.info('Done.');
+
+  return applicationArchives;
 }
 
 async function uploadBuildArtifacts({

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

@@ -117,7 +117,7 @@ export async function readIpaInfoAsync(ipaPath: string): Promise<IpaInfo> {
   }
 }
 
-function parseInfoPlistBuffer(data: Buffer): Record<string, unknown> {
+export function parseInfoPlistBuffer(data: Buffer): Record<string, unknown> {
   const isBinaryPlist = data.subarray(0, 8).toString('ascii') === 'bplist00';
   if (isBinaryPlist) {
     const parsedBinaryPlists = bplistParser.parseBuffer(data);

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

@@ -9,6 +9,8 @@ import path from 'node:path';
 import { type CustomBuildContext } from '../../customBuildContext';
 import { uploadRemoteSessionConfigWithLocalEgressAsync } from '../utils/localEgressSession';
 import { type DeviceSessionHost, startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
+import { createWarmDeviceSessionServer } from '../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../utils/warmIosSession';
 import { Sentry } from '../../sentry';
 import {
   PackageManager,
@@ -98,6 +100,7 @@ export async function runAgentDeviceRemoteSessionAsync(
     frameAncestors,
     corsOrigins,
     tasks,
+    warm,
     device,
   }: {
     env: BuildStepEnv;
@@ -114,6 +117,8 @@ export async function runAgentDeviceRemoteSessionAsync(
     frameAncestors?: string[];
     corsOrigins?: string[];
     tasks: StartupTasks;
+    /** A claimed warm Simulator: adopt it and use its agent-device daemon. */
+    warm?: WarmIosSession;
     device:
       | {
           booted: Promise<unknown>;
@@ -137,6 +142,9 @@ export async function runAgentDeviceRemoteSessionAsync(
   let agentDeviceTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
   let sessionHost: DeviceSessionHost | undefined;
   let eventCollection: Awaited<ReturnType<typeof startAgentDeviceEventCollectionAsync>> | undefined;
+  let artifactUploads: Promise<void> | undefined;
+  // Ends periodic polling; the poller then runs one bounded final inventory and upload drain.
+  const stopArtifactPolling = new AbortController();
   let sessionFailed = false;
   const daemonSecrets = [ngrokAuthtoken];
   const hostBootedDevice = 'iosSimulatorUdid' in device ? device : undefined;
@@ -144,7 +152,70 @@ export async function runAgentDeviceRemoteSessionAsync(
 
   // Each task stores what it started, so the teardown below can stop it even when
   // another task failed first.
+  const sessionHostStartup = tasks.run('session host', async taskLogger => {
+    if (externallyBootedDevice) {
+      await tasks.untilAborted(externallyBootedDevice.booted);
+    }
+    tasks.signal.throwIfAborted();
+    sessionHost = await startDeviceSessionHostAsync(
+      ctx,
+      {
+        separateLogPhase: true,
+        runtimePlatform,
+        env,
+        logger: taskLogger,
+        timeoutMs: STARTUP_TIMEOUT_MS,
+        preview: { baseDomain: ngrokTunnelDomain, authtoken: ngrokAuthtoken },
+        disableShare,
+        privatePreviewUrl,
+        frameAncestors,
+        corsOrigins,
+        signal: tasks.signal,
+        onStartupError: tasks.abort,
+        networkCapture: capture.networkCapture,
+        networkCaptureFields: capture.networkCaptureFields,
+        iosSimulatorUdid: hostBootedDevice?.iosSimulatorUdid,
+        bootEnv: hostBootedDevice?.bootEnv,
+        application: hostBootedDevice?.application,
+      },
+      ...(warm ? [createWarmDeviceSessionServer(ctx, taskLogger, warm)] : [])
+    );
+    tasks.signal.throwIfAborted();
+    const webPreview = await sessionHost.openPreviewAsync();
+    tasks.signal.throwIfAborted();
+    taskLogger.info(
+      webPreview.sharePageUrl
+        ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
+        : 'Private preview URL unavailable for this session.'
+    );
+    return webPreview;
+  });
   const agentDeviceStartup = tasks.run('agent-device daemon', async taskLogger => {
+    let daemonInfo: { port: number; token: string };
+    if (warm) {
+      // Adoption prepares the launcher's daemon for the claimed device.
+      await tasks.untilAborted(sessionHostStartup);
+      if (!warm.tools) {
+        throw new Error('The warm agent-device daemon was not prepared.');
+      }
+      daemonInfo = warm.tools;
+    } else {
+      daemonInfo = await startDaemonAsync(taskLogger);
+    }
+    tasks.signal.throwIfAborted();
+    agentDeviceTunnel = await startNgrokTunnelAsync({
+      port: daemonInfo.port,
+      subdomainPrefix: 'agent-device',
+      baseDomain: ngrokTunnelDomain,
+      authtoken: ngrokAuthtoken,
+      healthCheck: { path: '/health' },
+      logger: taskLogger,
+    });
+    tasks.signal.throwIfAborted();
+    taskLogger.info(`Tunnel is ready at ${agentDeviceTunnel.url}.`);
+    return { ...daemonInfo, remoteSessionUrl: agentDeviceTunnel.url };
+  });
+  async function startDaemonAsync(taskLogger: bunyan) {
     taskLogger.info('Launching agent-device daemon.');
     daemonProcess = await startAgentDeviceDaemonAsync({
       packageVersion,
@@ -160,56 +231,8 @@ export async function runAgentDeviceRemoteSessionAsync(
     const daemonInfo = await tasks.untilAborted(waitForDaemonInfoAsync({ daemonProcess }));
     daemonSecrets.push(daemonInfo.token);
     taskLogger.info(`Daemon is listening on port ${daemonInfo.port}; loaded auth token.`);
-
-    tasks.signal.throwIfAborted();
-    agentDeviceTunnel = await startNgrokTunnelAsync({
-      port: daemonInfo.port,
-      subdomainPrefix: 'agent-device',
-      baseDomain: ngrokTunnelDomain,
-      authtoken: ngrokAuthtoken,
-      healthCheck: { path: '/health' },
-      logger: taskLogger,
-    });
-    tasks.signal.throwIfAborted();
-    taskLogger.info(`Tunnel is ready at ${agentDeviceTunnel.url}.`);
-    return { ...daemonInfo, remoteSessionUrl: agentDeviceTunnel.url };
-  });
-  const sessionHostStartup = tasks.run('session host', async taskLogger => {
-    if (externallyBootedDevice) {
-      await tasks.untilAborted(externallyBootedDevice.booted);
-    }
-    tasks.signal.throwIfAborted();
-    sessionHost = await startDeviceSessionHostAsync(ctx, {
-      separateLogPhase: true,
-      runtimePlatform,
-      env,
-      logger: taskLogger,
-      timeoutMs: STARTUP_TIMEOUT_MS,
-      disableShare,
-      privatePreviewUrl,
-      frameAncestors,
-      corsOrigins,
-      signal: tasks.signal,
-      onStartupError: tasks.abort,
-      networkCapture: capture.networkCapture,
-      networkCaptureFields: capture.networkCaptureFields,
-      iosSimulatorUdid: hostBootedDevice?.iosSimulatorUdid,
-      bootEnv: hostBootedDevice?.bootEnv,
-      application: hostBootedDevice?.application,
-    });
-    tasks.signal.throwIfAborted();
-    const webPreview = await sessionHost.openPreviewAsync({
-      baseDomain: ngrokTunnelDomain,
-      authtoken: ngrokAuthtoken,
-    });
-    tasks.signal.throwIfAborted();
-    taskLogger.info(
-      webPreview.sharePageUrl
-        ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-        : 'Private preview URL unavailable for this session.'
-    );
-    return webPreview;
-  });
+    return daemonInfo;
+  }
   const deviceReady = externallyBootedDevice?.ready;
 
   try {
@@ -244,17 +267,21 @@ export async function runAgentDeviceRemoteSessionAsync(
       return;
     }
     tasks.signal.throwIfAborted();
-    void pollAgentDeviceArtifactsForUploadAsync(ctx, {
+    artifactUploads = pollAgentDeviceArtifactsForUploadAsync(ctx, {
       deviceRunSessionId,
       daemonUrl: `http://127.0.0.1:${daemonPort}`,
       daemonToken,
       logger,
+      signal,
+      stopPollingSignal: stopArtifactPolling.signal,
     });
+    // Attach a handler at once; the teardown still awaits and reports a rejection.
+    void artifactUploads.catch(() => {});
 
     eventCollection = await startAgentDeviceEventCollectionAsync({
       ctx,
       deviceRunSessionId,
-      stateDir: AGENT_DEVICE_STATE_DIR,
+      stateDir: warm?.agentDeviceStateDir ?? AGENT_DEVICE_STATE_DIR,
       logger,
     });
 
@@ -282,29 +309,41 @@ export async function runAgentDeviceRemoteSessionAsync(
     // everything that was started.
     await Promise.allSettled([agentDeviceStartup, sessionHostStartup, deviceReady]);
     const startedDaemon = daemonProcess;
+    const toolTeardown = (async () => {
+      try {
+        if (eventCollection) {
+          await stopAgentDeviceEventCollectionSafelyAsync({
+            eventCollection,
+            deviceRunSessionId,
+            logger,
+          });
+        }
+      } finally {
+        try {
+          // The final inventory reads from the daemon, so it finishes before the daemon stops.
+          stopArtifactPolling.abort();
+          await artifactUploads;
+        } finally {
+          await startedDaemon?.stopAsync();
+        }
+      }
+    })();
     await finishRemoteSessionAsync({
       logger,
       sessionFailed,
       teardown: [
         ['agent-device tunnel', agentDeviceTunnel?.stopAsync()],
+        ['agent-device daemon', toolTeardown],
         [
-          'agent-device daemon',
-          startedDaemon &&
-            (async () => {
-              try {
-                if (eventCollection) {
-                  await stopAgentDeviceEventCollectionSafelyAsync({
-                    eventCollection,
-                    deviceRunSessionId,
-                    logger,
-                  });
-                }
-              } finally {
-                await startedDaemon.stopAsync();
-              }
-            })(),
+          'session host',
+          (async () => {
+            if (warm) {
+              // The warm host owns the daemon too; keep it alive through the final downloads.
+              await Promise.allSettled([toolTeardown]);
+            }
+            await sessionHost?.finishAsync();
+          })(),
         ],
-        ['session host', sessionHost?.finishAsync()],
       ],
     });
   }

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

@@ -16,26 +16,29 @@ import {
   AndroidVirtualDeviceName,
 } from '../../utils/AndroidEmulatorUtils';
 import { getDeviceRunSessionWorkerApi } from '../utils/deviceRunSessionWorkerApi';
+import { readIosApplicationIdentifierAsync } from '../utils/iosAppArtifact';
+import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
+import { runOnWarmIosSimulatorAsync } from '../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../utils/warmIosSession';
 import { withLocalEgressSession } from '../utils/localEgressSession';
 import {
+  type ServeSimApplicationOptions,
   createCorsOriginsInputProvider,
   createFrameAncestorsInputProvider,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
+  createServeSimLaunchInputProviders,
   omitNgrokAuthtoken,
   parseCorsOriginsInput,
   parseFrameAncestorsInput,
   selectXcodeDeveloperDirectoryAsync,
+  validateServeSimLaunchOptions,
 } from '../utils/remoteDeviceRunSession';
 import {
   createNetworkCaptureInputProviders,
   parseNetworkCaptureInputs,
 } from '../utils/networkCaptureFields';
 import { createStartupTasks } from '../utils/startupTasks';
-import {
-  type ServeSimApplicationOptions,
-  validateServeSimLaunchOptions,
-} from '../utils/remoteDeviceRunSession';
 
 import { downloadBuildAsync } from './downloadBuild';
 import { installBuildAsync } from './installBuild';
@@ -49,22 +52,23 @@ import {
   runAgentDeviceRemoteSessionAsync,
 } from './startAgentDeviceRemoteSession';
 import { startAndroidEmulatorAsync } from './startAndroidEmulator';
-import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
-import { readIosApplicationIdentifierAsync } from '../utils/iosAppArtifact';
 
 const ANDROID_DEVICE_NAME = 'EasAndroidDevice01' as AndroidVirtualDeviceName;
 
 /**
- * Starts a device session, downloading the app alongside daemon startup.
+ * Starts a device session using an optional local app artifact, or one it downloads.
  * On iOS, serve-sim boots the selected Simulator, then installs and launches
- * the downloaded app. Build-tools verifies any egress guard before install and launch.
+ * the app. Build-tools verifies any egress guard before install and launch.
  */
-export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildContext): BuildFunction {
+export function createStartAgentDeviceSessionBuildFunction(
+  ctx: CustomBuildContext,
+  { warm = false }: { warm?: boolean } = {}
+): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: 'start_agent_device_session',
+    id: warm ? 'start_warm_agent_device_session' : 'start_agent_device_session',
     name: 'Start agent-device session',
-    __metricsId: 'eas/start_agent_device_session',
+    __metricsId: warm ? 'eas/start_warm_agent_device_session' : 'eas/start_agent_device_session',
     inputProviders: [
       // Device. On iOS a Simulator name or UDID, on Android an AVD hardware profile.
       BuildStepInput.createProvider({
@@ -93,7 +97,13 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
-      // Application. Pass at most one of build_id and application_archive_url.
+      // Application. Pass at most one of install_app_path, build_id and application_archive_url.
+      BuildStepInput.createProvider({
+        id: 'install_app_path',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+      // Deprecated: remove once workflows pass install_app_path.
       BuildStepInput.createProvider({
         id: 'build_id',
         required: false,
@@ -104,16 +114,7 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
-      BuildStepInput.createProvider({
-        id: 'launch_args',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-      }),
-      BuildStepInput.createProvider({
-        id: 'open_url',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
+      ...createServeSimLaunchInputProviders(),
       // Session.
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
@@ -144,22 +145,41 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
       // Validate everything before any expensive work starts.
       const sessionEnv = getAgentDeviceRemoteSessionEnvOrThrow(stepEnv);
       const env = omitNgrokAuthtoken(stepEnv);
+      const installAppPath = inputs.install_app_path.value as string | undefined;
       const buildId = inputs.build_id.value as string | undefined;
       const applicationArchiveUrl = inputs.application_archive_url.value as string | undefined;
-      if (buildId && applicationArchiveUrl) {
-        throw new UserError(
-          'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-          'Pass only one of build_id or application_archive_url.'
-        );
-      }
-      const hasApplication = Boolean(buildId || applicationArchiveUrl);
+      const launchAppIdentifier = inputs.launch_app_identifier.value as string | undefined;
       const launchArgs = parseLaunchArgsInput(inputs.launch_args.value);
       const openUrl =
         inputs.open_url.value === undefined ? undefined : parseOpenUrlInput(inputs.open_url.value);
-      if (!hasApplication && (launchArgs.length > 0 || openUrl)) {
+      const download = buildId || applicationArchiveUrl;
+      if ([installAppPath, buildId, applicationArchiveUrl].filter(Boolean).length > 1) {
+        throw new UserError(
+          'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
+          'Pass only one of install_app_path, build_id or application_archive_url.'
+        );
+      }
+      if (download && launchAppIdentifier !== undefined) {
         throw new UserError(
           'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-          'launch_args and open_url need an application: pass build_id or application_archive_url.'
+          'launch_app_identifier cannot be combined with build_id or application_archive_url.'
+        );
+      }
+      if (
+        !installAppPath &&
+        !download &&
+        !launchAppIdentifier &&
+        (launchArgs.length > 0 || openUrl)
+      ) {
+        throw new UserError(
+          'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
+          'launch_args and open_url need an application: pass install_app_path or launch_app_identifier.'
+        );
+      }
+      if (!isIos && launchAppIdentifier !== undefined) {
+        throw new UserError(
+          'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
+          'launch_app_identifier is only supported for iOS Simulator sessions. Pass install_app_path for Android.'
         );
       }
       if (isIos) {
@@ -176,87 +196,111 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
         { runtimePlatform }
       );
 
-      const tasks = createStartupTasks(logger, signal);
-      let downloaded: Promise<string> | undefined;
-      let applicationReady: Promise<ServeSimApplicationOptions | void> | undefined;
+      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
+        const tasks = createStartupTasks(logger, signal);
+        let downloaded: Promise<string> | undefined;
+        let applicationReady: Promise<ServeSimApplicationOptions | void> | undefined;
 
-      try {
-        if (isIos) {
-          // Select Xcode before serve-sim boots the device or any Simulator tools run.
-          await selectXcodeDeveloperDirectoryAsync({ env, logger });
-        }
-        tasks.signal.throwIfAborted();
-        const { iosStartup } = isIos
-          ? await resolveIosSessionStartupAsync({
-              runtimePlatform,
-              bootSimulator: true,
-              deviceIdentifier,
-              env,
-              logger,
-              signal: tasks.signal,
-            })
-          : {};
-        const iosSimulatorUdid = iosStartup?.iosSimulatorUdid;
-        if (iosSimulatorUdid) {
-          logger.info(`Selected iOS Simulator: ${iosSimulatorUdid}.`);
-        }
-
-        const booted = iosSimulatorUdid
-          ? undefined
-          : tasks.run('Android Emulator boot', async taskLogger => {
-              const logcatDirectory = await fs.promises.mkdtemp(
-                path.join(os.tmpdir(), 'eas-android-emulator-logcat-')
-              );
-              tasks.signal.throwIfAborted();
-              await startAndroidEmulatorAsync({
-                deviceName: ANDROID_DEVICE_NAME,
-                systemImagePackage: `${inputs.system_image_package.value}`,
-                deviceIdentifier: deviceIdentifier as AndroidDeviceName | undefined,
-                lcdWidth: inputs.lcd_width.value as number | undefined,
-                lcdHeight: inputs.lcd_height.value as number | undefined,
-                lcdDensity: inputs.lcd_density.value as number | undefined,
-                logcatDirectory,
+        try {
+          if (isIos) {
+            // Select Xcode before serve-sim boots the device or any Simulator tools run.
+            await selectXcodeDeveloperDirectoryAsync({ env, logger });
+          }
+          tasks.signal.throwIfAborted();
+          const { launch, iosStartup } = isIos
+            ? await resolveIosSessionStartupAsync({
+                runtimePlatform,
+                bootSimulator: true,
+                deviceIdentifier: warmSession?.device.udid ?? deviceIdentifier,
+                installAppPath,
+                launchAppIdentifier,
+                // A downloaded app gets its launch options after the download.
+                launchArgs: download ? [] : launchArgs,
+                openUrl: download ? undefined : openUrl,
                 env,
-                logger: taskLogger,
-              });
-            });
-
-        downloaded = hasApplication
-          ? tasks.run('build download', async taskLogger => {
-              const { artifactPath } = await downloadBuildAsync({
-                logger: taskLogger,
-                ...(buildId ? { buildId } : { applicationArchiveUrl: applicationArchiveUrl! }),
-                graphqlClient: ctx.graphqlClient,
-                deviceRunSessionWorkerApi: buildId ? getDeviceRunSessionWorkerApi(ctx) : null,
-                robotAccessToken: global.staticContext.job.secrets?.robotAccessToken ?? null,
-                extensions: isIos ? ['app'] : ['apk'],
+                logger,
                 signal: tasks.signal,
-              });
-              return artifactPath;
-            })
-          : undefined;
+              })
+            : {};
+          const iosSimulatorUdid = iosStartup?.iosSimulatorUdid;
+          if (iosSimulatorUdid) {
+            logger.info(`Selected iOS Simulator: ${iosSimulatorUdid}.`);
+          }
 
-        const download = downloaded;
-        applicationReady = download
-          ? tasks.run(isIos ? 'app preparation' : 'app install and launch', async taskLogger => {
-              if (booted) {
-                await tasks.untilAborted(booted);
-              }
-              const artifactPath = await download;
-              tasks.signal.throwIfAborted();
-              if (isIos) {
-                const applicationIdentifier = await readIosApplicationIdentifierAsync({
-                  artifactPath,
-                  env,
-                });
+          const booted = iosSimulatorUdid
+            ? Promise.resolve()
+            : tasks.run('Android Emulator boot', async taskLogger => {
+                const logcatDirectory = await fs.promises.mkdtemp(
+                  path.join(os.tmpdir(), 'eas-android-emulator-logcat-')
+                );
                 tasks.signal.throwIfAborted();
-                return {
-                  installAppPath: artifactPath,
-                  launchAppIdentifier: applicationIdentifier,
-                  launchArgs,
-                  openUrl,
-                };
+                await startAndroidEmulatorAsync({
+                  deviceName: ANDROID_DEVICE_NAME,
+                  systemImagePackage: `${inputs.system_image_package.value}`,
+                  deviceIdentifier: deviceIdentifier as AndroidDeviceName | undefined,
+                  lcdWidth: inputs.lcd_width.value as number | undefined,
+                  lcdHeight: inputs.lcd_height.value as number | undefined,
+                  lcdDensity: inputs.lcd_density.value as number | undefined,
+                  logcatDirectory,
+                  env,
+                  logger: taskLogger,
+                });
+              });
+
+          downloaded = download
+            ? tasks.run('build download', async taskLogger => {
+                const source = buildId
+                  ? { buildId }
+                  : applicationArchiveUrl
+                    ? { applicationArchiveUrl }
+                    : undefined;
+                if (!source) {
+                  throw new Error('No app source was provided for download.');
+                }
+                const { artifactPath } = await downloadBuildAsync({
+                  logger: taskLogger,
+                  ...source,
+                  graphqlClient: ctx.graphqlClient,
+                  deviceRunSessionWorkerApi: buildId ? getDeviceRunSessionWorkerApi(ctx) : null,
+                  robotAccessToken: global.staticContext.job.secrets?.robotAccessToken ?? null,
+                  extensions: isIos ? ['app'] : ['apk'],
+                  signal: tasks.signal,
+                });
+                return artifactPath;
+              })
+            : undefined;
+          const downloadedApp = downloaded;
+
+          if (isIos && downloadedApp) {
+            applicationReady = tasks.run('app preparation', async () => {
+              const artifactPath = await downloadedApp;
+              tasks.signal.throwIfAborted();
+              const applicationIdentifier = await readIosApplicationIdentifierAsync({
+                artifactPath,
+                env,
+              });
+              tasks.signal.throwIfAborted();
+              return {
+                installAppPath: artifactPath,
+                launchAppIdentifier: applicationIdentifier,
+                launchArgs,
+                openUrl,
+              };
+            });
+          } else if (isIos && launch?.launchAppIdentifier) {
+            applicationReady = Promise.resolve({
+              ...launch,
+              launchAppIdentifier: launch.launchAppIdentifier,
+              installAppPath,
+            });
+          } else if (!isIos && (installAppPath || downloadedApp)) {
+            applicationReady = tasks.run('app install and launch', async taskLogger => {
+              await tasks.untilAborted(booted);
+              const artifactPath = installAppPath ?? (await downloadedApp);
+              if (!artifactPath) {
+                throw new Error('No app artifact was prepared.');
               }
+              tasks.signal.throwIfAborted();
               const { applicationIdentifier, activityName } = await installBuildAsync({
                 artifactPath,
                 runtimePlatform,
@@ -273,39 +317,57 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
                 env,
                 logger: taskLogger,
               });
-            })
-          : undefined;
+            });
+          }
 
-        await runAgentDeviceRemoteSessionAsync(ctx, {
-          env,
-          logger,
-          signal,
-          runtimePlatform,
-          sessionEnv,
-          packageVersion: inputs.package_version.value as string | undefined,
-          // A missing or non-positive value disables the idle timeout (opt-in feature).
-          maxIdleTimeMinutes: inputs.max_idle_time_minutes.value as number | undefined,
-          maxDurationSeconds: inputs.max_duration_seconds.value as number | undefined,
-          capture,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          tasks,
-          device: iosSimulatorUdid
-            ? {
-                ...iosStartup,
-                iosSimulatorUdid,
-                application: applicationReady,
-              }
-            : {
-                booted: booted!,
-                ready: applicationReady ?? tasks.untilAborted(booted!),
-              },
-        });
-      } finally {
-        tasks.abort(new Error('Agent-device session ended.'));
-        await Promise.allSettled([downloaded, applicationReady]);
+          await runAgentDeviceRemoteSessionAsync(ctx, {
+            env,
+            logger,
+            signal,
+            runtimePlatform,
+            sessionEnv,
+            packageVersion: inputs.package_version.value as string | undefined,
+            // A missing or non-positive value disables the idle timeout (opt-in feature).
+            maxIdleTimeMinutes: inputs.max_idle_time_minutes.value as number | undefined,
+            maxDurationSeconds: inputs.max_duration_seconds.value as number | undefined,
+            capture,
+            disableShare: inputs.public_preview?.value === false,
+            privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+            frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
+            corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
+            tasks,
+            warm: warmSession,
+            device: iosSimulatorUdid
+              ? {
+                  iosSimulatorUdid,
+                  bootEnv: iosStartup?.bootEnv,
+                  application: applicationReady,
+                }
+              : {
+                  booted,
+                  ready: applicationReady ?? tasks.untilAborted(booted),
+                },
+          });
+        } finally {
+          tasks.abort(new Error('Agent-device session ended.'));
+          await Promise.allSettled([downloaded, applicationReady]);
+        }
+      };
+      // The warm path installs only a local app; build_id and application_archive_url start cold.
+      if (warm && isIos && !download) {
+        await runOnWarmIosSimulatorAsync(
+          {
+            engine: 'agent-device',
+            requestedDevice: deviceIdentifier,
+            packageVersion: inputs.package_version.value as string | undefined,
+            env,
+            logger,
+            signal,
+          },
+          startSessionAsync
+        );
+      } else {
+        await startSessionAsync();
       }
     }),
   });

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

@@ -22,6 +22,12 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import { type DeviceSessionHost, startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
+import {
+  WarmSessionAdoptionError,
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../utils/warmIosSession';
 import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
@@ -73,13 +79,14 @@ const AppiumInstalledDriversSchema = z.record(
 );
 
 export function createStartAppiumRemoteSessionBuildFunction(
-  ctx: CustomBuildContext
+  ctx: CustomBuildContext,
+  { warm = false }: { warm?: boolean } = {}
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: 'start_appium_remote_session',
+    id: warm ? 'start_warm_appium_remote_session' : 'start_appium_remote_session',
     name: 'Start Appium remote session',
-    __metricsId: 'eas/start_appium_remote_session',
+    __metricsId: warm ? 'eas/start_warm_appium_remote_session' : 'eas/start_appium_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -110,250 +117,284 @@ export function createStartAppiumRemoteSessionBuildFunction(
       if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
         await selectXcodeDeveloperDirectoryAsync({ env, logger });
       }
-      const { launch, iosStartup } = await resolveIosSessionStartupAsync({
-        runtimePlatform,
-        bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
-        deviceIdentifier: inputs.device_identifier?.value as string | undefined,
-        installAppPath: inputs.install_app_path?.value as string | undefined,
-        launchAppIdentifier: inputs.launch_app_identifier?.value,
-        launchArgs: inputs.launch_args?.value,
-        openUrl: inputs.open_url?.value,
-        env,
-        logger,
-        signal,
-      });
-      const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
-        {
-          networkCapture: inputs.network_capture?.value,
-          networkCaptureFields: inputs.network_capture_fields?.value,
-        },
-        { runtimePlatform }
-      );
-      const versionSpec = resolveAppium3VersionSpec(packageVersion);
-
-      logger.info(
-        `Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
-      );
-      const device: AppiumDevice = iosStartup
-        ? {
-            platformName: 'iOS',
-            automationName: 'XCUITest',
-            driverName: 'xcuitest',
-            udid: iosStartup.iosSimulatorUdid,
-          }
-        : await resolveAppiumDeviceAsync({ runtimePlatform, env });
-      const startupAbortController = new AbortController();
-      const startupSignal = signal
-        ? AbortSignal.any([signal, startupAbortController.signal])
-        : startupAbortController.signal;
-      const setupSignal = iosStartup ? startupSignal : undefined;
-      let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
-      let sessionHost: DeviceSessionHost | undefined;
-      let appiumProcess: ReturnType<typeof spawnDetached> | undefined;
-      let appiumHome: string | undefined;
-      let eventCollection: Awaited<ReturnType<typeof startAppiumEventCollectionAsync>> | undefined;
-      let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
-      let sessionFailed = false;
-      const startHost = () =>
-        startDeviceSessionHostAsync(ctx, {
-          ...iosStartup,
-          previewDeviceId: device.udid,
-          separateLogPhase: true,
+      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
+      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
+        const { launch, iosStartup } = await resolveIosSessionStartupAsync({
           runtimePlatform,
+          bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
+          deviceIdentifier: warmSession?.device.udid ?? deviceIdentifier,
+          installAppPath: inputs.install_app_path?.value as string | undefined,
+          launchAppIdentifier: inputs.launch_app_identifier?.value,
+          launchArgs: inputs.launch_args?.value,
+          openUrl: inputs.open_url?.value,
           env,
           logger,
-          timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          signal: startupSignal,
-          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-          ...launch,
-          networkCapture,
-          networkCaptureFields,
-        }).catch(error => {
-          if (iosStartup) {
-            startupAbortController.abort(error);
-          }
-          throw error;
+          signal,
         });
-      try {
-        if (iosStartup) {
-          hostStartup = asyncResult(startHost());
-        }
-        // Appium's startRecordingScreen runs ffmpeg on this host: XCUITest encodes the
-        // simulator stream with it, and UiAutomator2 merges long recordings with it. The
-        // macOS session image does not ship ffmpeg, so install it concurrently with Appium.
-        // Both owned installs settle before proceeding; a shared FFmpeg install keeps its owner.
-        const [appiumInstall] = await Promise.all([
-          asyncResult(
-            installAppiumAsync({
-              versionSpec,
-              driverName: device.driverName,
+        const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
+          {
+            networkCapture: inputs.network_capture?.value,
+            networkCaptureFields: inputs.network_capture_fields?.value,
+          },
+          { runtimePlatform }
+        );
+        const versionSpec = resolveAppium3VersionSpec(packageVersion);
+
+        logger.info(
+          `Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
+        );
+        const device: AppiumDevice = iosStartup
+          ? {
+              platformName: 'iOS',
+              automationName: 'XCUITest',
+              driverName: 'xcuitest',
+              udid: iosStartup.iosSimulatorUdid,
+            }
+          : await resolveAppiumDeviceAsync({ runtimePlatform, env });
+        const startupAbortController = new AbortController();
+        const startupSignal = signal
+          ? AbortSignal.any([signal, startupAbortController.signal])
+          : startupAbortController.signal;
+        const setupSignal = iosStartup ? startupSignal : undefined;
+        let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
+        let sessionHost: DeviceSessionHost | undefined;
+        let appiumProcess: ReturnType<typeof spawnDetached> | undefined;
+        let appiumHome: string | undefined;
+        let eventCollection:
+          | Awaited<ReturnType<typeof startAppiumEventCollectionAsync>>
+          | undefined;
+        let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
+        let sessionFailed = false;
+        let sessionError: unknown;
+        const startHost = () =>
+          startDeviceSessionHostAsync(
+            ctx,
+            {
+              ...iosStartup,
+              previewDeviceId: device.udid,
+              separateLogPhase: true,
+              runtimePlatform,
               env,
               logger,
-              signal: setupSignal,
-              onError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-            }).catch(error => {
-              if (iosStartup) {
-                startupAbortController.abort(error);
-              }
-              throw error;
-            })
-          ),
-          asyncResult(
-            ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger, signal: setupSignal })
-          ),
-        ]);
-        const installation = appiumInstall.enforceValue();
-        appiumHome = installation.appiumHome;
-        setupSignal?.throwIfAborted();
-        const { appiumBinPath, appiumEnv } = installation;
-        const wdaCapabilities = await preparePreinstalledWdaAsync({
-          runtimeIdentifier: iosStartup
-            ? (
-                await IosSimulatorUtils.getDeviceAsync({
-                  udid: iosStartup.iosSimulatorUdid as IosSimulatorUuid,
-                  env,
-                })
-              )?.runtime
-            : device.runtimeIdentifier,
-          appiumHome,
-          appiumBinPath,
-          appiumEnv,
-          logger,
-          signal: setupSignal,
-        });
-
-        setupSignal?.throwIfAborted();
-        const useFdaHelper =
-          runtimePlatform === BuildRuntimePlatform.DARWIN && fs.existsSync(FDA_HELPER);
-        appiumProcess = spawnDetached({
-          command: useFdaHelper ? FDA_HELPER : appiumBinPath,
-          args: [
-            ...(useFdaHelper ? [appiumBinPath] : []),
-            '--address',
-            APPIUM_HOST,
-            '--port',
-            String(APPIUM_PORT),
-            '--base-path',
-            '/',
-            '--log-level',
-            'error',
-            // Appium 3 gates session listing (GET /appium/sessions) behind the
-            // session_discovery insecure feature. We rely on it to poll for
-            // Appium Event Timings, so enable it for all drivers.
-            '--allow-insecure',
-            '*:session_discovery',
-            '--default-capabilities',
-            JSON.stringify({
-              'appium:eventTimings': true,
-              // Without it, XCUITest restarted the booted Simulator at session start, which
-              // closed the app serve-sim had launched. EAS VMs never show the Simulator window.
-              ...(device.platformName === 'iOS' ? { 'appium:isHeadless': true } : {}),
-              ...wdaCapabilities,
-            }),
-          ],
-          env: appiumEnv,
-          logger,
-        });
-        await waitForAppiumReadyAsync({ appiumProcess, logger, signal: setupSignal });
-        if (hostStartup) {
-          sessionHost = (await hostStartup).enforceValue();
-        }
-        setupSignal?.throwIfAborted();
-        eventCollection = await startAppiumEventCollectionAsync({
-          ctx,
-          deviceRunSessionId,
-          appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
-          logger,
-        });
-        appiumTunnel = await startNgrokTunnelAsync({
-          port: APPIUM_PORT,
-          subdomainPrefix: 'appium',
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-          healthCheck: { path: '/status' },
-          logger,
-        });
-
-        // The preview host uses the same device selected for Appium.
-        const launchDescription = describeServeSimLaunch(launch);
-        if (launchDescription) {
-          logger.info(launchDescription);
-        }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-        });
-
-        const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
-          signal,
-          ctx,
-          deviceRunSessionId,
-          remoteConfig: {
-            appiumUrl: appiumTunnel.url,
-            capabilities: {
-              platformName: device.platformName,
-              'appium:automationName': device.automationName,
-              'appium:udid': device.udid,
+              timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
+              preview: { baseDomain: ngrokTunnelDomain, authtoken: ngrokAuthtoken },
+              disableShare: inputs.public_preview?.value === false,
+              privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+              frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
+              corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
+              signal: startupSignal,
+              onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
+              ...launch,
+              networkCapture,
+              networkCaptureFields,
             },
-            webPreviewUrl: webPreview.previewPageUrl,
-            previewApiUrl: webPreview.apiUrl,
-            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
-          },
-          logger,
-        });
-        if (sessionStart === 'stopped') {
-          return;
-        }
+            ...(warmSession ? [createWarmDeviceSessionServer(ctx, logger, warmSession)] : [])
+          ).catch(error => {
+            if (iosStartup) {
+              startupAbortController.abort(error);
+            }
+            throw error;
+          });
+        try {
+          if (iosStartup) {
+            hostStartup = asyncResult(startHost());
+          }
+          // Appium's startRecordingScreen runs ffmpeg on this host: XCUITest encodes the
+          // simulator stream with it, and UiAutomator2 merges long recordings with it. The
+          // macOS session image does not ship ffmpeg, so install it concurrently with Appium.
+          // Both owned installs settle before proceeding; a shared FFmpeg install keeps its owner.
+          const [appiumInstall] = await Promise.all([
+            asyncResult(
+              installAppiumAsync({
+                versionSpec,
+                driverName: device.driverName,
+                env,
+                logger,
+                signal: setupSignal,
+                onError: iosStartup ? error => startupAbortController.abort(error) : undefined,
+              }).catch(error => {
+                if (iosStartup) {
+                  startupAbortController.abort(error);
+                }
+                throw error;
+              })
+            ),
+            asyncResult(
+              ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger, signal: setupSignal })
+            ),
+          ]);
+          const installation = appiumInstall.enforceValue();
+          appiumHome = installation.appiumHome;
+          setupSignal?.throwIfAborted();
+          const { appiumBinPath, appiumEnv } = installation;
+          const wdaCapabilities = await preparePreinstalledWdaAsync({
+            runtimeIdentifier: iosStartup
+              ? (
+                  await IosSimulatorUtils.getDeviceAsync({
+                    udid: iosStartup.iosSimulatorUdid as IosSimulatorUuid,
+                    env,
+                  })
+                )?.runtime
+              : device.runtimeIdentifier,
+            appiumHome,
+            appiumBinPath,
+            appiumEnv,
+            logger,
+            signal: setupSignal,
+          });
 
-        await waitForDeviceRunSessionStoppedAsync({
-          ctx,
-          deviceRunSessionId,
-          logger,
-          signal,
-          idleTimeout:
-            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-              ? {
-                  maxIdleTimeMinutes,
-                  getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                  getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
-                }
-              : undefined,
-        });
-      } catch (error) {
-        sessionFailed = true;
-        throw setupSignal?.aborted ? setupSignal.reason : error;
-      } finally {
-        startupAbortController.abort(new Error('Appium session ended.'));
-        await finishRemoteSessionAsync({
-          logger,
-          sessionFailed,
-          teardown: [
-            ['Appium tunnel', appiumTunnel?.stopAsync()],
-            [
-              'Appium server',
-              (async () => {
-                try {
-                  await eventCollection?.stopAsync();
-                } finally {
-                  try {
-                    await appiumProcess?.stopAsync();
-                  } finally {
-                    if (appiumHome) {
-                      await fs.promises.rm(appiumHome, { recursive: true, force: true });
-                    }
-                  }
-                }
-              })(),
+          setupSignal?.throwIfAborted();
+          const useFdaHelper =
+            runtimePlatform === BuildRuntimePlatform.DARWIN && fs.existsSync(FDA_HELPER);
+          appiumProcess = spawnDetached({
+            command: useFdaHelper ? FDA_HELPER : appiumBinPath,
+            args: [
+              ...(useFdaHelper ? [appiumBinPath] : []),
+              '--address',
+              APPIUM_HOST,
+              '--port',
+              String(APPIUM_PORT),
+              '--base-path',
+              '/',
+              '--log-level',
+              'error',
+              // Appium 3 gates session listing (GET /appium/sessions) behind the
+              // session_discovery insecure feature. We rely on it to poll for
+              // Appium Event Timings, so enable it for all drivers.
+              '--allow-insecure',
+              '*:session_discovery',
+              '--default-capabilities',
+              JSON.stringify({
+                'appium:eventTimings': true,
+                // Without it, XCUITest restarted the booted Simulator at session start, which
+                // closed the app serve-sim had launched. EAS VMs never show the Simulator window.
+                ...(device.platformName === 'iOS' ? { 'appium:isHeadless': true } : {}),
+                ...wdaCapabilities,
+              }),
             ],
-            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
-          ],
-        });
+            env: appiumEnv,
+            logger,
+          });
+          await waitForAppiumReadyAsync({ appiumProcess, logger, signal: setupSignal });
+          if (hostStartup) {
+            sessionHost = (await hostStartup).enforceValue();
+          }
+          setupSignal?.throwIfAborted();
+          eventCollection = await startAppiumEventCollectionAsync({
+            ctx,
+            deviceRunSessionId,
+            appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
+            logger,
+          });
+          appiumTunnel = await startNgrokTunnelAsync({
+            port: APPIUM_PORT,
+            subdomainPrefix: 'appium',
+            baseDomain: ngrokTunnelDomain,
+            authtoken: ngrokAuthtoken,
+            healthCheck: { path: '/status' },
+            logger,
+          });
+
+          // The preview host uses the same device selected for Appium.
+          const launchDescription = describeServeSimLaunch(launch);
+          if (launchDescription) {
+            logger.info(launchDescription);
+          }
+          sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+          const webPreview = await sessionHost.openPreviewAsync();
+
+          const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
+            env,
+            signal,
+            ctx,
+            deviceRunSessionId,
+            remoteConfig: {
+              appiumUrl: appiumTunnel.url,
+              capabilities: {
+                platformName: device.platformName,
+                'appium:automationName': device.automationName,
+                'appium:udid': device.udid,
+              },
+              webPreviewUrl: webPreview.previewPageUrl,
+              previewApiUrl: webPreview.apiUrl,
+              ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+            },
+            logger,
+          });
+          if (sessionStart === 'stopped') {
+            return;
+          }
+
+          await waitForDeviceRunSessionStoppedAsync({
+            ctx,
+            deviceRunSessionId,
+            logger,
+            signal,
+            idleTimeout:
+              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                ? {
+                    maxIdleTimeMinutes,
+                    getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                    getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
+                  }
+                : undefined,
+          });
+        } catch (error) {
+          sessionFailed = true;
+          sessionError = setupSignal?.aborted ? setupSignal.reason : error;
+          throw sessionError;
+        } finally {
+          startupAbortController.abort(new Error('Appium session ended.'));
+          const appiumStopErrors: unknown[] = [];
+          const appiumTeardown = (async () => {
+            try {
+              await eventCollection?.stopAsync();
+            } finally {
+              try {
+                await appiumProcess?.stopAsync();
+              } catch (error) {
+                appiumStopErrors.push(error);
+                throw error;
+              } finally {
+                if (appiumHome) {
+                  await fs.promises.rm(appiumHome, { recursive: true, force: true });
+                }
+              }
+            }
+          })();
+          await finishRemoteSessionAsync({
+            logger,
+            sessionFailed,
+            teardown: [
+              ['Appium tunnel', appiumTunnel?.stopAsync()],
+              ['Appium server', appiumTeardown],
+              [
+                'session host',
+                hostStartup?.then(async result => {
+                  if (warmSession) {
+                    await Promise.allSettled([appiumTeardown]);
+                  }
+                  await result.value?.finishAsync();
+                }),
+              ],
+            ],
+          });
+          if (sessionError instanceof WarmSessionAdoptionError && appiumStopErrors.length) {
+            throw new AggregateError(
+              [sessionError, ...appiumStopErrors],
+              'Could not stop Appium after warm adoption failed; a cold session cannot start safely.'
+            );
+          }
+        }
+      };
+      if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await runOnWarmIosSimulatorAsync(
+          // package_version is the Appium version, which the job installs either way.
+          { engine: 'appium', requestedDevice: deviceIdentifier, env, logger, signal },
+          startSessionAsync
+        );
+      } else {
+        await startSessionAsync();
       }
     }),
   });

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

@@ -12,7 +12,6 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { setTimeout as setTimeoutAsync } from 'node:timers/promises';
-import semver from 'semver';
 import { z } from 'zod';
 
 import { CustomBuildContext } from '../../customBuildContext';
@@ -21,6 +20,12 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import { type DeviceSessionHost, startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
+import {
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../utils/warmIosSession';
+import { validateControllerVersion } from '../utils/controllerVersion';
 import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
@@ -84,13 +89,14 @@ const ArgentToolServerStateSchema = z.object({
 type ArgentToolServerState = z.infer<typeof ArgentToolServerStateSchema>;
 
 export function createStartArgentRemoteSessionBuildFunction(
-  ctx: CustomBuildContext
+  ctx: CustomBuildContext,
+  { warm = false }: { warm?: boolean } = {}
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: 'start_argent_remote_session',
+    id: warm ? 'start_warm_argent_remote_session' : 'start_argent_remote_session',
     name: 'Start argent remote session',
-    __metricsId: 'eas/start_argent_remote_session',
+    __metricsId: warm ? 'eas/start_warm_argent_remote_session' : 'eas/start_argent_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -129,314 +135,362 @@ export function createStartArgentRemoteSessionBuildFunction(
       // A missing or non-positive value disables the idle timeout (opt-in feature).
       const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value as number | undefined;
       const maxDurationSeconds = inputs.max_duration_seconds?.value as number | undefined;
-      warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
+      validateControllerVersion({
+        packageName: ARGENT_PACKAGE_NAME,
+        minimumVersion: MIN_ARGENT_REMOTE_SESSION_VERSION,
+        packageVersion,
+        logger,
+      });
       const versionSpec = packageVersion ?? 'latest';
       const { runtimePlatform } = global;
       if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
         await selectXcodeDeveloperDirectoryAsync({ env, logger });
       }
-      const { launch, iosStartup } = await resolveIosSessionStartupAsync({
-        runtimePlatform,
-        bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
-        deviceIdentifier: inputs.device_identifier?.value as string | undefined,
-        installAppPath: inputs.install_app_path?.value as string | undefined,
-        launchAppIdentifier: inputs.launch_app_identifier?.value,
-        launchArgs: inputs.launch_args?.value,
-        openUrl: inputs.open_url?.value,
-        env,
-        logger,
-        signal,
-      });
-      const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
-        {
-          networkCapture: inputs.network_capture?.value,
-          networkCaptureFields: inputs.network_capture_fields?.value,
-        },
-        { runtimePlatform }
-      );
-      logger.info(
-        `Starting argent remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
-      );
-
-      // Start the potentially slow installation while Argent is being prepared.
-      // On Linux expo-device-hub calls this again and awaits the same in-flight
-      // setup before launching. On macOS this remains non-blocking, so only a
-      // recording started in the first moments may miss ffmpeg.
-      // Never rejects, so `void` is safe.
-      void ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger });
-
-      const packageManager = resolveConfiguredPackageManager(env, PackageManager.BUN);
-      const argentExec = (args: string[]): { command: string; args: string[] } =>
-        resolvePackageExec(packageManager, args);
-
-      const startupAbortController = new AbortController();
-      const startupSignal = signal
-        ? AbortSignal.any([signal, startupAbortController.signal])
-        : startupAbortController.signal;
-      const setupSignal = iosStartup ? startupSignal : undefined;
-      const artifactPollAbortController = new AbortController();
-      let artifactPollingPromise: Promise<void> | undefined;
-      let eventCollection: Awaited<ReturnType<typeof startArgentEventCollectionAsync>> | undefined;
-      let toolsTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
-      let argentServer: ReturnType<typeof spawnDetached> | undefined;
-      let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
-      let sessionHost: DeviceSessionHost | undefined;
-      let sessionFailed = false;
-      const startHost = () =>
-        startDeviceSessionHostAsync(ctx, {
-          ...iosStartup,
-          separateLogPhase: true,
+      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
+      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
+        const { launch, iosStartup } = await resolveIosSessionStartupAsync({
           runtimePlatform,
+          bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
+          deviceIdentifier: warmSession?.device.udid ?? deviceIdentifier,
+          installAppPath: inputs.install_app_path?.value as string | undefined,
+          launchAppIdentifier: inputs.launch_app_identifier?.value,
+          launchArgs: inputs.launch_args?.value,
+          openUrl: inputs.open_url?.value,
           env,
           logger,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          timeoutMs: STARTUP_TIMEOUT_MS,
-          signal: startupSignal,
-          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-          ...launch,
-          networkCapture,
-          networkCaptureFields,
-        }).catch(error => {
-          if (iosStartup) {
-            startupAbortController.abort(error);
-          }
-          throw error;
-        });
-      try {
-        if (iosStartup) {
-          hostStartup = asyncResult(startHost());
-        }
-        logger.info('Enabling the Argent artifacts list endpoint flag.');
-        const enableArtifacts = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'enable',
-          ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG,
-        ]);
-        await runArgentSetupCommandAsync(
-          enableArtifacts.command,
-          enableArtifacts.args,
-          { env, logger },
-          setupSignal
-        );
-
-        logger.info('Enabling the Argent tool-server event log flag.');
-        const enableEventLog = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'enable',
-          ARGENT_EVENT_LOG_FLAG,
-        ]);
-        await runArgentSetupCommandAsync(
-          enableEventLog.command,
-          enableEventLog.args,
-          { env, logger },
-          setupSignal
-        );
-
-        logger.info('Disabling the Argent video watermark flag.');
-        const disableVideoWatermark = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'disable',
-          ARGENT_VIDEO_WATERMARK_FLAG,
-        ]);
-        // The watermark is cosmetic, so a failure here must not fail the session.
-        try {
-          await runArgentSetupCommandAsync(
-            disableVideoWatermark.command,
-            disableVideoWatermark.args,
-            { env, logger },
-            setupSignal
-          );
-        } catch (err) {
-          setupSignal?.throwIfAborted();
-          logger.warn(
-            { err },
-            'Could not disable the Argent video watermark, so recorded videos may include it. Continuing the session.'
-          );
-        }
-
-        setupSignal?.throwIfAborted();
-        const startServer = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'server',
-          'start',
-          '--port',
-          '0',
-          '--idle-timeout',
-          '0',
-          '--force',
-        ]);
-        logger.info(
-          `Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via ${startServer.command}.`
-        );
-        // Keep Argent itself in foreground mode under the detached process. This preserves
-        // the npx/bun -> Argent CLI -> tool-server ancestry used to identify the matching state file.
-        const secrets: string[] = [];
-        argentServer = spawnDetached({
-          command: startServer.command,
-          args: startServer.args,
-          env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH, ARGENT_EMULATOR_NO_WINDOW: '1' },
-          logger,
-          secrets,
-        });
-        if (argentServer.pid === undefined) {
-          throw new SystemError(
-            'Failed to start Argent: could not determine the PID of the launched process.'
-          );
-        }
-
-        logger.info(`Waiting for argent tool-server state in ${ARGENT_STATE_DIR}.`);
-        let toolServerPort: number;
-        let toolServerToken: string | undefined;
-        try {
-          const toolServerState = await waitForArgentToolServerStateAsync({
-            stateDir: ARGENT_STATE_DIR,
-            ancestorPid: argentServer.pid,
-            timeoutMs: STARTUP_TIMEOUT_MS,
-            getExitError: argentServer.getExitError,
-            signal: setupSignal,
-          });
-          toolServerPort = toolServerState.port;
-          toolServerToken = toolServerState.token;
-          if (toolServerToken) {
-            secrets.push(toolServerToken);
-          }
-        } catch (err) {
-          const output = argentServer.getOutput();
-          throw new SystemError(
-            `${
-              err instanceof Error ? err.message : `Timed out waiting for argent tool-server state.`
-            }${output ? `\nArgent tool-server output:\n${output}` : ''}`
-          );
-        }
-        if (hostStartup) {
-          sessionHost = (await hostStartup).enforceValue();
-        }
-        setupSignal?.throwIfAborted();
-        logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
-        const artifactPollSignal = signal
-          ? AbortSignal.any([signal, artifactPollAbortController.signal])
-          : artifactPollAbortController.signal;
-        artifactPollingPromise = pollArgentArtifactsForUploadAsync(ctx, {
-          deviceRunSessionId,
-          toolsUrl: `http://127.0.0.1:${toolServerPort}`,
-          toolsAuthToken: toolServerToken,
-          logger,
-          signal: artifactPollSignal,
-        });
-
-        eventCollection = await startArgentEventCollectionAsync({
-          ctx,
-          deviceRunSessionId,
-          eventLogPath: ARGENT_EVENT_LOG_PATH,
-          logger,
-        });
-
-        toolsTunnel = await startNgrokTunnelAsync({
-          port: toolServerPort,
-          subdomainPrefix: 'argent',
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-          rewriteHostHeader: true,
-          healthCheck: { path: '/tools', statuses: [200, 401] },
-          logger,
-        });
-        const publicToolsUrl = toolsTunnel.url;
-        logger.info(`Tunnel is ready at ${publicToolsUrl}.`);
-
-        const launchDescription = describeServeSimLaunch(launch);
-        if (launchDescription) {
-          logger.info(launchDescription);
-        }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-        });
-        logger.info(
-          webPreview.sharePageUrl
-            ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-            : 'Private preview URL unavailable for this session.'
-        );
-
-        const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
           signal,
-          ctx,
-          deviceRunSessionId,
-          remoteConfig: {
-            toolsUrl: publicToolsUrl,
-            ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
-            webPreviewUrl: webPreview.previewPageUrl,
-            previewApiUrl: webPreview.apiUrl,
-            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+        });
+        const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
+          {
+            networkCapture: inputs.network_capture?.value,
+            networkCaptureFields: inputs.network_capture_fields?.value,
           },
-          logger,
-        });
-        if (sessionStart === 'stopped') {
-          return;
-        }
+          { runtimePlatform }
+        );
+        logger.info(
+          `Starting argent remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
+        );
 
-        await waitForDeviceRunSessionStoppedAsync({
-          ctx,
-          deviceRunSessionId,
-          logger,
-          maxDurationSeconds,
-          signal,
-          idleTimeout:
-            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-              ? {
-                  maxIdleTimeMinutes,
-                  getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                  getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
-                }
-              : undefined,
-        });
-      } catch (error) {
-        sessionFailed = true;
-        throw setupSignal?.aborted ? setupSignal.reason : error;
-      } finally {
-        startupAbortController.abort(new Error('Argent session ended.'));
-        await finishRemoteSessionAsync({
-          logger,
-          sessionFailed,
-          teardown: [
-            ['Argent tunnel', toolsTunnel?.stopAsync()],
-            [
-              'Argent tool-server',
-              (async () => {
-                try {
-                  if (eventCollection) {
-                    await stopArgentEventCollectionSafelyAsync({
-                      eventCollection,
-                      deviceRunSessionId,
-                      logger,
-                    });
+        // Start the potentially slow installation while Argent is being prepared.
+        // On Linux expo-device-hub calls this again and awaits the same in-flight
+        // setup before launching. On macOS this remains non-blocking, so only a
+        // recording started in the first moments may miss ffmpeg.
+        // Never rejects, so `void` is safe.
+        void ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger });
+
+        const packageManager = resolveConfiguredPackageManager(env, PackageManager.BUN);
+        const argentExec = (args: string[]): { command: string; args: string[] } =>
+          resolvePackageExec(packageManager, args);
+
+        const startupAbortController = new AbortController();
+        const startupSignal = signal
+          ? AbortSignal.any([signal, startupAbortController.signal])
+          : startupAbortController.signal;
+        const setupSignal = iosStartup ? startupSignal : undefined;
+        const artifactPollAbortController = new AbortController();
+        let artifactPollingPromise: Promise<void> | undefined;
+        let eventCollection:
+          | Awaited<ReturnType<typeof startArgentEventCollectionAsync>>
+          | undefined;
+        let toolsTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
+        let argentServer: ReturnType<typeof spawnDetached> | undefined;
+        let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
+        let sessionHost: DeviceSessionHost | undefined;
+        let sessionFailed = false;
+        const startHost = () =>
+          startDeviceSessionHostAsync(
+            ctx,
+            {
+              ...iosStartup,
+              separateLogPhase: true,
+              runtimePlatform,
+              env,
+              logger,
+              disableShare: inputs.public_preview?.value === false,
+              privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+              frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
+              corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
+              timeoutMs: STARTUP_TIMEOUT_MS,
+              preview: { baseDomain: ngrokTunnelDomain, authtoken: ngrokAuthtoken },
+              signal: startupSignal,
+              onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
+              ...launch,
+              networkCapture,
+              networkCaptureFields,
+            },
+            ...(warmSession ? [createWarmDeviceSessionServer(ctx, logger, warmSession)] : [])
+          ).catch(error => {
+            if (iosStartup) {
+              startupAbortController.abort(error);
+            }
+            throw error;
+          });
+        try {
+          if (iosStartup) {
+            hostStartup = asyncResult(startHost());
+          }
+          let toolServerPort: number;
+          let toolServerToken: string | undefined;
+          if (warmSession) {
+            // Adoption prepares the launcher's Argent server for the claimed device.
+            sessionHost = (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+            const tools = warmSession.tools;
+            if (!tools) {
+              throw new Error('The warm Argent server was not prepared.');
+            }
+            toolServerPort = tools.port;
+            toolServerToken = tools.token;
+          } else {
+            logger.info('Enabling the Argent artifacts list endpoint flag.');
+            const enableArtifacts = argentExec([
+              `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+              'enable',
+              ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG,
+            ]);
+            await runArgentSetupCommandAsync(
+              enableArtifacts.command,
+              enableArtifacts.args,
+              { env, logger },
+              setupSignal
+            );
+
+            logger.info('Enabling the Argent tool-server event log flag.');
+            const enableEventLog = argentExec([
+              `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+              'enable',
+              ARGENT_EVENT_LOG_FLAG,
+            ]);
+            await runArgentSetupCommandAsync(
+              enableEventLog.command,
+              enableEventLog.args,
+              { env, logger },
+              setupSignal
+            );
+
+            logger.info('Disabling the Argent video watermark flag.');
+            const disableVideoWatermark = argentExec([
+              `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+              'disable',
+              ARGENT_VIDEO_WATERMARK_FLAG,
+            ]);
+            // The watermark is cosmetic, so a failure here must not fail the session.
+            try {
+              await runArgentSetupCommandAsync(
+                disableVideoWatermark.command,
+                disableVideoWatermark.args,
+                { env, logger },
+                setupSignal
+              );
+            } catch (err) {
+              setupSignal?.throwIfAborted();
+              logger.warn(
+                { err },
+                'Could not disable the Argent video watermark, so recorded videos may include it. Continuing the session.'
+              );
+            }
+
+            setupSignal?.throwIfAborted();
+            const startServer = argentExec([
+              `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+              'server',
+              'start',
+              '--port',
+              '0',
+              '--idle-timeout',
+              '0',
+              '--force',
+            ]);
+            logger.info(
+              `Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via ${startServer.command}.`
+            );
+            // Keep Argent itself in foreground mode under the detached process. This preserves
+            // the npx/bun -> Argent CLI -> tool-server ancestry used to identify the matching state file.
+            const secrets: string[] = [];
+            argentServer = spawnDetached({
+              command: startServer.command,
+              args: startServer.args,
+              env: {
+                ...env,
+                ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH,
+                ARGENT_EMULATOR_NO_WINDOW: '1',
+              },
+              logger,
+              secrets,
+            });
+            if (argentServer.pid === undefined) {
+              throw new SystemError(
+                'Failed to start Argent: could not determine the PID of the launched process.'
+              );
+            }
+
+            logger.info(`Waiting for argent tool-server state in ${ARGENT_STATE_DIR}.`);
+            try {
+              const toolServerState = await waitForArgentToolServerStateAsync({
+                stateDir: ARGENT_STATE_DIR,
+                ancestorPid: argentServer.pid,
+                timeoutMs: STARTUP_TIMEOUT_MS,
+                getExitError: argentServer.getExitError,
+                signal: setupSignal,
+              });
+              toolServerPort = toolServerState.port;
+              toolServerToken = toolServerState.token;
+              if (toolServerToken) {
+                secrets.push(toolServerToken);
+              }
+            } catch (err) {
+              const output = argentServer.getOutput();
+              throw new SystemError(
+                `${
+                  err instanceof Error
+                    ? err.message
+                    : `Timed out waiting for argent tool-server state.`
+                }${output ? `\nArgent tool-server output:\n${output}` : ''}`
+              );
+            }
+            if (hostStartup) {
+              sessionHost = (await hostStartup).enforceValue();
+            }
+            setupSignal?.throwIfAborted();
+          }
+          logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
+          const artifactPollSignal = signal
+            ? AbortSignal.any([signal, artifactPollAbortController.signal])
+            : artifactPollAbortController.signal;
+          artifactPollingPromise = pollArgentArtifactsForUploadAsync(ctx, {
+            deviceRunSessionId,
+            toolsUrl: `http://127.0.0.1:${toolServerPort}`,
+            toolsAuthToken: toolServerToken,
+            logger,
+            signal: artifactPollSignal,
+          });
+
+          eventCollection = await startArgentEventCollectionAsync({
+            ctx,
+            deviceRunSessionId,
+            eventLogPath: warmSession?.argentEventLogPath ?? ARGENT_EVENT_LOG_PATH,
+            logger,
+          });
+
+          toolsTunnel = await startNgrokTunnelAsync({
+            port: toolServerPort,
+            subdomainPrefix: 'argent',
+            baseDomain: ngrokTunnelDomain,
+            authtoken: ngrokAuthtoken,
+            rewriteHostHeader: true,
+            healthCheck: { path: '/tools', statuses: [200, 401] },
+            logger,
+          });
+          const publicToolsUrl = toolsTunnel.url;
+          logger.info(`Tunnel is ready at ${publicToolsUrl}.`);
+
+          const launchDescription = describeServeSimLaunch(launch);
+          if (launchDescription) {
+            logger.info(launchDescription);
+          }
+          sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+          const webPreview = await sessionHost.openPreviewAsync();
+          logger.info(
+            webPreview.sharePageUrl
+              ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
+              : 'Private preview URL unavailable for this session.'
+          );
+
+          const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
+            env,
+            signal,
+            ctx,
+            deviceRunSessionId,
+            remoteConfig: {
+              toolsUrl: publicToolsUrl,
+              ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
+              webPreviewUrl: webPreview.previewPageUrl,
+              previewApiUrl: webPreview.apiUrl,
+              ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+            },
+            logger,
+          });
+          if (sessionStart === 'stopped') {
+            return;
+          }
+
+          await waitForDeviceRunSessionStoppedAsync({
+            ctx,
+            deviceRunSessionId,
+            logger,
+            maxDurationSeconds,
+            signal,
+            idleTimeout:
+              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                ? {
+                    maxIdleTimeMinutes,
+                    getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                    getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
                   }
-                  artifactPollAbortController.abort();
-                  try {
-                    await artifactPollingPromise;
-                  } catch (err) {
-                    const error = err instanceof Error ? err : new Error(String(err));
-                    Sentry.capture(
-                      'Could not finish Argent remote session artifact polling',
-                      error
-                    );
-                    logger.warn(
-                      { err: error },
-                      'Could not finish Argent remote session artifact polling.'
-                    );
+                : undefined,
+          });
+        } catch (error) {
+          sessionFailed = true;
+          throw setupSignal?.aborted ? setupSignal.reason : error;
+        } finally {
+          startupAbortController.abort(new Error('Argent session ended.'));
+          const toolTeardown = (async () => {
+            try {
+              if (eventCollection) {
+                await stopArgentEventCollectionSafelyAsync({
+                  eventCollection,
+                  deviceRunSessionId,
+                  logger,
+                });
+              }
+              artifactPollAbortController.abort();
+              try {
+                await artifactPollingPromise;
+              } catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                Sentry.capture('Could not finish Argent remote session artifact polling', error);
+                logger.warn(
+                  { err: error },
+                  'Could not finish Argent remote session artifact polling.'
+                );
+              }
+            } finally {
+              await argentServer?.stopAsync();
+            }
+          })();
+          await finishRemoteSessionAsync({
+            logger,
+            sessionFailed,
+            teardown: [
+              ['Argent tunnel', toolsTunnel?.stopAsync()],
+              ['Argent tool-server', toolTeardown],
+              [
+                'session host',
+                hostStartup?.then(async result => {
+                  if (warmSession) {
+                    // The warm host owns Argent too; leave it alive until the final downloads finish.
+                    await Promise.allSettled([toolTeardown]);
                   }
-                } finally {
-                  await argentServer?.stopAsync();
-                }
-              })(),
+                  await result.value?.finishAsync();
+                }),
+              ],
             ],
-            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
-          ],
-        });
+          });
+        }
+      };
+      if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await runOnWarmIosSimulatorAsync(
+          {
+            engine: 'argent',
+            requestedDevice: deviceIdentifier,
+            packageVersion,
+            env,
+            logger,
+            signal,
+          },
+          startSessionAsync
+        );
+      } else {
+        await startSessionAsync();
       }
     }),
   });
@@ -464,36 +518,6 @@ export async function stopArgentEventCollectionSafelyAsync({
   }
 }
 
-export function warnIfArgentPackageVersionCannotBeVerified({
-  packageVersion,
-  logger,
-}: {
-  packageVersion: string | undefined;
-  logger: bunyan;
-}): void {
-  if (!packageVersion || packageVersion === 'latest') {
-    return;
-  }
-
-  const validVersion = semver.valid(packageVersion);
-  if (!validVersion) {
-    logger.warn(
-      `Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer, ` +
-        `but package_version "${packageVersion}" is not an exact semver version that EAS can verify. ` +
-        `Continuing and letting the package manager resolve it.`
-    );
-    return;
-  }
-
-  if (semver.lt(validVersion, MIN_ARGENT_REMOTE_SESSION_VERSION)) {
-    throw new SystemError(
-      `Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer. ` +
-        `The requested package_version "${packageVersion}" is too old for the EAS remote-session API. ` +
-        `Use "latest" or pass an exact version >= ${MIN_ARGENT_REMOTE_SESSION_VERSION}.`
-    );
-  }
-}
-
 async function runArgentSetupCommandAsync(
   command: string,
   args: string[],

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

@@ -8,6 +8,11 @@ import {
 
 import { CustomBuildContext } from '../../customBuildContext';
 import { startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
+import {
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../utils/warmDeviceSessionHost';
+import { type WarmIosSession } from '../utils/warmIosSession';
 import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
@@ -38,13 +43,16 @@ import {
 const STARTUP_TIMEOUT_MS = 60_000;
 
 export function createStartWebPreviewRemoteSessionBuildFunction(
-  ctx: CustomBuildContext
+  ctx: CustomBuildContext,
+  { warm = false }: { warm?: boolean } = {}
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: 'start_serve_sim_remote_session',
+    id: warm ? 'start_warm_serve_sim_remote_session' : 'start_serve_sim_remote_session',
     name: 'Start web preview remote session',
-    __metricsId: 'eas/start_serve_sim_remote_session',
+    __metricsId: warm
+      ? 'eas/start_warm_serve_sim_remote_session'
+      : 'eas/start_serve_sim_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -91,100 +99,123 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
       if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
         await selectXcodeDeveloperDirectoryAsync({ env, logger });
       }
-      const { launch, iosStartup } = await resolveIosSessionStartupAsync({
-        runtimePlatform,
-        bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
-        deviceIdentifier: inputs.device_identifier?.value as string | undefined,
-        installAppPath: inputs.install_app_path?.value as string | undefined,
-        launchAppIdentifier: inputs.launch_app_identifier?.value,
-        launchArgs: inputs.launch_args?.value,
-        openUrl: inputs.open_url?.value,
-        env,
-        logger,
-        signal,
-      });
-      const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
-        {
-          networkCapture: inputs.network_capture?.value,
-          networkCaptureFields: inputs.network_capture_fields?.value,
-        },
-        { runtimePlatform }
-      );
-
-      logger.info(`Starting web preview remote session (runtime: ${runtimePlatform}).`);
-      const launchDescription = describeServeSimLaunch(launch);
-      if (launchDescription) {
-        logger.info(launchDescription);
-      }
-
-      const sessionHost = await startDeviceSessionHostAsync(ctx, {
-        ...iosStartup,
-        runtimePlatform,
-        env,
-        logger,
-        timeoutMs: STARTUP_TIMEOUT_MS,
-        signal,
-        packageVersion,
-        disableShare: inputs.public_preview?.value === false,
-        privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-        frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-        corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-        launchAppIdentifier: launch.launchAppIdentifier,
-        launchArgs: launch.launchArgs,
-        openUrl: launch.openUrl,
-        networkCapture,
-        networkCaptureFields,
-      });
-
-      try {
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-        });
-        logger.info(
-          webPreview.sharePageUrl
-            ? `Preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-            : 'Private preview URL unavailable for this session.'
-        );
-        const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
+      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
+      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
+        const { launch, iosStartup } = await resolveIosSessionStartupAsync({
+          runtimePlatform,
+          bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
+          deviceIdentifier: warmSession?.device.udid ?? deviceIdentifier,
+          installAppPath: inputs.install_app_path?.value as string | undefined,
+          launchAppIdentifier: inputs.launch_app_identifier?.value,
+          launchArgs: inputs.launch_args?.value,
+          openUrl: inputs.open_url?.value,
           env,
-          signal,
-          ctx,
-          deviceRunSessionId,
-          // WEB_PREVIEW_ONLY sessions read webPreviewUrl and webPreviewToken. Legacy SERVE_SIM
-          // sessions read previewUrl and previewToken. The server drops the keys that the
-          // session type does not use.
-          remoteConfig: {
-            webPreviewUrl: webPreview.previewPageUrl,
-            previewUrl: webPreview.previewPageUrl,
-            previewApiUrl: webPreview.apiUrl,
-            ...(webPreview.previewToken
-              ? { webPreviewToken: webPreview.previewToken, previewToken: webPreview.previewToken }
-              : {}),
-          },
           logger,
+          signal,
         });
-        if (sessionStart === 'stopped') {
-          return;
+        const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
+          {
+            networkCapture: inputs.network_capture?.value,
+            networkCaptureFields: inputs.network_capture_fields?.value,
+          },
+          { runtimePlatform }
+        );
+
+        logger.info(`Starting web preview remote session (runtime: ${runtimePlatform}).`);
+        const launchDescription = describeServeSimLaunch(launch);
+        if (launchDescription) {
+          logger.info(launchDescription);
         }
 
-        await waitForDeviceRunSessionStoppedAsync({
+        const sessionHost = await startDeviceSessionHostAsync(
           ctx,
-          deviceRunSessionId,
-          logger,
-          maxDurationSeconds,
-          signal,
-          idleTimeout:
-            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-              ? {
-                  maxIdleTimeMinutes,
-                  getLastEventObservedAt: () => undefined,
-                  getLastPreviewActivityAt: () => sessionHost.getLastPreviewActivityAt(),
-                }
-              : undefined,
-        });
-      } finally {
-        await sessionHost.finishAsync();
+          {
+            ...iosStartup,
+            runtimePlatform,
+            env,
+            logger,
+            timeoutMs: STARTUP_TIMEOUT_MS,
+            preview: { baseDomain: ngrokTunnelDomain, authtoken: ngrokAuthtoken },
+            signal,
+            packageVersion,
+            disableShare: inputs.public_preview?.value === false,
+            privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+            frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
+            corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
+            launchAppIdentifier: launch.launchAppIdentifier,
+            launchArgs: launch.launchArgs,
+            openUrl: launch.openUrl,
+            networkCapture,
+            networkCaptureFields,
+          },
+          ...(warmSession ? [createWarmDeviceSessionServer(ctx, logger, warmSession)] : [])
+        );
+
+        try {
+          const webPreview = await sessionHost.openPreviewAsync();
+          logger.info(
+            webPreview.sharePageUrl
+              ? `Preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
+              : 'Private preview URL unavailable for this session.'
+          );
+          const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
+            env,
+            signal,
+            ctx,
+            deviceRunSessionId,
+            // WEB_PREVIEW_ONLY sessions read webPreviewUrl and webPreviewToken. Legacy SERVE_SIM
+            // sessions read previewUrl and previewToken. The server drops the keys that the
+            // session type does not use.
+            remoteConfig: {
+              webPreviewUrl: webPreview.previewPageUrl,
+              previewUrl: webPreview.previewPageUrl,
+              previewApiUrl: webPreview.apiUrl,
+              ...(webPreview.previewToken
+                ? {
+                    webPreviewToken: webPreview.previewToken,
+                    previewToken: webPreview.previewToken,
+                  }
+                : {}),
+            },
+            logger,
+          });
+          if (sessionStart === 'stopped') {
+            return;
+          }
+
+          await waitForDeviceRunSessionStoppedAsync({
+            ctx,
+            deviceRunSessionId,
+            logger,
+            maxDurationSeconds,
+            signal,
+            idleTimeout:
+              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                ? {
+                    maxIdleTimeMinutes,
+                    getLastEventObservedAt: () => undefined,
+                    getLastPreviewActivityAt: () => sessionHost.getLastPreviewActivityAt(),
+                  }
+                : undefined,
+          });
+        } finally {
+          await sessionHost.finishAsync();
+        }
+      };
+      if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await runOnWarmIosSimulatorAsync(
+          {
+            engine: 'serve-sim',
+            requestedDevice: deviceIdentifier,
+            packageVersion,
+            env,
+            logger,
+            signal,
+          },
+          startSessionAsync
+        );
+      } else {
+        await startSessionAsync();
       }
     }),
   });

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

@@ -0,0 +1,224 @@
+import { BuildJob, Platform } from '@expo/eas-build-job';
+import {
+  BuildFunction,
+  BuildStepInput,
+  BuildStepInputValueTypeName,
+  spawnAsync,
+} from '@expo/steps';
+import { XMLParser } from 'fast-xml-parser';
+import fs from 'fs-extra';
+import { Client } from '@urql/core';
+import { graphql } from 'gql.tada';
+import path from 'node:path';
+
+import { parseInfoPlistBuffer, readIpaInfoAsync } from './readIpaInfo';
+import { CustomBuildContext } from '../../customBuildContext';
+import { Sentry } from '../../sentry';
+
+export function createUpdateResolvedVersionBuildFunction(
+  ctx: CustomBuildContext<BuildJob>
+): BuildFunction {
+  return new BuildFunction({
+    namespace: 'eas',
+    id: 'update_resolved_version',
+    name: 'Update resolved version',
+    __metricsId: 'eas/update_resolved_version',
+    inputProviders: [
+      BuildStepInput.createProvider({
+        id: 'application_archive_path',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+    ],
+    fn: async (stepCtx, { inputs }) => {
+      try {
+        const archivePathInput = inputs.application_archive_path.value as string | undefined;
+        if (!archivePathInput) {
+          stepCtx.logger.info('No application archive path provided, skipping.');
+          return;
+        }
+        const archivePath = path.resolve(stepCtx.workingDirectory, archivePathInput);
+
+        const buildId = ctx.env.EAS_BUILD_ID;
+        if (!buildId) {
+          stepCtx.logger.info('EAS_BUILD_ID not set, skipping.');
+          return;
+        }
+
+        const { appVersion, appBuildVersion } =
+          ctx.job.platform === Platform.IOS
+            ? await extractIosVersionAsync(archivePath)
+            : await extractAndroidVersionAsync(archivePath);
+
+        if (!appVersion && !appBuildVersion) {
+          stepCtx.logger.info('No resolved version found, skipping.');
+          return;
+        }
+
+        stepCtx.logger.info(
+          `Resolved version: ${appVersion ?? 'N/A'} (${appBuildVersion ?? 'N/A'})`
+        );
+
+        await updateResolvedVersionAsync(ctx.graphqlClient, buildId, {
+          appVersion,
+          appBuildVersion,
+        });
+
+        stepCtx.logger.info('Updated resolved version on EAS.');
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        Sentry.capture('Failed to update resolved version', error);
+        stepCtx.logger.warn({ err: error }, 'Failed to update resolved version (non-fatal)');
+      }
+    },
+  });
+}
+
+export async function extractIosVersionAsync(
+  archivePath: string
+): Promise<{ appVersion?: string; appBuildVersion?: string }> {
+  const ext = path.extname(archivePath).toLowerCase();
+
+  if (ext === '.app') {
+    return await extractSimulatorAppVersionAsync(archivePath);
+  }
+
+  const ipaInfo = await readIpaInfoAsync(archivePath);
+  return {
+    appVersion: ipaInfo.bundleShortVersion,
+    appBuildVersion: ipaInfo.bundleVersion,
+  };
+}
+
+async function extractSimulatorAppVersionAsync(
+  appPath: string
+): Promise<{ appVersion?: string; appBuildVersion?: string }> {
+  const infoPlistPath = path.join(appPath, 'Info.plist');
+
+  if (!(await fs.pathExists(infoPlistPath))) {
+    return {};
+  }
+
+  const infoPlistBuffer = await fs.readFile(infoPlistPath);
+  const infoPlist = parseInfoPlistBuffer(infoPlistBuffer);
+
+  return {
+    appVersion:
+      typeof infoPlist.CFBundleShortVersionString === 'string'
+        ? infoPlist.CFBundleShortVersionString
+        : undefined,
+    appBuildVersion:
+      typeof infoPlist.CFBundleVersion === 'string' ? infoPlist.CFBundleVersion : undefined,
+  };
+}
+
+export async function extractAndroidVersionAsync(
+  archivePath: string
+): Promise<{ appVersion?: string; appBuildVersion?: string }> {
+  const ext = path.extname(archivePath).toLowerCase();
+
+  if (ext === '.apk') {
+    return await extractVersionFromApkAsync(archivePath);
+  } else if (ext === '.aab') {
+    return await extractVersionFromAabAsync(archivePath);
+  }
+
+  return {};
+}
+
+async function extractVersionFromApkAsync(
+  apkPath: string
+): Promise<{ appVersion?: string; appBuildVersion?: string }> {
+  const result = await spawnAsync('aapt2', ['dump', 'badging', apkPath], {
+    stdio: 'pipe',
+  });
+
+  return parseAaptOutput(result.stdout);
+}
+
+async function extractVersionFromAabAsync(
+  aabPath: string
+): Promise<{ appVersion?: string; appBuildVersion?: string }> {
+  const result = await spawnAsync('bundletool', ['dump', 'manifest', '--bundle', aabPath], {
+    stdio: 'pipe',
+  });
+
+  return parseManifestXml(result.stdout);
+}
+
+export function parseAaptOutput(output: string): { appVersion?: string; appBuildVersion?: string } {
+  // aapt2 does not escape apostrophes inside versionName, so stop at the next known
+  // badging field (or the end of the line) rather than at the first closing quote.
+  const versionNameMatch = output.match(
+    /versionName='(.*?)'(?= split=| platformBuildVersionName=| platformBuildVersionCode=| compileSdkVersion=|\s*$)/m
+  );
+  const versionCodeMatch = output.match(/versionCode='([^']+)'/);
+
+  return {
+    appVersion: versionNameMatch?.[1] || undefined,
+    appBuildVersion: versionCodeMatch?.[1],
+  };
+}
+
+export function parseManifestXml(xml: string): { appVersion?: string; appBuildVersion?: string } {
+  const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
+  const parsed = parser.parse(xml);
+
+  const manifest = parsed?.manifest;
+  if (!manifest) {
+    return {};
+  }
+
+  const versionName = manifest['@_android:versionName'];
+  const versionCode = manifest['@_android:versionCode'];
+
+  return {
+    appVersion: versionName != null ? String(versionName) : undefined,
+    appBuildVersion: versionCode != null ? String(versionCode) : undefined,
+  };
+}
+
+export async function updateResolvedVersionAsync(
+  graphqlClient: Client,
+  buildId: string,
+  {
+    appVersion,
+    appBuildVersion,
+  }: {
+    appVersion: string | undefined;
+    appBuildVersion: string | undefined;
+  }
+): Promise<void> {
+  const result = await graphqlClient
+    .mutation(
+      graphql(`
+        mutation UpdateResolvedVersionMutation(
+          $buildId: ID!
+          $appVersion: String
+          $appBuildVersion: String
+        ) {
+          build {
+            updateBuildMetadata(
+              buildId: $buildId
+              metadata: {
+                appVersion: $appVersion
+                appBuildVersion: $appBuildVersion
+              }
+            ) {
+              id
+            }
+          }
+        }
+      `),
+      {
+        buildId,
+        appVersion,
+        appBuildVersion,
+      }
+    )
+    .toPromise();
+
+  if (result.error) {
+    throw result.error;
+  }
+}

packages/build-tools/src/steps/utils/IosSimulatorRecordingUtils.ts

@@ -57,11 +57,19 @@ type ActiveIosSimulatorRecording = IosSimulatorRecording & {
   hasExited: () => boolean;
 };
 
+type AdoptedIosSimulatorRecording = {
+  udid: string;
+  serverToken: string;
+  collectAsync(): Promise<void>;
+};
+
 type IosSimulatorRecordingSession = {
   env: Env;
   logger: bunyan;
   recordingsRootDirectory: string;
   activeRecordings: Map<IosSimulatorUuid, ActiveIosSimulatorRecording>;
+  adoptedRecordings: Map<string, AdoptedIosSimulatorRecording>;
+  runtimeDisplayNames: Map<string, string>;
   completedRecordings: IosSimulatorRecording[];
   recordingFailureCounts: Map<IosSimulatorUuid, number>;
   /** Failed attempts for the whole session; unlike recordingFailureCounts, never reset. */
@@ -81,6 +89,52 @@ export namespace IosSimulatorRecordingUtils {
     serveSimPackageSpec ??= packageSpec;
   }
 
+  /**
+   * Reserves this job's recording output before warm serve-sim adoption, which starts the
+   * recording. The poller skips that device, so it never starts a second recorder.
+   */
+  export async function prepareAdoptedRecordingAsync({
+    udid,
+    deviceName,
+    serverToken,
+  }: {
+    udid: string;
+    deviceName: string;
+    serverToken: string;
+  }): Promise<{ output: string; recordingId: string } | undefined> {
+    const session = activeIosSimulatorRecordingSession;
+    if (!session) {
+      return undefined;
+    }
+    udid = udid.toUpperCase();
+    const recordingId = randomUUID();
+    const output = path.join(session.recordingsRootDirectory, recordingId);
+    const startedAt = new Date();
+    await mkdir(output, { recursive: true });
+    session.adoptedRecordings.set(recordingId, {
+      udid,
+      serverToken,
+      async collectAsync() {
+        // Keep real footage eligible for the manifest wait if serve-sim shutdown was unconfirmed.
+        // The uploader preserves the manifest's partial or failed status.
+        await access(path.join(output, 'session.json')).catch(() =>
+          access(path.join(output, 'recording.mp4'))
+        );
+        session.completedRecordings.push({
+          id: recordingId,
+          udid: udid as IosSimulatorUuid,
+          deviceName,
+          runtimeDisplayName: session.runtimeDisplayNames.get(udid) ?? 'Unknown iOS runtime',
+          outputDirectory: output,
+          startedAt,
+          getOutput: () => '',
+          hasStarted: () => true,
+        });
+      },
+    });
+    return { output, recordingId };
+  }
+
   export async function startAsync({ env, logger }: { env: Env; logger: bunyan }): Promise<void> {
     if (activeIosSimulatorRecordingSession) {
       logger.info('iOS Simulator screen recording polling is already running.');
@@ -95,6 +149,8 @@ export namespace IosSimulatorRecordingUtils {
       logger,
       recordingsRootDirectory,
       activeRecordings: new Map(),
+      adoptedRecordings: new Map(),
+      runtimeDisplayNames: new Map(),
       completedRecordings: [],
       recordingFailureCounts: new Map(),
       failedAttemptCounts: new Map(),
@@ -190,6 +246,17 @@ export namespace IosSimulatorRecordingUtils {
       })
     );
 
+    await Promise.all(
+      [...session.adoptedRecordings.values()].map(recording =>
+        recording.collectAsync().catch(err => {
+          logger.warn(
+            { err },
+            'Could not collect the warm Simulator video recording after shutdown.'
+          );
+        })
+      )
+    );
+
     const completedRecordings = [...session.completedRecordings].sort(
       (a, b) => a.startedAt.getTime() - b.startedAt.getTime()
     );
@@ -243,6 +310,9 @@ async function pollIosSimulatorRecordingsAsync(
         break;
       }
       listDevicesErrorCount = 0;
+      for (const device of bootedDevices) {
+        session.runtimeDisplayNames.set(device.udid.toUpperCase(), device.runtimeDisplayName);
+      }
       const readyServers = new Map(
         (await readServeSimServersAsync(SERVE_SIM_STATE_DIR)).flatMap(server =>
           server.token ? [[server.udid, server.token] as const] : []
@@ -262,7 +332,14 @@ async function pollIosSimulatorRecordingsAsync(
       for (const device of bootedDevices) {
         const token = readyServers.get(device.udid);
         const packageSpec = serveSimPackageSpec;
-        if (!token || !packageSpec) {
+        if (
+          !token ||
+          !packageSpec ||
+          [...session.adoptedRecordings.values()].some(
+            recording =>
+              recording.udid === device.udid.toUpperCase() && recording.serverToken === token
+          )
+        ) {
           continue;
         }
         if (session.serveBearerTokens.get(device.udid) !== token) {

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

@@ -3,18 +3,20 @@ import { type bunyan } from '@expo/logger';
 import spawn from '@expo/turtle-spawn';
 import { type ChildProcess } from 'node:child_process';
 import { EventEmitter } from 'node:events';
-import { rm, writeFile } from 'node:fs/promises';
+import { readFile, rm, writeFile } from 'node:fs/promises';
 import { PassThrough } from 'node:stream';
 import { setTimeout } from 'node:timers/promises';
 
 import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { Sentry } from '../../../sentry';
+import { turtleFetch } from '../../../utils/turtleFetch';
 import { IosSimulatorRecordingUtils } from '../IosSimulatorRecordingUtils';
 import { readServeSimServersAsync } from '../serveSimMetricsRecorder';
 
 jest.mock('@expo/turtle-spawn');
 jest.mock('../serveSimMetricsRecorder');
 jest.mock('../../../sentry');
+jest.mock('../../../utils/turtleFetch');
 
 const logger = {
   info: jest.fn(),
@@ -566,3 +568,171 @@ test('records every booted device with the first serve-sim package', async () =>
   currentTime += 311_000;
   await IosSimulatorRecordingUtils.finishAsync({ logger });
 });
+
+test('does not request adopted video when job recording is disabled', async () => {
+  await expect(
+    IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+      udid,
+      deviceName: 'iPhone 17 Pro',
+      serverToken: 'job-token',
+    })
+  ).resolves.toBeUndefined();
+  expect(turtleFetch).not.toHaveBeenCalled();
+});
+
+test.each(['complete', 'failed'])(
+  'collects an adopted %s recording unchanged after host shutdown without a control request',
+  async status => {
+    let releaseDevices!: (devices: never[]) => void;
+    jest.mocked(IosSimulatorUtils.getAvailableDevicesAsync).mockImplementation(
+      () =>
+        new Promise(resolve => {
+          releaseDevices = resolve as never;
+        })
+    );
+    jest
+      .mocked(readServeSimServersAsync)
+      .mockResolvedValue([{ udid, url: 'http://127.0.0.1:3200', token: 'job-token' }]);
+    await IosSimulatorRecordingUtils.startAsync({ env, logger });
+    const recording = await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+      udid,
+      deviceName: 'iPhone 17 Pro',
+      serverToken: 'job-token',
+    });
+    if (!recording) {
+      throw new Error('Expected the adopted recording output.');
+    }
+    releaseDevices([{ udid, name: 'iPhone 17 Pro', runtimeDisplayName: 'iOS 26.4' }] as never);
+    await setTimeout(20);
+    expect(spawn).not.toHaveBeenCalled();
+    const manifest = JSON.stringify({
+      recording: 'recording.mp4',
+      status,
+      ...(status === 'failed' && { error: 'Recording interrupted; partial footage preserved.' }),
+    });
+    await writeFile(`${recording.output}/session.json`, manifest);
+    jest.mocked(turtleFetch).mockRejectedValue(new Error('serve-sim has stopped'));
+    expect(await IosSimulatorRecordingUtils.finishAsync({ logger })).toEqual([
+      {
+        udid,
+        deviceName: 'iPhone 17 Pro',
+        runtimeDisplayName: 'iOS 26.4',
+        directory: recording.output,
+      },
+    ]);
+    expect(await readFile(`${recording.output}/session.json`, 'utf8')).toBe(manifest);
+    expect(turtleFetch).not.toHaveBeenCalled();
+  }
+);
+
+test('waits for an adopted recording manifest when its MP4 already exists', async () => {
+  jest.mocked(readServeSimServersAsync).mockResolvedValue([]);
+  await IosSimulatorRecordingUtils.startAsync({ env, logger });
+  const recording = await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+    udid,
+    deviceName: 'iPhone 17 Pro',
+    serverToken: 'job-token',
+  });
+  if (!recording) {
+    throw new Error('Expected the adopted recording output.');
+  }
+  await writeFile(`${recording.output}/recording.mp4`, 'partial footage');
+  let finished = false;
+  const finishing = IosSimulatorRecordingUtils.finishAsync({ logger }).then(recordings => {
+    finished = true;
+    return recordings;
+  });
+  await setTimeout(20);
+  expect(finished).toBe(false);
+  const manifest = JSON.stringify({ recording: 'recording.mp4' });
+  await writeFile(`${recording.output}/session.json`, manifest);
+
+  expect(await finishing).toEqual([
+    {
+      udid,
+      deviceName: 'iPhone 17 Pro',
+      runtimeDisplayName: 'iOS 26.4',
+      directory: recording.output,
+    },
+  ]);
+  expect(await readFile(`${recording.output}/session.json`, 'utf8')).toBe(manifest);
+  expect(logger.warn).not.toHaveBeenCalled();
+  expect(turtleFetch).not.toHaveBeenCalled();
+  expect(spawn).not.toHaveBeenCalled();
+});
+
+test('bounds the manifest wait for an adopted MP4 and reports missing metadata', async () => {
+  let currentTime = Date.now();
+  jest.spyOn(Date, 'now').mockImplementation(() => currentTime);
+  jest.mocked(readServeSimServersAsync).mockResolvedValue([]);
+  await IosSimulatorRecordingUtils.startAsync({ env, logger });
+  const recording = await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+    udid,
+    deviceName: 'iPhone 17 Pro',
+    serverToken: 'job-token',
+  });
+  if (!recording) {
+    throw new Error('Expected the adopted recording output.');
+  }
+  await writeFile(`${recording.output}/recording.mp4`, 'partial footage');
+  let finished = false;
+  const finishing = IosSimulatorRecordingUtils.finishAsync({ logger }).then(recordings => {
+    finished = true;
+    return recordings;
+  });
+  await setTimeout(50);
+  expect(finished).toBe(false);
+  currentTime += 311_000;
+
+  expect(await finishing).toEqual([]);
+  expect(logger.warn).toHaveBeenCalledWith(
+    { recorderOutput: '' },
+    'Screen recording for iPhone 17 Pro ended without a manifest; its footage cannot be uploaded.'
+  );
+  expect(Sentry.capture).toHaveBeenCalledWith(
+    'iOS Simulator screen recording ended without a manifest',
+    { level: 'warning', extras: { deviceName: 'iPhone 17 Pro' } }
+  );
+  expect(turtleFetch).not.toHaveBeenCalled();
+  expect(spawn).not.toHaveBeenCalled();
+});
+
+test('does not wait for an empty adopted recording reservation', async () => {
+  jest.mocked(readServeSimServersAsync).mockResolvedValue([]);
+  await IosSimulatorRecordingUtils.startAsync({ env, logger });
+  await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+    udid,
+    deviceName: 'iPhone',
+    serverToken: 'job-token',
+  });
+  expect(await IosSimulatorRecordingUtils.finishAsync({ logger })).toEqual([]);
+  expect(logger.warn).toHaveBeenCalledWith(
+    { err: expect.any(Error) },
+    'Could not collect the warm Simulator video recording after shutdown.'
+  );
+  expect(turtleFetch).not.toHaveBeenCalled();
+});
+
+test('a reserved adopted recording does not suppress recording a replacement server token', async () => {
+  let releaseDevices!: (devices: never[]) => void;
+  jest.mocked(IosSimulatorUtils.getAvailableDevicesAsync).mockImplementationOnce(
+    () =>
+      new Promise(resolve => {
+        releaseDevices = resolve as never;
+      })
+  );
+  jest
+    .mocked(readServeSimServersAsync)
+    .mockResolvedValue([{ udid, url: 'http://127.0.0.1:3200', token: 'replacement-token' }]);
+  mockFailingRecorder();
+  await IosSimulatorRecordingUtils.startAsync({ env, logger });
+  await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+    udid,
+    deviceName: 'iPhone',
+    serverToken: 'old-token',
+  });
+  jest.mocked(turtleFetch).mockRejectedValue(new Error('old server stopped'));
+  releaseDevices([{ udid, name: 'iPhone', runtimeDisplayName: 'iOS 26.4' }] as never);
+  await waitForRecorderSpawnAsync();
+  expect(spawn).toHaveBeenCalledTimes(1);
+});

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

@@ -1,6 +1,7 @@
 import { bunyan } from '@expo/logger';
 import fetch from 'node-fetch';
 import { Readable } from 'node:stream';
+import timers from 'node:timers/promises';
 
 import { CustomBuildContext } from '../../../customBuildContext';
 import { Sentry } from '../../../sentry';
@@ -15,6 +16,7 @@ jest.mock('../deviceRunSessionArtifacts');
 jest.mock('../../../sentry');
 jest.mock('node-fetch');
 
+const sleepWithSignal = timers.setTimeout;
 const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
 
 async function readStreamAsync(stream: NodeJS.ReadableStream): Promise<void> {
@@ -276,6 +278,14 @@ describe(uploadAgentDeviceArtifactAsync, () => {
 describe(pollAgentDeviceArtifactsForUploadAsync, () => {
   beforeEach(() => {
     jest.useFakeTimers();
+    // Keep fake-clock tests deterministic; cancellation tests use the native abortable timer.
+    jest
+      .spyOn(timers, 'setTimeout')
+      .mockImplementation((delay, value, options) =>
+        options?.signal
+          ? sleepWithSignal(delay, value, options)
+          : new Promise(resolve => setTimeout(resolve, delay, value))
+      );
     jest.mocked(fetch).mockReset();
     jest.mocked(Sentry.capture).mockReset();
     jest.mocked(uploadDeviceRunSessionArtifactAsync).mockReset();
@@ -284,6 +294,257 @@ describe(pollAgentDeviceArtifactsForUploadAsync, () => {
   afterEach(() => {
     jest.clearAllTimers();
     jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('cancels a warm poller during its wait without another inventory request', async () => {
+    jest.useRealTimers();
+    const controller = new AbortController();
+    jest.mocked(fetch).mockResolvedValue(new Response(JSON.stringify({ artifacts: [] })));
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger: createLoggerMock(),
+      signal: controller.signal,
+    });
+    await new Promise(resolve => setImmediate(resolve));
+    controller.abort();
+    await polling;
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ signal: controller.signal })
+    );
+  });
+
+  it('cancels an in-flight warm artifact transfer and drains the poller', async () => {
+    jest.useRealTimers();
+    const controller = new AbortController();
+    let downloading!: () => void;
+    const started = new Promise<void>(resolve => {
+      downloading = resolve;
+    });
+    jest
+      .mocked(fetch)
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ artifacts: [{ id: 'new-artifact', filename: 'new.png' }] }))
+      )
+      .mockImplementationOnce(async (_url, options) => {
+        const signal = options?.signal as AbortSignal;
+        expect(signal).toBe(controller.signal);
+        downloading();
+        return await new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+        });
+      });
+    const logger = createLoggerMock();
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger,
+      signal: controller.signal,
+    });
+    await started;
+    controller.abort(new Error('session ended'));
+    await polling;
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(uploadDeviceRunSessionArtifactAsync).not.toHaveBeenCalled();
+  });
+
+  it('finishes an active cloud upload and collects final artifacts after normal stop', async () => {
+    jest.useRealTimers();
+    const stopPolling = new AbortController();
+    const cancellation = new AbortController();
+    let releaseUpload!: () => void;
+    let uploadStarted!: () => void;
+    const pendingUpload = new Promise<void>(resolve => {
+      releaseUpload = resolve;
+    });
+    const started = new Promise<void>(resolve => {
+      uploadStarted = resolve;
+    });
+    let inventories = 0;
+    const first = { id: 'first', filename: 'first.png' };
+    const last = { id: 'last', filename: 'last.png' };
+    jest
+      .mocked(fetch)
+      .mockImplementation(async url =>
+        String(url).endsWith('/artifacts')
+          ? new Response(
+              JSON.stringify({ artifacts: ++inventories === 1 ? [first] : [first, last] })
+            )
+          : new Response(Readable.from(['png']))
+      );
+    let transferSignal: AbortSignal | undefined;
+    jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_ctx, options) => {
+      await readStreamAsync(options.openStream());
+      if (options.artifactId === 'first') {
+        transferSignal = options.signal;
+        uploadStarted();
+        await pendingUpload;
+      }
+    });
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger: createLoggerMock(),
+      signal: cancellation.signal,
+      stopPollingSignal: stopPolling.signal,
+    });
+    let finished = false;
+    void polling.then(() => {
+      finished = true;
+    });
+    try {
+      await started;
+      stopPolling.abort();
+      await new Promise(resolve => setImmediate(resolve));
+      expect(transferSignal?.aborted).toBe(false);
+      expect(finished).toBe(false);
+      releaseUpload();
+      await polling;
+      expect(inventories).toBe(2);
+      expect(
+        jest
+          .mocked(uploadDeviceRunSessionArtifactAsync)
+          .mock.calls.map(([, options]) => options.artifactId)
+      ).toEqual(['first', 'last']);
+    } finally {
+      releaseUpload();
+      cancellation.abort();
+      await polling;
+    }
+  });
+
+  it('checks for an artifact created between the last poll and normal stop', async () => {
+    jest.useRealTimers();
+    const stopPolling = new AbortController();
+    jest
+      .mocked(fetch)
+      .mockResolvedValueOnce(new Response(JSON.stringify({ artifacts: [] })))
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ artifacts: [{ id: 'last', filename: 'last.png' }] }))
+      )
+      .mockResolvedValueOnce(new Response(Readable.from(['png'])));
+    jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_ctx, options) => {
+      await readStreamAsync(options.openStream());
+    });
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger: createLoggerMock(),
+      stopPollingSignal: stopPolling.signal,
+    });
+    await new Promise(resolve => setImmediate(resolve));
+    stopPolling.abort();
+    await polling;
+    expect(fetch).toHaveBeenCalledTimes(3);
+    expect(uploadDeviceRunSessionArtifactAsync).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ artifactId: 'last' })
+    );
+  });
+
+  it('reports a failed final inventory after normal stop', async () => {
+    jest.useRealTimers();
+    const stopPolling = new AbortController();
+    const logger = createLoggerMock();
+    const error = new Error('daemon is not ready');
+    jest
+      .mocked(fetch)
+      .mockResolvedValueOnce(new Response(JSON.stringify({ artifacts: [] })))
+      .mockRejectedValueOnce(error);
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger,
+      stopPollingSignal: stopPolling.signal,
+    });
+    await new Promise(resolve => setImmediate(resolve));
+    stopPolling.abort();
+    await polling;
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(logger.warn).toHaveBeenCalledWith(
+      { err: error, failedArtifactListCount: 1 },
+      'Could not list agent-device remote session artifacts.'
+    );
+    expect(Sentry.capture).toHaveBeenCalledTimes(1);
+  });
+
+  it('cancels a graceful collector immediately when the job is cancelled', async () => {
+    jest.useRealTimers();
+    const stopPolling = new AbortController();
+    const cancellation = new AbortController();
+    let entered!: () => void;
+    const started = new Promise<void>(resolve => {
+      entered = resolve;
+    });
+    jest.mocked(fetch).mockImplementation(async (_url, options) => {
+      const signal = options?.signal as AbortSignal;
+      entered();
+      return await new Promise((_resolve, reject) => {
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+      });
+    });
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger: createLoggerMock(),
+      signal: cancellation.signal,
+      stopPollingSignal: stopPolling.signal,
+    });
+    await started;
+    cancellation.abort();
+    await polling;
+    expect(stopPolling.signal.aborted).toBe(false);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('cancels a stuck transfer after the normal-stop drain budget expires', async () => {
+    jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate'] });
+    const stopPolling = new AbortController();
+    const logger = createLoggerMock();
+    let entered!: () => void;
+    const started = new Promise<void>(resolve => {
+      entered = resolve;
+    });
+    jest
+      .mocked(fetch)
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ artifacts: [{ id: 'large', filename: 'large.mp4' }] }))
+      )
+      .mockResolvedValueOnce(new Response(Readable.from(['video'])));
+    jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_ctx, options) => {
+      await readStreamAsync(options.openStream());
+      entered();
+      return await new Promise((_resolve, reject) => {
+        options.signal!.addEventListener('abort', () => reject(options.signal!.reason), {
+          once: true,
+        });
+      });
+    });
+    const polling = pollAgentDeviceArtifactsForUploadAsync({} as CustomBuildContext, {
+      deviceRunSessionId: 'drs-id',
+      daemonUrl: 'http://127.0.0.1:1234',
+      daemonToken: 'token',
+      logger,
+      stopPollingSignal: stopPolling.signal,
+    });
+    await started;
+    stopPolling.abort();
+    await jest.advanceTimersByTimeAsync(30_000);
+    await polling;
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(logger.warn).toHaveBeenCalledWith(
+      'Timed out draining agent-device artifacts; some session artifacts may not have been uploaded.'
+    );
   });
 
   it('reports artifact listing errors on every fifth consecutive failure', async () => {

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

@@ -0,0 +1,57 @@
+import spawn from '@expo/turtle-spawn';
+import fs from 'node:fs/promises';
+
+import { createColdIosSessionAsync } from '../coldIosSession';
+import { spawnDetached } from '../remoteDeviceRunSession';
+
+jest.mock('@expo/turtle-spawn');
+jest.mock('../remoteDeviceRunSession', () => ({
+  fetchWebPreviewTurnArgsAsync: jest.fn(async () => []),
+  findAvailablePortAsync: jest.fn(async () => 3200),
+  spawnDetached: jest.fn(() => ({ stopAsync: jest.fn() })),
+}));
+
+const STATE_FILE = '/tmp/expo-simulator-startup.json';
+const platform = Object.getOwnPropertyDescriptor(process, 'platform')!;
+const logger = { info: jest.fn(), warn: jest.fn() } as any;
+
+async function startServerAsync(signal?: AbortSignal) {
+  const server = await createColdIosSessionAsync({} as any, { env: {}, logger });
+  return await server.startAsync({
+    command: 'serve-sim',
+    args: [],
+    env: {},
+    logger,
+    secrets: [],
+    stopGracePeriodMs: 1000,
+    signal,
+  });
+}
+
+beforeEach(async () => {
+  jest.mocked(spawn).mockResolvedValue({ stdout: 'current-boot\n' } as never);
+  Object.defineProperty(process, 'platform', { value: 'darwin' });
+  await fs.mkdir('/tmp', { recursive: true });
+  await fs.writeFile(STATE_FILE, JSON.stringify({ status: 'stopping' }));
+});
+afterEach(() => {
+  Object.defineProperty(process, 'platform', platform);
+});
+
+it('starts serve-sim only after warm Simulator cleanup finished', async () => {
+  const starting = startServerAsync();
+  await new Promise(resolve => setTimeout(resolve, 600));
+  expect(spawnDetached).not.toHaveBeenCalled();
+  await fs.writeFile(STATE_FILE, JSON.stringify({ status: 'disabled', bootUuid: 'current-boot' }));
+  await starting;
+  expect(spawnDetached).toHaveBeenCalledTimes(1);
+});
+
+it('does not start serve-sim when the job is cancelled while cleanup runs', async () => {
+  const controller = new AbortController();
+  const starting = startServerAsync(controller.signal);
+  // Cleanup is still running; the cancellation alone must end the wait.
+  controller.abort(new Error('cancelled'));
+  await expect(starting).rejects.toThrow('cancelled');
+  expect(spawnDetached).not.toHaveBeenCalled();
+});

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

@@ -0,0 +1,62 @@
+import { SystemError } from '@expo/eas-build-job';
+import { type bunyan } from '@expo/logger';
+
+import { validateControllerVersion } from '../controllerVersion';
+
+describe(validateControllerVersion, () => {
+  const minimumVersion = '0.16.0';
+  const controller = { packageName: 'example-controller', minimumVersion };
+  const warn = jest.fn();
+  const logger = { warn } as unknown as bunyan;
+  const supportedVersion = '999.0.0';
+  const oldVersion = '0.0.0';
+
+  beforeEach(() => {
+    warn.mockClear();
+  });
+
+  it('allows the default latest package version', () => {
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: undefined, logger })
+    ).not.toThrow();
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: 'latest', logger })
+    ).not.toThrow();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('allows exact supported semver versions', () => {
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: minimumVersion, logger })
+    ).not.toThrow();
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: supportedVersion, logger })
+    ).not.toThrow();
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: `v${supportedVersion}`, logger })
+    ).not.toThrow();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('rejects exact semver versions that are too old', () => {
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: oldVersion, logger })
+    ).toThrow(SystemError);
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: oldVersion, logger })
+    ).toThrow(`Use "latest" or pass an exact version >= ${minimumVersion}`);
+  });
+
+  it('warns for package tags or ranges that cannot be verified', () => {
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: 'next', logger })
+    ).not.toThrow();
+    expect(() =>
+      validateControllerVersion({ ...controller, packageVersion: `^${minimumVersion}`, logger })
+    ).not.toThrow();
+    expect(warn).toHaveBeenCalledTimes(2);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('Continuing and letting the package manager resolve it.')
+    );
+  });
+});

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

@@ -3,7 +3,7 @@ import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-import { readIosApplicationIdentifierAsync } from '../iosAppArtifact';
+import { isPreinstalledExpoGoAsync, readIosApplicationIdentifierAsync } from '../iosAppArtifact';
 
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
 jest.unmock('fs');
@@ -61,3 +61,59 @@ describe(readIosApplicationIdentifierAsync, () => {
     ).rejects.toMatchObject({ errorCode: 'EAS_INSTALL_BUILD_MISSING_IDENTIFIER' });
   });
 });
+
+describe(isPreinstalledExpoGoAsync, () => {
+  const preinstalled = {
+    bundleIdentifier: 'host.exp.Exponent',
+    shortVersion: '58.0.7',
+    version: '58.0.7',
+  };
+  function plist(values: Record<string, string>) {
+    jest.mocked(spawn).mockImplementation((async (_command: string, args: string[]) => ({
+      stdout: `${values[args[1]]}\n`,
+    })) as never);
+  }
+  const app = (shortVersion: string, bundleIdentifier = 'host.exp.Exponent') => ({
+    CFBundleIdentifier: bundleIdentifier,
+    CFBundleShortVersionString: shortVersion,
+    CFBundleVersion: shortVersion,
+  });
+
+  beforeEach(() => {
+    jest.mocked(spawn).mockReset();
+  });
+
+  it('matches the preinstalled Expo Go without asking the Simulator', async () => {
+    plist(app('58.0.7'));
+    await expect(
+      isPreinstalledExpoGoAsync({ appPath: '/job/Expo Go.app', preinstalled, env: {} })
+    ).resolves.toBe(true);
+    expect(jest.mocked(spawn).mock.calls.every(([command]) => command === 'plutil')).toBe(true);
+  });
+
+  it('does not match a different Expo Go version', async () => {
+    plist(app('58.0.6'));
+    await expect(
+      isPreinstalledExpoGoAsync({ appPath: '/job/Expo Go.app', preinstalled, env: {} })
+    ).resolves.toBe(false);
+  });
+
+  it('never matches a custom build, even with the same version', async () => {
+    plist(app('58.0.7', 'com.example.app'));
+    await expect(
+      isPreinstalledExpoGoAsync({
+        appPath: '/job/Example.app',
+        preinstalled: { ...preinstalled, bundleIdentifier: 'com.example.app' },
+        env: {},
+      })
+    ).resolves.toBe(false);
+    expect(spawn).not.toHaveBeenCalled();
+  });
+
+  it('does not match an app it cannot read', async () => {
+    jest.mocked(spawn).mockRejectedValue(new Error('plutil failed'));
+    await expect(
+      isPreinstalledExpoGoAsync({ appPath: '/job/Expo Go.app', preinstalled, env: {} })
+    ).resolves.toBe(false);
+  });
+});

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

@@ -1087,7 +1087,13 @@ describe(startDeviceSessionHostAsync, () => {
   beforeEach(() => {
     jest.mocked(uploadDeviceRunSessionScreenRecordingsAsync).mockReset();
     jest.mocked(spawn).mockReset();
-    jest.mocked(ngrok.forward).mockReset();
+    jest
+      .mocked(ngrok.forward)
+      .mockReset()
+      .mockResolvedValue({
+        url: () => 'https://preview.example.test',
+        close: jest.fn().mockResolvedValue(undefined),
+      } as never);
     jest.mocked(turtleFetch).mockReset();
     jest
       .mocked(readServeSimServersAsync)
@@ -1150,6 +1156,7 @@ describe(startDeviceSessionHostAsync, () => {
   it('gives serve-sim its recording grace period on shutdown', async () => {
     const spawnDetachedSpy = jest.spyOn(remoteDeviceRunSession, 'spawnDetached');
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
@@ -1167,6 +1174,7 @@ describe(startDeviceSessionHostAsync, () => {
     'passes private sharing flags directly to serve-sim version %s',
     async packageVersion => {
       const host = await startDeviceSessionHostAsync(createCtxMock(), {
+        preview: { baseDomain, authtoken },
         runtimePlatform: BuildRuntimePlatform.DARWIN,
         env,
         logger: createLoggerMock(),
@@ -1195,6 +1203,7 @@ describe(startDeviceSessionHostAsync, () => {
     const privatePreviewUrl =
       'https://expo.dev/accounts/owner/projects/app/simulator-sessions/session-id/preview';
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
@@ -1202,7 +1211,7 @@ describe(startDeviceSessionHostAsync, () => {
       disableShare: true,
       privatePreviewUrl,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const serveSimArgs = jest
       .mocked(spawn)
@@ -1222,13 +1231,14 @@ describe(startDeviceSessionHostAsync, () => {
       close: jest.fn().mockResolvedValue(undefined),
     } as never);
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
       disableShare: true,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const serveSimArgs = jest
       .mocked(spawn)
@@ -1255,13 +1265,14 @@ describe(startDeviceSessionHostAsync, () => {
       .mockReturnValueOnce(Promise.resolve({}) as unknown as ReturnType<typeof spawn>);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.LINUX,
       env,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
       packageVersion,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const spawnCalls = jest.mocked(spawn).mock.calls;
     expect(spawnCalls[0]).toEqual([
@@ -1318,12 +1329,13 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     expect(preview.previewToken).toBe('tok-1');
     expect(preview.apiUrl).toBe('https://preview.example.test');
@@ -1353,12 +1365,13 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env: { ...env, EXPO_STAGING: '1' },
       logger: createLoggerMock(),
       timeoutMs: 10_000,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     expect(preview.previewPageUrl).toMatch(
       /^https:\/\/staging\.expo\.dev\/simulator-preview\/[a-f0-9]{32}$/
@@ -1378,6 +1391,7 @@ describe(startDeviceSessionHostAsync, () => {
 
     await expect(
       startDeviceSessionHostAsync(createCtxMock(), {
+        preview: { baseDomain, authtoken },
         runtimePlatform: BuildRuntimePlatform.DARWIN,
         env,
         logger: createLoggerMock(),
@@ -1395,12 +1409,13 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.LINUX,
       env,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     expect(preview.previewToken).toBe('hub-token');
     const [, args] = jest.mocked(spawn).mock.calls.find(([command]) => command === 'npx')!;
@@ -1417,13 +1432,14 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
       packageVersion,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1459,13 +1475,14 @@ describe(startDeviceSessionHostAsync, () => {
 
     const bunEnv = { ...env, EAS_OVERRIDE_PACKAGE_MANAGER: 'bun' };
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env: bunEnv,
       logger: createLoggerMock(),
       timeoutMs: 10_000,
       packageVersion: '4.5.6',
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1494,12 +1511,13 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env: { ...env, EAS_FALLBACK_PACKAGE_MANAGER: 'bun' },
       logger: createLoggerMock(),
       timeoutMs: 10_000,
     });
-    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
+    const preview = await host.openPreviewAsync();
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1525,6 +1543,7 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
+      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
@@ -1551,6 +1570,7 @@ describe(startDeviceSessionHostAsync, () => {
   it('refuses to launch an application on Linux, where expo-device-hub cannot', async () => {
     await expect(
       startDeviceSessionHostAsync(createCtxMock(), {
+        preview: { baseDomain, authtoken },
         runtimePlatform: BuildRuntimePlatform.LINUX,
         env,
         logger: createLoggerMock(),

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

@@ -0,0 +1,225 @@
+import { type bunyan } from '@expo/logger';
+import spawn from '@expo/turtle-spawn';
+
+import { type CustomBuildContext } from '../../../customBuildContext';
+import { IosSimulatorRecordingUtils } from '../IosSimulatorRecordingUtils';
+import { fetchWebPreviewTurnArgsAsync } from '../remoteDeviceRunSession';
+import {
+  WarmSessionAdoptionError,
+  createWarmDeviceSessionServer,
+  runOnWarmIosSimulatorAsync,
+} from '../warmDeviceSessionHost';
+import { type WarmIosSession, tryClaimWarmIosSessionAsync } from '../warmIosSession';
+
+jest.mock('@expo/turtle-spawn');
+jest.mock('../IosSimulatorRecordingUtils');
+jest.mock('../warmIosSession');
+jest.mock('../remoteDeviceRunSession', () => ({
+  ...jest.requireActual('../remoteDeviceRunSession'),
+  fetchWebPreviewTurnArgsAsync: jest.fn(),
+}));
+
+const ctx = {} as CustomBuildContext;
+const logger = { warn: jest.fn() } as unknown as bunyan;
+let warm: WarmIosSession;
+
+function launch(signal?: AbortSignal) {
+  return {
+    command: 'bunx',
+    args: ['serve-sim', '--port', '3200'],
+    env: {},
+    logger,
+    signal,
+    secrets: [],
+    stopGracePeriodMs: 1_000,
+  };
+}
+
+beforeEach(() => {
+  jest.resetAllMocks();
+  jest.mocked(fetchWebPreviewTurnArgsAsync).mockResolvedValue(['--turn', 'creds']);
+  jest.mocked(spawn).mockResolvedValue({ stdout: '' } as never);
+  jest
+    .mocked(IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync)
+    .mockResolvedValue({ output: '/recordings/id', recordingId: 'id' });
+  warm = {
+    device: { udid: 'UDID', name: 'iPhone 17' },
+    server: { pid: 10, port: 3200, token: 'serve-token' },
+    agentDeviceStateDir: '/agent',
+    argentEventLogPath: '/argent/events',
+    preinstalledExpoGo: {
+      bundleIdentifier: 'host.exp.Exponent',
+      shortVersion: '2.0',
+      version: '1',
+    },
+    prepareToolsAsync: jest.fn().mockResolvedValue(undefined),
+    process: {
+      pid: 10,
+      getOutput: () => '',
+      getExitError: () => undefined,
+      stopAsync: jest.fn().mockResolvedValue(undefined),
+    },
+  };
+});
+
+it('adopts the warm device on the warm port with its recording, then prepares tools', async () => {
+  const server = createWarmDeviceSessionServer(ctx, logger, warm);
+  expect(server).toMatchObject({
+    port: 3200,
+    requiresPreviewRetirement: true,
+    preinstalledApp: warm.preinstalledExpoGo,
+  });
+  const handle = await server.startAsync(launch());
+  expect(spawn).toHaveBeenCalledWith(
+    'bunx',
+    [
+      'serve-sim',
+      '--port',
+      '3200',
+      '--single-device',
+      'UDID',
+      '--adopt',
+      '--recording-output',
+      '/recordings/id',
+      '--recording-id',
+      'id',
+    ],
+    expect.objectContaining({ stdio: 'pipe' })
+  );
+  expect(warm.prepareToolsAsync).toHaveBeenCalled();
+  expect(handle.pid).toBe(10);
+  await handle.stopAsync();
+  expect(warm.process.stopAsync).toHaveBeenCalledTimes(1);
+});
+
+it.each([
+  ['adoption', () => jest.mocked(spawn).mockRejectedValue(new Error('adopt --turn creds failed'))],
+  [
+    'tool preparation',
+    () => jest.mocked(warm.prepareToolsAsync).mockRejectedValue(new Error('no tool')),
+  ],
+])('reports a %s failure as an adoption error without its details', async (_name, setup) => {
+  setup();
+  const error = await createWarmDeviceSessionServer(ctx, logger, warm)
+    .startAsync(launch())
+    .catch(error => error);
+  expect(error).toBeInstanceOf(WarmSessionAdoptionError);
+  expect(String(error)).not.toContain('creds');
+});
+
+it('reports a cancellation as a cancellation', async () => {
+  const controller = new AbortController();
+  jest.mocked(spawn).mockImplementation((() => {
+    controller.abort(new Error('cancelled'));
+    return Promise.reject(new Error('killed'));
+  }) as never);
+  await expect(
+    createWarmDeviceSessionServer(ctx, logger, warm).startAsync(launch(controller.signal))
+  ).rejects.toThrow('cancelled');
+});
+
+describe(runOnWarmIosSimulatorAsync, () => {
+  const claim = { engine: 'serve-sim' as const, env: {}, logger };
+
+  it('runs cold when there is no warm Simulator to claim', async () => {
+    jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(undefined);
+    const run = jest.fn().mockResolvedValue('cold');
+    await expect(runOnWarmIosSimulatorAsync(claim, run)).resolves.toBe('cold');
+    expect(run).toHaveBeenCalledWith(undefined);
+  });
+
+  it('runs on the claimed warm Simulator', async () => {
+    jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+    const run = jest.fn().mockResolvedValue('warm');
+    await expect(runOnWarmIosSimulatorAsync(claim, run)).resolves.toBe('warm');
+    expect(run).toHaveBeenCalledTimes(1);
+    expect(run).toHaveBeenCalledWith(warm);
+  });
+
+  it('stops warmup and runs cold after an adoption failure', async () => {
+    jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+    const run = jest
+      .fn()
+      .mockRejectedValueOnce(new WarmSessionAdoptionError())
+      .mockResolvedValueOnce('cold');
+    await expect(runOnWarmIosSimulatorAsync(claim, run)).resolves.toBe('cold');
+    expect(warm.process.stopAsync).toHaveBeenCalledTimes(1);
+    expect(run).toHaveBeenLastCalledWith(undefined);
+  });
+
+  it('does not run cold after a failure during the session', async () => {
+    jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+    const error = new Error('session failed');
+    const run = jest.fn().mockRejectedValue(error);
+    await expect(runOnWarmIosSimulatorAsync(claim, run)).rejects.toBe(error);
+    expect(warm.process.stopAsync).toHaveBeenCalledTimes(1);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([new Error('session failed'), new WarmSessionAdoptionError()])(
+    'preserves both errors and does not run cold when cleanup fails (%s)',
+    async error => {
+      jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+      const cleanupError = new Error('cleanup failed');
+      jest.mocked(warm.process.stopAsync).mockRejectedValue(cleanupError);
+      const run = jest.fn().mockRejectedValue(error);
+      await expect(runOnWarmIosSimulatorAsync(claim, run)).rejects.toMatchObject({
+        errors: [error, cleanupError],
+      });
+      expect(run).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it.each([false, true])(
+    'waits for cleanup before settling (adoption failure: %s)',
+    async adoption => {
+      jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+      const error = adoption ? new WarmSessionAdoptionError() : new Error('session failed');
+      let releaseCleanup = () => {};
+      let cleanupStarted = () => {};
+      const started = new Promise<void>(resolve => {
+        cleanupStarted = resolve;
+      });
+      jest.mocked(warm.process.stopAsync).mockImplementation(() => {
+        cleanupStarted();
+        return new Promise<void>(resolve => {
+          releaseCleanup = resolve;
+        });
+      });
+      const run = jest.fn().mockRejectedValueOnce(error).mockResolvedValue('cold');
+      const running = runOnWarmIosSimulatorAsync(claim, run);
+      let settled = false;
+      const result = running.then(
+        value => {
+          settled = true;
+          return value;
+        },
+        error => {
+          settled = true;
+          return error;
+        }
+      );
+      await started;
+      await Promise.resolve();
+      expect(settled).toBe(false);
+      expect(run).toHaveBeenCalledTimes(1);
+      releaseCleanup();
+      expect(await result).toBe(adoption ? 'cold' : error);
+      expect(run).toHaveBeenCalledTimes(adoption ? 2 : 1);
+    }
+  );
+
+  it('does not retry cold when cancellation occurs during cleanup', async () => {
+    jest.mocked(tryClaimWarmIosSessionAsync).mockResolvedValue(warm);
+    const controller = new AbortController();
+    const cancellation = new Error('cancelled');
+    jest.mocked(warm.process.stopAsync).mockImplementation(async () => {
+      controller.abort(cancellation);
+    });
+    const run = jest.fn().mockRejectedValue(new WarmSessionAdoptionError());
+    await expect(
+      runOnWarmIosSimulatorAsync({ ...claim, signal: controller.signal }, run)
+    ).rejects.toBe(cancellation);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,151 @@
+import { type bunyan } from '@expo/logger';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { runSimulatorLauncherAsync, stopWarmSimulatorAsync } from '../../../utils/warmSimulator';
+import { readLocalEgressHandoffAsync } from '../localEgress';
+import { tryClaimWarmIosSessionAsync } from '../warmIosSession';
+
+jest.mock('../../../utils/warmSimulator');
+jest.mock('../localEgress');
+
+const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
+const env = { EAS_USE_WARM_SIMULATOR: '1' };
+const claim = {
+  status: 'claimed',
+  device: { udid: 'UDID', name: 'iPhone 17' },
+  server: { pid: 10, port: 3200, token: 'serve-token', url: 'http://127.0.0.1:3200' },
+  agentDeviceStateDir: '/agent',
+  argentEventLogPath: '/argent/events',
+  preinstalledExpoGo: { bundleIdentifier: 'host.exp.Exponent', shortVersion: '2.0', version: '1' },
+};
+
+beforeEach(() => {
+  jest.resetAllMocks();
+  jest.mocked(stopWarmSimulatorAsync).mockResolvedValue();
+  jest
+    .mocked(runSimulatorLauncherAsync)
+    .mockImplementation(async ([command]) => (command === 'claim' ? JSON.stringify(claim) : '{}'));
+});
+afterEach(() => jest.restoreAllMocks());
+
+it('does not claim when the job does not use the warm Simulator', async () => {
+  await expect(
+    tryClaimWarmIosSessionAsync({ engine: 'serve-sim', env: {}, logger })
+  ).resolves.toBeUndefined();
+  expect(runSimulatorLauncherAsync).not.toHaveBeenCalled();
+  expect(stopWarmSimulatorAsync).not.toHaveBeenCalled();
+});
+
+it('logs the wait before claiming, without logging the private launcher record', async () => {
+  jest.mocked(runSimulatorLauncherAsync).mockImplementationOnce(async () => {
+    expect(logger.info).toHaveBeenCalledWith('Waiting for the warm Simulator launcher.');
+    return JSON.stringify(claim);
+  });
+  const session = await tryClaimWarmIosSessionAsync({
+    engine: 'serve-sim',
+    requestedDevice: 'iPhone 17',
+    env,
+    logger,
+  });
+  expect(runSimulatorLauncherAsync).toHaveBeenCalledWith(['claim', 'serve-sim', 'iPhone 17'], {
+    env,
+    signal: undefined,
+  });
+  expect(jest.mocked(logger.info).mock.calls).toEqual([
+    ['Waiting for the warm Simulator launcher.'],
+    ['Claimed the warm Simulator iPhone 17 (UDID).'],
+  ]);
+  expect(session).toMatchObject({
+    device: claim.device,
+    server: { pid: 10, port: 3200, token: 'serve-token' },
+    preinstalledExpoGo: claim.preinstalledExpoGo,
+  });
+  await session!.prepareToolsAsync();
+  expect(runSimulatorLauncherAsync).toHaveBeenLastCalledWith(['prepare-tools'], {
+    env,
+    signal: undefined,
+  });
+  expect(session!.tools).toBeUndefined();
+});
+
+it('takes the preinstalled Expo Go that prepare-tools reports', async () => {
+  const expoGo = { bundleIdentifier: 'host.exp.Exponent', shortVersion: '3.0', version: '2' };
+  jest
+    .mocked(runSimulatorLauncherAsync)
+    .mockImplementation(async ([command]) =>
+      command === 'claim'
+        ? JSON.stringify({ ...claim, preinstalledExpoGo: undefined })
+        : JSON.stringify({ preinstalledExpoGo: expoGo })
+    );
+  const session = await tryClaimWarmIosSessionAsync({ engine: 'serve-sim', env, logger });
+  expect(session!.preinstalledExpoGo).toBeUndefined();
+  await session!.prepareToolsAsync();
+  expect(session!.preinstalledExpoGo).toEqual(expoGo);
+});
+
+it('reads the agent-device server after tool preparation', async () => {
+  jest
+    .spyOn(fs, 'readFile')
+    .mockResolvedValue(JSON.stringify({ pid: 20, httpPort: 4310, token: 'agent-token' }));
+  const session = await tryClaimWarmIosSessionAsync({ engine: 'agent-device', env, logger });
+  await session!.prepareToolsAsync();
+  expect(fs.readFile).toHaveBeenCalledWith(path.join('/agent', 'daemon.json'), 'utf8');
+  expect(session!.tools).toEqual({ pid: 20, port: 4310, token: 'agent-token' });
+});
+
+it('uses the Argent identity validated by the launcher without scanning state files again', async () => {
+  const tools = { pid: 30, port: 3201, token: 'argent-token' };
+  const readDirectory = jest.spyOn(fs, 'readdir');
+  const readFile = jest.spyOn(fs, 'readFile');
+  jest
+    .mocked(runSimulatorLauncherAsync)
+    .mockImplementation(async ([command]) =>
+      JSON.stringify(command === 'claim' ? claim : { tools })
+    );
+  const session = await tryClaimWarmIosSessionAsync({ engine: 'argent', env, logger });
+  await session?.prepareToolsAsync();
+  expect(session?.tools).toEqual(tools);
+  expect(readDirectory).not.toHaveBeenCalled();
+  expect(readFile).not.toHaveBeenCalled();
+});
+
+it('rejects Argent preparation when the launcher returns no validated identity', async () => {
+  const session = await tryClaimWarmIosSessionAsync({ engine: 'argent', env, logger });
+  await expect(session?.prepareToolsAsync()).rejects.toThrow();
+});
+
+it.each([
+  [
+    'a failed claim',
+    {},
+    () => jest.mocked(runSimulatorLauncherAsync).mockRejectedValue(new Error('no session')),
+  ],
+  ['a pinned package version', { packageVersion: '1.2.3' }, () => {}],
+  ['a job Simulator setting', { env: { ...env, SIMCTL_CHILD_FOO: '1' } }, () => {}],
+  [
+    'a local egress session',
+    {},
+    () => jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue({ port: 1 } as never),
+  ],
+])('stops warmup and returns nothing for %s', async (_name, options, setup) => {
+  setup();
+  await expect(
+    tryClaimWarmIosSessionAsync({ engine: 'serve-sim', env, logger, ...options })
+  ).resolves.toBeUndefined();
+  expect(stopWarmSimulatorAsync).toHaveBeenCalledTimes(1);
+});
+
+it('rejects when warmup cleanup cannot be confirmed', async () => {
+  jest.mocked(runSimulatorLauncherAsync).mockRejectedValue(new Error('no session'));
+  jest.mocked(stopWarmSimulatorAsync).mockRejectedValue(new Error('cleanup failed'));
+  await expect(tryClaimWarmIosSessionAsync({ engine: 'serve-sim', env, logger })).rejects.toThrow(
+    'cleanup failed'
+  );
+});
+
+it('stops the claimed session once', async () => {
+  const session = await tryClaimWarmIosSessionAsync({ engine: 'serve-sim', env, logger });
+  await Promise.all([session!.process.stopAsync(), session!.process.stopAsync()]);
+  expect(stopWarmSimulatorAsync).toHaveBeenCalledTimes(1);
+});

packages/build-tools/src/steps/utils/agentDeviceArtifacts.ts

@@ -6,15 +6,16 @@ import fetch from 'node-fetch';
 import os from 'node:os';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
+import { setTimeout as sleepAsync } from 'node:timers/promises';
 import { z } from 'zod';
 
 import { CustomBuildContext } from '../../customBuildContext';
 import { Sentry } from '../../sentry';
 import { formatBytes } from '../../utils/artifacts';
-import { sleepAsync } from '../../utils/retry';
 import { uploadDeviceRunSessionArtifactAsync } from './deviceRunSessionArtifacts';
 
 const AGENT_DEVICE_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
+const AGENT_DEVICE_ARTIFACT_CLEANUP_TIMEOUT_MS = 30_000;
 
 const AgentDeviceArtifactSchema = z.object({
   id: z.string(),
@@ -45,69 +46,128 @@ export async function pollAgentDeviceArtifactsForUploadAsync(
     daemonUrl,
     daemonToken,
     logger,
+    signal,
+    stopPollingSignal,
   }: {
     deviceRunSessionId: string;
     daemonUrl: string;
     daemonToken: string;
     logger: bunyan;
+    signal?: AbortSignal;
+    stopPollingSignal?: AbortSignal;
   }
 ): Promise<void> {
   logger.info('Started polling agent-device daemon for artifacts.');
   const uploadedArtifactIds = new Set<string>();
   let listArtifactsErrorCount = 0;
 
-  for (;;) {
-    try {
-      const artifacts = await listAgentDeviceArtifactsAsync({ daemonUrl, daemonToken });
-      listArtifactsErrorCount = 0;
-      for (const artifact of artifacts) {
-        if (uploadedArtifactIds.has(artifact.id)) {
-          continue;
-        }
-        try {
-          await uploadAgentDeviceArtifactAsync(ctx, {
-            deviceRunSessionId,
-            daemonUrl,
-            daemonToken,
-            artifact,
-            logger,
-          });
-          uploadedArtifactIds.add(artifact.id);
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          Sentry.capture('Could not upload agent-device remote session artifact', error);
-          logger.warn({ err: error }, 'Could not upload agent-device remote session artifact.');
-        }
-      }
-    } catch (err) {
-      if (err instanceof AgentDeviceArtifactsUnsupportedError) {
-        logger.warn(
-          'agent-device daemon does not expose artifact inventory; remote session artifact uploads are disabled.'
-        );
+  // Ending normal polling must not cancel a transfer that the session already produced.
+  const cleanup = new AbortController();
+  const transferSignal = stopPollingSignal
+    ? AbortSignal.any([cleanup.signal, ...(signal ? [signal] : [])])
+    : signal;
+  const pollingSignal = stopPollingSignal
+    ? AbortSignal.any([stopPollingSignal, ...(signal ? [signal] : [])])
+    : signal;
+  let cleanupTimer: NodeJS.Timeout | undefined;
+  const startCleanupDeadline = (): void => {
+    cleanupTimer ??= setTimeout(() => cleanup.abort(), AGENT_DEVICE_ARTIFACT_CLEANUP_TIMEOUT_MS);
+  };
+  stopPollingSignal?.addEventListener('abort', startCleanupDeadline, { once: true });
+  if (stopPollingSignal?.aborted) {
+    startCleanupDeadline();
+  }
+
+  try {
+    for (;;) {
+      const finalInventory = stopPollingSignal?.aborted;
+      if (transferSignal?.aborted) {
         return;
       }
-      const error = err instanceof Error ? err : new Error(String(err));
-      listArtifactsErrorCount += 1;
-      if (listArtifactsErrorCount % 5 === 0) {
-        Sentry.capture('Could not list agent-device remote session artifacts', error);
-        logger.warn(
-          { err: error, failedArtifactListCount: listArtifactsErrorCount },
-          'Could not list agent-device remote session artifacts.'
-        );
+      try {
+        const artifacts = await listAgentDeviceArtifactsAsync({
+          daemonUrl,
+          daemonToken,
+          signal: transferSignal,
+        });
+        listArtifactsErrorCount = 0;
+        for (const artifact of artifacts) {
+          if (uploadedArtifactIds.has(artifact.id)) {
+            continue;
+          }
+          try {
+            await uploadAgentDeviceArtifactAsync(ctx, {
+              deviceRunSessionId,
+              daemonUrl,
+              daemonToken,
+              artifact,
+              logger,
+              ...(transferSignal ? { signal: transferSignal } : {}),
+            });
+            uploadedArtifactIds.add(artifact.id);
+          } catch (err) {
+            if (transferSignal?.aborted) {
+              return;
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            Sentry.capture('Could not upload agent-device remote session artifact', error);
+            logger.warn({ err: error }, 'Could not upload agent-device remote session artifact.');
+          }
+        }
+      } catch (err) {
+        if (transferSignal?.aborted) {
+          return;
+        }
+        if (err instanceof AgentDeviceArtifactsUnsupportedError) {
+          logger.warn(
+            'agent-device daemon does not expose artifact inventory; remote session artifact uploads are disabled.'
+          );
+          return;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        listArtifactsErrorCount += 1;
+        // The final inventory has no later retry, so always report its failure.
+        if (finalInventory || listArtifactsErrorCount % 5 === 0) {
+          Sentry.capture('Could not list agent-device remote session artifacts', error);
+          logger.warn(
+            { err: error, failedArtifactListCount: listArtifactsErrorCount },
+            'Could not list agent-device remote session artifacts.'
+          );
+        }
       }
+      if (finalInventory) {
+        return;
+      }
+      await sleepAsync(AGENT_DEVICE_ARTIFACT_UPLOAD_POLL_INTERVAL_MS, undefined, {
+        signal: pollingSignal,
+      }).catch(error => {
+        if (!pollingSignal?.aborted) {
+          throw error;
+        }
+      });
+    }
+  } finally {
+    clearTimeout(cleanupTimer);
+    stopPollingSignal?.removeEventListener('abort', startCleanupDeadline);
+    if (cleanup.signal.aborted) {
+      logger.warn(
+        'Timed out draining agent-device artifacts; some session artifacts may not have been uploaded.'
+      );
     }
-    await sleepAsync(AGENT_DEVICE_ARTIFACT_UPLOAD_POLL_INTERVAL_MS);
   }
 }
 
 export async function listAgentDeviceArtifactsAsync({
   daemonUrl,
   daemonToken,
+  signal,
 }: {
   daemonUrl: string;
   daemonToken: string;
+  signal?: AbortSignal;
 }): Promise<AgentDeviceArtifact[]> {
   const response = await fetch(new URL('/artifacts', daemonUrl).toString(), {
+    ...(signal ? { signal } : {}),
     headers: { Authorization: `Bearer ${daemonToken}` },
   });
   if (response.status === 404) {
@@ -133,14 +193,17 @@ export async function uploadAgentDeviceArtifactAsync(
     daemonToken,
     artifact,
     logger,
+    signal,
   }: {
     deviceRunSessionId: string;
     daemonUrl: string;
     daemonToken: string;
     artifact: AgentDeviceArtifact;
     logger: bunyan;
+    signal?: AbortSignal;
   }
 ): Promise<void> {
+  signal?.throwIfAborted();
   logger.info(`Downloading artifact ${artifact.filename}.`);
   const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'agent-device-artifact-'));
   try {
@@ -150,6 +213,7 @@ export async function uploadAgentDeviceArtifactAsync(
       daemonUrl,
       daemonToken,
       destinationPath: temporaryArtifactPath,
+      signal,
     });
     const { size } = await stat(temporaryArtifactPath);
     logger.info(`Uploading artifact ${artifact.filename} (${formatBytes(size)}).`);
@@ -164,6 +228,7 @@ export async function uploadAgentDeviceArtifactAsync(
         : {}),
       size,
       openStream: () => createReadStream(temporaryArtifactPath),
+      ...(signal ? { signal } : {}),
     });
   } finally {
     await rm(temporaryDirectory, { recursive: true, force: true });
@@ -175,16 +240,19 @@ async function downloadAgentDeviceArtifactToFileAsync({
   daemonUrl,
   daemonToken,
   destinationPath,
+  signal,
 }: {
   artifact: AgentDeviceArtifact;
   daemonUrl: string;
   daemonToken: string;
   destinationPath: string;
+  signal?: AbortSignal;
 }): Promise<void> {
   const response = await fetch(
     new URL(`/artifacts/${encodeURIComponent(artifact.id)}`, daemonUrl).toString(),
     {
       headers: { Authorization: `Bearer ${daemonToken}` },
+      ...(signal ? { signal } : {}),
     }
   );
   if (!response.ok) {
@@ -197,5 +265,9 @@ async function downloadAgentDeviceArtifactToFileAsync({
       `Agent-device artifact ${artifact.id} response did not include a readable body.`
     );
   }
-  await pipeline(response.body, createWriteStream(destinationPath));
+  if (signal) {
+    await pipeline(response.body, createWriteStream(destinationPath), { signal });
+  } else {
+    await pipeline(response.body, createWriteStream(destinationPath));
+  }
 }

packages/build-tools/src/steps/utils/coldIosSession.ts

@@ -0,0 +1,50 @@
+import type { bunyan } from '@expo/logger';
+import type { BuildStepEnv } from '@expo/steps';
+
+import type { CustomBuildContext } from '../../customBuildContext';
+import { IosSimulatorUtils, type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
+import { waitForWarmSimulatorCleanupAsync } from '../../utils/warmSimulatorCleanup';
+import type { DeviceSessionServer } from './deviceSessionHost';
+import {
+  fetchWebPreviewTurnArgsAsync,
+  findAvailablePortAsync,
+  spawnDetached,
+} from './remoteDeviceRunSession';
+
+/** Creates the cold iOS server handle; start and setup run when the host calls them. */
+export async function createColdIosSessionAsync(
+  ctx: CustomBuildContext,
+  {
+    env,
+    logger,
+    iosSimulatorUdid,
+  }: { env: BuildStepEnv; logger: bunyan; iosSimulatorUdid?: string }
+): Promise<DeviceSessionServer> {
+  const port = await findAvailablePortAsync();
+  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
+  return {
+    port,
+    turnArgs: Promise.resolve(turnArgs),
+    requiresPreviewRetirement: false,
+    async startAsync({ command, args, env, logger, signal, secrets, stopGracePeriodMs }) {
+      // serve-sim boots the device, so warm Simulator cleanup must finish first.
+      await waitForWarmSimulatorCleanupAsync(env, { signal });
+      signal?.throwIfAborted();
+      return spawnDetached({ command, args, env, logger, secrets, stopGracePeriodMs });
+    },
+    async setupSimulatorAsync({ signal, logger }) {
+      try {
+        await IosSimulatorUtils.disableApsdAsync({
+          udid: iosSimulatorUdid as IosSimulatorUuid,
+          env,
+        });
+      } catch (err) {
+        signal.throwIfAborted();
+        logger.warn({ err }, 'Failed to disable apsd in the Simulator.');
+      }
+      signal.throwIfAborted();
+    },
+    // A cold launch either returns its handle or starts no process.
+    async stopAsync() {},
+  };
+}

packages/build-tools/src/steps/utils/controllerVersion.ts

@@ -0,0 +1,34 @@
+import { SystemError } from '@expo/eas-build-job';
+import { type bunyan } from '@expo/logger';
+import semver from 'semver';
+
+export function validateControllerVersion({
+  packageName,
+  minimumVersion,
+  packageVersion,
+  logger,
+}: {
+  packageName: string;
+  minimumVersion: string;
+  packageVersion: string | undefined;
+  logger: bunyan;
+}): void {
+  if (!packageVersion || packageVersion === 'latest') {
+    return;
+  }
+  const requirement = `Remote sessions require ${packageName}@${minimumVersion} or newer.`;
+  const version = semver.valid(packageVersion);
+  if (!version) {
+    logger.warn(
+      `${requirement} package_version "${packageVersion}" is not an exact semver version that EAS can verify. ` +
+        'Continuing and letting the package manager resolve it.'
+    );
+    return;
+  }
+  if (semver.lt(version, minimumVersion)) {
+    throw new SystemError(
+      `${requirement} The requested package_version "${packageVersion}" is too old for the EAS remote-session API. ` +
+        `Use "latest" or pass an exact version >= ${minimumVersion}.`
+    );
+  }
+}

packages/build-tools/src/steps/utils/deviceSessionHost.ts

@@ -49,9 +49,15 @@ import {
 import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';
 import { startLogPhase } from '../../utils/logPhase';
 import { runServeSimActionAsync, stageServeSimAppAsync } from './serveSimActions';
+import {
+  type IosAppIdentity,
+  isPreinstalledExpoGoAsync,
+  readIosApplicationIdentifierAsync,
+} from './iosAppArtifact';
 import { type ServeSimActivityPolling, startServeSimActivityPolling } from './serveSimActivity';
 import { verifyLocalEgressGuardAsync } from './localEgressGuard';
-import { IosSimulatorUtils, type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
+import { type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
+import { createColdIosSessionAsync } from './coldIosSession';
 import { createStartupTasks } from './startupTasks';
 
 const WEB_PREVIEW_HOST = '127.0.0.1';
@@ -362,12 +368,13 @@ export type DeviceWebPreview = {
 };
 
 export type DeviceSessionHost = {
-  openPreviewAsync(options: { baseDomain: string; authtoken: string }): Promise<DeviceWebPreview>;
+  /** The preview tunnel opened during startup, or a new one after closeAsync. */
+  openPreviewAsync(): Promise<DeviceWebPreview>;
   /** Last observed preview input. Always `undefined` on Android, which keeps no event log. */
   getLastPreviewActivityAt(): Date | undefined;
   /**
-   * Terminal and idempotent. Never rejects: a failed finalization, host stop or upload is logged
-   * and reported, so callers need no error handling around it.
+   * Terminal and idempotent. Finalization, host-stop and upload failures are logged and reported.
+   * Warm preview-tunnel cleanup can reject when retirement cannot be confirmed.
    */
   finishAsync(): Promise<void>;
 };
@@ -379,11 +386,13 @@ type AndroidSessionRecording = {
   env: BuildStepEnv;
 };
 
-type DeviceSessionHostOptions = {
+export type DeviceSessionHostOptions = {
   runtimePlatform: BuildRuntimePlatform;
   env: BuildStepEnv;
   logger: bunyan;
   timeoutMs: number;
+  /** The host opens this preview tunnel while the server starts. */
+  preview: { baseDomain: string; authtoken: string };
   separateLogPhase?: boolean;
   startupTimeoutMs?: number;
   signal?: AbortSignal;
@@ -405,12 +414,69 @@ type DeviceSessionHostOptions = {
   networkCaptureFields?: string[];
 } & ServeSimLaunchOptions;
 
+export type DeviceSessionServerLaunch = {
+  command: string;
+  args: string[];
+  env: BuildStepEnv;
+  logger: bunyan;
+  signal?: AbortSignal;
+  /** Redacted from server output. The host adds the preview token after launch. */
+  secrets: string[];
+  stopGracePeriodMs: number;
+};
+
+/**
+ * The server process behind a session host. A cold server is launched for this session; a warm
+ * server was prepared before the job and is adopted. The host runs the same readiness, app
+ * actions and finalization for both.
+ */
+export type DeviceSessionServer = {
+  port: number;
+  turnArgs: Promise<string[]>;
+  /** Cold iOS setup runs after control readiness, alongside app installation and before launch. */
+  setupSimulatorAsync?(options: { signal: AbortSignal; logger: bunyan }): Promise<void>;
+  /** An app the server's launcher installed and never launched. */
+  preinstalledApp?: IosAppIdentity;
+  /** Another session can start on this machine, so an unconfirmed tunnel close fails cleanup. */
+  requiresPreviewRetirement: boolean;
+  startAsync(launch: DeviceSessionServerLaunch): Promise<DetachedProcessHandle>;
+  /** Stops the server after startAsync failed. Finalization stops the returned handle. */
+  stopAsync(): Promise<void>;
+};
+
+/** Fetches TURN before the host starts its collectors. */
+async function createAndroidDeviceSessionServerAsync(
+  ctx: CustomBuildContext,
+  { logger }: { logger: bunyan }
+): Promise<DeviceSessionServer> {
+  const port = await findAvailablePortAsync();
+  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
+  return {
+    port,
+    turnArgs: Promise.resolve(turnArgs),
+    requiresPreviewRetirement: false,
+    async startAsync({ command, args, env, logger, secrets, stopGracePeriodMs }) {
+      return spawnDetached({ command, args, env, logger, secrets, stopGracePeriodMs });
+    },
+    // A cold launch either returns its handle or starts no process.
+    async stopAsync() {},
+  };
+}
+
+/** Without a server, the host launches a cold one. */
 export async function startDeviceSessionHostAsync(
   ctx: CustomBuildContext,
-  options: DeviceSessionHostOptions
+  options: DeviceSessionHostOptions,
+  server?: DeviceSessionServer
 ): Promise<DeviceSessionHost> {
   if (!options.separateLogPhase) {
-    return await startDeviceSessionHostInternalAsync(ctx, options, () => {}, options.logger);
+    return await startDeviceSessionHostInternalAsync(
+      ctx,
+      options,
+      () => {},
+      options.logger,
+      server
+    );
   }
   const phase = startLogPhase(options.logger, 'Simulator preview');
   let ready = false;
@@ -420,7 +486,8 @@ export async function startDeviceSessionHostAsync(
       { ...options, logger: phase.logger },
       successful =>
         phase.end(ready && successful ? BuildPhaseResult.SUCCESS : BuildPhaseResult.FAIL),
-      options.logger
+      options.logger,
+      server
     );
     ready = true;
     return host;
@@ -455,9 +522,11 @@ async function startDeviceSessionHostInternalAsync(
     networkCapture = false,
     networkCaptureFields = [],
     bootEnv = {},
+    preview,
   }: DeviceSessionHostOptions,
   onFinished: (successful: boolean) => void,
-  artifactLogger: bunyan
+  artifactLogger: bunyan,
+  providedServer?: DeviceSessionServer
 ): Promise<DeviceSessionHost> {
   signal?.throwIfAborted();
   const isAndroid = runtimePlatform === BuildRuntimePlatform.LINUX;
@@ -509,95 +578,28 @@ async function startDeviceSessionHostInternalAsync(
   const subdomainId = randomBytes(16).toString('hex');
   const previewPageUrl = simulatorPreviewPageUrl(env, subdomainId);
   const sharePageUrl = disableShare ? privatePreviewUrl : previewPageUrl;
-  const port = await findAvailablePortAsync();
+  const server =
+    providedServer ??
+    (isAndroid
+      ? await createAndroidDeviceSessionServerAsync(ctx, { logger })
+      : await createColdIosSessionAsync(ctx, { env, logger, iosSimulatorUdid }));
+  const port = server.port;
   const serverName = isAndroid ? 'expo-device-hub' : 'serve-sim';
   const packageSpec = isAndroid
     ? createExpoDeviceHubPackageSpec(packageVersion)
     : createServeSimPackageSpec(packageVersion);
-  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
-  const localEgress = !isAndroid ? await readLocalEgressHandoffAsync() : null;
-  const previewExec = resolvePackageExec(
-    resolveConfiguredPackageManager(env, PackageManager.NPM),
-    isAndroid
-      ? createExpoDeviceHubArgs({
-          port,
-          device: previewDevice,
-          turnArgs,
-          packageVersion,
-          recordingDirectory: recording?.directory,
-          websiteArgs: websiteOriginArgs(env),
-          frameAncestorArgs: frameAncestorArgs(frameAncestors),
-          corsOriginArgs: corsOriginArgs(corsOrigins),
-        })
-      : createServeSimArgs({
-          port,
-          turnArgs,
-          packageVersion,
-          iosSimulatorUdid: previewDevice,
-          websiteArgs: websiteOriginArgs(env),
-          frameAncestorArgs: frameAncestorArgs(frameAncestors),
-          corsOriginArgs: corsOriginArgs(corsOrigins),
-          // serve-sim adds its bearer token to --share-url; private links are for worker logs only.
-          shareUrl: disableShare ? undefined : previewPageUrl,
-          disableShare,
-          installAppPath: iosSimulatorUdid ? undefined : installAppPath,
-          launchAppIdentifier: iosSimulatorUdid ? undefined : launchAppIdentifier,
-          launchArgs: iosSimulatorUdid ? [] : launchArgs,
-          openUrl: iosSimulatorUdid ? undefined : openUrl,
-          networkCapture,
-          networkCaptureFields,
-          networkCaptureProxy: localEgress
-            ? `http://${LOCAL_EGRESS_PROXY_HOST}:${localEgress.port}`
-            : undefined,
-        })
-  );
-  logger.info(
-    `Launching ${packageSpec} on ${WEB_PREVIEW_HOST}:${port} via ${previewExec.command}.`
-  );
-  // Redact these credentials before forwarding process output to build logs.
-  const secrets = [
-    ...turnArgs.filter((_, index) => turnArgs[index - 1] === '--turn-credential'),
-    ...(recording ? [recording.controlToken] : []),
-  ];
+  const turnArgsResult = asyncResult(server.turnArgs);
   const screenshots = await startDeviceRunSessionScreenshotsAsync(ctx, {
     deviceRunSessionId: getDeviceRunSessionIdOrThrow(env),
     logger: artifactLogger,
   });
-  let previewServer: DetachedProcessHandle;
-  try {
-    signal?.throwIfAborted();
-    previewServer = spawnDetached({
-      command: previewExec.command,
-      args: previewExec.args,
-      env: {
-        ...env,
-        ...bootEnv,
-        ...(isAndroid ? {} : { TMPDIR: serveSimTmpdir, SERVE_SIM_STATE_DIR: serveSimStateDir }),
-        EXPO_DEVICE_HUB_SCREENSHOT_DIRECTORY: screenshots.directory,
-        ...(recording ? { EXPO_DEVICE_HUB_RECORDING_CONTROL_TOKEN: recording.controlToken } : {}),
-        // The Hub would resolve its state directory from the step's env, which may set its own
-        // TMPDIR or state directory, so it writes its token where the host reads it below.
-        ...(isAndroid ? { EXPO_DEVICE_HUB_STATE_DIR } : {}),
-      },
-      // Only an Android host records through expo-device-hub; serve-sim records on iOS.
-      stopGracePeriodMs: recording
-        ? RECORDING_STOP_GRACE_PERIOD_MS
-        : SERVE_SIM_STOP_GRACE_PERIOD_MS,
-      logger,
-      secrets,
-    });
-  } catch (error) {
-    // Nothing was spawned, so nothing can still write into the directory.
-    await screenshots.finishAsync(true);
-    throw error;
-  }
-
   let stagedAppDirectory: string | undefined;
   let simulatorSetup: ReturnType<typeof asyncResult<void>> | undefined;
   const readinessController = new AbortController();
   const readinessSignal = AbortSignal.any([startup.signal, readinessController.signal]);
   let previewToken: string | undefined;
   let previewTask: Promise<DeviceWebPreview> | null = null;
+  const previewRetirementErrors: unknown[] = [];
   let finishTask: Promise<void> | null = null;
   let hostReady = false;
   let sessionPreview: ReturnType<typeof startDeviceRunSessionPreview> | null = null;
@@ -606,86 +608,239 @@ async function startDeviceSessionHostInternalAsync(
   let previewFailed = false;
   let previewActivity: ServeSimActivityPolling | null = null;
 
-  const host: DeviceSessionHost = {
-    openPreviewAsync({ baseDomain, authtoken }) {
-      if (finishTask) {
-        return Promise.reject(
-          new SystemError('Cannot open a preview after session host finalization.')
-        );
-      }
-      if (previewTask) {
-        return previewTask;
-      }
-      const opening = (async (): Promise<DeviceWebPreview> => {
-        const tunnel = await startNgrokTunnelAsync({
-          port,
-          subdomainPrefix: 'web-preview',
-          subdomainId,
-          baseDomain,
-          authtoken,
-          healthCheck: { path: isAndroid ? '/readyz' : '/healthz' },
-          logger,
-        });
-        if (finishTask) {
-          await withDeviceRunSessionTimeoutAsync(
-            { name: 'Late preview tunnel close', timeoutMs: 5_000 },
-            async () => await tunnel.stopAsync()
-          ).catch(err => logger.warn({ err }, 'Could not close a late preview tunnel.'));
-          throw new SystemError('Session host finalized while the preview was opening.');
-        }
-        let closeTask: Promise<void> | null = null;
-        previewFailed = false;
-        return {
-          previewPageUrl,
-          sharePageUrl,
-          apiUrl: tunnel.url,
-          previewToken,
-          closeAsync() {
-            return (closeTask ??= (async () => {
-              try {
-                await tunnel.stopAsync();
-              } finally {
-                if (previewTask === opening) {
-                  previewTask = null;
-                }
-              }
-            })());
-          },
-        };
-      })();
-      previewTask = opening;
-      // A failed tunnel may be retried without restarting capture.
-      void opening.catch(() => {
-        previewFailed = true;
-        if (previewTask === opening) {
-          previewTask = null;
-        }
+  function openPreviewAsync(): Promise<DeviceWebPreview> {
+    if (finishTask) {
+      return Promise.reject(
+        new SystemError('Cannot open a preview after session host finalization.')
+      );
+    }
+    if (previewTask) {
+      return previewTask;
+    }
+    const opening = (async (): Promise<DeviceWebPreview> => {
+      const tunnel = await startNgrokTunnelAsync({
+        port,
+        subdomainPrefix: 'web-preview',
+        subdomainId,
+        baseDomain: preview.baseDomain,
+        authtoken: preview.authtoken,
+        healthCheck: { path: isAndroid ? '/readyz' : '/healthz' },
+        logger,
       });
-      return opening;
-    },
+      if (finishTask) {
+        await withDeviceRunSessionTimeoutAsync(
+          { name: 'Late preview tunnel close', timeoutMs: 5_000 },
+          async () => await tunnel.stopAsync()
+        ).catch(err => {
+          if (server.requiresPreviewRetirement) {
+            previewRetirementErrors.push(err);
+          }
+          logger.warn({ err }, 'Could not close a late preview tunnel.');
+        });
+        throw new SystemError('Session host finalized while the preview was opening.');
+      }
+      let closeTask: Promise<void> | null = null;
+      previewFailed = false;
+      return {
+        previewPageUrl,
+        sharePageUrl,
+        apiUrl: tunnel.url,
+        get previewToken() {
+          return previewToken;
+        },
+        closeAsync() {
+          return (closeTask ??= (async () => {
+            try {
+              await tunnel.stopAsync();
+            } catch (error) {
+              if (server.requiresPreviewRetirement) {
+                previewRetirementErrors.push(error);
+              }
+              throw error;
+            } finally {
+              if (previewTask === opening) {
+                previewTask = null;
+              }
+            }
+          })());
+        },
+      };
+    })();
+    previewTask = opening;
+    // A failed tunnel may be retried without restarting capture.
+    void opening.catch(() => {
+      previewFailed = true;
+      if (previewTask === opening) {
+        previewTask = null;
+      }
+    });
+    return opening;
+  }
+  const earlyPreview = asyncResult(
+    withDeviceRunSessionTimeoutAsync(
+      { name: 'Preview tunnel opening', timeoutMs, signal: startup.signal },
+      async () => await openPreviewAsync()
+    ).catch(error => {
+      if (!finishTask) {
+        startup.abort(error);
+      }
+      throw error;
+    })
+  );
+  function retirePreviewAsync(): Promise<boolean> {
+    return withDeviceRunSessionTimeoutAsync(
+      { name: 'Preview tunnel retirement', timeoutMs: 5_000 },
+      async () => {
+        const preview = await previewTask?.catch(() => null);
+        await preview?.closeAsync();
+      }
+    ).then(
+      () => true,
+      err => {
+        if (server.requiresPreviewRetirement && !previewRetirementErrors.includes(err)) {
+          previewRetirementErrors.push(err);
+        }
+        logger.warn(
+          { err },
+          `Could not close the ${serverName} preview tunnel within its deadline.`
+        );
+        return false;
+      }
+    );
+  }
+  const secrets: string[] = [];
+  let previewServer: DetachedProcessHandle;
+  try {
+    const turnArgs = (await turnArgsResult).enforceValue();
+    const localEgress = !isAndroid ? await readLocalEgressHandoffAsync() : null;
+    const previewExec = resolvePackageExec(
+      resolveConfiguredPackageManager(env, PackageManager.NPM),
+      isAndroid
+        ? createExpoDeviceHubArgs({
+            port,
+            device: previewDevice,
+            turnArgs,
+            packageVersion,
+            recordingDirectory: recording?.directory,
+            websiteArgs: websiteOriginArgs(env),
+            frameAncestorArgs: frameAncestorArgs(frameAncestors),
+            corsOriginArgs: corsOriginArgs(corsOrigins),
+          })
+        : createServeSimArgs({
+            port,
+            turnArgs,
+            packageVersion,
+            iosSimulatorUdid: previewDevice,
+            websiteArgs: websiteOriginArgs(env),
+            frameAncestorArgs: frameAncestorArgs(frameAncestors),
+            corsOriginArgs: corsOriginArgs(corsOrigins),
+            // serve-sim adds its bearer token to --share-url; private links are for worker logs only.
+            shareUrl: disableShare ? undefined : previewPageUrl,
+            disableShare,
+            installAppPath: iosSimulatorUdid ? undefined : installAppPath,
+            launchAppIdentifier: iosSimulatorUdid ? undefined : launchAppIdentifier,
+            launchArgs: iosSimulatorUdid ? [] : launchArgs,
+            openUrl: iosSimulatorUdid ? undefined : openUrl,
+            networkCapture,
+            networkCaptureFields,
+            networkCaptureProxy: localEgress
+              ? `http://${LOCAL_EGRESS_PROXY_HOST}:${localEgress.port}`
+              : undefined,
+          })
+    );
+    logger.info(
+      `Launching ${packageSpec} on ${WEB_PREVIEW_HOST}:${port} via ${previewExec.command}.`
+    );
+    // Redact these credentials before forwarding process output to build logs.
+    secrets.push(
+      ...turnArgs.filter((_, index) => turnArgs[index - 1] === '--turn-credential'),
+      ...(recording ? [recording.controlToken] : [])
+    );
+    startup.signal.throwIfAborted();
+    const launchOptions = {
+      command: previewExec.command,
+      args: previewExec.args,
+      env: {
+        ...env,
+        ...bootEnv,
+        ...(isAndroid ? {} : { TMPDIR: serveSimTmpdir, SERVE_SIM_STATE_DIR: serveSimStateDir }),
+        EXPO_DEVICE_HUB_SCREENSHOT_DIRECTORY: screenshots.directory,
+        ...(recording ? { EXPO_DEVICE_HUB_RECORDING_CONTROL_TOKEN: recording.controlToken } : {}),
+        // The Hub must write its token in the directory read by this host.
+        ...(isAndroid ? { EXPO_DEVICE_HUB_STATE_DIR } : {}),
+      },
+      logger,
+    };
+    previewServer = await server.startAsync({
+      ...launchOptions,
+      signal: startup.signal,
+      secrets,
+      // Only an Android host records through expo-device-hub; serve-sim records on iOS.
+      stopGracePeriodMs: recording
+        ? RECORDING_STOP_GRACE_PERIOD_MS
+        : SERVE_SIM_STOP_GRACE_PERIOD_MS,
+    });
+  } catch (error) {
+    startup.abort(error);
+    // Mark the opening tunnel as retired; its late-open path closes it.
+    finishTask = Promise.resolve();
+    await Promise.allSettled([simulatorSetup, retirePreviewAsync()]);
+    let hostStopped = true;
+    try {
+      await server.stopAsync();
+    } catch (stopError) {
+      hostStopped = false;
+      logger.warn({ err: stopError }, 'Could not stop the session server after startup failed.');
+    }
+    // A warm server may already be writing here even if its adoption command failed.
+    await screenshots.finishAsync(hostStopped);
+    if (previewRetirementErrors.length) {
+      throw new AggregateError(
+        [error, ...previewRetirementErrors],
+        'The warm Simulator preview tunnel could not be closed. Another session cannot start safely.'
+      );
+    }
+    throw error;
+  }
+
+  const host: DeviceSessionHost = {
+    openPreviewAsync,
     getLastPreviewActivityAt() {
       return previewActivity?.getLastActivityObservedAt();
     },
     finishAsync() {
       readinessController.abort(new Error('Simulator preview ended.'));
-      return (finishTask ??= finishDeviceSessionHostAsync(ctx, {
-        previewTask,
-        stopSessionPreviewAsync: async () => {
-          previewSetupController.abort();
-          await previewSetupTask;
-          await sessionPreview?.stopAsync();
-          await previewActivity?.stopAsync();
-        },
-        previewServer,
-        screenshots,
-        serverName,
-        port,
-        // A host that never answered /readyz has nothing to finalize or upload.
-        recording: hostReady ? recording : null,
-        logger,
-        artifactLogger,
-        onStopped: successful => onFinished(successful && !previewFailed),
-      })
+      return (finishTask ??= (async () => {
+        const previewRetirement = retirePreviewAsync();
+        if (server.requiresPreviewRetirement) {
+          // Confirm the tunnel is closed before stop, so the next session cannot reach this one.
+          await previewRetirement;
+        }
+        await finishDeviceSessionHostAsync(ctx, {
+          previewRetirement,
+          stopSessionPreviewAsync: async () => {
+            previewSetupController.abort();
+            await previewSetupTask;
+            await sessionPreview?.stopAsync();
+            await previewActivity?.stopAsync();
+          },
+          previewServer,
+          screenshots,
+          serverName,
+          port,
+          // A host that never answered /readyz has nothing to finalize or upload.
+          recording: hostReady ? recording : null,
+          logger,
+          artifactLogger,
+          onStopped: successful => onFinished(successful && !previewFailed),
+        });
+        if (previewRetirementErrors.length) {
+          throw new AggregateError(
+            previewRetirementErrors,
+            'The warm Simulator preview tunnel could not be closed. Another session cannot start safely.'
+          );
+        }
+      })()
         .finally(async () => {
           await simulatorSetup;
           if (stagedAppDirectory) {
@@ -695,6 +850,12 @@ async function startDeviceSessionHostInternalAsync(
         .catch(err => {
           artifactLogger.warn({ err }, 'Could not finish the simulator preview.');
           onFinished(false);
+          if (previewRetirementErrors.length) {
+            throw new AggregateError(
+              [err, ...previewRetirementErrors],
+              'The warm Simulator preview tunnel could not be closed. Another session cannot start safely.'
+            );
+          }
         }));
     },
   };
@@ -713,7 +874,7 @@ async function startDeviceSessionHostInternalAsync(
       })
     );
     if (iosSimulatorUdid) {
-      previewToken = await waitForServeSimControlAsync({
+      const token = await waitForServeSimControlAsync({
         device: iosSimulatorUdid,
         port,
         previewServer,
@@ -721,7 +882,8 @@ async function startDeviceSessionHostInternalAsync(
         timeoutMs: startupTimeoutMs ?? timeoutMs,
         signal: readinessSignal,
       });
-      secrets.push(previewToken);
+      previewToken = token;
+      secrets.push(token);
       if (Object.keys(bootEnv).length > 0) {
         await startup.untilAborted(
           verifyLocalEgressGuardAsync({ udid: iosSimulatorUdid as IosSimulatorUuid, env, logger })
@@ -729,22 +891,16 @@ async function startDeviceSessionHostInternalAsync(
       }
       signal?.throwIfAborted();
       // APSD cleanup runs alongside app startup and readiness; teardown joins the task.
-      simulatorSetup = asyncResult(
-        startup.untilAborted(
-          startup.run('Simulator setup', async taskLogger => {
-            try {
-              await IosSimulatorUtils.disableApsdAsync({
-                udid: iosSimulatorUdid as IosSimulatorUuid,
-                env,
-              });
-            } catch (err) {
-              startup.signal.throwIfAborted();
-              taskLogger.warn({ err }, 'Failed to disable apsd in the Simulator.');
-            }
-            startup.signal.throwIfAborted();
-          })
-        )
-      );
+      const setupSimulatorAsync = server.setupSimulatorAsync;
+      if (setupSimulatorAsync) {
+        simulatorSetup = asyncResult(
+          startup.untilAborted(
+            startup.run('Simulator setup', taskLogger =>
+              setupSimulatorAsync({ signal: startup.signal, logger: taskLogger })
+            )
+          )
+        );
+      }
       const app = (application ? await startup.untilAborted(application) : undefined) ?? {
         installAppPath,
         launchAppIdentifier,
@@ -755,18 +911,39 @@ async function startDeviceSessionHostInternalAsync(
       const action = (name: string, params: Record<string, unknown>) =>
         runServeSimActionAsync({
           port,
-          token: previewToken!,
+          token,
           action: name,
           params,
           timeoutMs: startupTimeoutMs ?? timeoutMs,
           signal: startup.signal,
         });
-      if (app.installAppPath) {
+      // The bundle that has not run yet: just installed, or preinstalled and never launched.
+      let notYetLaunched =
+        !app.installAppPath && app.launchAppIdentifier === server.preinstalledApp?.bundleIdentifier
+          ? server.preinstalledApp?.bundleIdentifier
+          : undefined;
+      if (
+        app.installAppPath &&
+        server.preinstalledApp &&
+        (await isPreinstalledExpoGoAsync({
+          appPath: app.installAppPath,
+          preinstalled: server.preinstalledApp,
+          env,
+        }))
+      ) {
+        logger.info('This Expo Go version is already installed on the Simulator.');
+        notYetLaunched = server.preinstalledApp.bundleIdentifier;
+      } else if (app.installAppPath) {
         const staged = await stageServeSimAppAsync(app.installAppPath, serveSimTmpdir);
         stagedAppDirectory = staged.directory;
         signal?.throwIfAborted();
         await action('app.install', { udid: iosSimulatorUdid, path: staged.path });
+        notYetLaunched = await readIosApplicationIdentifierAsync({
+          artifactPath: app.installAppPath,
+          env,
+        }).catch(() => undefined);
       }
+      startup.signal.throwIfAborted();
       if (app.launchAppIdentifier) {
         signal?.throwIfAborted();
         await action('app.launch', {
@@ -774,6 +951,8 @@ async function startDeviceSessionHostInternalAsync(
           bundleId: app.launchAppIdentifier,
           launchArgs: app.launchArgs ?? [],
           openUrl: app.openUrl,
+          // An app that has not run yet needs no terminate check; any other app keeps it.
+          ...(notYetLaunched === app.launchAppIdentifier ? { restart: false } : {}),
         });
       }
     }
@@ -835,11 +1014,19 @@ async function startDeviceSessionHostInternalAsync(
         logger.warn({ err }, 'Could not start refreshing the session preview.');
       }
     });
+    (await earlyPreview).enforceValue();
     signal?.throwIfAborted();
     return host;
   } catch (error) {
     onStartupError?.(error);
-    await host.finishAsync();
+    try {
+      await host.finishAsync();
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [error, cleanupError],
+        'Device session startup failed, and cleanup also failed.'
+      );
+    }
     throw error;
   }
 }
@@ -888,7 +1075,7 @@ async function waitForServeSimControlAsync({
 async function finishDeviceSessionHostAsync(
   ctx: CustomBuildContext,
   {
-    previewTask,
+    previewRetirement,
     stopSessionPreviewAsync,
     previewServer,
     screenshots,
@@ -899,7 +1086,7 @@ async function finishDeviceSessionHostAsync(
     artifactLogger,
     onStopped,
   }: {
-    previewTask: Promise<DeviceWebPreview> | null;
+    previewRetirement: Promise<boolean>;
     stopSessionPreviewAsync: () => Promise<void>;
     previewServer: DetachedProcessHandle;
     screenshots: { finishAsync(hostStopped: boolean): Promise<void> };
@@ -914,21 +1101,6 @@ async function finishDeviceSessionHostAsync(
   // Stop capturing before the host stops, so the last thumbnail shows the session, not shutdown.
   await stopSessionPreviewAsync();
   const hostExited = previewServer.getExitError() !== undefined;
-  // Native ngrok operations have no scoped cancellation. Retire a late listener too.
-  const retirePreview = withDeviceRunSessionTimeoutAsync(
-    { name: 'Preview tunnel retirement', timeoutMs: 5_000 },
-    async () => {
-      // A preview that failed to open, or was closed by its opener after finish began, has no tunnel left.
-      const preview = await previewTask?.catch(() => null);
-      await preview?.closeAsync();
-    }
-  ).then(
-    () => true,
-    err => {
-      logger.warn({ err }, `Could not close the ${serverName} preview tunnel within its deadline.`);
-      return false;
-    }
-  );
   let finalization: AndroidRecordingFinalization | null = null;
   if (recording) {
     // stopAsync signals the whole process group, including capture's encoder.
@@ -949,7 +1121,7 @@ async function finishDeviceSessionHostAsync(
   } catch (err) {
     logger.warn({ err }, `Could not stop the ${serverName} session host.`);
   }
-  const previewRetired = await retirePreview;
+  const previewRetired = await previewRetirement;
   onStopped(hostStopped && !hostExited && previewRetired);
   await screenshots.finishAsync(hostStopped);
   // A Hub that never recorded has logged its reason and left nothing to upload.

packages/build-tools/src/steps/utils/iosAppArtifact.ts

@@ -39,3 +39,54 @@ export async function readIosApplicationIdentifierAsync({
   }
   return applicationIdentifier;
 }
+
+const EXPO_GO_BUNDLE_IDENTIFIER = 'host.exp.Exponent';
+
+export type IosAppIdentity = { bundleIdentifier: string; shortVersion: string; version: string };
+
+/**
+ * Expo Go releases are identified by their version, so a preinstalled copy with the same version is
+ * the same app. Custom builds can reuse a version, so they are always installed.
+ */
+export async function isPreinstalledExpoGoAsync({
+  appPath,
+  preinstalled,
+  env,
+}: {
+  appPath: string;
+  preinstalled: IosAppIdentity;
+  env: BuildStepEnv;
+}): Promise<boolean> {
+  if (preinstalled.bundleIdentifier !== EXPO_GO_BUNDLE_IDENTIFIER) {
+    return false;
+  }
+  try {
+    const requested = await readIosAppIdentityAsync(appPath, env);
+    return (
+      requested.bundleIdentifier === preinstalled.bundleIdentifier &&
+      requested.shortVersion === preinstalled.shortVersion &&
+      requested.version === preinstalled.version
+    );
+  } catch {
+    // An app that cannot be read is installed as usual.
+    return false;
+  }
+}
+
+async function readIosAppIdentityAsync(
+  appPath: string,
+  env: BuildStepEnv
+): Promise<IosAppIdentity> {
+  const infoPlistPath = path.join(appPath, 'Info.plist');
+  const [bundleIdentifier, shortVersion, version] = await Promise.all(
+    ['CFBundleIdentifier', 'CFBundleShortVersionString', 'CFBundleVersion'].map(async key =>
+      (
+        await spawn('plutil', ['-extract', key, 'raw', '-o', '-', infoPlistPath], {
+          stdio: 'pipe',
+          env,
+        })
+      ).stdout.trim()
+    )
+  );
+  return { bundleIdentifier, shortVersion, version };
+}

packages/build-tools/src/steps/utils/remoteDeviceRunSession.ts

@@ -607,7 +607,7 @@ export function isProcessRunning(pid: number): boolean {
   }
 }
 
-async function stopDetachedProcessAsync(
+export async function stopDetachedProcessAsync(
   pid: number | undefined,
   gracePeriodMs = 5_000
 ): Promise<void> {
@@ -773,7 +773,7 @@ export function createIosSessionStartupInputProviders(): ReturnType<
 }
 
 export type ServeSimApplicationOptions = ServeSimLaunchOptions & {
-  installAppPath: string;
+  installAppPath?: string;
   launchAppIdentifier: string;
 };
 

packages/build-tools/src/steps/utils/warmDeviceSessionHost.ts

@@ -0,0 +1,95 @@
+import type { bunyan } from '@expo/logger';
+import spawn from '@expo/turtle-spawn';
+
+import { type CustomBuildContext } from '../../customBuildContext';
+import { IosSimulatorRecordingUtils } from './IosSimulatorRecordingUtils';
+import { type DeviceSessionServer } from './deviceSessionHost';
+import { fetchWebPreviewTurnArgsAsync } from './remoteDeviceRunSession';
+import { type WarmIosSession, tryClaimWarmIosSessionAsync } from './warmIosSession';
+
+/** Adoption failed before app actions, so the caller can stop warmup and start cold. */
+export class WarmSessionAdoptionError extends Error {
+  constructor() {
+    // The adoption command line includes TURN credentials, so the cause stays out of the message.
+    super('Could not adopt the warm Simulator for this job.');
+    this.name = 'WarmSessionAdoptionError';
+  }
+}
+
+/** A session server that adopts the warm serve-sim for the job's device instead of launching one. */
+export function createWarmDeviceSessionServer(
+  ctx: CustomBuildContext,
+  logger: bunyan,
+  warm: WarmIosSession
+): DeviceSessionServer {
+  const { udid, name } = warm.device;
+  async function stopAsync(): Promise<void> {
+    await warm.process.stopAsync();
+  }
+  return {
+    port: warm.server.port,
+    turnArgs: fetchWebPreviewTurnArgsAsync(ctx, { logger }),
+    // Set by prepare-tools, which the host runs before it installs the app.
+    get preinstalledApp() {
+      return warm.preinstalledExpoGo;
+    },
+    requiresPreviewRetirement: true,
+    stopAsync,
+    async startAsync({ command, args, env, signal }) {
+      try {
+        // serve-sim starts this job's recording when it adopts the device.
+        const recording = await IosSimulatorRecordingUtils.prepareAdoptedRecordingAsync({
+          udid,
+          deviceName: name,
+          serverToken: warm.server.token,
+        });
+        const recordingArgs = recording
+          ? ['--recording-output', recording.output, '--recording-id', recording.recordingId]
+          : [];
+        const timeout = AbortSignal.timeout(360_000);
+        await spawn(command, [...args, '--single-device', udid, '--adopt', ...recordingArgs], {
+          env,
+          stdio: 'pipe',
+          signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+        });
+        await warm.prepareToolsAsync(signal);
+      } catch {
+        signal?.throwIfAborted();
+        throw new WarmSessionAdoptionError();
+      }
+      return { ...warm.process, stopAsync };
+    },
+  };
+}
+
+/**
+ * Runs an iOS session on the warm Simulator when the job can claim it, else cold. After a
+ * callback failure, it stops warmup. Only an adoption failure can retry cold.
+ */
+export async function runOnWarmIosSimulatorAsync<T>(
+  claim: Parameters<typeof tryClaimWarmIosSessionAsync>[0],
+  run: (warm?: WarmIosSession) => Promise<T>
+): Promise<T> {
+  const warm = await tryClaimWarmIosSessionAsync(claim);
+  if (!warm) {
+    return await run(undefined);
+  }
+  try {
+    return await run(warm);
+  } catch (error) {
+    try {
+      await warm.process.stopAsync();
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [error, cleanupError],
+        'Could not stop the warm Simulator after failure.'
+      );
+    }
+    if (!(error instanceof WarmSessionAdoptionError)) {
+      throw error;
+    }
+    claim.logger.warn('Could not adopt the warm Simulator; starting a cold Simulator.');
+    claim.signal?.throwIfAborted();
+    return await run(undefined);
+  }
+}

packages/build-tools/src/steps/utils/warmIosSession.ts

@@ -0,0 +1,119 @@
+import { type bunyan } from '@expo/logger';
+import { type BuildStepEnv } from '@expo/steps';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+
+import { runSimulatorLauncherAsync, stopWarmSimulatorAsync } from '../../utils/warmSimulator';
+import { readLocalEgressHandoffAsync } from './localEgress';
+import { type DetachedProcessHandle, isProcessRunning } from './remoteDeviceRunSession';
+
+const ServiceSchema = z.object({ pid: z.number(), port: z.number(), token: z.string() });
+const ClaimSchema = z.object({
+  device: z.object({ udid: z.string(), name: z.string() }),
+  server: ServiceSchema,
+  agentDeviceStateDir: z.string(),
+  argentEventLogPath: z.string(),
+  preinstalledExpoGo: z
+    .object({ bundleIdentifier: z.string(), shortVersion: z.string(), version: z.string() })
+    .optional(),
+});
+
+type Service = z.infer<typeof ServiceSchema>;
+
+/** The warm Simulator that the launcher handed to this job. */
+export type WarmIosSession = z.infer<typeof ClaimSchema> & {
+  /** The selected tool's server; set by prepareToolsAsync. */
+  tools?: Service;
+  /** Runs after adoption: the launcher prepares the selected tool for the adopted device. */
+  prepareToolsAsync(signal?: AbortSignal): Promise<void>;
+  process: DetachedProcessHandle;
+};
+
+/**
+ * Claims the warm Simulator. The launcher checks the session; build-tools only uses it. On any
+ * failure, warmup stops and the caller uses a cold start; a failed stop rejects.
+ */
+export async function tryClaimWarmIosSessionAsync({
+  engine,
+  requestedDevice,
+  packageVersion,
+  env,
+  logger,
+  signal,
+}: {
+  engine: 'serve-sim' | 'agent-device' | 'argent' | 'appium';
+  requestedDevice?: string;
+  packageVersion?: string;
+  env: BuildStepEnv;
+  logger: bunyan;
+  signal?: AbortSignal;
+}): Promise<WarmIosSession | undefined> {
+  if (env.EAS_USE_WARM_SIMULATOR !== '1') {
+    return undefined;
+  }
+  try {
+    // Warm tools run the latest release with the VM's Simulator settings.
+    if (packageVersion && packageVersion !== 'latest') {
+      throw new Error('A pinned package_version needs a cold start.');
+    }
+    const setting = Object.keys(env).find(
+      name => name === 'SERVE_SIM_ADDITIONAL_DYLIBS' || name.startsWith('SIMCTL_CHILD_')
+    );
+    if (setting) {
+      throw new Error(`${setting} needs a cold start.`);
+    }
+    if (await readLocalEgressHandoffAsync()) {
+      throw new Error('A local egress session needs a cold start.');
+    }
+    logger.info('Waiting for the warm Simulator launcher.');
+    const claimArgs = ['claim', engine, ...(requestedDevice ? [requestedDevice] : [])];
+    const claim = ClaimSchema.parse(
+      JSON.parse(await runSimulatorLauncherAsync(claimArgs, { env, signal }))
+    );
+    logger.info(`Claimed the warm Simulator ${claim.device.name} (${claim.device.udid}).`);
+    let stopping: Promise<void> | undefined;
+    const session: WarmIosSession = {
+      ...claim,
+      async prepareToolsAsync(prepareSignal = signal) {
+        const prepared = ClaimSchema.pick({ preinstalledExpoGo: true })
+          .extend({ tools: ServiceSchema.optional() })
+          .parse(
+            JSON.parse(
+              await runSimulatorLauncherAsync(['prepare-tools'], { env, signal: prepareSignal })
+            )
+          );
+        // The launcher reports the Expo Go it preinstalled once its install has finished.
+        session.preinstalledExpoGo = prepared.preinstalledExpoGo ?? session.preinstalledExpoGo;
+        if (engine === 'agent-device') {
+          const daemon = z
+            .object({ pid: z.number(), httpPort: z.number(), token: z.string() })
+            .parse(await readJsonAsync(path.join(claim.agentDeviceStateDir, 'daemon.json')));
+          session.tools = { pid: daemon.pid, port: daemon.httpPort, token: daemon.token };
+        } else if (engine === 'argent') {
+          session.tools = ServiceSchema.parse(prepared.tools);
+        }
+      },
+      process: {
+        pid: claim.server.pid,
+        getOutput: () => '',
+        getExitError: () =>
+          isProcessRunning(claim.server.pid) &&
+          (!session.tools || isProcessRunning(session.tools.pid))
+            ? undefined
+            : new Error('A service of the warm Simulator session has exited.'),
+        stopAsync: () => (stopping ??= stopWarmSimulatorAsync(env)),
+      },
+    };
+    return session;
+  } catch (error) {
+    logger.warn({ err: error }, 'Could not use the warm Simulator; stopping it for a cold start.');
+    await stopWarmSimulatorAsync(env);
+    signal?.throwIfAborted();
+    return undefined;
+  }
+}
+
+async function readJsonAsync(file: string): Promise<unknown> {
+  return JSON.parse(await fs.readFile(file, 'utf8'));
+}

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

@@ -0,0 +1,61 @@
+import spawn from '@expo/turtle-spawn';
+import fs from 'node:fs/promises';
+
+import { runSimulatorLauncherAsync, stopWarmSimulatorAsync } from '../warmSimulator';
+
+jest.mock('@expo/turtle-spawn');
+
+const originalPlatform = process.platform;
+
+beforeEach(() => {
+  Object.defineProperty(process, 'platform', { value: 'darwin' });
+  jest.resetAllMocks();
+  jest.mocked(spawn).mockResolvedValue({ stdout: '{"ok":true}' } as never);
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  Object.defineProperty(process, 'platform', { value: originalPlatform });
+});
+
+it('runs the launcher version that start recorded and returns its output', async () => {
+  jest.spyOn(fs, 'readFile').mockResolvedValue('{"launcherVersion":"27.1.0"}');
+  await expect(runSimulatorLauncherAsync(['claim', 'serve-sim'], { env: {} })).resolves.toBe(
+    '{"ok":true}'
+  );
+  expect(spawn).toHaveBeenCalledWith(
+    'bun',
+    ['x', '@expo/[email protected]', 'claim', 'serve-sim'],
+    expect.objectContaining({ stdio: 'pipe' })
+  );
+  expect(jest.mocked(spawn).mock.calls[0][2]).not.toHaveProperty('logger');
+});
+
+it.each([
+  [{}, 'bun', ['x']],
+  [{ EAS_OVERRIDE_PACKAGE_MANAGER: 'npm' }, 'npx', ['--yes']],
+])(
+  'stops with the latest launcher and the configured package manager for %j',
+  async (env, command, prefix) => {
+    jest
+      .spyOn(fs, 'readFile')
+      .mockRejectedValue(Object.assign(new Error('missing'), { code: 'ENOENT' }));
+    await stopWarmSimulatorAsync(env);
+    expect(spawn).toHaveBeenCalledWith(
+      command,
+      [...prefix, '@expo/simulator-launcher@latest', 'stop'],
+      expect.objectContaining({ env })
+    );
+  }
+);
+
+it('rejects when the launcher cannot confirm cleanup', async () => {
+  jest.spyOn(fs, 'readFile').mockResolvedValue('{}');
+  jest.mocked(spawn).mockRejectedValue(new Error('cleanup failed'));
+  await expect(stopWarmSimulatorAsync({})).rejects.toThrow('cleanup failed');
+});
+
+it('does nothing on other platforms', async () => {
+  Object.defineProperty(process, 'platform', { value: 'linux' });
+  await stopWarmSimulatorAsync({});
+  expect(spawn).not.toHaveBeenCalled();
+});

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

@@ -121,7 +121,7 @@ export async function uploadApplicationArchive(
     patternOrPath: string;
     rootDir: string;
   }
-): Promise<void> {
+): Promise<string[]> {
   const applicationArchives = await findArtifacts({ rootDir, patternOrPath, logger });
   const artifactsSizes = await getArtifactsSizes(applicationArchives);
   logger.info(`Application archives:`);
@@ -137,6 +137,8 @@ export async function uploadApplicationArchive(
     },
     logger,
   });
+
+  return applicationArchives;
 }
 
 async function getArtifactsSizes(artifacts: string[]): Promise<Record<string, number | undefined>> {

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

@@ -0,0 +1,39 @@
+import { type BuildStepEnv } from '@expo/steps';
+import spawn from '@expo/turtle-spawn';
+import fs from 'node:fs/promises';
+
+import {
+  PackageManager,
+  resolveConfiguredPackageManager,
+  resolvePackageExec,
+} from './packageManager';
+
+/**
+ * Runs a Simulator launcher command with the version that `start` recorded, which warmup cached.
+ * The output can contain credentials, so it is returned and never logged.
+ */
+export async function runSimulatorLauncherAsync(
+  launcherArgs: string[],
+  { env, signal }: { env: BuildStepEnv; signal?: AbortSignal }
+): Promise<string> {
+  const version = await fs
+    .readFile('/tmp/expo-simulator-startup.json', 'utf8')
+    .then(text => JSON.parse(text).launcherVersion)
+    .catch(() => undefined);
+  const { command, args } = resolvePackageExec(
+    resolveConfiguredPackageManager(env, PackageManager.BUN),
+    [
+      `@expo/simulator-launcher@${typeof version === 'string' ? version : 'latest'}`,
+      ...launcherArgs,
+    ]
+  );
+  const { stdout } = await spawn(command, args, { env, stdio: 'pipe', signal, timeout: 425_000 });
+  return stdout;
+}
+
+/** Stops warmup; resolves only after the launcher confirms cleanup. */
+export async function stopWarmSimulatorAsync(env: BuildStepEnv): Promise<void> {
+  if (process.platform === 'darwin') {
+    await runSimulatorLauncherAsync(['stop'], { env });
+  }
+}

packages/create-eas-build-function/CHANGELOG.md

@@ -1,5 +1,13 @@
 # create-eas-build-function
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

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

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

packages/downloader/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/downloader
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/downloader/package.json

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

packages/eas-build-cache-provider/CHANGELOG.md

@@ -1,5 +1,13 @@
 # eas-build-cache-provider
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

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

@@ -1,6 +1,6 @@
 {
   "name": "eas-build-cache-provider",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "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/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/eas-build-job
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 ### Minor Changes

packages/eas-build-job/package.json

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

packages/eas-cli/CHANGELOG.md

@@ -1,5 +1,15 @@
 # eas-cli
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+### Patch Changes
+
+- Show the Expo Simulators hint after a successful build from November 10 instead of November 5. ([#4801](https://github.com/expo/eas-cli/pull/4801) by [@williamgrosset](https://github.com/williamgrosset))
+
 ## 27.3.0
 
 ### Patch Changes

packages/eas-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eas-cli",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "description": "EAS command line tool",
   "keywords": [
     "cli",
@@ -48,12 +48,12 @@
     "@expo/code-signing-certificates": "0.0.5",
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/eas-build-job": "27.3.0",
-    "@expo/eas-json": "27.3.0",
+    "@expo/eas-build-job": "27.4.1",
+    "@expo/eas-json": "27.4.1",
     "@expo/env": "^1.0.0",
     "@expo/experimentation": "0.0.5",
     "@expo/json-file": "8.3.3",
-    "@expo/logger": "27.3.0",
+    "@expo/logger": "27.4.1",
     "@expo/multipart-body-parser": "2.0.0",
     "@expo/osascript": "2.1.4",
     "@expo/package-manager": "1.9.10",
@@ -65,7 +65,7 @@
     "@expo/results": "1.0.0",
     "@expo/rudder-sdk-node": "1.1.1",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "27.3.0",
+    "@expo/steps": "27.4.1",
     "@expo/timeago.js": "1.0.0",
     "@oclif/core": "^4.8.3",
     "@oclif/plugin-autocomplete": "^3.2.40",

packages/eas-cli/src/build/simulatorsLaunchHint.ts

@@ -8,7 +8,7 @@ import Log, { link } from '../log';
 import { LoggedInAuthenticationInfo } from '../user/SessionManager';
 import { Actor } from '../user/User';
 
-const SIMULATORS_LAUNCH_AT = new Date('2026-11-05T18:00:00Z');
+const SIMULATORS_LAUNCH_AT = new Date('2026-11-10T18:00:00Z');
 const SIMULATORS_LAUNCH_HINT_PREFERENCE_KEY = 'simulators-launch-cli-hint-seen';
 const REQUEST_TIMEOUT_MS = 3000;
 const SIMULATORS_QUICKSTART_URL =

packages/eas-json/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/eas-json
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/eas-json/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/eas-json",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "description": "A library for interacting with eas.json",
   "homepage": "https://github.com/expo/eas-cli",
   "bugs": "https://github.com/expo/eas-cli/issues",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@babel/code-frame": "7.23.5",
-    "@expo/eas-build-job": "27.3.0",
+    "@expo/eas-build-job": "27.4.1",
     "chalk": "4.1.2",
     "env-string": "1.0.1",
     "fs-extra": "11.2.0",

packages/local-build-plugin/CHANGELOG.md

@@ -1,5 +1,13 @@
 # eas-cli-local-build-plugin
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/local-build-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eas-cli-local-build-plugin",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "description": "Tool for running EAS compatible builds on a local machine.",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
@@ -26,12 +26,12 @@
     "clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
   },
   "dependencies": {
-    "@expo/build-tools": "27.3.0",
+    "@expo/build-tools": "27.4.1",
     "@expo/bunyan": "^4.0.1",
-    "@expo/eas-build-job": "27.3.0",
-    "@expo/logger": "27.3.0",
+    "@expo/eas-build-job": "27.4.1",
+    "@expo/logger": "27.4.1",
     "@expo/spawn-async": "^1.7.2",
-    "@expo/turtle-spawn": "27.3.0",
+    "@expo/turtle-spawn": "27.4.1",
     "chalk": "4.1.2",
     "env-paths": "^2.2.1",
     "fs-extra": "^11.2.0",

packages/logger/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/logger
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/logger/package.json

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

packages/simulator-launcher/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @expo/simulator-launcher
 
+## 27.4.1
+
+### Patch Changes
+
+- Wait for a starting warm Simulator launcher before claiming its session, instead of falling back to a cold start. ([#4810](https://github.com/expo/eas-cli/pull/4810) by [@gwdp](https://github.com/gwdp))
+
+## 27.4.0
+
+### Minor Changes
+
+- Add `eas/start_warm_appium_remote_session`, which runs the Appium session on the warm Simulator, or starts cold. An `appium` claim stops the unused tools first, so WDA does not share the Simulator with the agent-device runner. ([#4735](https://github.com/expo/eas-cli/pull/4735) by [@gwdp](https://github.com/gwdp))
+
 ## 27.3.0
 
 No changes in this release.

packages/simulator-launcher/README.md

@@ -15,11 +15,11 @@ exec bunx @expo/simulator-launcher@latest start
 - `start`: run one orphan serve-sim for the configured devices. Its default device becomes ready
   first; additional devices warm in the background. Argent and agent-device prestart on the default.
 - `claim ENGINE [DEVICE]`: reserve one job and return its selected device plus the existing server's
-  identity, port and credentials. Engines: `serve-sim`, `agent-device`, `argent`.
+  identity, port and credentials. Engines: `serve-sim`, `agent-device`, `argent`, `appium`.
   No DEVICE means the first configured device. Claim does not boot the selected device or wait for
   its tool. Build-tools privately adopts that device on the existing serve-sim port.
 - `prepare-tools`: continue the consumed claim after adoption. Keep global Argent, reuse the default
-  agent-device runner or prepare a runner for the selected device.
+  agent-device runner or prepare a runner for the selected device. Appium waits for old XCTest cleanup.
 - `stop`: permanently end warmup for this boot and wait for all owned resources to be cleaned up.
 
 ```sh
@@ -66,6 +66,7 @@ serializes updates; an abandoned lock fails closed. This private format requires
   and app actions. Job-time version and authentication checks remain authoritative.
 - Agent-device prestarts on the default device only. A secondary claim prepares its runner after
   adoption and old-runner cleanup finish. One device-independent Argent server is reused for the claimed device.
+  Appium waits for unused tools to stop before starting its own WDA.
 - Warmup downloads/extracts the latest stable Expo Go once and reuses it for the second device.
   Each initial device gets a preinstall attempt; ordinary failures warn. Claim prevents new
   preinstalls. `prepare-tools` waits for an install still running on the claimed device and

packages/simulator-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/simulator-launcher",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "description": "Launch and claim Simulator sessions on EAS workers",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",

packages/simulator-launcher/src/__tests__/main.test.ts

@@ -325,7 +325,7 @@ test('stop during post-adopt preparation prevents toolsReady and waits for owned
   const [completion] = await beginSession();
   await status('ready');
   jest.spyOn(process.stdout, 'write').mockReturnValue(true);
-  await claimAsync(boot, 'serve-sim');
+  await claimAsync(boot, 'appium');
   const entered = deferred();
   const release = deferred();
   let preparationSignal: AbortSignal;

packages/simulator-launcher/src/__tests__/simulatorSession.test.ts

@@ -377,6 +377,42 @@ it('keeps global Argent when selecting another device', async () => {
   await session.stopAsync();
 });
 
+it.each(['appium'] as const)(
+  'does not finish %s preparation before unused tool cleanup settles',
+  async engine => {
+    const retirement = deferred();
+    jest.mocked(stopProcessAndDescendantsAsync).mockImplementation(async handle => {
+      if (handle === agent) {
+        await retirement.promise;
+      }
+    });
+    const session = createSession();
+    await session.prepareAsync();
+    await session.claimAsync({ engine });
+    let ready = false;
+    const preparing = session.prepareToolsAsync().then(() => {
+      ready = true;
+    });
+    await new Promise(resolve => setImmediate(resolve));
+    expect(ready).toBe(false);
+    retirement.resolve();
+    await preparing;
+    await session.stopAsync();
+  }
+);
+
+it('Appium preparation rejects failed XCTest retirement and terminal stop retries the owned resources', async () => {
+  const failure = new Error('XCTest stop failed');
+  jest.mocked(stopProcessAndDescendantsAsync).mockRejectedValueOnce(failure);
+  const session = createSession();
+  await session.prepareAsync();
+  await session.claimAsync({ engine: 'appium' });
+  await expect(session.prepareToolsAsync()).rejects.toThrow();
+  // The terminal stop retries XCTest; that retry succeeds here, so the stop does too.
+  await session.stopAsync();
+  expect(shutdownSimulatorAsync).toHaveBeenCalledWith('DUO');
+});
+
 it('rejects a changed server identity before starting the selected runner', async () => {
   const session = createSession();
   await session.prepareAsync();

packages/simulator-launcher/src/__tests__/state.test.ts

@@ -4,13 +4,14 @@ import path from 'node:path';
 
 import { claimAsync } from '../commands/claim';
 import { stopAsync } from '../commands/stop';
+import * as launcherState from '../utils/state';
 import {
   LAUNCHER_STATE_FILE,
   readLauncherStateAsync,
   updateLauncherStateAsync,
   waitForLauncherStateAsync,
 } from '../utils/state';
-import { deferred } from './helpers';
+import { deferred, until } from './helpers';
 
 const boot = 'boot-one';
 let root: string;
@@ -30,6 +31,7 @@ const info = {
   argentEventLogPath: '/argent/events',
 };
 const directory = () => path.join(root, 'control');
+const pollLauncherStateAsync = waitForLauncherStateAsync;
 
 const nativeFs = {
   readFile: fs.readFile.bind(fs),
@@ -46,6 +48,7 @@ const remap = (file: unknown): unknown =>
     : file;
 
 beforeEach(async () => {
+  jest.spyOn(process.stderr, 'write').mockReturnValue(true);
   root = await fs.mkdtemp(path.join(os.tmpdir(), 'launcher-state-'));
   jest.spyOn(os, 'homedir').mockReturnValue(root);
   await fs.mkdir(path.join(root, 'control'));
@@ -192,6 +195,7 @@ test('two job claims acquire only one ready session and the result includes its
   await updateLauncherStateAsync(boot, state => ({ ...state!, status: 'claimed' }));
   await Promise.all(claims);
   expect(results.filter(value => value === 0)).toHaveLength(1);
+  expect(process.stderr.write).not.toHaveBeenCalled();
   expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({
     ...info,
     status: 'claimed',
@@ -200,6 +204,252 @@ test('two job claims acquire only one ready session and the result includes its
   await expect(claimAsync(boot, 'serve-sim')).rejects.toThrow('available');
 });
 
+async function beginStartingClaimAsync(engine = 'serve-sim') {
+  let observedStarting = false;
+  jest
+    .spyOn(launcherState, 'waitForLauncherStateAsync')
+    .mockImplementationOnce((bootUuid, isComplete, timeoutMs) =>
+      pollLauncherStateAsync(
+        bootUuid,
+        state => {
+          const complete = isComplete(state);
+          observedStarting ||= state?.status === 'starting';
+          return complete;
+        },
+        timeoutMs
+      )
+    );
+  const result = claimAsync(boot, engine, 'iPhone 17').then(
+    value => value,
+    error => error as Error
+  );
+  await until(() => observedStarting);
+  return { result };
+}
+
+test('a claim waits for the minimal starting record to become ready without changing it', async () => {
+  const starting = {
+    bootUuid: boot,
+    status: 'starting' as const,
+    controllerPid: info.controllerPid,
+    launcherVersion: '27.4.0',
+  };
+  await updateLauncherStateAsync(boot, () => starting);
+  const output = jest.spyOn(process.stdout, 'write').mockReturnValue(true);
+  const { result } = await beginStartingClaimAsync();
+  expect(await readLauncherStateAsync(boot)).toEqual(starting);
+  expect(await fs.readdir(directory())).toEqual([path.basename(LAUNCHER_STATE_FILE)]);
+  expect(output).not.toHaveBeenCalled();
+
+  await updateLauncherStateAsync(boot, state => ({ ...state!, ...info, status: 'ready' }));
+  await waitForLauncherStateAsync(boot, state => state?.status === 'claiming', 1_000);
+  await updateLauncherStateAsync(boot, state => ({ ...state!, status: 'claimed' }));
+  expect(await result).toBe(0);
+  expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({
+    ...info,
+    status: 'claimed',
+    engine: 'serve-sim',
+    requestedDevice: 'iPhone 17',
+  });
+});
+
+test('two claims waiting for startup still acquire only one session', async () => {
+  await updateLauncherStateAsync(boot, () => ({
+    bootUuid: boot,
+    status: 'starting',
+    controllerPid: info.controllerPid,
+  }));
+  jest.spyOn(process.stdout, 'write').mockReturnValue(true);
+  const first = await beginStartingClaimAsync();
+  const second = await beginStartingClaimAsync('argent');
+  await updateLauncherStateAsync(boot, state => ({ ...state!, ...info, status: 'ready' }));
+  await waitForLauncherStateAsync(boot, state => state?.status === 'claiming', 1_000);
+  await updateLauncherStateAsync(boot, state => ({ ...state!, status: 'claimed' }));
+  const results = await Promise.all([first.result, second.result]);
+  expect(results.filter(value => value === 0)).toHaveLength(1);
+  expect(results.filter(value => value instanceof Error)).toHaveLength(1);
+});
+
+test('startup wait progress is throttled and stdout remains the claim JSON', async () => {
+  let now = 0;
+  jest.spyOn(Date, 'now').mockImplementation(() => now);
+  const output = jest.spyOn(process.stdout, 'write').mockReturnValue(true);
+  const progress = jest.mocked(process.stderr.write);
+  await updateLauncherStateAsync(boot, () => ({
+    bootUuid: boot,
+    status: 'starting',
+    controllerPid: info.controllerPid,
+  }));
+  const { result } = await beginStartingClaimAsync();
+  expect(progress.mock.calls).toEqual([
+    ['Warm Simulator is still starting; waiting (0s elapsed, 420s limit).\n'],
+  ]);
+  const reads = jest.mocked(fs.readFile).mock.calls.length;
+  now = 10_000;
+  await until(() => jest.mocked(fs.readFile).mock.calls.length >= reads + 2);
+  expect(progress).toHaveBeenCalledTimes(1);
+  expect(output).not.toHaveBeenCalled();
+  now = 30_000;
+  await until(() => progress.mock.calls.length === 2);
+  expect(progress.mock.calls[1]).toEqual([
+    'Warm Simulator is still starting; waiting (30s elapsed, 420s limit).\n',
+  ]);
+  now = 31_000;
+  await updateLauncherStateAsync(boot, state => ({ ...state!, ...info, status: 'ready' }));
+  await waitForLauncherStateAsync(boot, state => state?.status === 'claiming', 1_000);
+  await updateLauncherStateAsync(boot, state => ({ ...state!, status: 'claimed' }));
+  expect(await result).toBe(0);
+  expect(progress.mock.calls).toHaveLength(3);
+  expect(progress.mock.calls[2]).toEqual(['Warm Simulator became ready after waiting 31s.\n']);
+  expect(output).toHaveBeenCalledTimes(1);
+  expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({
+    status: 'claimed',
+    server: { token: info.server.token },
+  });
+  expect(progress.mock.calls.flat().join('')).not.toContain(info.server.token);
+});
+
+test.each(['stopping', 'disabled'] as const)(
+  'a waiting claim preserves a startup failure in %s state',
+  async status => {
+    await updateLauncherStateAsync(boot, () => ({
+      bootUuid: boot,
+      status: 'starting',
+      controllerPid: info.controllerPid,
+    }));
+    const { result } = await beginStartingClaimAsync();
+    await updateLauncherStateAsync(boot, state => ({
+      ...state!,
+      status,
+      error: 'serve-sim exited',
+    }));
+    expect(await result).toEqual(
+      new Error(
+        'Simulator preparation was interrupted; cleanup may still be running. serve-sim exited'
+      )
+    );
+    expect((await readLauncherStateAsync(boot))?.status).toBe(status);
+  }
+);
+
+test.each(['missing', 'old boot', 'different controller', 'different start time'] as const)(
+  'a waiting claim cannot acquire %s state',
+  async replacement => {
+    await updateLauncherStateAsync(boot, () => ({
+      bootUuid: boot,
+      status: 'starting',
+      controllerPid: info.controllerPid,
+      controllerStartTime: info.controllerStartTime,
+    }));
+    const { result } = await beginStartingClaimAsync();
+    if (replacement === 'missing') {
+      await fs.rm(LAUNCHER_STATE_FILE);
+    } else if (replacement === 'old boot') {
+      await updateLauncherStateAsync('other-boot', () => ({
+        bootUuid: 'other-boot',
+        status: 'ready',
+        ...info,
+      }));
+    } else {
+      await updateLauncherStateAsync(boot, state => ({
+        ...state!,
+        ...info,
+        status: 'ready',
+        ...(replacement === 'different controller'
+          ? { controllerPid: info.controllerPid + 1 }
+          : { controllerStartTime: 'replacement-start' }),
+      }));
+    }
+    expect(await result).toBeInstanceOf(Error);
+    expect((await readLauncherStateAsync(boot))?.status).not.toBe('claiming');
+  }
+);
+
+test('a claim rechecks controller identity under the state lock', async () => {
+  await updateLauncherStateAsync(boot, () => ({ bootUuid: boot, status: 'ready', ...info }));
+  jest.spyOn(fs, 'mkdir').mockImplementationOnce(async file => {
+    await nativeFs.writeFile(
+      remap(LAUNCHER_STATE_FILE) as string,
+      JSON.stringify({ bootUuid: boot, status: 'ready', ...info, controllerPid: 9002 })
+    );
+    await nativeFs.mkdir(remap(file) as string);
+    return undefined;
+  });
+  await expect(claimAsync(boot, 'serve-sim')).rejects.toThrow('different session');
+  expect(await readLauncherStateAsync(boot)).toMatchObject({
+    status: 'ready',
+    controllerPid: 9002,
+  });
+});
+
+test('startup and claim acknowledgement share one timeout', async () => {
+  let now = 0;
+  jest.spyOn(Date, 'now').mockImplementation(() => now);
+  await updateLauncherStateAsync(boot, () => ({
+    bootUuid: boot,
+    status: 'starting',
+    controllerPid: info.controllerPid,
+  }));
+  const { result } = await beginStartingClaimAsync();
+  now = 419_000;
+  await updateLauncherStateAsync(boot, state => ({ ...state!, ...info, status: 'ready' }));
+  await waitForLauncherStateAsync(boot, state => state?.status === 'claiming', 1_000);
+  now = 420_001;
+  let settled = false;
+  void result.then(() => {
+    settled = true;
+  });
+  try {
+    await until(() => settled);
+    expect(await result).toEqual(
+      new Error('Timed out waiting for the Simulator launcher; cleanup may still be running.')
+    );
+  } finally {
+    now = 1_000_000;
+    await result;
+  }
+});
+
+test('startup times out without acquiring or changing the starting record', async () => {
+  let now = 0;
+  jest.spyOn(Date, 'now').mockImplementation(() => now);
+  await updateLauncherStateAsync(boot, () => ({
+    bootUuid: boot,
+    status: 'starting',
+    controllerPid: info.controllerPid,
+  }));
+  const { result } = await beginStartingClaimAsync();
+  now = 420_001;
+  expect(await result).toEqual(
+    new Error('Timed out waiting for the Simulator launcher; cleanup may still be running.')
+  );
+  expect((await readLauncherStateAsync(boot))?.status).toBe('starting');
+});
+
+test('a claim cannot acquire after the deadline expires while taking the state lock', async () => {
+  let now = 0;
+  jest.spyOn(Date, 'now').mockImplementation(() => now);
+  await updateLauncherStateAsync(boot, () => ({ bootUuid: boot, status: 'ready', ...info }));
+  jest.spyOn(fs, 'mkdir').mockImplementationOnce(async file => {
+    now = 420_001;
+    await nativeFs.mkdir(remap(file) as string);
+    return undefined;
+  });
+  await expect(claimAsync(boot, 'serve-sim')).rejects.toThrow('Timed out');
+  expect((await readLauncherStateAsync(boot))?.status).toBe('ready');
+});
+
+test.each(['missing', 'old boot', 'starting without a controller'] as const)(
+  'a claim immediately rejects %s state',
+  async state => {
+    if (state !== 'missing') {
+      const bootUuid = state === 'old boot' ? 'old-boot' : boot;
+      await updateLauncherStateAsync(bootUuid, () => ({ bootUuid, status: 'starting' }));
+    }
+    await expect(claimAsync(boot, 'serve-sim')).rejects.toThrow('available');
+  }
+);
+
 test('a claim fails when the launcher hands over a different device than requested', async () => {
   await updateLauncherStateAsync(boot, () => ({ bootUuid: boot, status: 'ready', ...info }));
   const claim = expect(claimAsync(boot, 'serve-sim', 'iPad Pro')).rejects.toThrow(

packages/simulator-launcher/src/commands/claim.ts

@@ -1,5 +1,6 @@
 import {
   ClaimInputSchema,
+  type LauncherState,
   WarmSessionInfoSchema,
   updateLauncherStateAsync,
   waitForLauncherStateAsync,
@@ -16,13 +17,72 @@ export async function claimAsync(
       `Invalid Simulator session request. Choose ${ClaimInputSchema.shape.engine.options.join(', ')} and an optional device name or UDID.`
     );
   }
+  // Startup and handoff share the worker's existing claim timeout.
+  const startedAt = Date.now();
+  const deadline = startedAt + 420_000;
+  let lastWaitLogAt: number | undefined;
+  let controller: LauncherState | undefined;
+  const ready = await waitForLauncherStateAsync(
+    bootUuid,
+    state => {
+      if (state?.status === 'stopping' || state?.status === 'disabled' || state?.error) {
+        throw new Error(
+          `Simulator preparation was interrupted; cleanup may still be running.${state.error ? ` ${state.error}` : ''}`
+        );
+      }
+      if (
+        !state ||
+        (state.status !== 'starting' && state.status !== 'ready') ||
+        state.controllerPid === undefined
+      ) {
+        throw new Error('No warm Simulator session is available to claim on this VM.');
+      }
+      if (
+        controller &&
+        (state.controllerPid !== controller.controllerPid ||
+          (controller.controllerStartTime !== undefined &&
+            state.controllerStartTime !== controller.controllerStartTime))
+      ) {
+        throw new Error('The Simulator launcher returned a different session or engine.');
+      }
+      controller = state;
+      if (state.status === 'starting') {
+        const now = Date.now();
+        if (lastWaitLogAt === undefined || now - lastWaitLogAt >= 30_000) {
+          process.stderr.write(
+            `Warm Simulator is still starting; waiting (${Math.floor((now - startedAt) / 1_000)}s elapsed, 420s limit).\n`
+          );
+          lastWaitLogAt = now;
+        }
+      }
+      return state.status === 'ready';
+    },
+    deadline - Date.now()
+  );
+  const prepared = WarmSessionInfoSchema.parse(ready);
   const acquired = await updateLauncherStateAsync(bootUuid, state => {
     if (state?.status !== 'ready') {
       throw new Error('No warm Simulator session is available to claim on this VM.');
     }
+    if (
+      state.controllerPid !== prepared.controllerPid ||
+      state.controllerStartTime !== prepared.controllerStartTime
+    ) {
+      throw new Error('The Simulator launcher returned a different session or engine.');
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(
+        'Timed out waiting for the Simulator launcher; cleanup may still be running.'
+      );
+    }
     WarmSessionInfoSchema.parse(state);
     return { ...state, ...input.data, status: 'claiming' };
   });
+  if (lastWaitLogAt !== undefined) {
+    process.stderr.write(
+      `Warm Simulator became ready after waiting ${Math.floor((Date.now() - startedAt) / 1_000)}s.\n`
+    );
+  }
   const claimed = await waitForLauncherStateAsync(
     bootUuid,
     state => {
@@ -40,7 +100,7 @@ export async function claimAsync(
       }
       return state.status === 'claimed';
     },
-    420_000
+    Math.max(0, deadline - Date.now())
   );
   const { device } = WarmSessionInfoSchema.parse(claimed);
   if (

packages/simulator-launcher/src/commands/start.ts

@@ -468,7 +468,8 @@ export function createWarmSimulatorSession({
       // runs in the background but is joined before teardown.
       startSimulatorsSetupAsync([info.device.udid], Promise.resolve()).catch(() => {});
       const tool = warmTools.find(tool => tool.name === engine);
-      if (tool?.name === 'agent-device' && !startedTools.has(tool)) {
+      // In particular, Appium cannot start WDA until old XCTest retirement succeeded.
+      if (engine === 'appium' || (tool?.name === 'agent-device' && !startedTools.has(tool))) {
         const results = await toolRetirement;
         const failed = results.find(result => result.status === 'rejected');
         if (failed?.status === 'rejected') {

packages/simulator-launcher/src/utils/state.ts

@@ -20,7 +20,7 @@ export const WarmServerSchema = z.object({
 });
 const ToolServerSchema = WarmServerSchema.pick({ pid: true, port: true, token: true });
 export const ClaimInputSchema = z.object({
-  engine: z.enum(['serve-sim', 'agent-device', 'argent']),
+  engine: z.enum(['serve-sim', 'agent-device', 'argent', 'appium']),
   requestedDevice: NonBlankStringSchema.optional(),
 });
 /** The Expo Go this launcher installed on `udid` and never launched. */

packages/steps/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/steps
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/steps/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/steps",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -27,8 +27,8 @@
     "clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
   },
   "dependencies": {
-    "@expo/eas-build-job": "27.3.0",
-    "@expo/logger": "27.3.0",
+    "@expo/eas-build-job": "27.4.1",
+    "@expo/logger": "27.4.1",
     "@expo/spawn-async": "^1.7.2",
     "arg": "^5.0.2",
     "fast-glob": "^3.3.2",

packages/template-file/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/template-file
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/template-file/package.json

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

packages/turtle-spawn/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/turtle-spawn
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/turtle-spawn/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/turtle-spawn",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -25,7 +25,7 @@
     "clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
   },
   "dependencies": {
-    "@expo/logger": "27.3.0",
+    "@expo/logger": "27.4.1",
     "@expo/spawn-async": "^1.7.2"
   },
   "devDependencies": {

packages/vm-tools/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/vm-tools
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 No changes in this release.

packages/vm-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/vm-tools",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "description": "VM startup script loader",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",

packages/worker/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @expo/worker
 
+## 27.4.1
+
+No changes in this release.
+
+## 27.4.0
+
+No changes in this release.
+
 ## 27.3.0
 
 ### Patch Changes

packages/worker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/worker",
-  "version": "27.3.0",
+  "version": "27.4.1",
   "private": true,
   "scripts": {
     "start": "yarn watch",
@@ -19,17 +19,17 @@
   },
   "dependencies": {
     "@babel/core": "7.24.7",
-    "@expo/build-tools": "27.3.0",
+    "@expo/build-tools": "27.4.1",
     "@expo/config-plugins": "55.0.7",
     "@expo/config-types": "55.0.5",
-    "@expo/eas-build-job": "27.3.0",
-    "@expo/logger": "27.3.0",
+    "@expo/eas-build-job": "27.4.1",
+    "@expo/logger": "27.4.1",
     "@expo/results": "1.0.0",
     "@expo/rudder-sdk-node": "1.1.1",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "27.3.0",
-    "@expo/template-file": "27.3.0",
-    "@expo/turtle-spawn": "27.3.0",
+    "@expo/steps": "27.4.1",
+    "@expo/template-file": "27.4.1",
+    "@expo/turtle-spawn": "27.4.1",
     "@hapi/boom": "10.0.1",
     "check-disk-space": "3.4.0",
     "fast-glob": "3.3.2",

yarn.lock

@@ -2515,24 +2515,24 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/build-tools@npm:27.3.0, @expo/build-tools@workspace:packages/build-tools":
+"@expo/build-tools@npm:27.4.1, @expo/build-tools@workspace:packages/build-tools":
   version: 0.0.0-use.local
   resolution: "@expo/build-tools@workspace:packages/build-tools"
   dependencies:
     "@expo/config": "npm:55.0.10"
     "@expo/config-plugins": "npm:55.0.7"
-    "@expo/downloader": "npm:27.3.0"
-    "@expo/eas-build-job": "npm:27.3.0"
+    "@expo/downloader": "npm:27.4.1"
+    "@expo/eas-build-job": "npm:27.4.1"
     "@expo/env": "npm:^0.4.0"
-    "@expo/logger": "npm:27.3.0"
+    "@expo/logger": "npm:27.4.1"
     "@expo/package-manager": "npm:1.9.10"
     "@expo/plist": "npm:^0.3.5"
     "@expo/repack-app": "npm:~0.9.0"
     "@expo/results": "npm:^1.0.0"
     "@expo/spawn-async": "npm:1.7.2"
-    "@expo/steps": "npm:27.3.0"
-    "@expo/template-file": "npm:27.3.0"
-    "@expo/turtle-spawn": "npm:27.3.0"
+    "@expo/steps": "npm:27.4.1"
+    "@expo/template-file": "npm:27.4.1"
+    "@expo/turtle-spawn": "npm:27.4.1"
     "@expo/xcpretty": "npm:^4.4.7"
     "@ngrok/ngrok": "npm:1.7.0"
     "@sentry/node": "npm:7.77.0"
@@ -2768,7 +2768,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/downloader@npm:27.3.0, @expo/downloader@workspace:packages/downloader":
+"@expo/downloader@npm:27.4.1, @expo/downloader@workspace:packages/downloader":
   version: 0.0.0-use.local
   resolution: "@expo/downloader@workspace:packages/downloader"
   dependencies:
@@ -2784,13 +2784,13 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@expo/eas-build-job@npm:27.3.0, @expo/eas-build-job@workspace:packages/eas-build-job":
+"@expo/eas-build-job@npm:27.4.1, @expo/eas-build-job@workspace:packages/eas-build-job":
   version: 0.0.0-use.local
   resolution: "@expo/eas-build-job@workspace:packages/eas-build-job"
   dependencies:
-    "@expo/logger": "npm:27.3.0"
+    "@expo/logger": "npm:27.4.1"
     "@expo/results": "npm:1.0.0"
-    "@expo/turtle-spawn": "npm:27.3.0"
+    "@expo/turtle-spawn": "npm:27.4.1"
     "@types/jest": "npm:^29.5.12"
     "@types/node": "npm:22.20.5"
     jest: "npm:^29.7.0"
@@ -2803,12 +2803,12 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@expo/eas-json@npm:27.3.0, @expo/eas-json@workspace:packages/eas-json":
+"@expo/eas-json@npm:27.4.1, @expo/eas-json@workspace:packages/eas-json":
   version: 0.0.0-use.local
   resolution: "@expo/eas-json@workspace:packages/eas-json"
   dependencies:
     "@babel/code-frame": "npm:7.23.5"
-    "@expo/eas-build-job": "npm:27.3.0"
+    "@expo/eas-build-job": "npm:27.4.1"
     "@tsconfig/node22": "npm:22.0.6"
     "@types/babel__code-frame": "npm:7.0.3"
     "@types/fs-extra": "npm:11.0.4"
@@ -2931,7 +2931,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/logger@npm:27.3.0, @expo/logger@workspace:packages/logger":
+"@expo/logger@npm:27.4.1, @expo/logger@workspace:packages/logger":
   version: 0.0.0-use.local
   resolution: "@expo/logger@workspace:packages/logger"
   dependencies:
@@ -3147,12 +3147,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/steps@npm:27.3.0, @expo/steps@workspace:packages/steps":
+"@expo/steps@npm:27.4.1, @expo/steps@workspace:packages/steps":
   version: 0.0.0-use.local
   resolution: "@expo/steps@workspace:packages/steps"
   dependencies:
-    "@expo/eas-build-job": "npm:27.3.0"
-    "@expo/logger": "npm:27.3.0"
+    "@expo/eas-build-job": "npm:27.4.1"
+    "@expo/logger": "npm:27.4.1"
     "@expo/spawn-async": "npm:^1.7.2"
     "@jest/globals": "npm:^29.7.0"
     "@types/jest": "npm:^29.5.12"
@@ -3178,7 +3178,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@expo/template-file@npm:27.3.0, @expo/template-file@workspace:packages/template-file":
+"@expo/template-file@npm:27.4.1, @expo/template-file@workspace:packages/template-file":
   version: 0.0.0-use.local
   resolution: "@expo/template-file@workspace:packages/template-file"
   dependencies:
@@ -3201,11 +3201,11 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/turtle-spawn@npm:27.3.0, @expo/turtle-spawn@workspace:packages/turtle-spawn":
+"@expo/turtle-spawn@npm:27.4.1, @expo/turtle-spawn@workspace:packages/turtle-spawn":
   version: 0.0.0-use.local
   resolution: "@expo/turtle-spawn@workspace:packages/turtle-spawn"
   dependencies:
-    "@expo/logger": "npm:27.3.0"
+    "@expo/logger": "npm:27.4.1"
     "@expo/spawn-async": "npm:^1.7.2"
     "@types/jest": "npm:^29.5.12"
     "@types/node": "npm:22.20.5"
@@ -3236,17 +3236,17 @@ __metadata:
   resolution: "@expo/worker@workspace:packages/worker"
   dependencies:
     "@babel/core": "npm:7.24.7"
-    "@expo/build-tools": "npm:27.3.0"
+    "@expo/build-tools": "npm:27.4.1"
     "@expo/config-plugins": "npm:55.0.7"
     "@expo/config-types": "npm:55.0.5"
-    "@expo/eas-build-job": "npm:27.3.0"
-    "@expo/logger": "npm:27.3.0"
+    "@expo/eas-build-job": "npm:27.4.1"
+    "@expo/logger": "npm:27.4.1"
     "@expo/results": "npm:1.0.0"
     "@expo/rudder-sdk-node": "npm:1.1.1"
     "@expo/spawn-async": "npm:1.7.2"
-    "@expo/steps": "npm:27.3.0"
-    "@expo/template-file": "npm:27.3.0"
-    "@expo/turtle-spawn": "npm:27.3.0"
+    "@expo/steps": "npm:27.4.1"
+    "@expo/template-file": "npm:27.4.1"
+    "@expo/turtle-spawn": "npm:27.4.1"
     "@hapi/boom": "npm:10.0.1"
     "@types/babel__core": "npm:7.20.5"
     "@types/fs-extra": "npm:11.0.4"
@@ -10130,7 +10130,7 @@ __metadata:
   resolution: "create-eas-build-function@workspace:packages/create-eas-build-function"
   dependencies:
     "@expo/package-manager": "npm:1.9.10"
-    "@expo/steps": "npm:27.3.0"
+    "@expo/steps": "npm:27.4.1"
     "@jest/globals": "npm:^29.7.0"
     "@types/jest": "npm:^29.5.12"
     "@types/node": "npm:22.20.5"
@@ -10714,12 +10714,12 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "eas-cli-local-build-plugin@workspace:packages/local-build-plugin"
   dependencies:
-    "@expo/build-tools": "npm:27.3.0"
+    "@expo/build-tools": "npm:27.4.1"
     "@expo/bunyan": "npm:^4.0.1"
-    "@expo/eas-build-job": "npm:27.3.0"
-    "@expo/logger": "npm:27.3.0"
+    "@expo/eas-build-job": "npm:27.4.1"
+    "@expo/logger": "npm:27.4.1"
     "@expo/spawn-async": "npm:^1.7.2"
-    "@expo/turtle-spawn": "npm:27.3.0"
+    "@expo/turtle-spawn": "npm:27.4.1"
     "@types/fs-extra": "npm:^11.0.4"
     "@types/hapi__joi": "npm:^17.1.14"
     "@types/lodash": "npm:^4.17.4"
@@ -10773,12 +10773,12 @@ __metadata:
     "@expo/code-signing-certificates": "npm:0.0.5"
     "@expo/config": "npm:55.0.10"
     "@expo/config-plugins": "npm:55.0.7"
-    "@expo/eas-build-job": "npm:27.3.0"
-    "@expo/eas-json": "npm:27.3.0"
+    "@expo/eas-build-job": "npm:27.4.1"
+    "@expo/eas-json": "npm:27.4.1"
     "@expo/env": "npm:^1.0.0"
     "@expo/experimentation": "npm:0.0.5"
     "@expo/json-file": "npm:8.3.3"
-    "@expo/logger": "npm:27.3.0"
+    "@expo/logger": "npm:27.4.1"
     "@expo/multipart-body-parser": "npm:2.0.0"
     "@expo/osascript": "npm:2.1.4"
     "@expo/package-manager": "npm:1.9.10"
@@ -10790,7 +10790,7 @@ __metadata:
     "@expo/results": "npm:1.0.0"
     "@expo/rudder-sdk-node": "npm:1.1.1"
     "@expo/spawn-async": "npm:1.7.2"
-    "@expo/steps": "npm:27.3.0"
+    "@expo/steps": "npm:27.4.1"
     "@expo/timeago.js": "npm:1.0.0"
     "@graphql-codegen/cli": "npm:6.3.1"
     "@graphql-codegen/introspection": "npm:5.0.2"