[build-tools] retire upload processing wait after producer migration

.changeset/afraid-beds-invite.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': patch
+---
+
+Regenerate graphql code

.changeset/agent-device-stop-during-startup.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Stop an agent-device session that is still starting up when it is stopped.

.changeset/android-35-adb-memory.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Default Android emulators to 4 GiB of RAM to reduce ADB disconnects during large transfers. Retain the 2 GiB default for API 34 and below outside interactive device sessions, and preserve explicit emulator configuration overrides.

.changeset/android-launch-arg-early-validation.md

@@ -0,0 +1,6 @@
+---
+'@expo/eas-build-job': minor
+'@expo/build-tools': patch
+---
+
+Export `validateAndroidLaunchOptions` and `quoteAndroidShellCommand` from `@expo/eas-build-job`, so Android launch arguments can be checked for NUL characters and length before a simulator session starts, and check them before the emulator boots in agent-device sessions.

.changeset/appium-stop-during-startup.md

@@ -1,6 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Stop an Appium session that is still starting up when it is stopped.
-Report temporary-directory cleanup failures when Stop interrupts Appium installation.

.changeset/argent-stop-during-startup.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Stop an Argent session that is still starting up when it is stopped.

.changeset/build-profile-expo-token-role.md

@@ -0,0 +1,5 @@
+---
+'@expo/eas-json': minor
+---
+
+Add `permissions.account.role` to build profiles to request a role for the build's `EXPO_TOKEN`.

.changeset/config.json

@@ -19,9 +19,7 @@
       "@expo/downloader",
       "@expo/turtle-spawn",
       "@expo/template-file",
-      "create-eas-build-function",
-      "@expo/vm-tools",
-      "@expo/simulator-launcher"
+      "create-eas-build-function"
     ]
   ],
   "linked": [],

.changeset/device-session-request-retries.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Retry transient failures when reporting that a device run session has started.

.changeset/download-build-network-retries.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Retry the build lookup and the archive download of `eas/download_build` on transient failures, and name the failure cause in the build log.

.changeset/fewer-app-config-reads.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': patch
+---
+
+Read the app config fewer times in `eas build` and other project commands. An iOS build now runs `expo config` 2 times instead of 6.

.changeset/help-description-style.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': none
+---
+
+Make command descriptions in `eas --help` consistently lowercase without trailing periods.

.changeset/native-hooks-log-group.md

@@ -0,0 +1,6 @@
+---
+'@expo/build-tools': patch
+'@expo/steps': patch
+---
+
+Stop printing workflow hook parsing messages in build logs: native builds showed them under an "Unknown build phase" group, and custom builds warned about unknown hook keys and hooks on steps that never run.

.changeset/node-22-23-4.md

@@ -0,0 +1,6 @@
+---
+'eas-cli': none
+'@expo/build-tools': none
+---
+
+Bump Node.js to 22.23.4 to fix the CVEs in the [October 2026 Node.js security releases](https://nodejs.org/en/blog/vulnerability/october-2026-security-releases).

.changeset/node-install-mirror-fallback.md

@@ -0,0 +1,5 @@
+---
+'@expo/worker': patch
+---
+
+Retry Node.js installation without the internal Node.js cache mirror when the first attempt fails, while preserving other configured mirrors.

.changeset/quiet-android-logs.md

@@ -1,8 +0,0 @@
----
-'@expo/build-tools': patch
-'eas-cli': patch
----
-
-Record and upload Android emulator process output as a simulator session artifact by default. Add explicit source selection and a simulator CLI flag to opt in to recording and uploading device-wide logcat. Unselected sources are not recorded by simulator sessions.
-
-Simulator sessions retain the last 20 MiB of each selected Android log source across launches and retries. Each log file is a fixed-size ring on disk, so the end of the final attempt is always kept; older output is dropped first, and artifacts remain uncompressed.

.changeset/remove-asc-upload-wait.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': major
+---
+
+Remove `wait_for_processing` from `eas/upload_to_asc`; use a separate `eas/wait_for_asc_build_processing` step to wait for App Store Connect processing.

.changeset/sandbox-duration.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': minor
+---
+
+Stop sandboxes after an optional maximum duration measured from readiness.

.changeset/separate-asc-processing-step.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': minor
+---
+
+Add `eas/wait_for_asc_build_processing` to wait for an existing App Store Connect upload. Keep `eas/upload_to_asc`'s `wait_for_processing` input supported through the same processing logic.

.changeset/shared-graphql-client.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': patch
+---
+
+Share one GraphQL client between the project ID check and the command, so commands send one fewer app query.

.changeset/simulator-get-job-run-errors.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': patch
+---
+
+Show why a simulator session failed in `eas simulator:get`, and add an `errors` array to its `--json` output. For an unknown error, `simulator:start` and `simulator:get` now show the failed step's error from the session logs.

.changeset/simulator-start-job-run-errors.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': patch
+---
+
+Show why a simulator session failed in `eas simulator:start`, such as an unknown `--device` name, instead of only the session status.

.changeset/simulators-hint-date.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Show the Expo Simulators hint after a successful build from November 12 instead of November 10.

.changeset/unify-signed-url-uploads.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': minor
+---
+
+Unify signed URL uploading to a single implementation and use it everywhere

.changeset/web-preview-stop-during-startup.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Stop a web-preview session that is still starting up when it is stopped.

.changeset/worker-mask-logged-errors.md

@@ -0,0 +1,5 @@
+---
+'@expo/worker': patch
+---
+
+Mask secrets in every field of uploaded job log records, such as logged errors, not only in log messages.

.changeset/workflow-artifact-types.md

@@ -0,0 +1,6 @@
+---
+'@expo/eas-build-job': major
+'@expo/build-tools': major
+---
+
+Remove legacy artifact type exports and route workflow uploads through workflow storage without file-type categories. Preserve workflow uploads and Maestro reports.

.github/workflows/test-graphql.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches: [main]
   pull_request:
+    branches: [main]
   schedule:
     - cron: '0 8 * * *' # 8:00 AM UTC time every day
 

CHANGELOG.md

@@ -2,158 +2,6 @@
 
 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
-
-- [eas-build-job] Add optional Observe error context to workflow jobs. ([#4787](https://github.com/expo/eas-cli/pull/4787) by [@AbbanMustafa](https://github.com/AbbanMustafa))
-
-### 🐛 Bug fixes
-
-- [eas-cli] Bump `@expo/apple-utils` to `2.3.0` to fix iOS capability sync when App Store Connect rejects enabling, disabling or changing a capability. ([#4790](https://github.com/expo/eas-cli/pull/4790) by [@douglowder](https://github.com/douglowder))
-- [eas-cli] Keep already linked App Groups, Merchant IDs and iCloud containers when capability sync links another identifier. ([#4584](https://github.com/expo/eas-cli/pull/4584) by [@ceydaakin](https://github.com/ceydaakin))
-- [worker] Mask secrets in every record the worker process writes to its stdout: the build log records and the worker's own records. ([#4782](https://github.com/expo/eas-cli/pull/4782) by [@hSATAC](https://github.com/hSATAC))
-- [worker][build-tools] Stop warmup in the background for jobs that do not use the warm Simulator, so job setup does not wait for it. Before build-tools boots or clones a Simulator, it waits until the launcher's state file records that cleanup finished, and fails if cleanup does not finish in time. ([#4721](https://github.com/expo/eas-cli/pull/4721) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Recover unhealthy device-session tunnels without changing their URLs and block further traffic when shutdown starts, even if ngrok cleanup times out. ([#4526](https://github.com/expo/eas-cli/pull/4526) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Stop sending the SSH host when registering an SSH session. ([#4784](https://github.com/expo/eas-cli/pull/4784) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
-
-## [27.2.0](https://github.com/expo/eas-cli/releases/tag/v27.2.0) - 2026-10-29
-
-### 🎉 New features
-
-- [build-tools] Use single-device previews when the session already has a valid device ID. ([#4733](https://github.com/expo/eas-cli/pull/4733) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Add an experiment that suggests Expo Update to coding agents after a build when the Free plan account is within 5 builds of the platform limit. ([#4758](https://github.com/expo/eas-cli/pull/4758) by [@williamgrosset](https://github.com/williamgrosset))
-- [eas-cli] Add `eas observe:traces` to list request trace spans (or a summary of span names and counts), `eas observe:trace` to display one trace as a span tree, and span rows in the `eas observe:session` timeline. ([#4772](https://github.com/expo/eas-cli/pull/4772) by [@kadikraman](https://github.com/kadikraman))
-- [simulator-launcher] Accept a comma-separated list of warm Simulators in `EXPO_SIMULATOR_DEVICE`; the first is the default. One serve-sim serves every listed device on one port. After the default device is ready, warmup preinstalls the latest stable Expo Go from one download and tries to disable apsd on the other devices, until a job claims one. A claim can select any listed device and reports its preinstalled Expo Go. ([#4764](https://github.com/expo/eas-cli/pull/4764) by [@gwdp](https://github.com/gwdp))
-- [simulator-launcher] Add `@expo/simulator-launcher`, which warms an iOS Simulator at VM boot and hands it to one EAS job (`start`, `claim`, `prepare-tools`, `stop`). ([#4722](https://github.com/expo/eas-cli/pull/4722) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Show a one-time Expo Simulators hint after a successful build. ([#4768](https://github.com/expo/eas-cli/pull/4768) by [@FiberJW](https://github.com/FiberJW))
-- [vm-tools] Add a macOS startup script loader that runs `/usr/local/share/vm-tools/startup.sh` once per VM boot. ([#4725](https://github.com/expo/eas-cli/pull/4725) by [@gwdp](https://github.com/gwdp))
-
-### 🐛 Bug fixes
-
-- [build-tools] Explain missing background task identifiers reported by App Store Connect. ([#3465](https://github.com/expo/eas-cli/pull/3465) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Explain App Store Connect NOT_AUTHORIZED responses in the shared API client. ([#3462](https://github.com/expo/eas-cli/pull/3462) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Explain App Store Connect UNEXPECTED_ERROR responses in the shared API client. ([#3467](https://github.com/expo/eas-cli/pull/3467) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Explain missing app icons reported by App Store Connect, including codes 90022 and 90023, while preserving Apple’s validation details. ([#3466](https://github.com/expo/eas-cli/pull/3466) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] List failed Google Play commit attempts in order, including network failures, when the outcome is uncertain. ([#4660](https://github.com/expo/eas-cli/pull/4660) by [@sjchmiela](https://github.com/sjchmiela))
-- [worker] Run package-manager version queries in parallel during worker preparation. ([#4710](https://github.com/expo/eas-cli/pull/4710) by [@gwdp](https://github.com/gwdp))
-- [worker] Start the Xcode version check in the background during worker tool preparation. Apply the Xcode 26.0 upload workaround when the query finishes, without delaying job startup. ([#4707](https://github.com/expo/eas-cli/pull/4707) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Fix a five-minute cleanup delay when a device session is canceled during startup and its screen recorder fails before connecting. ([#4761](https://github.com/expo/eas-cli/pull/4761) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Remove the Free plan build limit guidance experiment for coding agents from `eas build`. ([#4757](https://github.com/expo/eas-cli/pull/4757) by [@williamgrosset](https://github.com/williamgrosset))
-- [worker] Allow jobs to skip installing the CocoaPods cache proxy with EAS_BUILD_DISABLE_COCOAPODS_CACHE_PLUGIN=1. ([#4709](https://github.com/expo/eas-cli/pull/4709) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Handle TURN requests for a stopped device session without reporting a warning. ([#4762](https://github.com/expo/eas-cli/pull/4762) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Preserve indented and incomplete Xcode compiler errors in formatted build logs, including the final diagnostic when logging stops. ([#4365](https://github.com/expo/eas-cli/pull/4365) by [@sjchmiela](https://github.com/sjchmiela))
-
-### 🧹 Chores
-
-- [simulator-launcher] Add the state, request command and service helpers for the warm Simulator launcher. The package stays private until #4722 adds its CLI entry point. ([#4766](https://github.com/expo/eas-cli/pull/4766) by [@gwdp](https://github.com/gwdp))
-
-## [27.1.0](https://github.com/expo/eas-cli/releases/tag/v27.1.0) - 2026-10-28
-
-### 🎉 New features
-
-- [eas-cli] Display queued workflow runs: `workflow:run --wait` and `workflow:status` show a run waiting for its concurrency group and the run blocking it, and `workflow:cancel` includes queued runs in its selection list. ([#4258](https://github.com/expo/eas-cli/pull/4258) by [@hSATAC](https://github.com/hSATAC))
-- [eas-cli] Upload the workflow files that `uses` jobs reference, including nested ones, when running a local workflow file with `eas workflow:run`. ([#4769](https://github.com/expo/eas-cli/pull/4769) by [@sswrk](https://github.com/sswrk))
-
-### 🐛 Bug fixes
-
-- [build-tools] Explain App Store Connect error 90189 as a duplicate build number. ([#3461](https://github.com/expo/eas-cli/pull/3461) by [@sjchmiela](https://github.com/sjchmiela))
-- [eas-cli] Fail the command when EAS CLI cannot pull environment variables from EAS servers, instead of continuing without them. ([#4774](https://github.com/expo/eas-cli/pull/4774) by [@wschurman](https://github.com/wschurman))
-- [eas-cli] Format the generated root changelog before committing a release. ([#4773](https://github.com/expo/eas-cli/pull/4773) by [@gwdp](https://github.com/gwdp))
-- [build-tools][worker] Put the `NPM_TOKEN` registry credential in the builder's npm user config on EAS Build (`~/.npmrc`, or the file `NPM_CONFIG_USERCONFIG` names), where pnpm 10.34.2+ and 11.5.3+ still expand `${NPM_TOKEN}` (they ignore it in a project-level `.npmrc`). Explain what to change when the project's pnpm version needs a newer Node.js than the build runs, including when eas.json sets `node` or `pnpm`. ([#4729](https://github.com/expo/eas-cli/pull/4729) by [@hSATAC](https://github.com/hSATAC))
-- [build-tools] Install `@expo/repack-app` for the `eas/repack` step with npm in a sandbox that sees only `PATH` and its own `HOME`, so the build machine's npm and Yarn configuration cannot break the install, fetch it through the EAS npm cache when the job uses one, and show the installer output in the build log. The step no longer looks the version up separately before installing. When the npm cache fails, the install retries against the public registry like the project install does; the `eas/run_agent` agent CLI install shares the same helper and gains the same retry. ([#4728](https://github.com/expo/eas-cli/pull/4728) by [@hSATAC](https://github.com/hSATAC))
-- [eas-cli] Honor the `--non-interactive` flag in `workflow:cancel`; it was parsed but never applied, so automation could hang on the interactive picker. ([#4258](https://github.com/expo/eas-cli/pull/4258) by [@hSATAC](https://github.com/hSATAC))
-- [eas-cli] Stop reporting a finish time for workflow runs that have not finished: `workflow:runs` reports `finishedAt` only for runs in a final status. ([#4258](https://github.com/expo/eas-cli/pull/4258) by [@hSATAC](https://github.com/hSATAC))
-
-## [27.0.0](https://github.com/expo/eas-cli/releases/tag/v27.0.0) - 2026-10-27
-
-### 🛠 Breaking changes
-
-- [eas-cli] Write the reason a command failed to stderr, next to the `command failed.` line, instead of to stdout. A program that reads the reason from stdout must read stderr instead. ([#4592](https://github.com/expo/eas-cli/pull/4592) by [@vonovak](https://github.com/vonovak))
-
-### 🎉 New features
-
-- [eas-cli] Send the `permissions.account.role` from the build profile to request a role for the build's `EXPO_TOKEN`. ([#4734](https://github.com/expo/eas-cli/pull/4734) by [@wschurman](https://github.com/wschurman))
-- [eas-cli] Add `simulator:logs` to read and follow logs from an iOS simulator session and download saved logs after it stops. ([#4545](https://github.com/expo/eas-cli/pull/4545) by [@gwdp](https://github.com/gwdp))
-
-### 🐛 Bug fixes
-
-- [build-tools] Keep the launched app open when an Appium iOS session starts. ([#4699](https://github.com/expo/eas-cli/pull/4699) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Run Appium through the prepared Full Disk Access helper when available on macOS. ([#4622](https://github.com/expo/eas-cli/pull/4622) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Show permission guidance, including `permissions.account.role` in eas.json, when a build request fails with an authorization error. ([#4760](https://github.com/expo/eas-cli/pull/4760) by [@wschurman](https://github.com/wschurman))
-- [eas-cli] Print the notice about eas-cli in project dependencies only when stderr is a terminal, so programs that read stderr get the command's error. ([#4591](https://github.com/expo/eas-cli/pull/4591) by [@vonovak](https://github.com/vonovak))
-- [eas-cli] Show account roles and credential permission limits in `eas login` when you are already logged in. ([#4759](https://github.com/expo/eas-cli/pull/4759) by [@wschurman](https://github.com/wschurman))
-- [build-tools] Identify the build or application archive when a download fails, and explain when the archive is no longer available. ([#4703](https://github.com/expo/eas-cli/pull/4703) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Run apsd setup in the background without delaying iOS app launch or preview readiness. ([#4706](https://github.com/expo/eas-cli/pull/4706) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Fix simulator control action help routing and show help when a flag is incomplete. ([#4681](https://github.com/expo/eas-cli/pull/4681) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Require explicit `host:` simulator-host upload paths and report missing local files. ([#4683](https://github.com/expo/eas-cli/pull/4683) by [@gwdp](https://github.com/gwdp))
-
-  Missing local absolute paths now require the `host:` prefix. Actions that require upload IDs accept local files and reject host paths with an explanation.
-
-- [build-tools] Handle a device session stopped during startup as normal cleanup instead of reporting a startup error. ([#4716](https://github.com/expo/eas-cli/pull/4716) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Support idle timeouts for iOS web-preview-only sessions, resetting the timer when preview input arrives. ([#4731](https://github.com/expo/eas-cli/pull/4731) by [@gwdp](https://github.com/gwdp))
-
-### 🧹 Chores
-
-- [eas-cli] Run the GraphQL schema and generated code check on pull requests to any base branch, including stacked pull requests. ([#4763](https://github.com/expo/eas-cli/pull/4763) by [@wschurman](https://github.com/wschurman))
-
-## [26.0.0](https://github.com/expo/eas-cli/releases/tag/v26.0.0) - 2026-10-26
-
-### 🛠 Breaking changes
-
-- [eas-build-job][build-tools] Remove legacy artifact type exports and route workflow uploads through workflow storage without file-type categories. Preserve workflow uploads and Maestro reports. ([#4719](https://github.com/expo/eas-cli/pull/4719) by [@sjchmiela](https://github.com/sjchmiela))
-
-### 🎉 New features
-
-- [eas-build-job][build-tools] Export `validateAndroidLaunchOptions` and `quoteAndroidShellCommand` from `@expo/eas-build-job`, so Android launch arguments can be checked for NUL characters and length before a simulator session starts, and check them before the emulator boots in agent-device sessions. ([#4696](https://github.com/expo/eas-cli/pull/4696) by [@brentvatne](https://github.com/brentvatne))
-- [eas-json] Add `permissions.account.role` to build profiles to request a role for the build's `EXPO_TOKEN`. ([#4732](https://github.com/expo/eas-cli/pull/4732) by [@wschurman](https://github.com/wschurman))
-- [build-tools] Stop sandboxes after an optional maximum duration measured from readiness. ([#4702](https://github.com/expo/eas-cli/pull/4702) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Unify signed URL uploading to a single implementation and use it everywhere. ([#4712](https://github.com/expo/eas-cli/pull/4712) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
-
-### 🐛 Bug fixes
-
-- [eas-cli] Regenerate graphql code. ([#4692](https://github.com/expo/eas-cli/pull/4692) by [@wschurman](https://github.com/wschurman))
-- [build-tools] Default Android emulators to 4 GiB of RAM to reduce ADB disconnects during large transfers. Retain the 2 GiB default for API 34 and below outside interactive device sessions, and preserve explicit emulator configuration overrides. ([#4727](https://github.com/expo/eas-cli/pull/4727) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Retry transient failures when reporting that a device run session has started. ([#4680](https://github.com/expo/eas-cli/pull/4680) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Retry the build lookup and the archive download of `eas/download_build` on transient failures, and name the failure cause in the build log. ([#4690](https://github.com/expo/eas-cli/pull/4690) by [@hSATAC](https://github.com/hSATAC))
-- [eas-cli] Read the app config fewer times in `eas build` and other project commands. An iOS build now runs `expo config` 2 times instead of 6. ([`78ba760`](https://github.com/expo/eas-cli/commit/78ba76001b67c9971236af1a1d02e46c2f82d24a) by [@vonovak](https://github.com/vonovak))
-- [build-tools][steps] Stop printing workflow hook parsing messages in build logs: native builds showed them under an "Unknown build phase" group, and custom builds warned about unknown hook keys and hooks on steps that never run. ([#4717](https://github.com/expo/eas-cli/pull/4717) by [@hSATAC](https://github.com/hSATAC))
-- [worker] Retry Node.js installation without the internal Node.js cache mirror when the first attempt fails, while preserving other configured mirrors. ([#3452](https://github.com/expo/eas-cli/pull/3452) by [@sjchmiela](https://github.com/sjchmiela))
-- [eas-cli] Share one GraphQL client between the project ID check and the command, so commands send one fewer app query. ([#4646](https://github.com/expo/eas-cli/pull/4646) by [@vonovak](https://github.com/vonovak))
-- [eas-cli] Show why a simulator session failed in `eas simulator:get`, and add an `errors` array to its `--json` output. For an unknown error, `simulator:start` and `simulator:get` now show the failed step's error from the session logs. ([#4694](https://github.com/expo/eas-cli/pull/4694) by [@brentvatne](https://github.com/brentvatne))
-- [eas-cli] Show why a simulator session failed in `eas simulator:start`, such as an unknown `--device` name, instead of only the session status. ([#4693](https://github.com/expo/eas-cli/pull/4693) by [@brentvatne](https://github.com/brentvatne))
-- [worker] Mask secrets in every field of uploaded job log records, such as logged errors, not only in log messages. ([#4698](https://github.com/expo/eas-cli/pull/4698) by [@brentvatne](https://github.com/brentvatne))
-
-### 🧹 Chores
-
-- [eas-cli] Make command descriptions in `eas --help` consistently lowercase without trailing periods. ([#4385](https://github.com/expo/eas-cli/pull/4385) by [@brentvatne](https://github.com/brentvatne))
-- [eas-cli][build-tools] Bump Node.js to 22.23.4 to fix the CVEs in the [October 2026 Node.js security releases](https://nodejs.org/en/blog/vulnerability/october-2026-security-releases). ([#4714](https://github.com/expo/eas-cli/pull/4714) by [@ramonclaudio](https://github.com/ramonclaudio))
-
 ## [25.3.0](https://github.com/expo/eas-cli/releases/tag/v25.3.0) - 2026-10-20
 
 ### 🎉 New features

cli-versions.json

@@ -1,4 +1,4 @@
 {
-  "STAGING": "27.4.1",
-  "PRODUCTION": "27.4.1"
+  "STAGING": "25.3.0",
+  "PRODUCTION": "25.3.0"
 }

lerna.json

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

packages/build-tools/CHANGELOG.md

@@ -1,88 +1,5 @@
 # @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
-
-- Stop warmup in the background for jobs that do not use the warm Simulator, so job setup does not wait for it. Before build-tools boots or clones a Simulator, it waits until the launcher's state file records that cleanup finished, and fails if cleanup does not finish in time. ([#4721](https://github.com/expo/eas-cli/pull/4721) by [@gwdp](https://github.com/gwdp))
-- Recover unhealthy device-session tunnels without changing their URLs and block further traffic when shutdown starts, even if ngrok cleanup times out. ([#4526](https://github.com/expo/eas-cli/pull/4526) by [@gwdp](https://github.com/gwdp))
-- Stop sending the SSH host when registering an SSH session. ([#4784](https://github.com/expo/eas-cli/pull/4784) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
-
-## 27.2.0
-
-### Minor Changes
-
-- Use single-device previews when the session already has a valid device ID. ([#4733](https://github.com/expo/eas-cli/pull/4733) by [@gwdp](https://github.com/gwdp))
-
-### Patch Changes
-
-- Explain missing background task identifiers reported by App Store Connect. ([#3465](https://github.com/expo/eas-cli/pull/3465) by [@sjchmiela](https://github.com/sjchmiela))
-- Explain App Store Connect NOT_AUTHORIZED responses in the shared API client. ([#3462](https://github.com/expo/eas-cli/pull/3462) by [@sjchmiela](https://github.com/sjchmiela))
-- Explain App Store Connect UNEXPECTED_ERROR responses in the shared API client. ([#3467](https://github.com/expo/eas-cli/pull/3467) by [@sjchmiela](https://github.com/sjchmiela))
-- Explain missing app icons reported by App Store Connect, including codes 90022 and 90023, while preserving Apple’s validation details. ([#3466](https://github.com/expo/eas-cli/pull/3466) by [@sjchmiela](https://github.com/sjchmiela))
-- List failed Google Play commit attempts in order, including network failures, when the outcome is uncertain. ([#4660](https://github.com/expo/eas-cli/pull/4660) by [@sjchmiela](https://github.com/sjchmiela))
-- Fix a five-minute cleanup delay when a device session is canceled during startup and its screen recorder fails before connecting. ([#4761](https://github.com/expo/eas-cli/pull/4761) by [@gwdp](https://github.com/gwdp))
-- Handle TURN requests for a stopped device session without reporting a warning. ([#4762](https://github.com/expo/eas-cli/pull/4762) by [@gwdp](https://github.com/gwdp))
-- Preserve indented and incomplete Xcode compiler errors in formatted build logs, including the final diagnostic when logging stops. ([#4365](https://github.com/expo/eas-cli/pull/4365) by [@sjchmiela](https://github.com/sjchmiela))
-
-## 27.1.0
-
-### Patch Changes
-
-- Explain App Store Connect error 90189 as a duplicate build number. ([#3461](https://github.com/expo/eas-cli/pull/3461) by [@sjchmiela](https://github.com/sjchmiela))
-- Put the `NPM_TOKEN` registry credential in the builder's npm user config on EAS Build (`~/.npmrc`, or the file `NPM_CONFIG_USERCONFIG` names), where pnpm 10.34.2+ and 11.5.3+ still expand `${NPM_TOKEN}` (they ignore it in a project-level `.npmrc`). Explain what to change when the project's pnpm version needs a newer Node.js than the build runs, including when eas.json sets `node` or `pnpm`. ([#4729](https://github.com/expo/eas-cli/pull/4729) by [@hSATAC](https://github.com/hSATAC))
-- Install `@expo/repack-app` for the `eas/repack` step with npm in a sandbox that sees only `PATH` and its own `HOME`, so the build machine's npm and Yarn configuration cannot break the install, fetch it through the EAS npm cache when the job uses one, and show the installer output in the build log. The step no longer looks the version up separately before installing. When the npm cache fails, the install retries against the public registry like the project install does; the `eas/run_agent` agent CLI install shares the same helper and gains the same retry. ([#4728](https://github.com/expo/eas-cli/pull/4728) by [@hSATAC](https://github.com/hSATAC))
-
-## 27.0.0
-
-### Patch Changes
-
-- Keep the launched app open when an Appium iOS session starts. ([#4699](https://github.com/expo/eas-cli/pull/4699) by [@gwdp](https://github.com/gwdp))
-- Run Appium through the prepared Full Disk Access helper when available on macOS. ([#4622](https://github.com/expo/eas-cli/pull/4622) by [@gwdp](https://github.com/gwdp))
-- Identify the build or application archive when a download fails, and explain when the archive is no longer available. ([#4703](https://github.com/expo/eas-cli/pull/4703) by [@gwdp](https://github.com/gwdp))
-- Run apsd setup in the background without delaying iOS app launch or preview readiness. ([#4706](https://github.com/expo/eas-cli/pull/4706) by [@gwdp](https://github.com/gwdp))
-- Handle a device session stopped during startup as normal cleanup instead of reporting a startup error. ([#4716](https://github.com/expo/eas-cli/pull/4716) by [@gwdp](https://github.com/gwdp))
-- Support idle timeouts for iOS web-preview-only sessions, resetting the timer when preview input arrives. ([#4731](https://github.com/expo/eas-cli/pull/4731) by [@gwdp](https://github.com/gwdp))
-
-## 26.0.0
-
-### Major Changes
-
-- Remove legacy artifact type exports and route workflow uploads through workflow storage without file-type categories. Preserve workflow uploads and Maestro reports. ([#4719](https://github.com/expo/eas-cli/pull/4719) by [@sjchmiela](https://github.com/sjchmiela))
-
-### Minor Changes
-
-- Stop sandboxes after an optional maximum duration measured from readiness. ([#4702](https://github.com/expo/eas-cli/pull/4702) by [@sjchmiela](https://github.com/sjchmiela))
-- Unify signed URL uploading to a single implementation and use it everywhere. ([#4712](https://github.com/expo/eas-cli/pull/4712) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
-
-### Patch Changes
-
-- Default Android emulators to 4 GiB of RAM to reduce ADB disconnects during large transfers. Retain the 2 GiB default for API 34 and below outside interactive device sessions, and preserve explicit emulator configuration overrides. ([#4727](https://github.com/expo/eas-cli/pull/4727) by [@sjchmiela](https://github.com/sjchmiela))
-- Export `validateAndroidLaunchOptions` and `quoteAndroidShellCommand` from `@expo/eas-build-job`, so Android launch arguments can be checked for NUL characters and length before a simulator session starts, and check them before the emulator boots in agent-device sessions. ([#4696](https://github.com/expo/eas-cli/pull/4696) by [@brentvatne](https://github.com/brentvatne))
-- Retry transient failures when reporting that a device run session has started. ([#4680](https://github.com/expo/eas-cli/pull/4680) by [@gwdp](https://github.com/gwdp))
-- Retry the build lookup and the archive download of `eas/download_build` on transient failures, and name the failure cause in the build log. ([#4690](https://github.com/expo/eas-cli/pull/4690) by [@hSATAC](https://github.com/hSATAC))
-- Stop printing workflow hook parsing messages in build logs: native builds showed them under an "Unknown build phase" group, and custom builds warned about unknown hook keys and hooks on steps that never run. ([#4717](https://github.com/expo/eas-cli/pull/4717) by [@hSATAC](https://github.com/hSATAC))
-
 ## 25.3.0
 
 ### Minor Changes

packages/build-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "27.4.1",
+  "version": "25.3.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -42,18 +42,18 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "27.4.1",
-    "@expo/eas-build-job": "27.4.1",
+    "@expo/downloader": "25.3.0",
+    "@expo/eas-build-job": "25.3.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "27.4.1",
+    "@expo/logger": "25.3.0",
     "@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.4.1",
-    "@expo/template-file": "27.4.1",
-    "@expo/turtle-spawn": "27.4.1",
-    "@expo/xcpretty": "^4.4.7",
+    "@expo/steps": "25.3.0",
+    "@expo/template-file": "25.3.0",
+    "@expo/turtle-spawn": "25.3.0",
+    "@expo/xcpretty": "^4.3.1",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",

packages/build-tools/src/__tests__/utils/startupWatch.ts

@@ -1,22 +0,0 @@
-import { type watchDeviceRunSessionStartup } from '../../steps/utils/deviceRunSessionStartup';
-import { DeviceRunSessionStoppedError } from '../../steps/utils/remoteDeviceRunSession';
-
-/**
- * A `watchDeviceRunSessionStartup` stand-in that never polls. A test calls `stop` on the
- * returned watch (`jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value`) to act like
- * a Stop request during startup.
- */
-export function createStartupWatchMock({
-  startup,
-}: Parameters<typeof watchDeviceRunSessionStartup>[0]): ReturnType<
-  typeof watchDeviceRunSessionStartup
-> & { stop: () => void } {
-  const stopped = new DeviceRunSessionStoppedError('Stopped during startup.');
-  return {
-    stopped,
-    stop: () => startup.abort(stopped),
-    isStopped: () => startup.signal.reason === stopped,
-    completeAsync: jest.fn(async () => startup.signal.throwIfAborted()),
-    finishAsync: jest.fn(async () => {}),
-  };
-}

packages/build-tools/src/buildErrors/__tests__/detectError.test.ts

@@ -125,31 +125,6 @@ describe(resolveBuildPhaseErrorAsync, () => {
     expect(err.trackingCode).toBeUndefined();
   });
 
-  it('explains that the pnpm version needs a newer Node.js than the build runs', async () => {
-    const fakeError = new Error();
-    const err = await resolveBuildPhaseErrorAsync(
-      fakeError,
-      [
-        'Running "pnpm install --frozen-lockfile" in /home/expo/workingdir/build directory',
-        'warn: This version of pnpm requires at least Node.js v22.13',
-        'warn: The current version of Node.js is v20.19.4',
-        'warn: Visit https://r.pnpm.io/comp to see the list of past pnpm versions with respective Node.js version support.',
-        'Error [ERR_UNKNOWN_BUILTIN_MODULE]: No such built-in module: node:sqlite',
-      ],
-      {
-        job: { platform: Platform.ANDROID } as Job,
-        phase: BuildPhase.INSTALL_DEPENDENCIES,
-        env: {},
-      },
-      '/fake/path'
-    );
-    expect(err.errorCode).toBe('EAS_BUILD_PNPM_UNSUPPORTED_NODE_VERSION_ERROR');
-    expect(err.message).toBe(
-      'This build uses a pnpm version that requires Node.js 22.13.0 or newer, but runs Node.js 20.19.4. You can fix it by either:\n- setting "node" to "22.13.0" or a newer version in the build profile in eas.json\n- using a pnpm version that supports Node.js 20.19.4: change "packageManager" in package.json if your project sets it, and set "pnpm" in the build profile in eas.json'
-    );
-    expect(err.docsUrl).toBe('https://docs.expo.dev/eas/json/');
-  });
-
   it('detects xcode line error', async () => {
     vol.fromJSON({
       '/path/to/xcodelogs.log': originalFs.readFileSync(

packages/build-tools/src/buildErrors/pnpmUnsupportedNodeVersionError.ts

@@ -1,33 +0,0 @@
-import { errors } from '@expo/eas-build-job';
-import nullthrows from 'nullthrows';
-import semver from 'semver';
-
-import { ErrorHandler } from './errors.types';
-
-// example log: "warn: This version of pnpm requires at least Node.js v22.13" followed by "warn: The current version of Node.js is v20.19.4"
-const PNPM_UNSUPPORTED_NODE_VERSION_REGEXP =
-  /This version of pnpm requires at least Node\.js v([\d.]+)\n.*The current version of Node\.js is v([\d.]+)/;
-
-function createPnpmUnsupportedNodeVersionError(matchResult: RegExpMatchArray): errors.UserError {
-  const [, requiredNodeVersion, currentNodeVersion] = matchResult;
-  const minimumNodeVersion = nullthrows(semver.coerce(requiredNodeVersion)).version;
-  return new errors.UserError(
-    'EAS_BUILD_PNPM_UNSUPPORTED_NODE_VERSION_ERROR',
-    `This build uses a pnpm version that requires Node.js ${minimumNodeVersion} or newer, but runs Node.js ${currentNodeVersion}. You can fix it by either:
-- setting "node" to "${minimumNodeVersion}" or a newer version in the build profile in eas.json
-- using a pnpm version that supports Node.js ${currentNodeVersion}: change "packageManager" in package.json if your project sets it, and set "pnpm" in the build profile in eas.json`,
-    { docsUrl: 'https://docs.expo.dev/eas/json/' }
-  );
-}
-
-export const pnpmUnsupportedNodeVersionErrorHandler: ErrorHandler<errors.UserError> = {
-  regexp: PNPM_UNSUPPORTED_NODE_VERSION_REGEXP,
-  createError: createPnpmUnsupportedNodeVersionError,
-};
-
-export function detectPnpmUnsupportedNodeVersionError(
-  output: string
-): errors.UserError | undefined {
-  const match = output.match(PNPM_UNSUPPORTED_NODE_VERSION_REGEXP);
-  return match ? createPnpmUnsupportedNodeVersionError(match) : undefined;
-}

packages/build-tools/src/buildErrors/userErrorHandlers.ts

@@ -1,7 +1,6 @@
 import { BuildMode, BuildPhase, Platform, Workflow, errors } from '@expo/eas-build-job';
 
 import { ErrorHandler, XCODE_BUILD_PHASE } from './errors.types';
-import { pnpmUnsupportedNodeVersionErrorHandler } from './pnpmUnsupportedNodeVersionError';
 
 import UserError = errors.UserError;
 
@@ -212,7 +211,6 @@ You are seeing this error because either:
       return undefined;
     },
   },
-  pnpmUnsupportedNodeVersionErrorHandler,
   {
     platform: Platform.IOS,
     phase: XCODE_BUILD_PHASE,

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(async () => []),
+  uploadApplicationArchive: jest.fn(),
 }));
 jest.mock('../../utils/expoUpdates', () => ({
   configureExpoUpdatesIfInstalledAsync: jest.fn(),

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

@@ -17,10 +17,6 @@ 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,
@@ -224,30 +220,11 @@ async function buildInnerAsync(
   });
 
   await ctx.runBuildPhase(BuildPhase.UPLOAD_APPLICATION_ARCHIVE, async () => {
-    const [archivePath] = await uploadApplicationArchive(ctx, {
+    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,10 +18,6 @@ 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,
@@ -240,30 +236,11 @@ async function buildInnerAsync(
   });
 
   await ctx.runBuildPhase(BuildPhase.UPLOAD_APPLICATION_ARCHIVE, async () => {
-    const [archivePath] = await uploadApplicationArchive(ctx, {
+    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/common/__tests__/xcpretty.test.ts

@@ -3,7 +3,6 @@ import { EventEmitter } from 'events';
 import spawnAsync from '@expo/spawn-async';
 import { ExpoRunFormatter } from '@expo/xcpretty';
 import fg from 'fast-glob';
-import { vol } from 'memfs';
 
 import { createMockLogger } from '../../__tests__/utils/logger';
 import { Sentry } from '../../sentry';
@@ -60,47 +59,6 @@ describe(XcodeBuildLogger, () => {
     expect(Sentry.capture).not.toHaveBeenCalled();
   });
 
-  it('flushes the final incomplete compiler error when the log reader is interrupted', async () => {
-    const { ExpoRunFormatter: RealFormatter } =
-      jest.requireActual<typeof import('@expo/xcpretty')>('@expo/xcpretty');
-    jest.mocked(ExpoRunFormatter.create).mockImplementation(RealFormatter.create);
-
-    let rejectReader!: (error: Error) => void;
-    const spawnPromise = Object.assign(
-      new Promise<never>((_resolve, reject) => {
-        rejectReader = reject;
-      }),
-      {
-        child: {
-          stdout,
-          kill: () =>
-            rejectReader(Object.assign(new Error('tail interrupted'), { signal: 'SIGINT' })),
-        },
-      }
-    );
-    jest.mocked(spawnAsync).mockReturnValue(spawnPromise as any);
-    const diagnostics =
-      '/project/First.swift:12:3: error: first compiler error\n' +
-      '    /project/Last.swift:20:4: error: final compiler error\n';
-    vol.fromJSON({ '/logs/build.log': diagnostics });
-    const logger = createMockLogger();
-    const buildLogger = new XcodeBuildLogger(logger, '/project');
-    await buildLogger.watchLogFiles('/logs');
-    stdout.emit('data', diagnostics);
-
-    await buildLogger.flush();
-
-    const output = jest
-      .mocked(logger.info)
-      .mock.calls.map(([line]) => String(line))
-      .join('\n');
-    expect(output).toContain('first compiler error');
-    expect(output).toContain('final compiler error');
-    expect(output).toContain('Last.swift:20:4');
-    expect(output).toContain('2 error(s)');
-    expect(output.match(/final compiler error/g)).toHaveLength(1);
-  });
-
   it('falls back to raw logs when the formatter throws', async () => {
     const logger = createMockLogger();
     await startWatchingAsync(logger);

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

@@ -4,7 +4,6 @@ import path from 'path';
 
 import { BuildContext } from '../context';
 import { Sentry } from '../sentry';
-import { NpmCacheRegistryInstallError, isNpmCacheInstallFailure } from '../utils/npmCacheRegistry';
 import { PackageManager, findPackagerRootDir } from '../utils/packageManager';
 import { isUsingModernYarnVersion } from '../utils/project';
 
@@ -197,6 +196,10 @@ export function resolvePackagerDir(ctx: BuildContext<Job>): string {
   return packagerRunDir;
 }
 
+function isNpmCacheInstallFailure(err: unknown, npmCacheUrl: string): boolean {
+  return getErrorOutput(err).includes(npmCacheUrl);
+}
+
 function isNpmCacheRegistryErrorLine(line: string, npmCacheUrl: string): boolean {
   return (
     line.includes(npmCacheUrl) &&
@@ -204,9 +207,24 @@ function isNpmCacheRegistryErrorLine(line: string, npmCacheUrl: string): boolean
   );
 }
 
+function getErrorOutput(err: unknown): string {
+  if (!(err instanceof Error)) {
+    return '';
+  }
+  const { stdout, stderr } = err as Error & { stdout?: string; stderr?: string };
+  return [stdout, stderr].filter(Boolean).join('\n');
+}
+
 class NpmCacheRegistryNonFatalError extends SystemError {
   override name = 'NpmCacheRegistryNonFatalError';
   constructor() {
     super('Non-fatal npm cache registry error during dependency install');
   }
 }
+
+class NpmCacheRegistryInstallError extends SystemError {
+  override name = 'NpmCacheRegistryInstallError';
+  constructor(cause: unknown) {
+    super('Failed to install dependencies using npm cache registry', { cause });
+  }
+}

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

@@ -71,12 +71,7 @@ export async function setupAsync<TJob extends BuildJob>(
       }
     );
 
-    await setUpNpmrcAsync({
-      projectTargetDirectory: ctx.buildDirectory,
-      workingDirectory: ctx.getReactNativeProjectDirectory(),
-      env: ctx.env,
-      logger: ctx.logger,
-    });
+    await setUpNpmrcAsync(ctx, ctx.logger);
     if (ctx.job.platform === Platform.IOS && ctx.env.EAS_BUILD_RUNNER === 'eas-build') {
       await deleteXcodeEnvLocalIfExistsAsync(ctx as BuildContext<Ios.Job>);
     }

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

@@ -80,12 +80,9 @@ export class XcodeBuildLogger {
           this.logger.info(data.toString());
         }
       });
-      try {
-        await this.logReaderPromise;
-      } finally {
-        // flush() interrupts tail, but the formatter may still hold a final compiler diagnostic.
-        this.logger.info(formatter.getBuildSummary());
-      }
+      await this.logReaderPromise;
+
+      this.logger.info(formatter.getBuildSummary());
     } catch (err: any) {
       if (!this.flushing) {
         this.loggerError = err;

packages/build-tools/src/index.ts

@@ -34,7 +34,6 @@ export { formatSecondsForLog } from './utils/formatDuration';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';
 
 export { Hook, runHookIfPresent } from './utils/hooks';
-export { detectPnpmUnsupportedNodeVersionError } from './buildErrors/pnpmUnsupportedNodeVersionError';
 
 export { parseGradleProfile, formatGradleProfileReport } from './android/gradleProfile';
 export type { GradleProfileTask } from './android/gradleProfile';

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

@@ -1,18 +0,0 @@
-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,7 +33,6 @@ 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 {
@@ -62,13 +61,13 @@ import { createStartWebPreviewRemoteSessionBuildFunction } from './functions/sta
 import { createStartServeSimMetricsBuildFunction } from './functions/startServeSimMetrics';
 import { createStartServeSimLogsBuildFunction } from './functions/startServeSimLogs';
 import { createCollectServeSimLogsBuildFunction } from './functions/collectServeSimLogs';
-import { createCollectAndroidEmulatorLogsBuildFunction } from './functions/collectAndroidEmulatorLogs';
 import { createStartSandboxBuildFunction } from './functions/startSandbox';
 import { createCollectServeSimMetricsBuildFunction } from './functions/collectServeSimMetrics';
 import { createUploadArtifactBuildFunction } from './functions/uploadArtifact';
 import { createUploadDeviceRunSessionScreenRecordingsBuildFunction } from './functions/uploadDeviceRunSessionScreenRecordings';
 import { createUploadEmbeddedBundleBuildFunction } from './functions/uploadEmbeddedBundle';
 import { createUploadToAscBuildFunction } from './functions/uploadToAsc';
+import { createWaitForAscBuildProcessingBuildFunction } from './functions/waitForAscBuildProcessing';
 import { createUpdateTestFlightMetadataBuildFunction } from './functions/updateTestFlightMetadata';
 import { createSetUpNpmrcBuildFunction } from './functions/useNpmToken';
 import { createWaitForPosthogMetricFunction } from './functions/waitForPosthogMetric';
@@ -113,11 +112,8 @@ 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(),
@@ -126,11 +122,9 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     createFinishIosSimulatorRecordingsBuildFunction(),
     createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx),
     createStartWebPreviewRemoteSessionBuildFunction(ctx),
-    createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true }),
     createStartServeSimMetricsBuildFunction(),
     createStartServeSimLogsBuildFunction(),
     createCollectServeSimLogsBuildFunction(ctx),
-    createCollectAndroidEmulatorLogsBuildFunction(ctx),
     createStartSandboxBuildFunction(ctx),
     createRunAgentBuildFunction(ctx),
     createCollectServeSimMetricsBuildFunction(ctx),
@@ -151,6 +145,7 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
     createSubmissionEntityFunction(),
     createSubmitToGooglePlayBuildFunction(),
     createUploadToAscBuildFunction(),
+    createWaitForAscBuildProcessingBuildFunction(),
     createUpdateTestFlightMetadataBuildFunction(),
 
     createReportMaestroTestResultsFunction(ctx),
@@ -161,7 +156,6 @@ 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,35 +130,6 @@ 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,7 +19,6 @@ 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';
@@ -184,20 +183,7 @@ function createStepsForIosSimulatorBuild({
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).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 }',
-        },
-      }
-    ),
+    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
     saveCache,
     createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
       workingDirectory,
@@ -318,10 +304,7 @@ function createStepsForIosBuildWithCredentials({
     runFastlane,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, {
-      id: 'find_and_upload_build_artifacts',
-      workingDirectory,
-    }),
+    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -335,16 +318,6 @@ 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,
@@ -431,10 +404,7 @@ function createStepsForAndroidBuildWithoutCredentials({
     runGradle,
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, {
-      id: 'find_and_upload_build_artifacts',
-      workingDirectory,
-    }),
+    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -448,16 +418,6 @@ 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,
@@ -550,10 +510,7 @@ function createStepsForAndroidBuildWithCredentials({
       : []),
     createFindAndUploadBuildArtifactsBuildFunction(
       buildToolsContext
-    ).createBuildStepFromFunctionCall(globalCtx, {
-      id: 'find_and_upload_build_artifacts',
-      workingDirectory,
-    }),
+    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
     ...(shouldUploadEmbeddedBundle({
       env: globalCtx.env,
       metadata: globalCtx.staticContext.metadata,
@@ -567,16 +524,6 @@ 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__/collectAndroidEmulatorLogs.test.ts

@@ -1,48 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-
-import {
-  createCustomBuildContextMock,
-  createGlobalContextMock,
-} from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { Sentry } from '../../../sentry';
-import { collectAndroidEmulatorLogsAsync } from '../../utils/androidEmulatorLogs';
-import { createCollectAndroidEmulatorLogsBuildFunction } from '../collectAndroidEmulatorLogs';
-
-jest.mock('../../../sentry');
-jest.mock('../../utils/androidEmulatorLogs');
-
-function createStep(callInputs: Record<string, unknown> = {}) {
-  const logger = createMockLogger();
-  const ctx = createCustomBuildContextMock();
-  const global = createGlobalContextMock({ logger });
-  const fn = createCollectAndroidEmulatorLogsBuildFunction(ctx);
-  const step = fn.createBuildStepFromFunctionCall(global, {
-    callInputs,
-    env: { DEVICE_RUN_SESSION_ID: 'session' },
-  });
-  return { ctx, global, logger, fn, step };
-}
-
-it('collects captured logs without a second source selection', async () => {
-  const { ctx, global, fn, step } = createStep();
-  expect(fn.supportedRuntimePlatforms).toEqual([BuildRuntimePlatform.LINUX]);
-  await step.executeAsync();
-  expect(collectAndroidEmulatorLogsAsync).toHaveBeenCalledWith(ctx, {
-    global,
-    deviceRunSessionId: 'session',
-    logger: expect.anything(),
-  });
-});
-
-it('reports collection failure without changing the session result', async () => {
-  jest
-    .mocked(collectAndroidEmulatorLogsAsync)
-    .mockRejectedValueOnce(new Error('collection failed'));
-  const { step } = createStep();
-  await expect(step.executeAsync()).resolves.toBeUndefined();
-  expect(Sentry.capture).toHaveBeenCalledWith(
-    'Could not collect Android emulator logs',
-    expect.any(Error)
-  );
-});

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

@@ -2,12 +2,10 @@ import { BuildRuntimePlatform, type BuildStepContext } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
 
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
 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';
@@ -46,26 +44,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   waitForFileAsync: jest.fn(),
 }));
 
-// Agent-device also polls for Stop while it starts up. That watch sets neither an idle timeout nor
-// a duration; keep it pending until startup retires it, and give each lifetime wait its own mock.
-const lifetimeWait = jest.fn<
-  ReturnType<typeof waitForDeviceRunSessionStoppedAsync>,
-  Parameters<typeof waitForDeviceRunSessionStoppedAsync>
->();
-function routeStartupWatch(): void {
-  lifetimeWait.mockReset();
-  jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async args => {
-    if ('idleTimeout' in args || 'maxDurationSeconds' in args) {
-      return await lifetimeWait(args);
-    }
-    if (!args.signal?.aborted) {
-      await new Promise<void>(resolve =>
-        args.signal?.addEventListener('abort', () => resolve(), { once: true })
-      );
-    }
-  });
-}
-
 const finishHost = jest.fn();
 const closePreview = jest.fn();
 const stopTool = jest.fn();
@@ -76,8 +54,6 @@ const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnTh
 
 beforeEach(() => {
   jest.clearAllMocks();
-  jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockResolvedValue();
-  routeStartupWatch();
   // 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.
@@ -122,8 +98,8 @@ beforeEach(() => {
   const events = { stopAsync: stopEvents, getLastEventObservedAt: () => undefined };
   jest.mocked(startAgentDeviceEventCollectionAsync).mockResolvedValue(events);
   jest.mocked(startAppiumEventCollectionAsync).mockResolvedValue(events);
-  jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue('started');
-  lifetimeWait.mockResolvedValue(undefined);
+  jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
+  jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
 });
 
 afterEach(() => {
@@ -140,20 +116,13 @@ describe.each([
     corsOrigins?: string[]
   ) {
     const fn = createFunction({} as CustomBuildContext);
-    const global = createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX });
-    const defaults = new Map(
-      fn.inputProviders?.map(provider => {
-        const input = provider(global, 'Test session');
-        return [input.id, input.defaultValue];
-      })
-    );
     await fn.fn!(
       {
         logger,
         global: { runtimePlatform: BuildRuntimePlatform.LINUX },
       } as unknown as BuildStepContext,
       {
-        // Match step execution: omitted inputs use their declared defaults.
+        // Inputs a step does not get default to undefined, like in a real step call.
         inputs: new Proxy(
           {
             public_preview: { value: publicPreview },
@@ -161,7 +130,7 @@ describe.each([
             cors_origins: { value: corsOrigins },
           } as Record<string, { value: unknown }>,
           {
-            get: (target, id: string) => target[id] ?? { value: defaults.get(id) },
+            get: (target, id: string) => target[id] ?? { value: undefined },
           }
         ),
         outputs: {},
@@ -176,11 +145,7 @@ describe.each([
 
   it('holds the host until session completion', async () => {
     await runAsync();
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ preview: { baseDomain: 'example.test', authtoken: 'token' } })
-    );
-    expect(openPreview).toHaveBeenCalledWith();
+    expect(openPreview).toHaveBeenCalledWith({ baseDomain: 'example.test', authtoken: 'token' });
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
       expect.objectContaining({
         remoteConfig: expect.objectContaining({
@@ -192,7 +157,7 @@ describe.each([
     expect(finishHost).toHaveBeenCalledTimes(1);
     expect(closePreview).not.toHaveBeenCalled();
     expect(finishHost.mock.invocationCallOrder[0]).toBeGreaterThan(
-      lifetimeWait.mock.invocationCallOrder[0]
+      jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.invocationCallOrder[0]
     );
     expect(stopTool).toHaveBeenCalledTimes(1);
     expect(stopEvents).toHaveBeenCalledTimes(1);
@@ -337,7 +302,7 @@ describe.each([
     } else if (phase === 'config') {
       jest.mocked(uploadRemoteSessionConfigAsync).mockRejectedValueOnce(error);
     } else {
-      lifetimeWait.mockRejectedValueOnce(error);
+      jest.mocked(waitForDeviceRunSessionStoppedAsync).mockRejectedValueOnce(error);
     }
     await expect(runAsync()).rejects.toBe(error);
     expect(finishHost).toHaveBeenCalledTimes(1);
@@ -385,10 +350,6 @@ 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 =>
@@ -399,26 +360,25 @@ 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, started };
+    return finish;
   }
 
   it.each(['installed', 'failed'] as const)(
     'starts Appium after the ffmpeg install settles (%s)',
     async outcome => {
-      const { finish, started } = holdFfmpegInstall();
+      const finishFfmpegInstall = holdFfmpegInstall();
 
       const run = runAppiumAsync();
-      await started;
+      await new Promise(resolve => setImmediate(resolve));
       expect(spawnDetached).not.toHaveBeenCalled();
 
-      finish(outcome);
+      finishFfmpegInstall(outcome);
       await run;
       expect(spawnDetached).toHaveBeenCalledTimes(1);
     }
@@ -426,16 +386,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 { finish, started } = holdFfmpegInstall({ appiumError });
+    const finishFfmpegInstall = holdFfmpegInstall({ appiumError });
 
     let settled = false;
     const run = runAppiumAsync().finally(() => {
       settled = true;
     });
-    await started;
+    await new Promise(resolve => setImmediate(resolve));
     expect(settled).toBe(false);
 
-    finish('installed');
+    finishFfmpegInstall('installed');
     await expect(run).rejects.toBe(appiumError);
   });
 });

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

@@ -162,59 +162,6 @@ afterEach(() => {
 });
 
 describe('downloadBuild', () => {
-  it.each([404, 410])('identifies the unavailable build on HTTP %s', async status => {
-    const buildId = randomUUID();
-    const { Response: ActualResponse } =
-      jest.requireActual<typeof import('node-fetch')>('node-fetch');
-    jest
-      .mocked(fetch)
-      .mockResolvedValue(new ActualResponse('<Error>NoSuchKey</Error>', { status }));
-
-    await expect(
-      downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        buildId,
-        graphqlClient: createMockGraphqlClient({ applicationArchiveUrl: APPLICATION_ARCHIVE_URL }),
-        robotAccessToken: null,
-        extensions: ['app'],
-      })
-    ).rejects.toMatchObject({
-      errorCode: 'EAS_DOWNLOAD_BUILD_ARCHIVE_UNAVAILABLE',
-      message:
-        `Failed to download the application archive for build ${buildId} (HTTP ${status}). ` +
-        'The archive is unavailable. Check that the archive still exists and try again.',
-    });
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([404, 410, 500])(
-    'identifies the application URL without credentials on HTTP %s',
-    async status => {
-      const { Response: ActualResponse } =
-        jest.requireActual<typeof import('node-fetch')>('node-fetch');
-      jest.mocked(fetch).mockResolvedValue(new ActualResponse('download failed', { status }));
-
-      const download = downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        applicationArchiveUrl:
-          'https://user:[email protected]/app.tar.gz?token=secret#fragment',
-        graphqlClient: createMockGraphqlClient({}),
-        robotAccessToken: null,
-        extensions: ['app'],
-      });
-
-      const prefix = `Failed to download the archive at https://example.test/app.tar.gz (HTTP ${status})`;
-      await expect(download).rejects.toThrow(
-        status === 500
-          ? `${prefix}: download failed`
-          : `${prefix}. The archive is unavailable. ` +
-              'Check that the URL is correct and the archive still exists, then try again.'
-      );
-      await expect(download).rejects.not.toThrow(/password|secret|fragment/);
-      expect(fetch).toHaveBeenCalledTimes(1);
-    }
-  );
-
   it('downloads from applicationArchiveUrl returned by GraphQL', async () => {
     const buildId = randomUUID();
     const graphqlClient = createMockGraphqlClient({

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

@@ -51,24 +51,6 @@ 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,7 +7,6 @@ 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,
@@ -83,26 +82,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
 
-// Agent-device also polls for Stop while it starts up. That watch sets neither an idle timeout nor
-// a duration; keep it pending until startup retires it, and give each lifetime wait its own mock.
-const lifetimeWait = jest.fn<
-  ReturnType<typeof waitForDeviceRunSessionStoppedAsync>,
-  Parameters<typeof waitForDeviceRunSessionStoppedAsync>
->();
-function routeStartupWatch(): void {
-  lifetimeWait.mockReset();
-  jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async args => {
-    if ('idleTimeout' in args || 'maxDurationSeconds' in args) {
-      return await lifetimeWait(args);
-    }
-    if (!args.signal?.aborted) {
-      await new Promise<void>(resolve =>
-        args.signal?.addEventListener('abort', () => resolve(), { once: true })
-      );
-    }
-  });
-}
-
 const logger = {
   info: jest.fn(),
   warn: jest.fn(),
@@ -145,8 +124,6 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
   }
   beforeEach(() => {
     jest.clearAllMocks();
-    jest.mocked(pollAgentDeviceArtifactsForUploadAsync).mockResolvedValue();
-    routeStartupWatch();
     lifetime = registerLocalEgressResources(stopEgress);
     stopEgress.mockResolvedValue(undefined);
     stopPreview.mockResolvedValue(undefined);
@@ -188,8 +165,8 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
       getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopPreview,
     });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue('started');
-    lifetimeWait.mockImplementation(async () => {
+    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
+    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async () => {
       expect(lifetime.aborted).toBe(false);
       expect(monitorLocalEgressAsync).toHaveBeenCalledTimes(1);
     });
@@ -199,30 +176,18 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
     jest.restoreAllMocks();
   });
 
-  it('releases resources without monitoring when the session stopped during startup', async () => {
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValueOnce('stopped');
-    await run();
-    expect(lifetimeWait).not.toHaveBeenCalled();
-    expect(monitorLocalEgressAsync).not.toHaveBeenCalled();
-    expect(stopPreview).toHaveBeenCalledTimes(1);
-    expect(stopEgress).toHaveBeenCalledTimes(1);
-    expect(lifetime.aborted).toBe(true);
-  });
-
   it('reports credentials and starts monitoring before waiting, then releases resources', async () => {
     await run();
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        ctx,
-        deviceRunSessionId: 'session-id',
-        logger,
-        remoteConfig: expect.objectContaining({
-          ...fields,
-          [controllerField]: expect.any(String),
-          [controllerField === 'previewUrl' ? 'previewToken' : 'webPreviewToken']: 'preview-secret',
-        }),
-      })
-    );
+    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith({
+      ctx,
+      deviceRunSessionId: 'session-id',
+      logger,
+      remoteConfig: expect.objectContaining({
+        ...fields,
+        [controllerField]: expect.any(String),
+        [controllerField === 'previewUrl' ? 'previewToken' : 'webPreviewToken']: 'preview-secret',
+      }),
+    });
     expect(monitorLocalEgressAsync).toHaveBeenCalledWith({
       port: handoff.port,
       env,
@@ -236,7 +201,7 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
     await stopLocalEgressResourcesAsync(logger);
     stopEgress.mockClear();
     jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue(null);
-    lifetimeWait.mockResolvedValue(undefined);
+    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
     await run();
     const { remoteConfig } = jest.mocked(uploadRemoteSessionConfigAsync).mock.calls[0][0];
     expect(remoteConfig).toHaveProperty(controllerField);
@@ -255,7 +220,7 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
       } else if (phase === 'report') {
         jest.mocked(uploadRemoteSessionConfigAsync).mockRejectedValue(error);
       } else if (phase === 'wait') {
-        lifetimeWait.mockRejectedValue(error);
+        jest.mocked(waitForDeviceRunSessionStoppedAsync).mockRejectedValue(error);
       } else {
         stopPreview.mockRejectedValue(error);
       }
@@ -269,10 +234,11 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
   );
   it('passes cancellation to the monitor and releases the lifetime', async () => {
     const abort = new AbortController();
-    lifetimeWait.mockImplementation(async () => abort.abort());
+    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async () => abort.abort());
     await run(abort.signal);
-    // Agent-device hands the monitor its startup signal, which follows the step signal.
-    expect(jest.mocked(monitorLocalEgressAsync).mock.calls[0][0].signal?.aborted).toBe(true);
+    expect(monitorLocalEgressAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ signal: abort.signal })
+    );
     expect(lifetime.aborted).toBe(true);
     expect(stopEgress).toHaveBeenCalledTimes(1);
   });

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

@@ -1,10 +1,8 @@
 import { type bunyan } from '@expo/logger';
-import turtleSpawnAsync from '@expo/turtle-spawn';
 import assert from 'node:assert';
 import fg from 'fast-glob';
 import { vol } from 'memfs';
 import path from 'node:path';
-import resolveFrom from 'resolve-from';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { createTestAndroidJob, createTestIosJob } from '../../../__tests__/utils/job';
@@ -19,100 +17,17 @@ import {
 } from '../repack';
 
 jest.mock('fs');
-jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
+jest.mock('@expo/spawn-async');
 jest.mock('@expo/repack-app');
-jest.mock('resolve-from', () => jest.fn(() => '@expo/repack-app'));
+jest.mock('resolve-from', () => jest.fn((_, moduleName) => moduleName));
 jest.mock('../../utils/ios/credentials/manager');
 
 describe(createRepackBuildFunction, () => {
-  beforeEach(() => {
-    jest.mocked(turtleSpawnAsync).mockImplementation((async (_command: string, args: string[]) => {
-      const sandbox = args[args.indexOf('--prefix') + 1];
-      const packageName = args[args.length - 1].replace(/@[^@/]*$/, '');
-      vol.fromJSON({
-        [path.join(sandbox, 'node_modules', packageName, 'package.json')]: JSON.stringify({
-          version: '2.0.0-next.1',
-        }),
-      });
-    }) as unknown as typeof turtleSpawnAsync);
-  });
-
   afterEach(() => {
     jest.restoreAllMocks();
     vol.reset();
   });
 
-  it('installs the repack package with npm in a sandbox whose env is only PATH and HOME, through the npm cache registry', async () => {
-    const globalCtx = createGlobalContextMock({
-      staticContextContent: {
-        job: {},
-      },
-    });
-    globalCtx.updateEnv({
-      PATH: '/usr/local/bin:/usr/bin',
-      EAS_BUILD_NPM_CACHE_URL: 'https://npm-cache.expo.test',
-      NPM_TOKEN: 'secret',
-    });
-    const repack = createRepackBuildFunction();
-    const repackStep = repack.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: {
-        platform: 'ios',
-        source_app_path: '/path/to/source_app.ipa',
-        repack_package: '@scope/fork',
-        repack_version: 'next',
-      },
-    });
-    const logInfo = jest.spyOn(repackStep.ctx.logger, 'info');
-
-    await repackStep.executeAsync();
-
-    const [installCall] = jest.mocked(turtleSpawnAsync).mock.calls;
-    const npmEnv = installCall[2]?.env;
-    assert(npmEnv);
-    expect(Object.keys(npmEnv).sort()).toEqual(['HOME', 'PATH']);
-    expect(npmEnv.PATH).toMatch(/\/usr\/local\/bin:\/usr\/bin$/);
-    expect(installCall).toEqual([
-      'npm',
-      [
-        'install',
-        '--prefix',
-        npmEnv.HOME,
-        '--no-save',
-        '--package-lock=false',
-        '--no-audit',
-        '--no-fund',
-        '--no-update-notifier',
-        '--registry',
-        'https://npm-cache.expo.test',
-        '@scope/fork@next',
-      ],
-      { env: npmEnv, logger: repackStep.ctx.logger },
-    ]);
-    expect(logInfo).toHaveBeenCalledWith('Using repack from: @scope/fork@next (2.0.0-next.1)');
-    expect(resolveFrom).toHaveBeenCalledWith(npmEnv.HOME, '@scope/fork');
-  });
-
-  it('installs the repack package from the default registry when the job has no npm cache', async () => {
-    const globalCtx = createGlobalContextMock({
-      staticContextContent: {
-        job: {},
-      },
-    });
-    globalCtx.updateEnv({ PATH: '/usr/local/bin:/usr/bin' });
-    const repack = createRepackBuildFunction();
-    const repackStep = repack.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: {
-        platform: 'ios',
-        source_app_path: '/path/to/source_app.ipa',
-      },
-    });
-
-    await repackStep.executeAsync();
-
-    const [installCall] = jest.mocked(turtleSpawnAsync).mock.calls;
-    expect(installCall[1]).not.toContain('--registry');
-  });
-
   it('should set generated output path for successful repack', async () => {
     const repack = createRepackBuildFunction();
     const repackStep = repack.createBuildStepFromFunctionCall(

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

@@ -103,7 +103,7 @@ describe(createRunAgentBuildFunction, () => {
     );
     const npmEnv = installMock.mock.calls[0][2]!.env!;
     const agentEnv = spawnMock.mock.calls[0][2].env!;
-    expect(Object.keys(npmEnv).sort()).toEqual(['HOME', 'PATH']);
+    expect(Object.keys(npmEnv).sort()).toEqual(['HOME', 'LANG', 'PATH', 'TMPDIR']);
     expect(Object.keys(agentEnv).sort()).toEqual([
       'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
       'CLAUDE_CODE_OAUTH_TOKEN',

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

@@ -1,18 +1,14 @@
 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 {
-  DeviceRunSessionStoppedError,
   getDeviceRunSessionIdOrThrow,
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
@@ -25,8 +21,6 @@ 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
@@ -44,14 +38,10 @@ 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(),
@@ -84,7 +74,10 @@ const NO_CAPTURE: CaptureInputs = { networkCapture: false, networkCaptureFields:
 async function runAsync(
   logger: { info: jest.Mock; warn: jest.Mock; child: jest.Mock },
   runtimePlatform: BuildRuntimePlatform,
-  options: Partial<Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]> = {}
+  capture: CaptureInputs = NO_CAPTURE,
+  disableShare = false,
+  privatePreviewUrl?: string,
+  maxIdleTimeMinutes?: number
 ): Promise<void> {
   await runAgentDeviceRemoteSessionAsync(ctx, {
     env: {},
@@ -96,31 +89,20 @@ async function runAsync(
       ngrokAuthtoken: 'ngrok-token',
     },
     packageVersion: undefined,
-    maxIdleTimeMinutes: undefined,
+    maxIdleTimeMinutes,
     maxDurationSeconds: undefined,
-    capture: NO_CAPTURE,
-    tasks: createStartupTasks(logger as never, options.signal),
+    capture,
+    disableShare,
+    privatePreviewUrl,
+    tasks: createStartupTasks(logger as never),
     device:
       runtimePlatform === BuildRuntimePlatform.DARWIN
         ? { iosSimulatorUdid: 'selected-udid', application: Promise.resolve() }
         : { booted: Promise.resolve(), ready: Promise.resolve() },
-    ...options,
   });
 }
 
 describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
-  it('cleans up a stopped startup without starting live-session polling', async () => {
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValueOnce('stopped');
-    await runAsync(logger, BuildRuntimePlatform.DARWIN);
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-    expect(pollAgentDeviceArtifactsForUploadAsync).not.toHaveBeenCalled();
-    expect(startAgentDeviceEventCollectionAsync).not.toHaveBeenCalled();
-    expect(mockDaemonStopAsync).toHaveBeenCalled();
-    expect(mockTunnelStopAsync).toHaveBeenCalled();
-    expect(mockPreviewStopAsync).toHaveBeenCalled();
-  });
-
   beforeEach(async () => {
     jest.clearAllMocks();
 
@@ -165,7 +147,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       }
       return host;
     });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue('started');
+    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
     jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
 
     await fs.promises.mkdir(path.dirname(DAEMON_ENTRY_PATH), { recursive: true });
@@ -201,213 +183,6 @@ 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/+';
@@ -437,7 +212,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     } as never);
     jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(previewInputAt);
 
-    await runAsync(logger, BuildRuntimePlatform.LINUX, { maxIdleTimeMinutes: 5 });
+    await runAsync(logger, BuildRuntimePlatform.LINUX, NO_CAPTURE, false, undefined, 5);
 
     const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
     expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
@@ -448,7 +223,8 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
 
     await runAsync(logger, BuildRuntimePlatform.DARWIN, {
-      capture: { networkCapture: true, networkCaptureFields: ['header'] },
+      networkCapture: true,
+      networkCaptureFields: ['header'],
     });
 
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
@@ -459,10 +235,13 @@ 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, {
-      disableShare: true,
-      privatePreviewUrl: 'https://expo.dev/private-preview',
-    });
+    await runAsync(
+      logger,
+      BuildRuntimePlatform.DARWIN,
+      NO_CAPTURE,
+      true,
+      'https://expo.dev/private-preview'
+    );
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
       ctx,
       expect.objectContaining({
@@ -558,8 +337,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     type Device = Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]['device'];
     function startSession(
       device: Device | ((tasks: StartupTasks) => Device),
-      signal?: AbortSignal,
-      onStarted?: () => Promise<void>
+      signal?: AbortSignal
     ) {
       const logger = {
         info: jest.fn(),
@@ -587,7 +365,6 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
         capture: NO_CAPTURE,
         tasks,
         device: sessionDevice,
-        onStarted,
       });
     }
 
@@ -826,7 +603,10 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
         ctx,
         {} as never
       );
-      const preview = await host.openPreviewAsync();
+      const preview = await host.openPreviewAsync({
+        baseDomain: 'tunnel.example.com',
+        authtoken: 'ngrok-token',
+      });
       jest.mocked(host.openPreviewAsync).mockImplementation(async () => {
         await previewReady.promise;
         return preview;
@@ -860,106 +640,6 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
     });
 
-    it('reports late host cleanup failure after startup Stop', async () => {
-      const stopped = new DeviceRunSessionStoppedError('stopped during startup');
-      const failed = new AggregateError([stopped, new Error('host cleanup failed')]);
-      let entered!: () => void;
-      const starting = new Promise<void>(resolve => {
-        entered = resolve;
-      });
-      jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-        entered();
-        return await new Promise((_resolve, reject) => {
-          options.signal!.addEventListener('abort', () => setImmediate(() => reject(failed)), {
-            once: true,
-          });
-        });
-      });
-      let tasks!: StartupTasks;
-      const running = startSession(startup => {
-        tasks = startup;
-        return { booted: Promise.resolve(), ready: Promise.resolve() };
-      });
-      running.catch(() => {});
-      await starting;
-      tasks.abort(stopped);
-      await expect(running).rejects.toBe(failed);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    });
-
-    it('drains resources and preserves the explicit startup Stop reason', async () => {
-      const stopped = new DeviceRunSessionStoppedError('stopped during startup');
-      let tasks!: StartupTasks;
-      const session = startSession(startup => {
-        tasks = startup;
-        return { booted: Promise.resolve(), ready: tasks.untilAborted(new Promise(() => {})) };
-      });
-      session.catch(() => {});
-      await flushAsync();
-      tasks.abort(stopped);
-      await expect(session).rejects.toBe(stopped);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-      expect(mockDaemonStopAsync).toHaveBeenCalledTimes(1);
-    });
-
-    it('does not hide a teardown failure after an explicit startup Stop', async () => {
-      const stopped = new DeviceRunSessionStoppedError('stopped during startup');
-      const failed = new Error('daemon teardown failed');
-      let tasks!: StartupTasks;
-      const session = startSession(startup => {
-        tasks = startup;
-        return { booted: Promise.resolve(), ready: tasks.untilAborted(new Promise(() => {})) };
-      });
-      session.catch(() => {});
-      await flushAsync();
-      mockDaemonStopAsync.mockRejectedValueOnce(failed);
-      tasks.abort(stopped);
-      await expect(session).rejects.toBe(failed);
-    });
-
-    it('retires startup monitoring after reporting and before lifetime waiting', async () => {
-      const retired = deferred();
-      const retiring = jest.fn(() => retired.promise);
-      const session = startSession(
-        { booted: Promise.resolve(), ready: Promise.resolve() },
-        undefined,
-        retiring
-      );
-      await flushAsync();
-      expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledTimes(1);
-      expect(retiring).toHaveBeenCalledTimes(1);
-      expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-      retired.resolve();
-      await session;
-      expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledTimes(1);
-    });
-
-    it('aborts a pending ready report when startup is stopped', async () => {
-      const stopped = new DeviceRunSessionStoppedError('stopped during startup');
-      let tasks!: StartupTasks;
-      jest.mocked(uploadRemoteSessionConfigAsync).mockImplementation(
-        async ({ signal }) =>
-          new Promise((_resolve, reject) => {
-            signal!.addEventListener('abort', () => reject(new Error('request aborted')), {
-              once: true,
-            });
-          })
-      );
-      const session = startSession(startup => {
-        tasks = startup;
-        return { booted: Promise.resolve(), ready: Promise.resolve() };
-      });
-      session.catch(() => {});
-      await flushAsync();
-      expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
-        expect.objectContaining({ signal: tasks.signal })
-      );
-      tasks.abort(stopped);
-      await expect(session).rejects.toBe(stopped);
-      expect(startAgentDeviceEventCollectionAsync).not.toHaveBeenCalled();
-    });
-
     it('starts the Android host before application readiness and waits before reporting ready', async () => {
       const ready = deferred();
       const session = startSession({ booted: Promise.resolve(), ready: ready.promise });

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

@@ -4,18 +4,14 @@ import spawn from '@expo/turtle-spawn';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
-import { AndroidEmulatorLogCapture } from '../../../utils/androidEmulatorLogCapture';
-import { getAndroidEmulatorLogCapture } from '../../utils/androidEmulatorLogs';
+import { DeviceRunSessionWorkerApi } from '../../utils/deviceRunSessionWorkerApi';
 import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { stopLocalEgressResourcesAsync } from '../../utils/localEgress';
 import {
   resolveLocalEgressServeSimBootEnvironmentAsync,
   startLocalEgressGuardRelayAsync,
 } from '../../utils/localEgressGuard';
-import {
-  selectXcodeDeveloperDirectoryAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../../utils/remoteDeviceRunSession';
+import { selectXcodeDeveloperDirectoryAsync } from '../../utils/remoteDeviceRunSession';
 import { downloadBuildAsync } from '../downloadBuild';
 import { installBuildAsync } from '../installBuild';
 import { readIosApplicationIdentifierAsync } from '../../utils/iosAppArtifact';
@@ -24,7 +20,6 @@ import {
   getAgentDeviceRemoteSessionEnvOrThrow,
   runAgentDeviceRemoteSessionAsync,
 } from '../startAgentDeviceRemoteSession';
-import { runOnWarmIosSimulatorAsync } from '../../utils/warmDeviceSessionHost';
 import { createStartAgentDeviceSessionBuildFunction } from '../startAgentDeviceSession';
 import { startAndroidEmulatorAsync } from '../startAndroidEmulator';
 import { bootIosSimulatorAsync } from '../startIosSimulator';
@@ -37,19 +32,16 @@ jest.mock('../../utils/localEgressGuard', () => ({
   startLocalEgressGuardRelayAsync: jest.fn(),
 }));
 jest.mock('@expo/turtle-spawn');
-jest.mock('../../utils/androidEmulatorLogs');
 jest.mock('../../../utils/IosSimulatorUtils');
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   selectXcodeDeveloperDirectoryAsync: jest.fn(),
-  waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
 jest.mock('../startIosSimulator', () => ({
   ...jest.requireActual('../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', () => ({
@@ -110,29 +102,41 @@ function runStep(
   runtimePlatform: BuildRuntimePlatform,
   inputValues: Record<string, unknown> = {},
   signal?: AbortSignal,
-  stepCtx: CustomBuildContext = ctx,
-  warm = false,
-  env: NodeJS.ProcessEnv = {}
+  stepCtx: CustomBuildContext = ctx
 ): Promise<void> {
-  const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx, { warm });
+  const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx);
   const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-  const global = createGlobalContextMock({
-    runtimePlatform,
-    staticContextContent: { job: { secrets: { robotAccessToken: 'robot-token' } } },
-  });
   const inputs = Object.fromEntries(
-    (buildFunction.inputProviders ?? []).map(provider => {
-      const input = provider(global, 'test');
-      input.set(inputValues[input.id]);
-      return [input.id, { value: input.rawValue }];
-    })
+    [
+      'device_identifier',
+      'system_image_package',
+      'lcd_width',
+      'lcd_height',
+      'lcd_density',
+      'build_id',
+      'application_archive_url',
+      'launch_args',
+      'open_url',
+      'network_capture',
+      'network_capture_fields',
+      'public_preview',
+      'private_preview_url',
+      'frame_ancestors',
+      'cors_origins',
+      'package_version',
+      'max_idle_time_minutes',
+      'max_duration_seconds',
+    ].map(id => [id, { value: inputValues[id] }])
   );
   return buildFunction.fn!(
     {
       logger,
-      global,
+      global: {
+        runtimePlatform,
+        staticContext: { job: { secrets: { robotAccessToken: 'robot-token' } } },
+      },
     } as unknown as BuildStepContext,
-    { inputs, outputs: {}, env, signal } as never
+    { inputs, outputs: {}, env: {}, signal } as never
   ) as Promise<void>;
 }
 
@@ -141,31 +145,7 @@ function sessionDevice(): Device {
 }
 
 describe(createStartAgentDeviceSessionBuildFunction, () => {
-  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 };
-  }
-
   beforeEach(() => {
-    jest
-      .mocked(getAndroidEmulatorLogCapture)
-      .mockImplementation(
-        jest.requireActual('../../utils/androidEmulatorLogs').getAndroidEmulatorLogCapture
-      );
     deviceLaunch = undefined;
     jest.clearAllMocks();
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(null);
@@ -177,13 +157,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
       .mockResolvedValue([{ name: 'iPhone 17', udid: 'SELECTED-UDID' }] as never);
     jest.mocked(getAgentDeviceRemoteSessionEnvOrThrow).mockReturnValue(sessionEnv);
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async ({ signal }) => {
-      if (!signal?.aborted) {
-        await new Promise<void>(resolve =>
-          signal?.addEventListener('abort', () => resolve(), { once: true })
-        );
-      }
-    });
     jest
       .mocked(runAgentDeviceRemoteSessionAsync)
       .mockImplementation(async (_ctx, { device, tasks }) => {
@@ -199,6 +172,7 @@ 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' });
@@ -206,43 +180,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     jest.mocked(readIosApplicationIdentifierAsync).mockResolvedValue('dev.example.app');
   });
 
-  it.each([false, true])(
-    'observes Stop during warm claim and preserves cleanup failure=%s',
-    async failCleanup => {
-      const stopped = deferred();
-      jest.mocked(waitForDeviceRunSessionStoppedAsync).mockReturnValue(stopped.promise);
-      let entered!: () => void;
-      const claiming = new Promise<void>(resolve => {
-        entered = resolve;
-      });
-      const cleanup = new Error('warm cleanup failed');
-      jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async claim => {
-        entered();
-        await new Promise<void>((_resolve, reject) => {
-          claim.signal!.addEventListener(
-            'abort',
-            () =>
-              reject(
-                failCleanup
-                  ? new AggregateError([claim.signal!.reason, cleanup])
-                  : claim.signal!.reason
-              ),
-            { once: true }
-          );
-        });
-      });
-      const running = runStep(BuildRuntimePlatform.DARWIN, {}, undefined, ctx, true);
-      running.catch(() => {});
-      await claiming;
-      stopped.resolve();
-      if (failCleanup) {
-        await expect(running).rejects.toMatchObject({ errors: expect.arrayContaining([cleanup]) });
-      } else {
-        await expect(running).resolves.toBeUndefined();
-      }
-      expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-    }
-  );
   it('hands guarded iOS boot to serve-sim and starts reporting before host startup', async () => {
     const bootEnv = {
       SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
@@ -251,7 +188,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     };
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(bootEnv);
     await runStep(BuildRuntimePlatform.DARWIN, {
-      install_app_path: '/tmp/App.app',
+      build_id: 'build-id',
       launch_args: ['-flag'],
       open_url: 'exp://example.test',
     });
@@ -265,7 +202,14 @@ 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({
@@ -309,48 +253,63 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     );
   });
 
-  it('fails before app installation or host startup when guarded device shutdown fails', async () => {
+  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 () => {
     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, { install_app_path: '/tmp/App.app' })
-    ).rejects.toThrow('shutdown failed');
-
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-    expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('treats Stop during guarded device shutdown as normal cancellation', async () => {
-    const stopped = deferred();
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockReturnValue(stopped.promise);
-    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).mockImplementation(
-      (_command, _args, options) =>
-        new Promise((_resolve, reject) => {
-          options!.signal!.addEventListener('abort', () => reject(new Error('shutdown aborted')), {
-            once: true,
-          });
-        }) as ReturnType<typeof spawn>
+    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
+      'shutdown failed'
     );
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' });
-    step.catch(() => {});
-    await flushAsync();
-    expect(spawn).toHaveBeenCalled();
-    stopped.resolve();
-    await expect(step).resolves.toBeUndefined();
     expect(downloadBuildAsync).not.toHaveBeenCalled();
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-    expect(startLocalEgressGuardRelayAsync).not.toHaveBeenCalled();
     expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
   });
 
-  it('provides Simulator preparation and local app startup options to the remote session', async () => {
+  it('provides Simulator preparation and downloaded startup options to the remote session', async () => {
     const hostReady = deferred();
     jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
       SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
@@ -365,7 +324,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     });
     const step = runStep(BuildRuntimePlatform.DARWIN, {
       device_identifier: 'iPhone 17',
-      install_app_path: '/tmp/App.app',
+      build_id: 'build-id',
       launch_args: ['-flag'],
       open_url: 'exp://example.test',
     });
@@ -375,7 +334,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       env: {},
     });
     expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-
+    expect(downloadBuildAsync).toHaveBeenCalledTimes(1);
     expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
       artifactPath: '/tmp/App.app',
       env: {},
@@ -393,15 +352,15 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     });
   });
 
-  it('fails a guarded session before app installation or host startup if its boot files are missing', async () => {
+  it('fails a guarded session before download 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, { install_app_path: '/tmp/App.app' })
-    ).rejects.toThrow('missing bin/egress-guard-check');
+    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).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();
@@ -416,21 +375,37 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     jest
       .mocked(runAgentDeviceRemoteSessionAsync)
       .mockRejectedValueOnce(new Error('guard check failed'));
-    await expect(
-      runStep(BuildRuntimePlatform.DARWIN, { install_app_path: '/tmp/App.app' })
-    ).rejects.toThrow('guard check failed');
+    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).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(getAndroidEmulatorLogCapture).not.toHaveBeenCalled();
     expect(sessionDevice()).toEqual({
       iosSimulatorUdid: 'SELECTED-UDID',
       bootEnv: undefined,
@@ -438,48 +413,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     });
   });
 
-  it('defaults an omitted session log input to emulator output through the step boundary', async () => {
-    const buildFunction = createStartAgentDeviceSessionBuildFunction(ctx);
-    const global = createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX });
-    const step = buildFunction.createBuildStepFromFunctionCall(global, {
-      callInputs: {},
-      env: { DEVICE_RUN_SESSION_ID: 'session' },
-    });
-    await step.executeAsync();
-    expect(startAndroidEmulatorAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ logSources: ['emulator-output'] })
-    );
-  });
-
-  it('passes an explicit empty source list and the workflow capture to Android boot', async () => {
-    const capture = new AndroidEmulatorLogCapture();
-    jest.mocked(getAndroidEmulatorLogCapture).mockReturnValue(capture);
-    const env = { DEVICE_RUN_SESSION_ID: 'session' };
-    await runStep(
-      BuildRuntimePlatform.LINUX,
-      { android_log_sources: [] },
-      undefined,
-      ctx,
-      false,
-      env
-    );
-    expect(getAndroidEmulatorLogCapture).toHaveBeenCalledWith(expect.anything(), env);
-    expect(startAndroidEmulatorAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ logSources: [], logCapture: capture })
-    );
-  });
-
-  it('rejects invalid Android log sources before boot or downloading', async () => {
-    await expect(
-      runStep(BuildRuntimePlatform.LINUX, {
-        android_log_sources: ['unknown'],
-        build_id: 'build-id',
-      })
-    ).rejects.toThrow();
-    expect(startAndroidEmulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-  });
-
   it('boots the Android Emulator with the device inputs', async () => {
     await runStep(BuildRuntimePlatform.LINUX, {
       device_identifier: 'pixel_7',
@@ -487,7 +420,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       lcd_width: 720,
       lcd_height: 1600,
       lcd_density: 300,
-      install_app_path: '/tmp/App.app',
+      build_id: 'build-id',
     });
 
     expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
@@ -500,21 +433,67 @@ 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' }, undefined, ctx, false, {
-        DEVICE_RUN_SESSION_ID: 'session',
-      })
-    ).rejects.toThrow('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.
@@ -522,107 +501,40 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     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, { install_app_path: '/tmp/App.app' }, controller.signal)
+      runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal)
     ).rejects.toThrow('cancelled');
     expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
-
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'observes Stop during a held download on %s and drains startup normally',
-    async runtimePlatform => {
-      const download = mockStalledDownload();
-      const stopped = deferred();
-      const controller = new AbortController();
-      jest.mocked(waitForDeviceRunSessionStoppedAsync).mockReturnValue(stopped.promise);
-      const step = runStep(runtimePlatform, { build_id: 'build-id' }, controller.signal);
-      step.catch(() => {});
-      try {
-        await flushAsync();
-        expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledWith(
-          expect.objectContaining({
-            deviceRunSessionId: sessionEnv.deviceRunSessionId,
-            signal: expect.any(AbortSignal),
-          })
-        );
-        stopped.resolve();
-        await expect(step).resolves.toBeUndefined();
-        expect(download.aborted()).toBe(true);
-        expect(download.settled()).toBe(true);
-        expect(installBuildAsync).not.toHaveBeenCalled();
-        expect(launchApplicationAsync).not.toHaveBeenCalled();
-        expect(readIosApplicationIdentifierAsync).not.toHaveBeenCalled();
-      } finally {
-        controller.abort(new Error('test cleanup'));
-        stopped.resolve();
-        await step.catch(() => {});
-      }
-    }
-  );
-
-  it('waits for an in-flight Android boot after Stop without installing or launching', async () => {
-    const boot = deferred<Awaited<ReturnType<typeof startAndroidEmulatorAsync>>>();
-    const stopped = deferred();
-    jest.mocked(startAndroidEmulatorAsync).mockReturnValue(boot.promise);
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockReturnValue(stopped.promise);
-    let settled = false;
-    const step = runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' });
-    void step
-      .finally(() => {
-        settled = true;
-      })
-      .catch(() => {});
-    try {
-      await flushAsync();
-      expect(startAndroidEmulatorAsync).toHaveBeenCalled();
-      stopped.resolve();
-      await flushAsync();
-      expect(settled).toBe(false);
-    } finally {
-      boot.resolve({} as Awaited<ReturnType<typeof startAndroidEmulatorAsync>>);
-      stopped.resolve();
-      await step;
-    }
-    expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-  });
-
-  it('retires the startup watch without treating its abort as user Stop', async () => {
-    jest
-      .mocked(runAgentDeviceRemoteSessionAsync)
-      .mockImplementation(async (_ctx, { onStarted, tasks }) => {
-        await onStarted!();
-        expect(tasks.signal.aborted).toBe(false);
-      });
-    await expect(runStep(BuildRuntimePlatform.DARWIN)).resolves.toBeUndefined();
-    const options = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
-    expect(options.maxDurationSeconds).toBeUndefined();
-    expect(options.idleTimeout).toBeUndefined();
-    expect(options.signal!.aborted).toBe(true);
-  });
-
-  it('preserves a download failure that wins before Stop', async () => {
-    const failed = new Error('download failed first');
-    const stopped = deferred();
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockReturnValue(stopped.promise);
-    jest.mocked(downloadBuildAsync).mockRejectedValue(failed);
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' });
-    step.catch(() => {});
-    await flushAsync();
-    stopped.resolve();
-    await expect(step).rejects.toBe(failed);
-  });
-
-  it('fails when the startup status watch rejects', async () => {
-    const failed = new Error('session errored');
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockRejectedValue(failed);
-    await expect(runStep(BuildRuntimePlatform.DARWIN)).rejects.toBe(failed);
     expect(downloadBuildAsync).not.toHaveBeenCalled();
     expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
   });
@@ -641,15 +553,11 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     expect(installBuildAsync).not.toHaveBeenCalled();
   });
 
-  it('does not start device or app work after cancellation during Xcode selection', async () => {
+  it('does not start device or download 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,
-      { install_app_path: '/tmp/App.app' },
-      controller.signal
-    );
+    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'));
@@ -658,7 +566,42 @@ 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();
   });
 
@@ -669,16 +612,13 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     expect(
       buildFunction.inputProviders?.map(provider => provider(globalCtx, 'Test step').id)
     ).toEqual([
-      'android_log_sources',
       'device_identifier',
       'system_image_package',
       'lcd_width',
       'lcd_height',
       'lcd_density',
-      'install_app_path',
       'build_id',
       'application_archive_url',
-      'launch_app_identifier',
       'launch_args',
       'open_url',
       'network_capture',
@@ -738,15 +678,12 @@ 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, {
-      install_app_path: '/tmp/App.app',
-      ...inputs,
-    });
+    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id', ...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();
   });
 
@@ -755,22 +692,16 @@ 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, {
-      install_app_path: '/tmp/App.app',
-      ...inputs,
-    });
+    const step = runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', ...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, {
-      install_app_path: '/tmp/App.app',
-      launch_args: launchArgs,
-    });
+    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', launch_args: launchArgs });
     expect(launchApplicationAsync).toHaveBeenCalledWith(
       expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX, launchArgs })
     );
@@ -797,170 +728,4 @@ 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__/startAndroidEmulator.test.ts

@@ -9,8 +9,6 @@ import {
 } from '../../../utils/AndroidEmulatorUtils';
 import { retryAsync } from '../../../utils/retry';
 import { resolveAndroidEmulatorLocalEgressAsync } from '../../utils/androidLocalEgress';
-import { AndroidEmulatorLogCapture } from '../../../utils/androidEmulatorLogCapture';
-import { getAndroidEmulatorLogCapture } from '../../utils/androidEmulatorLogs';
 import { createStartAndroidEmulatorBuildFunction } from '../startAndroidEmulator';
 
 jest.mock('@expo/turtle-spawn', () => ({
@@ -26,8 +24,6 @@ jest.mock('../../utils/androidLocalEgress', () => ({
   resolveAndroidEmulatorLocalEgressAsync: jest.fn(),
 }));
 
-jest.mock('../../utils/androidEmulatorLogs');
-
 jest.mock('../../../utils/AndroidEmulatorUtils', () => ({
   AndroidEmulatorUtils: {
     defaultSystemImagePackage: 'system-images;android-30;default;x86_64',
@@ -66,11 +62,6 @@ function createStartResult(serialId: string) {
 
 describe(createStartAndroidEmulatorBuildFunction, () => {
   beforeEach(() => {
-    jest
-      .mocked(getAndroidEmulatorLogCapture)
-      .mockImplementation(
-        jest.requireActual('../../utils/androidEmulatorLogs').getAndroidEmulatorLogCapture
-      );
     mockedMkdtemp.mockResolvedValue('/tmp/logcat-directory');
     mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
     mockedAndroidUtils.getAvailableDevicesAsync.mockResolvedValue([]);
@@ -99,30 +90,6 @@ describe(createStartAndroidEmulatorBuildFunction, () => {
     mockedMkdtemp.mockRestore();
   });
 
-  it('preserves an explicit empty source list and one capture through boot retries and clones', async () => {
-    mockedAndroidUtils.waitForReadyAsync.mockRejectedValueOnce(new Error('retry boot'));
-    const capture = new AndroidEmulatorLogCapture();
-    jest.mocked(getAndroidEmulatorLogCapture).mockReturnValue(capture);
-    await createStep(
-      { android_log_sources: [], count: 2 },
-      { DEVICE_RUN_SESSION_ID: 'session' }
-    ).executeAsync();
-    expect(getAndroidEmulatorLogCapture).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ DEVICE_RUN_SESSION_ID: 'session' })
-    );
-    expect(mockedAndroidUtils.startAsync).toHaveBeenCalledTimes(4);
-    for (const [options] of mockedAndroidUtils.startAsync.mock.calls) {
-      expect(options.logSources).toEqual([]);
-      expect(options.logCapture).toBe(capture);
-    }
-  });
-
-  it('rejects invalid sources before starting the emulator', async () => {
-    await expect(createStep({ android_log_sources: ['unknown'] }).executeAsync()).rejects.toThrow();
-    expect(mockedAndroidUtils.startAsync).not.toHaveBeenCalled();
-  });
-
   describe('local egress', () => {
     function createLocalEgress() {
       return {
@@ -144,8 +111,6 @@ describe(createStartAndroidEmulatorBuildFunction, () => {
         deviceName: 'EasAndroidDevice01',
         env: expect.any(Object),
         logcatDirectory: '/tmp/logcat-directory',
-        logSources: ['emulator-output', 'device-logcat'],
-        logCapture: expect.any(AndroidEmulatorLogCapture),
       });
       expect(mockedAndroidUtils.waitForReadyAsync).toHaveBeenCalledWith({
         env: expect.any(Object),

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

@@ -1,9 +1,6 @@
-import { type WarmIosSession } from '../../utils/warmIosSession';
 import { BuildRuntimePlatform, type BuildStepContext } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
-import path from 'node:path';
-import * as timersPromises from 'node:timers/promises';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
@@ -15,12 +12,6 @@ import { turtleFetch } from '../../../utils/turtleFetch';
 import { startAppiumEventCollectionAsync } from '../../utils/appiumEvents';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
 import { preparePreinstalledWdaAsync } from '../../utils/preinstalledWda';
-import { resolveLocalEgressServeSimBootEnvironmentAsync } from '../../utils/localEgressGuard';
-import {
-  WarmSessionAdoptionError,
-  runOnWarmIosSimulatorAsync,
-} from '../../utils/warmDeviceSessionHost';
-import * as warmIosSession from '../../utils/warmIosSession';
 import {
   ensureFfmpegInstalledOnceAsync,
   selectXcodeDeveloperDirectoryAsync,
@@ -28,8 +19,6 @@ import {
   startNgrokTunnelAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
-import { watchDeviceRunSessionStartup } from '../../utils/deviceRunSessionStartup';
-import { createStartupWatchMock } from '../../../__tests__/utils/startupWatch';
 
 import {
   createStartAppiumRemoteSessionBuildFunction,
@@ -38,10 +27,6 @@ import {
   resolveAppiumDeviceAsync,
 } from '../startAppiumRemoteSession';
 
-jest.mock('node:timers/promises', () => ({
-  ...jest.requireActual('node:timers/promises'),
-  setTimeout: jest.fn(jest.requireActual('node:timers/promises').setTimeout),
-}));
 jest.mock('../../../utils/AndroidEmulatorUtils', () => ({
   AndroidEmulatorUtils: { getAttachedDevicesAsync: jest.fn() },
 }));
@@ -60,9 +45,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   startNgrokTunnelAsync: jest.fn(),
   waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
-jest.mock('../../utils/deviceRunSessionStartup', () => ({
-  watchDeviceRunSessionStartup: jest.fn(),
-}));
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
 jest.mock('../../../sentry');
 jest.mock('../../../utils/retry', () => ({
@@ -75,14 +57,6 @@ 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'),
@@ -118,7 +92,6 @@ describe(resolveAppium3VersionSpec, () => {
 describe(resolveAppiumDeviceAsync, () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    jest.mocked(watchDeviceRunSessionStartup).mockImplementation(createStartupWatchMock);
   });
 
   it('returns XCUITest capabilities for the booted iOS simulator', async () => {
@@ -171,7 +144,6 @@ describe(resolveAppiumDeviceAsync, () => {
 describe(installAppiumAsync, () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    jest.mocked(watchDeviceRunSessionStartup).mockImplementation(createStartupWatchMock);
     jest.mocked(spawn).mockImplementation((async (_command: string, args: string[]) => {
       if (args.includes('--json')) {
         return { stdout: JSON.stringify({}) };
@@ -230,108 +202,6 @@ describe(installAppiumAsync, () => {
 });
 
 describe('createStartAppiumRemoteSessionBuildFunction', () => {
-  it.each([
-    [BuildRuntimePlatform.DARWIN, true],
-    [BuildRuntimePlatform.DARWIN, false],
-    [BuildRuntimePlatform.LINUX, true],
-    [BuildRuntimePlatform.LINUX, false],
-  ])('starts Appium on %s with helper present=%s', async (runtimePlatform, helperPresent) => {
-    const helper = '/usr/local/libexec/turtle-tcc-fda';
-    if (helperPresent) {
-      fs.mkdirSync(path.dirname(helper), { recursive: true });
-      fs.writeFileSync(helper, 'prepared helper');
-    }
-    jest.mocked(spawn).mockResolvedValue({ stdout: '{}' } as never);
-    jest
-      .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ udid: 'simulator' }] as never);
-    jest
-      .mocked(AndroidEmulatorUtils.getAttachedDevicesAsync)
-      .mockResolvedValue([{ serialId: 'emulator-5554', state: 'device' }] as never);
-    // Stop at the launch boundary; no readiness requests or remote session are needed.
-    const launched = new Error('launch captured');
-    jest.mocked(spawnDetached).mockImplementation(() => {
-      throw launched;
-    });
-    const env = {
-      DEVICE_RUN_SESSION_ID: 'session',
-      EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN: 'example.test',
-      PATH: '/configured/node/bin:/usr/bin',
-      DEVELOPER_DIR: '/Applications/Xcode.app/Contents/Developer',
-    };
-    const buildFunction = createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext);
-    await expect(
-      buildFunction.fn!(
-        { logger, global: { runtimePlatform } } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env: { ...env, NGROK_AUTHTOKEN: 'token' },
-        } as never
-      )
-    ).rejects.toBe(launched);
-
-    expect(spawnDetached).toHaveBeenCalledTimes(1);
-    const launch = jest.mocked(spawnDetached).mock.calls[0][0];
-    const appiumBinPath = path.join(launch.env.APPIUM_HOME!, 'node_modules', '.bin', 'appium');
-    const useHelper = runtimePlatform === BuildRuntimePlatform.DARWIN && helperPresent;
-    expect(launch).toEqual({
-      command: useHelper ? helper : appiumBinPath,
-      args: [
-        ...(useHelper ? [appiumBinPath] : []),
-        '--address',
-        '127.0.0.1',
-        '--port',
-        '4723',
-        '--base-path',
-        '/',
-        '--log-level',
-        'error',
-        '--allow-insecure',
-        '*:session_discovery',
-        '--default-capabilities',
-        runtimePlatform === BuildRuntimePlatform.DARWIN
-          ? '{"appium:eventTimings":true,"appium:isHeadless":true}'
-          : '{"appium:eventTimings":true}',
-      ],
-      env: { ...env, APPIUM_HOME: launch.env.APPIUM_HOME },
-      logger,
-    });
-  });
-
-  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);
@@ -355,13 +225,8 @@ 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(timersPromises.setTimeout)
-      .mockImplementation(jest.requireActual('node:timers/promises').setTimeout);
-    jest.mocked(watchDeviceRunSessionStartup).mockImplementation(createStartupWatchMock);
     jest.mocked(ensureFfmpegInstalledOnceAsync).mockResolvedValue(undefined);
     jest.mocked(preparePreinstalledWdaAsync).mockResolvedValue({});
     jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({
@@ -393,7 +258,6 @@ 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',
@@ -401,7 +265,7 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
         closeAsync: jest.fn(),
       }),
       getLastPreviewActivityAt: jest.fn(),
-      finishAsync: finishHost,
+      finishAsync: jest.fn(),
     });
   });
 
@@ -413,11 +277,9 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     logger: { info: jest.Mock; warn: jest.Mock },
     maxIdleTimeMinutes?: number,
     runtimePlatform = BuildRuntimePlatform.LINUX,
-    startupInputs: Record<string, { value: unknown }> = {},
-    warm = false,
-    signal?: AbortSignal
+    startupInputs: Record<string, { value: unknown }> = {}
   ): Promise<void> {
-    await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext, { warm }).fn!(
+    await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
       {
         logger,
         global: { runtimePlatform },
@@ -429,7 +291,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
           ...startupInputs,
         },
         outputs: {},
-        signal,
         env: {
           DEVICE_RUN_SESSION_ID: 'device-run-session-id',
           EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN: 'tunnel.example.com',
@@ -448,448 +309,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     );
   }
 
-  it('does not allocate Appium or a host after parent cancellation during Xcode selection', async () => {
-    const controller = new AbortController();
-    const failure = new Error('parent step cancelled');
-    jest
-      .mocked(selectXcodeDeveloperDirectoryAsync)
-      .mockImplementationOnce(async () => controller.abort(failure));
-    await expect(
-      runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {}, false, controller.signal)
-    ).rejects.toBe(failure);
-    expect(spawnDetached).not.toHaveBeenCalled();
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-  });
-
-  it('preserves an aggregate host startup failure', async () => {
-    const failure = new AggregateError([
-      new Error('host failed'),
-      new Error('host cleanup failed'),
-    ]);
-    jest.mocked(startDeviceSessionHostAsync).mockRejectedValueOnce(failure);
-    stopAppium.mockResolvedValue(undefined);
-    await expect(runSessionAsync(logger)).rejects.toBe(failure);
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-  });
-
-  it('reports late host cleanup failure after startup Stop', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    let entered!: () => void;
-    const starting = new Promise<void>(resolve => {
-      entered = resolve;
-    });
-    let failed!: AggregateError;
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-      entered();
-      return await new Promise((_resolve, reject) => {
-        options.signal!.addEventListener(
-          'abort',
-          () => {
-            failed = new AggregateError([options.signal!.reason, new Error('host cleanup failed')]);
-            setImmediate(() => reject(failed));
-          },
-          { once: true }
-        );
-      });
-    });
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'selected-ios-udid' },
-    });
-    running.catch(() => {});
-    await starting;
-    jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-    const failure = await running.then(
-      () => undefined,
-      error => error
-    );
-    expect(failure).toBe(failed);
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-  });
-
-  it('keeps watching startup when warm adoption retries cold', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    const adoption = new Error('warm adoption failed');
-    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async (_claim, run) => {
-      try {
-        return await run({
-          device: { udid: 'selected-ios-udid', name: 'iPhone 17' },
-        } as WarmIosSession);
-      } catch (error) {
-        if (error !== adoption) {
-          throw error;
-        }
-        return await run(undefined);
-      }
-    });
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-      options.onStartupError?.(adoption);
-      throw adoption;
-    });
-    await expect(
-      Promise.resolve(
-        runSessionAsync(
-          logger,
-          undefined,
-          BuildRuntimePlatform.DARWIN,
-          { boot_simulator: { value: true }, device_identifier: { value: 'selected-ios-udid' } },
-          true
-        )
-      )
-    ).resolves.toBeUndefined();
-    expect(watchDeviceRunSessionStartup).toHaveBeenCalledTimes(1);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(2);
-  });
-
-  it.each([false, true])(
-    'observes Stop during warm claim and preserves cleanup failure=%s',
-    async failCleanup => {
-      let entered!: () => void;
-      const claiming = new Promise<void>(resolve => {
-        entered = resolve;
-      });
-      const cleanup = new Error('warm cleanup failed');
-      jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async claim => {
-        entered();
-        await new Promise<void>((_resolve, reject) => {
-          claim.signal!.addEventListener(
-            'abort',
-            () =>
-              reject(
-                failCleanup
-                  ? new AggregateError([claim.signal!.reason, cleanup])
-                  : claim.signal!.reason
-              ),
-            { once: true }
-          );
-        });
-      });
-      const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {}, true);
-      running.catch(() => {});
-      await claiming;
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-      if (failCleanup) {
-        await expect(running).rejects.toMatchObject({ errors: expect.arrayContaining([cleanup]) });
-      } else {
-        await expect(running).resolves.toBeUndefined();
-      }
-      expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    }
-  );
-  it('passes the existing Android selection to the preview host', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    await runSessionAsync(logger);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ previewDeviceId: 'emulator-5554' })
-    );
-  });
-
-  it('passes the selected iOS preview target without enabling Simulator startup', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    const udid = 'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA';
-    jest
-      .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ udid }, { udid: 'BBBBBBBB-BBBB-BBBB-BBBB-BBBBBBBBBBBB' }] as Awaited<
-        ReturnType<typeof IosSimulatorUtils.getAvailableDevicesAsync>
-      >);
-    await runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN);
-    const options = jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1];
-    expect(options).toHaveProperty('previewDeviceId', udid);
-    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([
-    [BuildRuntimePlatform.LINUX, false],
-    [BuildRuntimePlatform.DARWIN, false],
-    [BuildRuntimePlatform.DARWIN, true],
-  ])(
-    'handles Stop during the readiness retry sleep on %s with startup=%s',
-    async (runtimePlatform, bootSimulator) => {
-      stopAppium.mockResolvedValue(undefined);
-      jest
-        .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-        .mockResolvedValue([{ udid: 'chosen-ios-udid' } as never]);
-      jest.mocked(turtleFetch).mockResolvedValue({ ok: false } as never);
-      jest.mocked(timersPromises.setTimeout).mockImplementationOnce((async (ms, value, options) => {
-        const sleeping = jest.requireActual('node:timers/promises').setTimeout(ms, value, options);
-        jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-        return sleeping;
-      }) as typeof timersPromises.setTimeout);
-      await expect(
-        runSessionAsync(
-          logger,
-          undefined,
-          runtimePlatform,
-          bootSimulator
-            ? { boot_simulator: { value: true }, device_identifier: { value: 'chosen-device' } }
-            : {}
-        )
-      ).resolves.toBeUndefined();
-      expect(stopAppium).toHaveBeenCalledTimes(1);
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-      expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-    }
-  );
-
-  it('does not open the preview after Stop while the Appium tunnel is opening', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    let tunnelEntered!: () => void;
-    const entered = new Promise<void>(resolve => {
-      tunnelEntered = resolve;
-    });
-    let finishTunnel!: () => void;
-    const pendingTunnel = new Promise<void>(resolve => {
-      finishTunnel = resolve;
-    });
-    const stopTunnel = jest.fn();
-    jest.mocked(startNgrokTunnelAsync).mockImplementationOnce(async () => {
-      tunnelEntered();
-      await pendingTunnel;
-      return { url: 'https://appium.example.com', subdomainId: 'appium', stopAsync: stopTunnel };
-    });
-    const openPreviewAsync = jest.fn();
-    const finishHost = jest.fn();
-    jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-      openPreviewAsync,
-      finishAsync: finishHost,
-      getLastPreviewActivityAt: jest.fn(),
-    });
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'chosen-device' },
-    });
-    running.catch(() => {});
-    try {
-      await entered;
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-    } finally {
-      finishTunnel();
-    }
-    await expect(running).resolves.toBeUndefined();
-    expect(openPreviewAsync).not.toHaveBeenCalled();
-    expect(stopTunnel).toHaveBeenCalledTimes(1);
-    expect(finishHost).toHaveBeenCalledTimes(1);
-    expect(stopAppium).toHaveBeenCalledTimes(1);
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-  });
-
-  it('ends normally when Stop interrupts the LOCAL-guard Simulator shutdown', async () => {
-    jest
-      .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
-      .mockResolvedValueOnce({ SERVE_SIM_ADDITIONAL_DYLIBS: '/guard.dylib' });
-    jest
-      .mocked(IosSimulatorUtils.getDeviceAsync)
-      .mockResolvedValueOnce({ state: 'Booted' } as never);
-    let shutdownEntered!: () => void;
-    const entered = new Promise<void>(resolve => {
-      shutdownEntered = resolve;
-    });
-    jest.mocked(spawn).mockImplementationOnce((_command, _args, options) => {
-      shutdownEntered();
-      return new Promise((_resolve, reject) =>
-        options!.signal!.addEventListener(
-          'abort',
-          () => reject(new Error('Shutdown process aborted', { cause: options!.signal!.reason })),
-          { once: true }
-        )
-      ) as ReturnType<typeof spawn>;
-    });
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'chosen-device' },
-    });
-    running.catch(() => {});
-    await entered;
-    jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-    await expect(running).resolves.toBeUndefined();
-    expect(ensureFfmpegInstalledOnceAsync).not.toHaveBeenCalled();
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    expect(spawnDetached).not.toHaveBeenCalled();
-    expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-  });
-
   it.each([false, true])(
     'preserves preview settings with Simulator startup %s',
     async bootSimulator => {
@@ -918,154 +337,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     }
   );
 
-  it.each([
-    [BuildRuntimePlatform.DARWIN, false],
-    [BuildRuntimePlatform.LINUX, false],
-    [BuildRuntimePlatform.DARWIN, true],
-  ])(
-    'handles Stop during %s setup, preserving teardown failure=%s',
-    async (runtimePlatform, teardownFails) => {
-      let setupEntered!: () => void;
-      const entered = new Promise<void>(resolve => {
-        setupEntered = resolve;
-      });
-      jest.mocked(ensureFfmpegInstalledOnceAsync).mockImplementationOnce(({ signal }) => {
-        setupEntered();
-        return new Promise<void>(resolve =>
-          signal!.addEventListener('abort', () => resolve(), { once: true })
-        );
-      });
-      const teardownError = new Error('host teardown failed');
-      const finishHost = jest.fn().mockImplementation(async () => {
-        if (teardownFails) {
-          throw teardownError;
-        }
-      });
-      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-          openPreviewAsync: jest.fn(),
-          finishAsync: finishHost,
-          getLastPreviewActivityAt: () => undefined,
-        });
-      }
-      const running = runSessionAsync(
-        { info: jest.fn(), warn: jest.fn() },
-        undefined,
-        runtimePlatform,
-        runtimePlatform === BuildRuntimePlatform.DARWIN
-          ? { boot_simulator: { value: true }, device_identifier: { value: 'chosen-ios-udid' } }
-          : {}
-      );
-      running.catch(() => {});
-      await entered;
-      const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-      watch.stop();
-      if (teardownFails) {
-        await expect(running).rejects.toBe(teardownError);
-      } else {
-        await expect(running).resolves.toBeUndefined();
-      }
-      expect(spawnDetached).not.toHaveBeenCalled();
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-      expect(watch.finishAsync).toHaveBeenCalled();
-      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        expect(finishHost).toHaveBeenCalledTimes(1);
-      }
-    }
-  );
-
-  it.each([
-    [BuildRuntimePlatform.DARWIN, false],
-    [BuildRuntimePlatform.DARWIN, true],
-    [BuildRuntimePlatform.LINUX, false],
-  ])(
-    'preserves failed installer cleanup after Stop on %s with Simulator startup=%s',
-    async (runtimePlatform, bootSimulator) => {
-      const cleanupError = new Error('Appium home removal failed: EACCES');
-      const remove = fs.promises.rm.bind(fs.promises);
-      jest
-        .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-        .mockResolvedValue([{ udid: 'chosen-ios-udid' } as never]);
-      let enteredInstall!: () => void;
-      const installEntered = new Promise<void>(resolve => {
-        enteredInstall = resolve;
-      });
-      let closeInstaller!: (error: Error) => void;
-      jest.mocked(spawn).mockImplementationOnce(() => {
-        enteredInstall();
-        return Object.assign(
-          new Promise((_resolve, reject) => {
-            closeInstaller = reject;
-          }),
-          { child: { pid: 12345 } }
-        ) as never;
-      });
-      jest.spyOn(processes, 'killProcessGroup').mockImplementation(() => {});
-      const rm = jest.spyOn(fs.promises, 'rm').mockRejectedValueOnce(cleanupError);
-      const running = runSessionAsync(
-        { info: jest.fn(), warn: jest.fn() },
-        undefined,
-        runtimePlatform,
-        bootSimulator
-          ? { boot_simulator: { value: true }, device_identifier: { value: 'chosen-ios-udid' } }
-          : {}
-      );
-      const observed = running.catch(() => {});
-      let home: string | undefined;
-      try {
-        await installEntered;
-        home = jest.mocked(spawn).mock.calls[0][2]?.cwd as string;
-        const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-        watch.stop();
-        closeInstaller(new Error('installer interrupted'));
-        await expect(running).rejects.toBe(cleanupError);
-        expect(rm).toHaveBeenCalledWith(home, { recursive: true, force: true });
-        expect(fs.existsSync(home)).toBe(true);
-        expect(spawnDetached).not.toHaveBeenCalled();
-        expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-        expect(watch.finishAsync).toHaveBeenCalled();
-      } finally {
-        closeInstaller?.(new Error('test cleanup'));
-        await observed;
-        if (home) {
-          await remove(home, { recursive: true, force: true });
-        }
-      }
-    }
-  );
-
-  it('preserves an Android installer failure observed before a later Stop', async () => {
-    const failed = new Error('Appium install failed first');
-    let observedFailure!: () => void;
-    const installFailed = new Promise<void>(resolve => {
-      observedFailure = resolve;
-    });
-    jest.mocked(spawn).mockImplementationOnce((() => {
-      observedFailure();
-      return Promise.reject(failed);
-    }) as never);
-    jest
-      .mocked(ensureFfmpegInstalledOnceAsync)
-      .mockImplementationOnce(
-        ({ signal }) =>
-          new Promise<void>(resolve =>
-            signal!.addEventListener('abort', () => resolve(), { once: true })
-          )
-      );
-    const running = runSessionAsync(
-      { info: jest.fn(), warn: jest.fn() },
-      undefined,
-      BuildRuntimePlatform.LINUX
-    );
-    running.catch(() => {});
-    await installFailed;
-    await new Promise(resolve => setImmediate(resolve));
-    const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-    watch.stop();
-    await expect(running).rejects.toBe(failed);
-    expect(spawnDetached).not.toHaveBeenCalled();
-  });
-
   it('selects Xcode only once for an already-prepared iOS session', async () => {
     stopAppium.mockResolvedValue(undefined);
     jest.mocked(selectXcodeDeveloperDirectoryAsync).mockClear();
@@ -1090,7 +361,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     expect(IosSimulatorUtils.getDeviceAsync).not.toHaveBeenCalled();
     expect(JSON.parse(jest.mocked(spawnDetached).mock.calls[0][0].args.at(-1)!)).toEqual({
       'appium:eventTimings': true,
-      'appium:isHeadless': true,
       'appium:usePreinstalledWDA': true,
       'appium:prebuiltWDAPath': '/tmp/legacy-wda.app',
     });
@@ -1177,7 +447,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     );
     expect(JSON.parse(jest.mocked(spawnDetached).mock.calls[0][0].args.at(-1)!)).toEqual({
       'appium:eventTimings': true,
-      'appium:isHeadless': true,
       'appium:usePreinstalledWDA': true,
       'appium:prebuiltWDAPath': '/tmp/selected-wda.app',
     });
@@ -1382,9 +651,9 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
   it('keeps the readiness error when Appium cannot be stopped', async () => {
     let now = Date.now();
     jest.spyOn(Date, 'now').mockImplementation(() => now);
-    jest.mocked(timersPromises.setTimeout).mockImplementation((async ms => {
-      now += Number(ms ?? 0);
-    }) as typeof timersPromises.setTimeout);
+    jest.mocked(sleepAsync).mockImplementation(async ms => {
+      now += ms;
+    });
     jest.mocked(turtleFetch).mockRejectedValue(new Error('connect ECONNREFUSED'));
     const logger = { info: jest.fn(), warn: jest.fn() };
 

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

@@ -24,13 +24,6 @@ import {
   uploadRemoteSessionConfigAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
-import {
-  createWarmDeviceSessionServer,
-  runOnWarmIosSimulatorAsync,
-} from '../../utils/warmDeviceSessionHost';
-import { type WarmIosSession } from '../../utils/warmIosSession';
-import { watchDeviceRunSessionStartup } from '../../utils/deviceRunSessionStartup';
-import { createStartupWatchMock } from '../../../__tests__/utils/startupWatch';
 import { createStartArgentRemoteSessionBuildFunction } from '../startArgentRemoteSession';
 import { readIosApplicationIdentifierAsync } from '../../utils/iosAppArtifact';
 
@@ -57,7 +50,6 @@ 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'),
@@ -88,9 +80,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   uploadRemoteSessionConfigAsync: jest.fn(),
   waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
-jest.mock('../../utils/deviceRunSessionStartup', () => ({
-  watchDeviceRunSessionStartup: jest.fn(),
-}));
 
 const TEST_HOME = path.join(os.tmpdir(), 'eas-argent-orchestration-home');
 const ARGENT_STATE_DIR = path.join(TEST_HOME, '.argent');
@@ -139,9 +128,8 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
       getLastPreviewActivityAt: jest.fn(),
       finishAsync: mockPreviewStopAsync,
     });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue('started');
+    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
     jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
-    jest.mocked(watchDeviceRunSessionStartup).mockImplementation(createStartupWatchMock);
 
     // The (real) tool-server state wait reads this file from the redirected ~/.argent.
     await fs.promises.mkdir(ARGENT_STATE_DIR, { recursive: true });
@@ -155,363 +143,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     await fs.promises.rm(TEST_HOME, { recursive: true, force: true });
   });
 
-  it.each([
-    [BuildRuntimePlatform.DARWIN, false],
-    [BuildRuntimePlatform.LINUX, false],
-    [BuildRuntimePlatform.DARWIN, true],
-  ])(
-    'handles Stop during %s setup, keeping teardown failure=%s visible',
-    async (runtimePlatform, teardownFails) => {
-      let rejectSetup!: (error: Error) => void;
-      const setup = Object.assign(
-        new Promise<never>((_resolve, reject) => {
-          rejectSetup = reject;
-        }),
-        { child: { pid: 12345 } }
-      );
-      jest.mocked(spawn).mockReturnValueOnce(setup as unknown as ReturnType<typeof spawn>);
-      jest
-        .mocked(killProcessGroup)
-        .mockImplementationOnce(() => rejectSetup(new Error('setup killed')));
-      const teardownError = new Error('host teardown failed');
-      if (teardownFails) {
-        mockPreviewStopAsync.mockRejectedValueOnce(teardownError);
-      }
-      const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-      const running = Promise.resolve(
-        buildFunction.fn!(
-          {
-            logger: { info: jest.fn(), warn: jest.fn() },
-            global: { runtimePlatform },
-          } as unknown as BuildStepContext,
-          {
-            inputs: {
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-              boot_simulator: {
-                value: runtimePlatform === BuildRuntimePlatform.DARWIN ? true : undefined,
-              },
-            },
-            outputs: {},
-            env: {},
-          } as never
-        )
-      );
-      running.catch(() => {});
-      try {
-        for (let i = 0; i < 20 && !jest.mocked(spawn).mock.calls.length; i++) {
-          await new Promise(resolve => setImmediate(resolve));
-        }
-        expect(spawn).toHaveBeenCalledTimes(1);
-        const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-        watch.stop();
-        if (teardownFails) {
-          await expect(running).rejects.toBe(teardownError);
-        } else {
-          await expect(running).resolves.toBeUndefined();
-        }
-        expect(killProcessGroup).toHaveBeenCalledTimes(1);
-        expect(spawnDetached).not.toHaveBeenCalled();
-        expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-        expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-        expect(watch.finishAsync).toHaveBeenCalled();
-      } finally {
-        rejectSetup(new Error('test cleanup'));
-        await running.catch(() => {});
-      }
-    }
-  );
-
-  it('does not allocate Argent or a host after parent cancellation during Xcode selection', async () => {
-    const logger = { info: jest.fn(), warn: jest.fn() };
-    const controller = new AbortController();
-    const failure = new Error('parent step cancelled');
-    jest
-      .mocked(selectXcodeDeveloperDirectoryAsync)
-      .mockImplementationOnce(async () => controller.abort(failure));
-    await expect(
-      createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
-        {
-          logger,
-          global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env: {},
-          signal: controller.signal,
-        } as never
-      )
-    ).rejects.toBe(failure);
-    expect(spawnDetached).not.toHaveBeenCalled();
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-  });
-
-  it('preserves an aggregate host startup failure', async () => {
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    const failure = new AggregateError([
-      new Error('host failed'),
-      new Error('host cleanup failed'),
-    ]);
-    jest.mocked(startDeviceSessionHostAsync).mockRejectedValueOnce(failure);
-    await expect(
-      createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
-        {
-          logger,
-          global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-            boot_simulator: { value: true },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      )
-    ).rejects.toBe(failure);
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-  });
-
-  it('reports late host cleanup failure after startup Stop', async () => {
-    const ctx = {} as CustomBuildContext;
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    let entered!: () => void;
-    const starting = new Promise<void>(resolve => {
-      entered = resolve;
-    });
-    let failed!: AggregateError;
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-      entered();
-      return await new Promise((_resolve, reject) => {
-        options.signal!.addEventListener(
-          'abort',
-          () => {
-            failed = new AggregateError([options.signal!.reason, new Error('host cleanup failed')]);
-            setImmediate(() => reject(failed));
-          },
-          { once: true }
-        );
-      });
-    });
-    const running = createStartArgentRemoteSessionBuildFunction(ctx).fn!(
-      { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
-      {
-        inputs: {
-          boot_simulator: { value: true },
-          device_identifier: { value: 'selected-ios-udid' },
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    ) as Promise<void>;
-    running.catch(() => {});
-    await starting;
-    jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-    const failure = await running.then(
-      () => undefined,
-      error => error
-    );
-    expect(failure).toBe(failed);
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-  });
-
-  it('keeps watching startup when warm adoption retries cold', async () => {
-    const ctx = {} as CustomBuildContext;
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    const adoption = new Error('warm adoption failed');
-    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async (_claim, run) => {
-      try {
-        return await run({
-          device: { udid: 'selected-ios-udid', name: 'iPhone 17' },
-        } as WarmIosSession);
-      } catch (error) {
-        if (error !== adoption) {
-          throw error;
-        }
-        return await run(undefined);
-      }
-    });
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-      options.onStartupError?.(adoption);
-      throw adoption;
-    });
-    await expect(
-      Promise.resolve(
-        createStartArgentRemoteSessionBuildFunction(ctx, { warm: true }).fn!(
-          { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
-          {
-            inputs: {
-              boot_simulator: { value: true },
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-            },
-            outputs: {},
-            env: {},
-          } as never
-        )
-      )
-    ).resolves.toBeUndefined();
-    expect(watchDeviceRunSessionStartup).toHaveBeenCalledTimes(1);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(2);
-  });
-
-  it.each([false, true])(
-    'observes Stop during warm claim and preserves cleanup failure=%s',
-    async failCleanup => {
-      const ctx = {} as CustomBuildContext;
-      const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-      let entered!: () => void;
-      const claiming = new Promise<void>(resolve => {
-        entered = resolve;
-      });
-      const cleanup = new Error('warm cleanup failed');
-      jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async claim => {
-        entered();
-        await new Promise<void>((_resolve, reject) => {
-          claim.signal!.addEventListener(
-            'abort',
-            () =>
-              reject(
-                failCleanup
-                  ? new AggregateError([claim.signal!.reason, cleanup])
-                  : claim.signal!.reason
-              ),
-            { once: true }
-          );
-        });
-      });
-      const running = createStartArgentRemoteSessionBuildFunction(ctx, { warm: true }).fn!(
-        { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      ) as Promise<void>;
-      running.catch(() => {});
-      await claiming;
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-      if (failCleanup) {
-        await expect(running).rejects.toMatchObject({ errors: expect.arrayContaining([cleanup]) });
-      } else {
-        await expect(running).resolves.toBeUndefined();
-      }
-      expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    }
-  );
-  it('does not open the preview after Stop while the tools tunnel is opening', async () => {
-    let tunnelEntered!: () => void;
-    const entered = new Promise<void>(resolve => {
-      tunnelEntered = resolve;
-    });
-    let finishTunnel!: () => void;
-    const pendingTunnel = new Promise<void>(resolve => {
-      finishTunnel = resolve;
-    });
-    jest.mocked(startNgrokTunnelAsync).mockImplementationOnce(async () => {
-      tunnelEntered();
-      await pendingTunnel;
-      return {
-        url: 'https://argent.example.com',
-        subdomainId: 'argent',
-        stopAsync: mockTunnelStopAsync,
-      };
-    });
-    const openPreviewAsync = jest.fn();
-    jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-      openPreviewAsync,
-      finishAsync: mockPreviewStopAsync,
-      getLastPreviewActivityAt: jest.fn(),
-    });
-    const running = Promise.resolve(
-      createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext).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 },
-            boot_simulator: { value: true },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      )
-    );
-    running.catch(() => {});
-    try {
-      await entered;
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-    } finally {
-      finishTunnel();
-    }
-    await expect(running).resolves.toBeUndefined();
-    expect(openPreviewAsync).not.toHaveBeenCalled();
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
-    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'preserves an earlier prepared %s host failure when Stop arrives during cleanup',
-    async runtimePlatform => {
-      const failure = new Error('Host became ready without a session token');
-      let cleanupEntered!: () => void;
-      const entered = new Promise<void>(resolve => {
-        cleanupEntered = resolve;
-      });
-      let finishCleanup!: () => void;
-      const cleanup = new Promise<void>(resolve => {
-        finishCleanup = resolve;
-      });
-      jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-        options.onStartupError?.(failure);
-        cleanupEntered();
-        await cleanup;
-        throw failure;
-      });
-      const running = Promise.resolve(
-        createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
-          {
-            logger: { info: jest.fn(), warn: jest.fn() },
-            global: { runtimePlatform },
-          } as unknown as BuildStepContext,
-          {
-            inputs: {
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-            },
-            outputs: {},
-            env: {},
-          } as never
-        )
-      );
-      running.catch(() => {});
-      try {
-        await entered;
-        jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-      } finally {
-        finishCleanup();
-      }
-      await expect(running).rejects.toBe(failure);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-      expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
-    }
-  );
-
   it('reports an early exit with output and stops Argent before opening tunnels', async () => {
     const stopError = new Error('drain timed out');
     const stopServer = jest.fn().mockRejectedValue(stopError);
@@ -974,72 +605,6 @@ 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() };
@@ -1327,7 +892,7 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
   });
 
   it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'makes %s prepared setup commands cancellable',
+    'keeps %s prepared setup commands outside the new cancellation path',
     async runtimePlatform => {
       const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
       await buildFunction.fn!(
@@ -1346,7 +911,7 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
       );
       expect(spawn).toHaveBeenCalledTimes(3);
       for (const [, , options] of jest.mocked(spawn).mock.calls) {
-        expect(options).toHaveProperty('detached', true);
+        expect(options).not.toHaveProperty('detached');
         expect(options).not.toHaveProperty('signal');
       }
       expect(killProcessGroup).not.toHaveBeenCalled();

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

@@ -1,3 +1,4 @@
+import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -5,12 +6,79 @@ 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,17 +12,9 @@ import {
   uploadRemoteSessionConfigAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
-import {
-  createWarmDeviceSessionServer,
-  runOnWarmIosSimulatorAsync,
-} from '../../utils/warmDeviceSessionHost';
-import { type WarmIosSession } from '../../utils/warmIosSession';
-import { watchDeviceRunSessionStartup } from '../../utils/deviceRunSessionStartup';
-import { createStartupWatchMock } from '../../../__tests__/utils/startupWatch';
 import { createStartWebPreviewRemoteSessionBuildFunction } from '../startWebPreviewRemoteSession';
 
 jest.mock('../../utils/deviceSessionHost');
-jest.mock('../../utils/warmDeviceSessionHost');
 jest.mock('../../../utils/IosSimulatorUtils', () => ({
   IosSimulatorUtils: {
     resolveUdidAsync: jest.fn().mockResolvedValue('selected-ios-udid'),
@@ -47,9 +39,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   uploadRemoteSessionConfigAsync: jest.fn(),
   waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
-jest.mock('../../utils/deviceRunSessionStartup', () => ({
-  watchDeviceRunSessionStartup: jest.fn(),
-}));
 
 const ctx = {} as CustomBuildContext;
 const env = { NGROK_AUTHTOKEN: 'ngrok-token', PATH: '/usr/bin' } as BuildStepEnv;
@@ -59,8 +48,7 @@ const stopAsync = jest.fn();
 
 async function runAsync(
   runtimePlatform: BuildRuntimePlatform,
-  launchInputs: Record<string, { value: unknown }> = {},
-  signal?: AbortSignal
+  launchInputs: Record<string, { value: unknown }> = {}
 ): Promise<void> {
   const buildFunction = createStartWebPreviewRemoteSessionBuildFunction(ctx);
   await buildFunction.fn!(
@@ -75,7 +63,6 @@ async function runAsync(
         ...launchInputs,
       },
       outputs: {},
-      signal,
       env,
     } as never
   );
@@ -97,276 +84,11 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue('started');
+    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
     jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
-    jest.mocked(watchDeviceRunSessionStartup).mockImplementation(createStartupWatchMock);
     stopAsync.mockResolvedValue(undefined);
   });
 
-  it('does not start a host when the parent aborts during Xcode selection', async () => {
-    const controller = new AbortController();
-    const failure = new Error('parent step cancelled');
-    jest
-      .mocked(selectXcodeDeveloperDirectoryAsync)
-      .mockImplementationOnce(async () => controller.abort(failure));
-    await expect(runAsync(BuildRuntimePlatform.DARWIN, {}, controller.signal)).rejects.toBe(
-      failure
-    );
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    expect(watchDeviceRunSessionStartup).toHaveBeenCalledTimes(1);
-    expect(
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.finishAsync
-    ).toHaveBeenCalled();
-  });
-
-  it('keeps watching startup when warm adoption retries cold', async () => {
-    const adoption = new Error('warm adoption failed');
-    jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async (_claim, run) => {
-      try {
-        return await run({
-          device: { udid: 'selected-ios-udid', name: 'iPhone 17' },
-        } as WarmIosSession);
-      } catch (error) {
-        if (error !== adoption) {
-          throw error;
-        }
-        return await run(undefined);
-      }
-    });
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-      options.onStartupError?.(adoption);
-      throw adoption;
-    });
-    await expect(
-      Promise.resolve(
-        createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true }).fn!(
-          { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
-          {
-            inputs: {
-              boot_simulator: { value: true },
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-            },
-            outputs: {},
-            env,
-          } as never
-        )
-      )
-    ).resolves.toBeUndefined();
-    expect(watchDeviceRunSessionStartup).toHaveBeenCalledTimes(1);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(2);
-  });
-
-  it.each([false, true])(
-    'observes Stop during warm claim and preserves cleanup failure=%s',
-    async failCleanup => {
-      let entered!: () => void;
-      const claiming = new Promise<void>(resolve => {
-        entered = resolve;
-      });
-      const cleanup = new Error('warm cleanup failed');
-      jest.mocked(runOnWarmIosSimulatorAsync).mockImplementation(async claim => {
-        entered();
-        await new Promise<void>((_resolve, reject) => {
-          claim.signal!.addEventListener(
-            'abort',
-            () =>
-              reject(
-                failCleanup
-                  ? new AggregateError([claim.signal!.reason, cleanup])
-                  : claim.signal!.reason
-              ),
-            { once: true }
-          );
-        });
-      });
-      const running = createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true }).fn!(
-        { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as never,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env,
-        } as never
-      ) as Promise<void>;
-      running.catch(() => {});
-      await claiming;
-      jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-      if (failCleanup) {
-        await expect(running).rejects.toMatchObject({ errors: expect.arrayContaining([cleanup]) });
-      } else {
-        await expect(running).resolves.toBeUndefined();
-      }
-      expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    }
-  );
-  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];
-    expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
-    expect(idleTimeout?.getLastEventObservedAt()).toBeUndefined();
-    const host = await jest.mocked(startDeviceSessionHostAsync).mock.results[0].value;
-    const observedAt = new Date();
-    jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(observedAt);
-    expect(idleTimeout?.getLastPreviewActivityAt?.()).toBe(observedAt);
-    expect(stopAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'leaves the idle timer disabled when omitted on %s',
-    async runtimePlatform => {
-      await runAsync(runtimePlatform);
-      expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledWith(
-        expect.objectContaining({ idleTimeout: undefined, maxDurationSeconds: 120 })
-      );
-    }
-  );
-
-  it('leaves the idle timer disabled for zero', async () => {
-    await runAsync(BuildRuntimePlatform.DARWIN, {
-      max_idle_time_minutes: { value: 0 },
-    });
-    expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ idleTimeout: undefined, maxDurationSeconds: 120 })
-    );
-  });
-
-  it('rejects an Android idle timeout before starting the host', async () => {
-    await expect(
-      runAsync(BuildRuntimePlatform.LINUX, {
-        max_idle_time_minutes: { value: 5 },
-      })
-    ).rejects.toThrow('Omit max_idle_time_minutes for Android sessions.');
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-  });
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'handles Stop while the %s host starts',
-    async runtimePlatform => {
-      let hostEntered!: () => void;
-      const entered = new Promise<void>(resolve => {
-        hostEntered = resolve;
-      });
-      jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce((_ctx, { signal }) => {
-        hostEntered();
-        return new Promise((_resolve, reject) =>
-          signal!.addEventListener('abort', () => reject(new Error('host aborted')), { once: true })
-        );
-      });
-      const running = runAsync(runtimePlatform);
-      running.catch(() => {});
-      await entered;
-      const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-      watch.stop();
-      await expect(running).resolves.toBeUndefined();
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-      expect(watch.finishAsync).toHaveBeenCalled();
-    }
-  );
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'preserves an earlier %s host failure when Stop arrives during cleanup',
-    async runtimePlatform => {
-      const failure = new Error('Host became ready without a session token');
-      let cleanupEntered!: () => void;
-      const entered = new Promise<void>(resolve => {
-        cleanupEntered = resolve;
-      });
-      let finishCleanup!: () => void;
-      const cleanup = new Promise<void>(resolve => {
-        finishCleanup = resolve;
-      });
-      jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(async (_ctx, options) => {
-        options.onStartupError?.(failure);
-        cleanupEntered();
-        await cleanup;
-        throw failure;
-      });
-      const running = runAsync(runtimePlatform);
-      running.catch(() => {});
-      try {
-        await entered;
-        jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value.stop();
-      } finally {
-        finishCleanup();
-      }
-      await expect(running).rejects.toBe(failure);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      expect(waitForDeviceRunSessionStoppedAsync).not.toHaveBeenCalled();
-    }
-  );
-
-  it('keeps a teardown failure visible after Stop during preview setup', async () => {
-    let previewEntered!: () => void;
-    let finishPreview!: (value: {
-      previewPageUrl: string;
-      apiUrl: string;
-      closeAsync: () => Promise<void>;
-    }) => void;
-    const entered = new Promise<void>(resolve => {
-      previewEntered = resolve;
-    });
-    jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-      openPreviewAsync: () => {
-        previewEntered();
-        return new Promise(resolve => {
-          finishPreview = resolve;
-        });
-      },
-      finishAsync: stopAsync,
-      getLastPreviewActivityAt: jest.fn(),
-    });
-    const failed = new Error('host teardown failed');
-    stopAsync.mockRejectedValueOnce(failed);
-    const running = runAsync(BuildRuntimePlatform.LINUX);
-    running.catch(() => {});
-    await entered;
-    const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-    watch.stop();
-    finishPreview({
-      previewPageUrl: 'https://preview.test',
-      apiUrl: 'https://server.test',
-      closeAsync: async () => {},
-    });
-    await expect(running).rejects.toBe(failed);
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    expect(stopAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('retires the startup watcher before lifetime waiting', async () => {
-    await runAsync(BuildRuntimePlatform.LINUX);
-    const watch = jest.mocked(watchDeviceRunSessionStartup).mock.results[0].value;
-    expect(watch.completeAsync.mock.invocationCallOrder[0]).toBeLessThan(
-      jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.invocationCallOrder[0]
-    );
-  });
-
   it('reports the session token when serve-sim minted one', async () => {
     jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: jest.fn().mockResolvedValue({
@@ -483,9 +205,7 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       env: childEnv,
       logger,
       timeoutMs: 60_000,
-      preview: { baseDomain: 'tunnel.example.com', authtoken: 'ngrok-token' },
-      signal: expect.any(AbortSignal),
-      onStartupError: expect.any(Function),
+      signal: undefined,
       ...(selectsXcode
         ? {
             iosSimulatorUdid: 'SELECTED-IOS-UDID',
@@ -504,7 +224,10 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       networkCaptureFields: [],
     });
     const host = await jest.mocked(startDeviceSessionHostAsync).mock.results[0].value;
-    expect(host.openPreviewAsync).toHaveBeenCalledWith();
+    expect(host.openPreviewAsync).toHaveBeenCalledWith({
+      baseDomain: 'tunnel.example.com',
+      authtoken: 'ngrok-token',
+    });
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith({
       ctx,
       deviceRunSessionId: 'device-run-session-id',
@@ -514,7 +237,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         previewApiUrl: 'https://web-preview.example.test',
       },
       logger,
-      signal: expect.any(AbortSignal),
     });
     expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledWith({
       ctx,
@@ -546,7 +268,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       'frame_ancestors',
       'cors_origins',
       'package_version',
-      'max_idle_time_minutes',
       'max_duration_seconds',
     ]);
   });

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

@@ -198,10 +198,7 @@ it('does not delete the edit or publish outputs when commit outcome is unknown',
       return [204];
     });
   const task = submission();
-  const error = await task.run().catch(error => error);
-  expect(error).toBeInstanceOf(SystemError);
-  expect((error as Error).message).toContain('HTTP 404');
-  expect((error as Error).message).toContain('Could not confirm whether Google Play saved');
+  await expect(task.run()).rejects.toBeInstanceOf(SystemError);
   expect(deleted).toBe(false);
   expect(task.setters.every(set => set.mock.calls.length === 0)).toBe(true);
 });

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

@@ -1,407 +0,0 @@
-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/__tests__/uploadToAsc.test.ts

@@ -1,344 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import fs from 'fs-extra';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { AscApiClient } from '../../utils/ios/AscApiClient';
-import { AscApiUtils } from '../../utils/ios/AscApiUtils';
-import {
-  createUploadToAscBuildFunction,
-  isClosedVersionTrainError,
-  isInvalidBundleIdentifierError,
-  isMissingAppIconsError,
-  isMissingBackgroundTaskIdentifiersError,
-  isMissingPurposeStringError,
-  isRedundantBinaryUploadError,
-  isSdkVersionIssueError,
-  parseMissingUsageDescriptionKeys,
-} from '../uploadToAsc';
-
-describe(isClosedVersionTrainError, () => {
-  it('returns true when all errors are closed-version-train codes', () => {
-    expect(
-      isClosedVersionTrainError([
-        { code: '90062' },
-        { code: '90186' },
-        { code: '90478' },
-        { code: '90062' },
-      ])
-    ).toBe(true);
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(
-      isClosedVersionTrainError([{ code: '90062' }, { code: '90186' }, { code: '12345' }])
-    ).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isClosedVersionTrainError([])).toBe(false);
-  });
-});
-
-describe(isInvalidBundleIdentifierError, () => {
-  it('returns true when all errors are invalid-bundle-id codes', () => {
-    expect(
-      isInvalidBundleIdentifierError([{ code: '90054' }, { code: '90055' }, { code: '90055' }])
-    ).toBe(true);
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(isInvalidBundleIdentifierError([{ code: '90055' }, { code: '90713' }])).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isInvalidBundleIdentifierError([])).toBe(false);
-  });
-});
-
-describe(isRedundantBinaryUploadError, () => {
-  it('returns true when all errors are redundant-binary-upload codes', () => {
-    expect(isRedundantBinaryUploadError([{ code: '90189' }, { code: '90189' }])).toBe(true);
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(isRedundantBinaryUploadError([{ code: '90189' }, { code: '90062' }])).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isRedundantBinaryUploadError([])).toBe(false);
-  });
-});
-
-describe(isMissingPurposeStringError, () => {
-  it('returns true when all errors are missing-purpose-string codes', () => {
-    expect(isMissingPurposeStringError([{ code: '90683' }, { code: '90683' }])).toBe(true);
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(isMissingPurposeStringError([{ code: '90683' }, { code: '90054' }])).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isMissingPurposeStringError([])).toBe(false);
-  });
-});
-
-describe(isSdkVersionIssueError, () => {
-  it('returns true when all errors are SDK-version-issue codes', () => {
-    expect(isSdkVersionIssueError([{ code: '90725' }, { code: '90725' }])).toBe(true);
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(isSdkVersionIssueError([{ code: '90725' }, { code: '90062' }])).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isSdkVersionIssueError([])).toBe(false);
-  });
-});
-
-describe(isMissingBackgroundTaskIdentifiersError, () => {
-  it('returns true when all errors are missing BG task identifiers codes', () => {
-    expect(isMissingBackgroundTaskIdentifiersError([{ code: '90771' }, { code: '90771' }])).toBe(
-      true
-    );
-  });
-
-  it('returns false when any other error code is present', () => {
-    expect(isMissingBackgroundTaskIdentifiersError([{ code: '90771' }, { code: '90062' }])).toBe(
-      false
-    );
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isMissingBackgroundTaskIdentifiersError([])).toBe(false);
-  });
-});
-
-describe(isMissingAppIconsError, () => {
-  it.each([['90391', '90713', '90713'], ['90713', '90022', '90023'], ['90022'], ['90023']])(
-    'recognizes missing-icon validation codes %j',
-    (...codes) => {
-      expect(isMissingAppIconsError(codes.map(code => ({ code })))).toBe(true);
-    }
-  );
-
-  it('returns false when any other error code is present', () => {
-    expect(isMissingAppIconsError([{ code: '90391' }, { code: '90771' }])).toBe(false);
-  });
-
-  it('returns false when there are no errors', () => {
-    expect(isMissingAppIconsError([])).toBe(false);
-  });
-});
-
-describe(parseMissingUsageDescriptionKeys, () => {
-  it('extracts missing UsageDescription keys from ASC messages', () => {
-    expect(
-      parseMissingUsageDescriptionKeys([
-        {
-          description:
-            'The Info.plist file should contain a NSPhotoLibraryUsageDescription key with a user-facing purpose string. (90683)',
-        },
-        {
-          description:
-            'The Info.plist file should contain a NSCameraUsageDescription key with a user-facing purpose string. (90683)',
-        },
-      ])
-    ).toEqual(['NSPhotoLibraryUsageDescription', 'NSCameraUsageDescription']);
-  });
-
-  it('deduplicates repeated keys', () => {
-    expect(
-      parseMissingUsageDescriptionKeys([
-        {
-          description:
-            'The Info.plist file should contain a NSCameraUsageDescription key with a user-facing purpose string. (90683)',
-        },
-        {
-          description:
-            'The Info.plist file should contain a NSCameraUsageDescription key with a user-facing purpose string. (90683)',
-        },
-      ])
-    ).toEqual(['NSCameraUsageDescription']);
-  });
-
-  it('returns an empty array when no usage description key is present', () => {
-    expect(
-      parseMissingUsageDescriptionKeys([{ description: 'Some other upload validation error.' }])
-    ).toEqual([]);
-  });
-});
-
-describe(createUploadToAscBuildFunction, () => {
-  it('keeps Apple duplicate-build details in the public error and the full state as its cause', async () => {
-    const state = {
-      state: 'FAILED',
-      errors: [
-        {
-          code: '90189',
-          description: 'Redundant Binary Upload. Build number 1 was already uploaded.',
-        },
-      ],
-      warnings: [{ code: 'WARNING', description: 'Apple warning.' }],
-      infos: [{ code: 'INFO', description: 'Apple information.' }],
-    };
-    await fs.writeFile('/app.ipa', 'ipa');
-    await fs.writeFile('/key.json', '{}');
-    jest.spyOn(AscApiUtils, 'loadApiKeyAsync').mockResolvedValue({} as never);
-    jest.spyOn(AscApiUtils, 'getAppInfoAsync').mockResolvedValue({
-      data: { attributes: { name: 'App', bundleId: 'com.example.app' } },
-    } as never);
-    jest.spyOn(AscApiUtils, 'createBuildUploadAsync').mockResolvedValue({
-      data: { id: 'upload-id' },
-    } as never);
-    jest.spyOn(AscApiUtils, 'commitBuildUploadFileAsync').mockResolvedValue(undefined as never);
-    jest.spyOn(AscApiClient.prototype, 'postAsync').mockResolvedValue({
-      data: { id: 'file-id', attributes: { uploadOperations: [] } },
-    } as never);
-    jest
-      .spyOn(AscApiClient.prototype, 'getAsync')
-      .mockResolvedValueOnce({
-        data: { attributes: { assetDeliveryState: { state: 'COMPLETE' } } },
-      } as never)
-      .mockResolvedValueOnce({ data: { attributes: { state } } } as never);
-    try {
-      const step = createUploadToAscBuildFunction().createBuildStepFromFunctionCall(
-        createGlobalContextMock({ staticContextContent: { job: {} } }),
-        {
-          callInputs: {
-            ipa_path: '/app.ipa',
-            asc_api_key_path: '/key.json',
-            apple_app_identifier: 'app-id',
-            bundle_version: '1',
-            bundle_short_version: '1.0',
-            wait_for_processing: true,
-          },
-        }
-      );
-      const error = await step.executeAsync().catch(error => error);
-      expect(error).toBeInstanceOf(UserError);
-      expect(error.errorCode).toBe('EAS_UPLOAD_TO_ASC_VERSION_DUPLICATE');
-      expect(error.cause).toEqual(state);
-      expect(error.toExternalExpoError().message).toContain(
-        'Redundant Binary Upload. Build number 1 was already uploaded. (90189)'
-      );
-    } finally {
-      jest.restoreAllMocks();
-    }
-  });
-});
-
-describe(createUploadToAscBuildFunction, () => {
-  it('keeps Apple background-task details in the public error and the full state as its cause', async () => {
-    const state = {
-      state: 'FAILED',
-      errors: [
-        {
-          code: '90771',
-          description:
-            'Missing BGTaskSchedulerPermittedIdentifiers while UIBackgroundModes includes processing.',
-        },
-      ],
-      warnings: [{ code: 'WARNING', description: 'Apple warning.' }],
-      infos: [{ code: 'INFO', description: 'Apple information.' }],
-    };
-    await fs.writeFile('/app.ipa', 'ipa');
-    await fs.writeFile('/key.json', '{}');
-    jest.spyOn(AscApiUtils, 'loadApiKeyAsync').mockResolvedValue({} as never);
-    jest.spyOn(AscApiUtils, 'getAppInfoAsync').mockResolvedValue({
-      data: { attributes: { name: 'App', bundleId: 'com.example.app' } },
-    } as never);
-    jest.spyOn(AscApiUtils, 'createBuildUploadAsync').mockResolvedValue({
-      data: { id: 'upload-id' },
-    } as never);
-    jest.spyOn(AscApiUtils, 'commitBuildUploadFileAsync').mockResolvedValue(undefined as never);
-    jest.spyOn(AscApiClient.prototype, 'postAsync').mockResolvedValue({
-      data: { id: 'file-id', attributes: { uploadOperations: [] } },
-    } as never);
-    jest
-      .spyOn(AscApiClient.prototype, 'getAsync')
-      .mockResolvedValueOnce({
-        data: { attributes: { assetDeliveryState: { state: 'COMPLETE' } } },
-      } as never)
-      .mockResolvedValueOnce({ data: { attributes: { state } } } as never);
-    try {
-      const step = createUploadToAscBuildFunction().createBuildStepFromFunctionCall(
-        createGlobalContextMock({ staticContextContent: { job: {} } }),
-        {
-          callInputs: {
-            ipa_path: '/app.ipa',
-            asc_api_key_path: '/key.json',
-            apple_app_identifier: 'app-id',
-            bundle_version: '1',
-            bundle_short_version: '1.0',
-            wait_for_processing: true,
-          },
-        }
-      );
-      const error = await step.executeAsync().catch(error => error);
-      expect(error).toBeInstanceOf(UserError);
-      expect(error.errorCode).toBe('EAS_UPLOAD_TO_ASC_MISSING_BG_TASK_IDENTIFIERS');
-      expect(error.cause).toEqual(state);
-      expect(error.toExternalExpoError().message).toContain(
-        'Missing BGTaskSchedulerPermittedIdentifiers while UIBackgroundModes includes processing. (90771)'
-      );
-    } finally {
-      jest.restoreAllMocks();
-    }
-  });
-});
-
-describe(createUploadToAscBuildFunction, () => {
-  it('keeps Apple validation details in the public error and the full state as its cause', async () => {
-    const state = {
-      state: 'FAILED',
-      errors: [{ code: '90713', description: 'Missing CFBundleIconName in Watch.app.' }],
-      warnings: [{ code: 'WARNING', description: 'Apple warning.' }],
-      infos: [{ code: 'INFO', description: 'Apple information.' }],
-    };
-    await fs.writeFile('/app.ipa', 'ipa');
-    await fs.writeFile('/key.json', '{}');
-    jest.spyOn(AscApiUtils, 'loadApiKeyAsync').mockResolvedValue({} as never);
-    jest.spyOn(AscApiUtils, 'getAppInfoAsync').mockResolvedValue({
-      data: { attributes: { name: 'App', bundleId: 'com.example.app' } },
-    } as never);
-    jest.spyOn(AscApiUtils, 'createBuildUploadAsync').mockResolvedValue({
-      data: { id: 'upload-id' },
-    } as never);
-    jest.spyOn(AscApiUtils, 'commitBuildUploadFileAsync').mockResolvedValue(undefined as never);
-    jest.spyOn(AscApiClient.prototype, 'postAsync').mockResolvedValue({
-      data: { id: 'file-id', attributes: { uploadOperations: [] } },
-    } as never);
-    jest
-      .spyOn(AscApiClient.prototype, 'getAsync')
-      .mockResolvedValueOnce({
-        data: { attributes: { assetDeliveryState: { state: 'COMPLETE' } } },
-      } as never)
-      .mockResolvedValueOnce({ data: { attributes: { state } } } as never);
-    try {
-      const step = createUploadToAscBuildFunction().createBuildStepFromFunctionCall(
-        createGlobalContextMock({ staticContextContent: { job: {} } }),
-        {
-          callInputs: {
-            ipa_path: '/app.ipa',
-            asc_api_key_path: '/key.json',
-            apple_app_identifier: 'app-id',
-            bundle_version: '1',
-            bundle_short_version: '1.0',
-            wait_for_processing: true,
-          },
-        }
-      );
-      const error = await step.executeAsync().catch(error => error);
-      expect(error).toBeInstanceOf(UserError);
-      expect(error.errorCode).toBe('EAS_UPLOAD_TO_ASC_MISSING_APP_ICONS');
-      expect(error.cause).toEqual(state);
-      expect(error.toExternalExpoError().message).toContain(
-        'Missing CFBundleIconName in Watch.app. (90713)'
-      );
-    } finally {
-      jest.restoreAllMocks();
-    }
-  });
-});

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

@@ -1,39 +0,0 @@
-import spawn from '@expo/turtle-spawn';
-import { vol } from 'memfs';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { NpmrcAuthTokenLine } from '../../../templates/npmrc';
-import { createSetUpNpmrcBuildFunction } from '../useNpmToken';
-
-jest.mock('fs');
-jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
-
-const projectTargetDirectory = '/workingdir/project';
-const homeDirectory = '/home/expo';
-
-describe(createSetUpNpmrcBuildFunction, () => {
-  beforeEach(async () => {
-    vol.reset();
-    await vol.promises.mkdir(projectTargetDirectory, { recursive: true });
-    await vol.promises.mkdir(homeDirectory, { recursive: true });
-    jest.mocked(spawn).mockResolvedValue({ stdout: `${homeDirectory}/.npmrc\n` } as never);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('adds the NPM_TOKEN placeholder from the step env to ~/.npmrc on EAS Build', async () => {
-    const globalCtx = createGlobalContextMock({ projectTargetDirectory });
-    globalCtx.updateEnv({ NPM_TOKEN: 'npm_secret_token', EAS_BUILD_RUNNER: 'eas-build' });
-    const step = createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: {},
-    });
-
-    await step.executeAsync();
-
-    expect(await vol.promises.readFile(`${homeDirectory}/.npmrc`, 'utf8')).toContain(
-      NpmrcAuthTokenLine
-    );
-  });
-});

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

@@ -0,0 +1,222 @@
+import fs from 'fs-extra';
+import nock from 'nock';
+import { generateKeyPairSync } from 'node:crypto';
+import { setTimeout } from 'node:timers/promises';
+
+import {
+  createCustomBuildContextMock,
+  createGlobalContextMock,
+} from '../../../__tests__/utils/context';
+import { createMockLogger } from '../../../__tests__/utils/logger';
+import { getEasFunctions } from '../../easFunctions';
+import { readIpaInfoAsync } from '../readIpaInfo';
+import { createUploadToAscBuildFunction } from '../uploadToAsc';
+
+jest.unmock('node-fetch');
+jest.mock('node:timers/promises', () => ({ setTimeout: jest.fn().mockResolvedValue(undefined) }));
+jest.mock('../readIpaInfo', () => ({
+  ...jest.requireActual('../readIpaInfo'),
+  readIpaInfoAsync: jest.fn(),
+}));
+
+const { privateKey } = generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+const api = () => nock('https://api.appstoreconnect.apple.com');
+const logger = createMockLogger();
+const globalContext = () => createGlobalContextMock({ projectTargetDirectory: '/project', logger });
+
+async function waitAsync(diagnostics: Record<string, string> = {}): Promise<void> {
+  const fn = getEasFunctions(createCustomBuildContextMock()).find(
+    fn => fn.getFullId() === 'eas/wait_for_asc_build_processing'
+  )!;
+  await fn
+    .createBuildStepFromFunctionCall(globalContext(), {
+      callInputs: { asc_api_key_path: 'key.json', build_upload_id: 'upload', ...diagnostics },
+    })
+    .executeAsync();
+}
+
+async function uploadAsync(): Promise<void> {
+  await fs.outputFile('/project/app.ipa', 'ipa');
+  jest.mocked(readIpaInfoAsync).mockResolvedValue({
+    bundleIdentifier: 'com.test.ipa',
+    bundleVersion: '1',
+    bundleShortVersion: '1.0',
+    dtPlatformName: 'iphoneos',
+  });
+  mockUpload();
+  const step = createUploadToAscBuildFunction().createBuildStepFromFunctionCall(globalContext(), {
+    callInputs: {
+      ipa_path: 'app.ipa',
+      asc_api_key_path: 'key.json',
+      apple_app_identifier: 'app',
+      bundle_version: '1',
+      bundle_short_version: '1.0',
+    },
+  });
+  await step.executeAsync();
+}
+
+function mockProcessing(state: string, errors: { code: string; description: string }[] = []): void {
+  api()
+    .get('/v1/buildUploads/upload')
+    .query(true)
+    .reply(200, {
+      data: { type: 'buildUploads', id: 'upload', attributes: { state: { state, errors } } },
+    });
+}
+
+function mockApp(): void {
+  api()
+    .get('/v1/apps/app')
+    .query(true)
+    .reply(200, {
+      data: { type: 'apps', id: 'app', attributes: { name: 'Test app', bundleId: 'com.test.app' } },
+    });
+}
+
+function mockUpload(): void {
+  mockApp();
+  api()
+    .post('/v1/buildUploads')
+    .reply(201, { data: { type: 'buildUploads', id: 'upload' } });
+  api()
+    .post('/v1/buildUploadFiles')
+    .reply(201, {
+      data: {
+        type: 'buildUploadFiles',
+        id: 'file',
+        attributes: {
+          uploadOperations: [
+            {
+              length: 3,
+              offset: 0,
+              partNumber: 1,
+              method: 'PUT',
+              requestHeaders: [],
+              url: 'https://upload.example.com/ipa',
+            },
+          ],
+        },
+      },
+    });
+  nock('https://upload.example.com').put('/ipa', 'ipa').reply(200);
+  api()
+    .get('/v1/buildUploadFiles/file')
+    .query(true)
+    .twice()
+    .reply(200, {
+      data: {
+        type: 'buildUploadFiles',
+        id: 'file',
+        attributes: { assetDeliveryState: { state: 'COMPLETE' } },
+      },
+    });
+}
+
+beforeAll(() => nock.disableNetConnect());
+afterAll(() => nock.enableNetConnect());
+beforeEach(async () => {
+  await fs.outputJson('/project/key.json', {
+    key_id: 'TESTKEY',
+    key: privateKey.export({ type: 'pkcs8', format: 'pem' }),
+  });
+  jest.mocked(setTimeout).mockResolvedValue(undefined);
+});
+afterEach(() => {
+  try {
+    expect(nock.pendingMocks()).toEqual([]);
+  } finally {
+    nock.cleanAll();
+    jest.restoreAllMocks();
+  }
+});
+
+it('polls an existing upload through awaiting and processing states until complete', async () => {
+  mockProcessing('AWAITING_UPLOAD');
+  mockProcessing('PROCESSING');
+  mockProcessing('COMPLETE');
+  await expect(waitAsync()).resolves.toBeUndefined();
+});
+
+it('uses the supplied bundle identifier in mismatch errors without an IPA', async () => {
+  mockProcessing(
+    'FAILED',
+    ['90054', '90055'].map(code => ({ code, description: 'Bundle mismatch' }))
+  );
+  mockApp();
+  api().get('/v1/apps').query(true).reply(200, { data: [] });
+  await expect(
+    waitAsync({ bundle_identifier: 'com.test.ipa', apple_app_identifier: 'app' })
+  ).rejects.toMatchObject({
+    errorCode: 'EAS_UPLOAD_TO_ASC_INVALID_BUNDLE_ID',
+    message: expect.stringContaining(
+      'IPA bundle identifier: com.test.ipa\nApp Store Connect app bundle identifier: com.test.app'
+    ),
+  });
+});
+
+it.each<[string, string[], string]>([
+  ['SDK version', ['90725'], 'EAS_UPLOAD_TO_ASC_SDK_VERSION_ISSUE'],
+  ['closed version train', ['90062', '90186', '90478'], 'EAS_UPLOAD_TO_ASC_CLOSED_VERSION_TRAIN'],
+])('reports a %s processing error', async (_label, codes, errorCode) => {
+  mockProcessing(
+    'FAILED',
+    codes.map(code => ({ code, description: 'Rejected' }))
+  );
+  await expect(waitAsync()).rejects.toMatchObject({ errorCode });
+});
+
+it.each(
+  [
+    [],
+    ['OTHER'],
+    ['90725', 'OTHER'],
+    ['90062', 'OTHER'],
+    ['90054', 'OTHER'],
+    ['90683', 'OTHER'],
+  ].map(codes => ({ codes }))
+)('keeps unclassified or mixed processing errors generic: $codes', async ({ codes }) => {
+  mockProcessing(
+    'FAILED',
+    codes.map(code => ({ code, description: 'Rejected' }))
+  );
+  await expect(waitAsync()).rejects.toThrow('Build upload (ID: upload) failed.');
+});
+
+it('reports missing privacy keys once each', async () => {
+  mockProcessing('FAILED', [
+    {
+      code: '90683',
+      description: 'Missing NSCameraUsageDescription and NSPhotoLibraryUsageDescription.',
+    },
+    { code: '90683', description: 'Missing NSCameraUsageDescription.' },
+  ]);
+  await expect(waitAsync()).rejects.toMatchObject({
+    errorCode: 'EAS_UPLOAD_TO_ASC_MISSING_PURPOSE_STRING',
+    message: expect.stringContaining(
+      'Missing keys reported by App Store Connect:\n- NSCameraUsageDescription\n- NSPhotoLibraryUsageDescription\n\n'
+    ),
+  });
+});
+
+it('reports missing privacy purpose strings when Apple does not name a key', async () => {
+  mockProcessing('FAILED', [{ code: '90683', description: 'Missing purpose string.' }]);
+  await expect(waitAsync()).rejects.toMatchObject({
+    errorCode: 'EAS_UPLOAD_TO_ASC_MISSING_PURPOSE_STRING',
+    message: expect.not.stringContaining('Missing keys reported by App Store Connect:'),
+  });
+});
+
+it('finishes the upload without waiting for processing', async () => {
+  await expect(uploadAsync()).resolves.toBeUndefined();
+});
+
+it('preserves the successful timeout return for the wait step', async () => {
+  mockProcessing('PROCESSING');
+  const start = Date.now();
+  jest.spyOn(Date, 'now').mockReturnValue(start);
+  jest.mocked(setTimeout).mockImplementationOnce(async () => {
+    jest.spyOn(Date, 'now').mockReturnValue(start + 30 * 60 * 1000);
+  });
+  await expect(waitAsync()).resolves.toBeUndefined();
+});

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

@@ -1,34 +0,0 @@
-import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
-
-import { type CustomBuildContext } from '../../customBuildContext';
-import { Sentry } from '../../sentry';
-import { collectAndroidEmulatorLogsAsync } from '../utils/androidEmulatorLogs';
-import { getDeviceRunSessionIdOrThrow } from '../utils/remoteDeviceRunSession';
-
-export function createCollectAndroidEmulatorLogsBuildFunction(
-  ctx: CustomBuildContext
-): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'collect_android_emulator_logs',
-    name: 'Collect Android emulator logs',
-    __metricsId: 'eas/collect_android_emulator_logs',
-    supportedRuntimePlatforms: [BuildRuntimePlatform.LINUX],
-    fn: async ({ logger, global }, { env }) => {
-      try {
-        await collectAndroidEmulatorLogsAsync(ctx, {
-          global,
-          deviceRunSessionId: getDeviceRunSessionIdOrThrow(env),
-          logger,
-        });
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        Sentry.capture('Could not collect Android emulator logs', error);
-        logger.warn(
-          { err: error },
-          'Could not collect Android logs; the session result is unchanged.'
-        );
-      }
-    },
-  });
-}

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

@@ -312,22 +312,8 @@ export async function downloadBuildAsync(
         const response = await fetch(downloadUrl, { headers, signal });
         if (!response.ok) {
           const textResult = await asyncResult(response.text());
-          const archiveUrl = new URL(downloadUrl);
-          const source = params.buildId
-            ? `application archive for build ${params.buildId}`
-            : `archive at ${archiveUrl.origin}${archiveUrl.pathname}`;
-          if (response.status === 404 || response.status === 410) {
-            throw new UserError(
-              'EAS_DOWNLOAD_BUILD_ARCHIVE_UNAVAILABLE',
-              `Failed to download the ${source} (HTTP ${response.status}). ` +
-                'The archive is unavailable. ' +
-                (params.buildId
-                  ? 'Check that the archive still exists and try again.'
-                  : 'Check that the URL is correct and the archive still exists, then try again.')
-            );
-          }
           throw new Error(
-            `Failed to download the ${source} (HTTP ${response.status}): ${textResult.value}`
+            `Unexpected response from server (${response.status}): ${textResult.value}`
           );
         }
         const archiveFilename = resolveArchiveFilename({ response, extensions });

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, BuildStepOutput } from '@expo/steps';
+import { BuildFunction, BuildStepContext } from '@expo/steps';
 
 import { CustomBuildContext } from '../../customBuildContext';
 import { findXcodeBuildLogsPathAsync } from '../../ios/xcodeBuildLogs';
@@ -13,13 +13,7 @@ export function createFindAndUploadBuildArtifactsBuildFunction(
     id: 'find_and_upload_build_artifacts',
     name: 'Find and upload build artifacts',
     __metricsId: 'eas/find_and_upload_build_artifacts',
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'application_archive_path',
-        required: false,
-      }),
-    ],
-    fn: async (stepCtx, { outputs }) => {
+    fn: async stepCtx => {
       // 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.
@@ -30,10 +24,7 @@ export function createFindAndUploadBuildArtifactsBuildFunction(
       let firstError: any = null;
 
       try {
-        const [firstArchivePath] = await uploadApplicationArchivesAsync({ ctx, stepCtx });
-        if (firstArchivePath) {
-          outputs.application_archive_path.set(firstArchivePath);
-        }
+        await uploadApplicationArchivesAsync({ ctx, stepCtx });
       } catch (err: unknown) {
         stepCtx.logger.error({ err }, `Failed to upload application archives.`);
         firstError ||= err;
@@ -77,7 +68,7 @@ async function uploadApplicationArchivesAsync({
 }: {
   ctx: CustomBuildContext<BuildJob>;
   stepCtx: BuildStepContext;
-}): Promise<string[]> {
+}): Promise<void> {
   const applicationArchivePatternOrPath =
     ctx.job.platform === Platform.ANDROID
       ? (ctx.job.applicationArchivePath ?? 'android/app/build/outputs/**/*.{apk,aab}')
@@ -108,8 +99,6 @@ 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> {
   }
 }
 
-export function parseInfoPlistBuffer(data: Buffer): Record<string, unknown> {
+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/repack.ts

@@ -23,7 +23,7 @@ import resolveFrom from 'resolve-from';
 
 import { COMMON_FASTLANE_ENV } from '../../common/fastlane';
 import IosCredentialsManager from '../utils/ios/credentials/manager';
-import { installIsolatedNpmPackageAsync } from '../../utils/installIsolatedNpmPackageAsync';
+import { resolvePackageVersionAsync } from '../../utils/packageManager';
 
 export function createRepackBuildFunction(): BuildFunction {
   return new BuildFunction({
@@ -121,12 +121,18 @@ export function createRepackBuildFunction(): BuildFunction {
         : undefined;
       const jsBundleOnly = (inputs.js_bundle_only.value as boolean | undefined) ?? false;
 
+      const resolvedRepackVersion =
+        (await resolvePackageVersionAsync({
+          logger: stepsCtx.logger,
+          packageName: inputs.repack_package.value as string,
+          distTag: inputs.repack_version.value as string,
+        })) ?? (inputs.repack_version.value as string);
+      stepsCtx.logger.info(
+        `Using repack from: ${inputs.repack_package.value}@${inputs.repack_version.value} (${resolvedRepackVersion})`
+      );
       const repackApp = await installAndImportRepackAsync({
         packageName: inputs.repack_package.value as string,
-        versionSpec: inputs.repack_version.value as string,
-        pathEnv: env.PATH,
-        npmCacheUrl: env.EAS_BUILD_NPM_CACHE_URL,
-        logger: stepsCtx.logger,
+        version: resolvedRepackVersion,
       });
       const { repackAppIosAsync, repackAppAndroidAsync } = repackApp;
 
@@ -220,28 +226,16 @@ function createOutputPath({
  */
 async function installAndImportRepackAsync({
   packageName,
-  versionSpec,
-  pathEnv,
-  npmCacheUrl,
-  logger,
+  version,
 }: {
   packageName: string;
-  versionSpec: string;
-  pathEnv: string | undefined;
-  npmCacheUrl: string | undefined;
-  logger: bunyan;
+  version: string;
 }): Promise<typeof import('@expo/repack-app')> {
   const sandbox = await fs.promises.mkdtemp(path.join(os.tmpdir(), `repack-package-root-`));
-  await installIsolatedNpmPackageAsync({
-    packageSpec: `${packageName}@${versionSpec}`,
-    directory: sandbox,
-    npmCacheUrl,
-    pathEnv,
-    logger,
+  await spawnAsync('yarn', ['add', `${packageName}@${version}`], {
+    stdio: 'inherit',
+    cwd: sandbox,
   });
-  const packageJsonPath = path.join(sandbox, 'node_modules', packageName, 'package.json');
-  const { version } = JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
-  logger.info(`Using repack from: ${packageName}@${versionSpec} (${version})`);
   return require(resolveFrom(sandbox, packageName));
 }
 

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

@@ -9,8 +9,6 @@ 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,
@@ -25,7 +23,6 @@ import { type ServeSimApplicationOptions } from '../utils/remoteDeviceRunSession
 import { type StartupTasks } from '../utils/startupTasks';
 import {
   type DetachedProcessHandle,
-  DeviceRunSessionStoppedError,
   finishRemoteSessionAsync,
   getDeviceRunSessionIdOrThrow,
   getNgrokAuthtokenOrThrow,
@@ -101,8 +98,6 @@ export async function runAgentDeviceRemoteSessionAsync(
     frameAncestors,
     corsOrigins,
     tasks,
-    warm,
-    onStarted,
     device,
   }: {
     env: BuildStepEnv;
@@ -119,9 +114,6 @@ export async function runAgentDeviceRemoteSessionAsync(
     frameAncestors?: string[];
     corsOrigins?: string[];
     tasks: StartupTasks;
-    /** A claimed warm Simulator: adopt it and use its agent-device daemon. */
-    warm?: WarmIosSession;
-    onStarted?: () => Promise<void>;
     device:
       | {
           booted: Promise<unknown>;
@@ -145,9 +137,6 @@ 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;
@@ -155,70 +144,7 @@ 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,
@@ -234,8 +160,55 @@ 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.`);
-    return daemonInfo;
-  }
+
+    tasks.signal.throwIfAborted();
+    agentDeviceTunnel = await startNgrokTunnelAsync({
+      port: daemonInfo.port,
+      subdomainPrefix: 'agent-device',
+      baseDomain: ngrokTunnelDomain,
+      authtoken: ngrokAuthtoken,
+      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;
+  });
   const deviceReady = externallyBootedDevice?.ready;
 
   try {
@@ -252,9 +225,9 @@ export async function runAgentDeviceRemoteSessionAsync(
     tasks.signal.throwIfAborted();
     logger.info(tasks.summary());
 
-    const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
+    await uploadRemoteSessionConfigWithLocalEgressAsync({
       env,
-      signal: tasks.signal,
+      signal,
       ctx,
       deviceRunSessionId,
       remoteConfig: {
@@ -266,26 +239,18 @@ export async function runAgentDeviceRemoteSessionAsync(
       },
       logger,
     });
-    if (sessionStart === 'stopped') {
-      return;
-    }
-    await onStarted?.();
     tasks.signal.throwIfAborted();
-    artifactUploads = pollAgentDeviceArtifactsForUploadAsync(ctx, {
+    void 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: warm?.agentDeviceStateDir ?? AGENT_DEVICE_STATE_DIR,
+      stateDir: AGENT_DEVICE_STATE_DIR,
       logger,
     });
 
@@ -305,64 +270,37 @@ export async function runAgentDeviceRemoteSessionAsync(
           : undefined,
     });
   } catch (error) {
-    if (
-      tasks.signal.reason instanceof DeviceRunSessionStoppedError &&
-      !(error instanceof AggregateError)
-    ) {
-      throw tasks.signal.reason;
-    }
     sessionFailed = true;
     throw error;
   } finally {
     // Promise.all rejects on the first failure while other tasks can still be starting.
     // They stop at their next abort check. Wait for all of them, so the teardown sees
     // everything that was started.
-    const startupResults = await Promise.allSettled([
-      agentDeviceStartup,
-      sessionHostStartup,
-      deviceReady,
-    ]);
+    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: [
-        ...startupResults.flatMap((result): [string, Promise<unknown>][] =>
-          result.status === 'rejected' && result.reason instanceof AggregateError
-            ? [['startup cleanup', Promise.reject(result.reason)]]
-            : []
-        ),
         ['agent-device tunnel', agentDeviceTunnel?.stopAsync()],
-        ['agent-device daemon', toolTeardown],
         [
-          '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();
-          })(),
+          'agent-device daemon',
+          startedDaemon &&
+            (async () => {
+              try {
+                if (eventCollection) {
+                  await stopAgentDeviceEventCollectionSafelyAsync({
+                    eventCollection,
+                    deviceRunSessionId,
+                    logger,
+                  });
+                }
+              } finally {
+                await startedDaemon.stopAsync();
+              }
+            })(),
         ],
+        ['session host', sessionHost?.finishAsync()],
       ],
     });
   }

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

@@ -15,33 +15,27 @@ import {
   AndroidEmulatorUtils,
   AndroidVirtualDeviceName,
 } from '../../utils/AndroidEmulatorUtils';
-import { watchDeviceRunSessionStartup } from '../utils/deviceRunSessionStartup';
-import { AndroidEmulatorLogSourcesSchema } from '../../utils/androidEmulatorLogSources';
-import { getAndroidEmulatorLogCapture } from '../utils/androidEmulatorLogs';
 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';
@@ -55,30 +49,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 using an optional local app artifact, or one it downloads.
+ * Starts a device session, downloading the app alongside daemon startup.
  * On iOS, serve-sim boots the selected Simulator, then installs and launches
- * the app. Build-tools verifies any egress guard before install and launch.
+ * the downloaded app. Build-tools verifies any egress guard before install and launch.
  */
-export function createStartAgentDeviceSessionBuildFunction(
-  ctx: CustomBuildContext,
-  { warm = false }: { warm?: boolean } = {}
-): BuildFunction {
+export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildContext): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: warm ? 'start_warm_agent_device_session' : 'start_agent_device_session',
+    id: 'start_agent_device_session',
     name: 'Start agent-device session',
-    __metricsId: warm ? 'eas/start_warm_agent_device_session' : 'eas/start_agent_device_session',
+    __metricsId: 'eas/start_agent_device_session',
     inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'android_log_sources',
-        required: false,
-        defaultValue: ['emulator-output'],
-        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-      }),
       // Device. On iOS a Simulator name or UDID, on Android an AVD hardware profile.
       BuildStepInput.createProvider({
         id: 'device_identifier',
@@ -106,13 +93,7 @@ export function createStartAgentDeviceSessionBuildFunction(
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
-      // 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.
+      // Application. Pass at most one of build_id and application_archive_url.
       BuildStepInput.createProvider({
         id: 'build_id',
         required: false,
@@ -123,7 +104,16 @@ export function createStartAgentDeviceSessionBuildFunction(
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
-      ...createServeSimLaunchInputProviders(),
+      BuildStepInput.createProvider({
+        id: 'launch_args',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
+      }),
+      BuildStepInput.createProvider({
+        id: 'open_url',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
       // Session.
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
@@ -154,41 +144,22 @@ export function createStartAgentDeviceSessionBuildFunction(
       // 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;
-      const launchAppIdentifier = inputs.launch_app_identifier.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 launchArgs = parseLaunchArgsInput(inputs.launch_args.value);
       const openUrl =
         inputs.open_url.value === undefined ? undefined : parseOpenUrlInput(inputs.open_url.value);
-      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) {
+      if (!hasApplication && (launchArgs.length > 0 || openUrl)) {
         throw new UserError(
           'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-          '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.'
+          'launch_args and open_url need an application: pass build_id or application_archive_url.'
         );
       }
       if (isIos) {
@@ -196,9 +167,6 @@ export function createStartAgentDeviceSessionBuildFunction(
       } else {
         validateAndroidLaunchOptions({ launchArgs, openUrl });
       }
-      const logSources = isIos
-        ? []
-        : AndroidEmulatorLogSourcesSchema.parse(inputs.android_log_sources.value);
       const deviceIdentifier = inputs.device_identifier.value as string | undefined;
       const capture = parseNetworkCaptureInputs(
         {
@@ -208,123 +176,87 @@ export function createStartAgentDeviceSessionBuildFunction(
         { runtimePlatform }
       );
 
-      const startup = new AbortController();
-      const startupSignal = signal ? AbortSignal.any([signal, startup.signal]) : startup.signal;
-      const startupWatch = watchDeviceRunSessionStartup({
-        ctx,
-        deviceRunSessionId: sessionEnv.deviceRunSessionId,
-        logger,
-        startup: { signal: startupSignal, abort: reason => startup.abort(reason) },
-      });
-      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
-        const tasks = createStartupTasks(logger, startupSignal);
-        let booted: Promise<void> | undefined;
-        let sessionOwnsTeardown = false;
-        let downloaded: Promise<string> | undefined;
-        let applicationReady: Promise<ServeSimApplicationOptions | void> | undefined;
+      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 { 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,
+      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,
                 env,
-                logger,
+                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'],
                 signal: tasks.signal,
-              })
-            : {};
-          const iosSimulatorUdid = iosStartup?.iosSimulatorUdid;
-          if (iosSimulatorUdid) {
-            logger.info(`Selected iOS Simulator: ${iosSimulatorUdid}.`);
-          }
-
-          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();
-                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,
-                  logSources,
-                  logCapture: getAndroidEmulatorLogCapture(global, env),
-                  env,
-                  logger: taskLogger,
-                });
               });
+              return artifactPath;
+            })
+          : undefined;
 
-          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.');
+        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,
+                });
+                tasks.signal.throwIfAborted();
+                return {
+                  installAppPath: artifactPath,
+                  launchAppIdentifier: applicationIdentifier,
+                  launchArgs,
+                  openUrl,
+                };
+              }
               const { applicationIdentifier, activityName } = await installBuildAsync({
                 artifactPath,
                 runtimePlatform,
@@ -341,76 +273,39 @@ export function createStartAgentDeviceSessionBuildFunction(
                 env,
                 logger: taskLogger,
               });
-            });
-          }
+            })
+          : undefined;
 
-          sessionOwnsTeardown = true;
-          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,
-            onStarted: () => startupWatch.completeAsync(),
-            device: iosSimulatorUdid
-              ? {
-                  iosSimulatorUdid,
-                  bootEnv: iosStartup?.bootEnv,
-                  application: applicationReady,
-                }
-              : {
-                  booted,
-                  ready: applicationReady ?? tasks.untilAborted(booted),
-                },
-          });
-        } catch (error) {
-          if (
-            !sessionOwnsTeardown &&
-            tasks.signal.reason === startupWatch.stopped &&
-            !(error instanceof AggregateError)
-          ) {
-            throw startupWatch.stopped;
-          }
-          throw error;
-        } finally {
-          tasks.abort(new Error('Agent-device session ended.'));
-          await Promise.allSettled([booted, downloaded, applicationReady]);
-        }
-      };
-      try {
-        startupSignal.throwIfAborted();
-        if (warm && isIos && !download) {
-          await runOnWarmIosSimulatorAsync(
-            {
-              engine: 'agent-device',
-              requestedDevice: deviceIdentifier,
-              packageVersion: inputs.package_version.value as string | undefined,
-              env,
-              logger,
-              signal: startupSignal,
-            },
-            startSessionAsync
-          );
-        } else {
-          await startSessionAsync();
-        }
-      } catch (error) {
-        if (error !== startupWatch.stopped) {
-          throw error;
-        }
+        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 {
-        await startupWatch.finishAsync();
+        tasks.abort(new Error('Agent-device session ended.'));
+        await Promise.allSettled([downloaded, applicationReady]);
       }
     }),
   });

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

@@ -20,15 +20,8 @@ import {
   AndroidEmulatorUtils,
   AndroidVirtualDeviceName,
 } from '../../utils/AndroidEmulatorUtils';
-import { type AndroidEmulatorLogCapture } from '../../utils/androidEmulatorLogCapture';
 import { retryAsync } from '../../utils/retry';
 import { resolveAndroidEmulatorLocalEgressAsync } from '../utils/androidLocalEgress';
-import {
-  ALL_ANDROID_EMULATOR_LOG_SOURCES,
-  type AndroidEmulatorLogSource,
-  AndroidEmulatorLogSourcesSchema,
-} from '../../utils/androidEmulatorLogSources';
-import { getAndroidEmulatorLogCapture } from '../utils/androidEmulatorLogs';
 
 const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
 const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
@@ -40,12 +33,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
     name: 'Start Android Emulator',
     __metricsId: 'eas/start_android_emulator',
     inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'android_log_sources',
-        required: false,
-        defaultValue: [...ALL_ANDROID_EMULATOR_LOG_SOURCES],
-        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-      }),
       BuildStepInput.createProvider({
         id: 'device_name',
         required: false,
@@ -91,12 +78,10 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
         required: true,
       }),
     ],
-    fn: async ({ logger, global }, { inputs, outputs, env }) => {
-      const logSources = AndroidEmulatorLogSourcesSchema.parse(inputs.android_log_sources.value);
+    fn: async ({ logger }, { inputs, outputs, env }) => {
       const logcatDirectory = await fs.promises.mkdtemp(
         path.join(os.tmpdir(), 'eas-android-emulator-logcat-')
       );
-      const logCapture = getAndroidEmulatorLogCapture(global, env);
       outputs.logcat_directory.set(logcatDirectory);
 
       const deviceName = `${inputs.device_name.value}` as AndroidVirtualDeviceName;
@@ -110,8 +95,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
           lcdHeight: inputs.lcd_height.value as number | undefined,
           lcdDensity: inputs.lcd_density.value as number | undefined,
           logcatDirectory,
-          logSources,
-          logCapture,
           env,
           logger,
         });
@@ -150,8 +133,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
                   deviceName: cloneIdentifier,
                   env,
                   logcatDirectory,
-                  logSources,
-                  logCapture,
                 });
                 cloneSerialId = startResult.serialId;
 
@@ -221,8 +202,6 @@ export async function startAndroidEmulatorAsync({
   lcdHeight,
   lcdDensity,
   logcatDirectory,
-  logSources,
-  logCapture,
   env,
   logger,
 }: {
@@ -233,8 +212,6 @@ export async function startAndroidEmulatorAsync({
   lcdHeight?: number;
   lcdDensity?: number;
   logcatDirectory: string;
-  logSources: readonly AndroidEmulatorLogSource[];
-  logCapture: AndroidEmulatorLogCapture;
   env: BuildStepEnv;
   logger: bunyan;
 }): Promise<{
@@ -316,8 +293,6 @@ export async function startAndroidEmulatorAsync({
           deviceName,
           env,
           logcatDirectory,
-          logSources,
-          logCapture,
           ...(localEgress ? { launchGate: localEgress.launchGate } : {}),
         });
         attemptSerialId = startResult.serialId;

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

@@ -22,12 +22,6 @@ 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,
@@ -45,9 +39,7 @@ import { sleepAsync } from '../../utils/retry';
 import { turtleFetch } from '../../utils/turtleFetch';
 import { startAppiumEventCollectionAsync } from '../utils/appiumEvents';
 import { preparePreinstalledWdaAsync } from '../utils/preinstalledWda';
-import { watchDeviceRunSessionStartup } from '../utils/deviceRunSessionStartup';
 import {
-  DeviceRunSessionStoppedError,
   createCorsOriginsInputProvider,
   createFrameAncestorsInputProvider,
   createIosSessionStartupInputProviders,
@@ -73,7 +65,6 @@ const APPIUM_HOST = '127.0.0.1';
 const APPIUM_PORT = 4723;
 const APPIUM_STARTUP_TIMEOUT_MS = 120_000;
 const DEFAULT_APPIUM_VERSION = '^3';
-const FDA_HELPER = '/usr/local/libexec/turtle-tcc-fda';
 
 const AppiumInstalledDriversSchema = z.record(
   z.string(),
@@ -81,14 +72,13 @@ const AppiumInstalledDriversSchema = z.record(
 );
 
 export function createStartAppiumRemoteSessionBuildFunction(
-  ctx: CustomBuildContext,
-  { warm = false }: { warm?: boolean } = {}
+  ctx: CustomBuildContext
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: warm ? 'start_warm_appium_remote_session' : 'start_appium_remote_session',
+    id: 'start_appium_remote_session',
     name: 'Start Appium remote session',
-    __metricsId: warm ? 'eas/start_warm_appium_remote_session' : 'eas/start_appium_remote_session',
+    __metricsId: 'eas/start_appium_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -116,327 +106,240 @@ export function createStartAppiumRemoteSessionBuildFunction(
       const packageVersion = inputs.package_version.value as string | undefined;
       const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value as number | undefined;
       const { runtimePlatform } = global;
-      const startupStop = new AbortController();
-      const watchSignal = signal
-        ? AbortSignal.any([signal, startupStop.signal])
-        : startupStop.signal;
-      const startupWatch = watchDeviceRunSessionStartup({
-        ctx,
-        deviceRunSessionId,
+      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,
-        startup: { signal: watchSignal, abort: reason => startupStop.abort(reason) },
+        signal,
       });
-      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
-      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
-        const startupAbortController = new AbortController();
-        const startupSignal = AbortSignal.any([watchSignal, startupAbortController.signal]);
-        const { launch, iosStartup } = await resolveIosSessionStartupAsync({
+      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,
+          separateLogPhase: true,
           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,
-        });
-        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 });
-        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,
-              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: error => startupAbortController.abort(error),
-              ...launch,
-              networkCapture,
-              networkCaptureFields,
-            },
-            ...(warmSession ? [createWarmDeviceSessionServer(ctx, logger, warmSession)] : [])
-          ).catch(error => {
-            startupAbortController.abort(error);
-            throw error;
-          });
-        try {
+          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
+          ...launch,
+          networkCapture,
+          networkCaptureFields,
+        }).catch(error => {
           if (iosStartup) {
-            hostStartup = asyncResult(startHost());
+            startupAbortController.abort(error);
           }
-          // 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: startupSignal,
-                onError: error => startupAbortController.abort(error),
-              }).catch(error => {
-                startupAbortController.abort(error);
-                throw error;
-              })
-            ),
-            asyncResult(
-              ensureFfmpegInstalledOnceAsync({
-                runtimePlatform,
-                env,
-                logger,
-                signal: startupSignal,
-              })
-            ),
-          ]);
-          const installation = appiumInstall.enforceValue();
-          appiumHome = installation.appiumHome;
-          startupSignal?.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: startupSignal,
-          });
-
-          startupSignal?.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: startupSignal });
-          if (hostStartup) {
-            sessionHost = (await hostStartup).enforceValue();
-          }
-          startupSignal?.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();
-          startupSignal.throwIfAborted();
-          const webPreview = await sessionHost.openPreviewAsync();
-
-          const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
-            env,
-            signal: startupSignal,
-            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 startupWatch.completeAsync();
-          await waitForDeviceRunSessionStoppedAsync({
-            ctx,
-            deviceRunSessionId,
-            logger,
-            signal,
-            idleTimeout:
-              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-                ? {
-                    maxIdleTimeMinutes,
-                    getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                    getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
-                  }
-                : undefined,
-          });
-        } catch (error) {
-          if (
-            error === startupSignal.reason &&
-            startupSignal.reason instanceof DeviceRunSessionStoppedError
-          ) {
-            throw startupSignal.reason;
-          }
-          sessionFailed = true;
-          sessionError =
-            error instanceof AggregateError
-              ? error
-              : startupSignal.aborted &&
-                  !(startupSignal.reason instanceof DeviceRunSessionStoppedError)
-                ? startupSignal.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]);
-                  }
-                  if (result.reason instanceof AggregateError) {
-                    throw result.reason;
-                  }
-                  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.'
-            );
-          }
-        }
-      };
+          throw error;
+        });
       try {
-        if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await selectXcodeDeveloperDirectoryAsync({ env, logger });
+        if (iosStartup) {
+          hostStartup = asyncResult(startHost());
         }
-        watchSignal.throwIfAborted();
-        if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await runOnWarmIosSimulatorAsync(
-            // package_version is the Appium version, which the job installs either way.
-            {
-              engine: 'appium',
-              requestedDevice: deviceIdentifier,
+        // 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: watchSignal,
+              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();
+        appiumProcess = spawnDetached({
+          command: appiumBinPath,
+          args: [
+            '--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, ...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,
+          logger,
+        });
+
+        // expo-device-hub has no serial-selection flag. Device run session workflows must expose
+        // a single booted Android emulator so the Hub and Appium resolve the same device.
+        const launchDescription = describeServeSimLaunch(launch);
+        if (launchDescription) {
+          logger.info(launchDescription);
+        }
+        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+        const webPreview = await sessionHost.openPreviewAsync({
+          baseDomain: ngrokTunnelDomain,
+          authtoken: ngrokAuthtoken,
+        });
+
+        await uploadRemoteSessionConfigWithLocalEgressAsync({
+          env,
+          signal,
+          ctx,
+          deviceRunSessionId,
+          remoteConfig: {
+            appiumUrl: appiumTunnel.url,
+            capabilities: {
+              platformName: device.platformName,
+              'appium:automationName': device.automationName,
+              'appium:udid': device.udid,
             },
-            startSessionAsync
-          );
-        } else {
-          await startSessionAsync();
-        }
+            webPreviewUrl: webPreview.previewPageUrl,
+            previewApiUrl: webPreview.apiUrl,
+            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+          },
+          logger,
+        });
+
+        await waitForDeviceRunSessionStoppedAsync({
+          ctx,
+          deviceRunSessionId,
+          logger,
+          signal,
+          idleTimeout:
+            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+              ? {
+                  maxIdleTimeMinutes,
+                  getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                  getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
+                }
+              : undefined,
+        });
       } catch (error) {
-        if (error !== startupWatch.stopped) {
-          throw error;
-        }
+        sessionFailed = true;
+        throw setupSignal?.aborted ? setupSignal.reason : error;
       } finally {
-        await startupWatch.finishAsync();
+        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 });
+                    }
+                  }
+                }
+              })(),
+            ],
+            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
+          ],
+        });
       }
     }),
   });
@@ -612,11 +515,11 @@ async function waitForAppiumReadyAsync({
 }: {
   appiumProcess: { getOutput: () => string };
   logger: bunyan;
-  signal: AbortSignal;
+  signal?: AbortSignal;
 }): Promise<void> {
   const deadline = Date.now() + APPIUM_STARTUP_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    signal.throwIfAborted();
+    signal?.throwIfAborted();
     try {
       const response = await turtleFetch(`http://${APPIUM_HOST}:${APPIUM_PORT}/status`, 'GET', {
         timeout: 2_000,
@@ -624,17 +527,16 @@ async function waitForAppiumReadyAsync({
         logger,
         signal,
       });
-      signal.throwIfAborted();
+      signal?.throwIfAborted();
       if (response.ok) {
         return;
       }
     } catch {}
-    signal.throwIfAborted();
-    try {
+    signal?.throwIfAborted();
+    if (signal) {
       await setTimeoutAsync(1_000, undefined, { signal });
-    } catch (error) {
-      signal.throwIfAborted();
-      throw error;
+    } else {
+      await sleepAsync(1_000);
     }
   }
   const output = appiumProcess.getOutput();

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

@@ -12,6 +12,7 @@ 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';
@@ -20,12 +21,6 @@ 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,
@@ -41,9 +36,7 @@ import { isProcessDescendantOfAsync, killProcessGroup } from '../../utils/proces
 import { sleepAsync } from '../../utils/retry';
 import { pollArgentArtifactsForUploadAsync } from '../utils/argentArtifacts';
 import { ARGENT_EVENT_LOG_FILENAME, startArgentEventCollectionAsync } from '../utils/argentEvents';
-import { watchDeviceRunSessionStartup } from '../utils/deviceRunSessionStartup';
 import {
-  DeviceRunSessionStoppedError,
   createCorsOriginsInputProvider,
   createFrameAncestorsInputProvider,
   createIosSessionStartupInputProviders,
@@ -91,14 +84,13 @@ const ArgentToolServerStateSchema = z.object({
 type ArgentToolServerState = z.infer<typeof ArgentToolServerStateSchema>;
 
 export function createStartArgentRemoteSessionBuildFunction(
-  ctx: CustomBuildContext,
-  { warm = false }: { warm?: boolean } = {}
+  ctx: CustomBuildContext
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: warm ? 'start_warm_argent_remote_session' : 'start_argent_remote_session',
+    id: 'start_argent_remote_session',
     name: 'Start argent remote session',
-    __metricsId: warm ? 'eas/start_warm_argent_remote_session' : 'eas/start_argent_remote_session',
+    __metricsId: 'eas/start_argent_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -137,392 +129,310 @@ 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;
-      validateControllerVersion({
-        packageName: ARGENT_PACKAGE_NAME,
-        minimumVersion: MIN_ARGENT_REMOTE_SESSION_VERSION,
-        packageVersion,
-        logger,
-      });
+      warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
       const versionSpec = packageVersion ?? 'latest';
       const { runtimePlatform } = global;
-      const startupStop = new AbortController();
-      const watchSignal = signal
-        ? AbortSignal.any([signal, startupStop.signal])
-        : startupStop.signal;
-      const startupWatch = watchDeviceRunSessionStartup({
-        ctx,
-        deviceRunSessionId,
+      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,
-        startup: { signal: watchSignal, abort: reason => startupStop.abort(reason) },
+        signal,
       });
-      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
-      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
-        const startupAbortController = new AbortController();
-        const startupSignal = AbortSignal.any([watchSignal, startupAbortController.signal]);
-        const { launch, iosStartup } = await resolveIosSessionStartupAsync({
+      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,
           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,
-        });
-        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 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: error => startupAbortController.abort(error),
-              ...launch,
-              networkCapture,
-              networkCaptureFields,
-            },
-            ...(warmSession ? [createWarmDeviceSessionServer(ctx, logger, warmSession)] : [])
-          ).catch(error => {
-            startupAbortController.abort(error);
-            throw error;
-          });
-        try {
+          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
+          ...launch,
+          networkCapture,
+          networkCaptureFields,
+        }).catch(error => {
           if (iosStartup) {
-            hostStartup = asyncResult(startHost());
+            startupAbortController.abort(error);
           }
-          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 },
-              startupSignal
-            );
-
-            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 },
-              startupSignal
-            );
-
-            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 },
-                startupSignal
-              );
-            } catch (err) {
-              startupSignal?.throwIfAborted();
-              logger.warn(
-                { err },
-                'Could not disable the Argent video watermark, so recorded videos may include it. Continuing the session.'
-              );
-            }
-
-            startupSignal?.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: startupSignal,
-              });
-              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();
-            }
-            startupSignal?.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();
-          startupSignal.throwIfAborted();
-          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: startupSignal,
-            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 startupWatch.completeAsync();
-          await waitForDeviceRunSessionStoppedAsync({
-            ctx,
-            deviceRunSessionId,
-            logger,
-            maxDurationSeconds,
-            signal,
-            idleTimeout:
-              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-                ? {
-                    maxIdleTimeMinutes,
-                    getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                    getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
-                  }
-                : undefined,
-          });
-        } catch (error) {
-          if (
-            startupSignal.reason instanceof DeviceRunSessionStoppedError &&
-            !(error instanceof AggregateError)
-          ) {
-            throw startupSignal.reason;
-          }
-          sessionFailed = true;
-          throw error instanceof AggregateError
-            ? error
-            : startupSignal.aborted &&
-                !(startupSignal.reason instanceof DeviceRunSessionStoppedError)
-              ? startupSignal.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]);
-                  }
-                  if (result.reason instanceof AggregateError) {
-                    throw result.reason;
-                  }
-                  await result.value?.finishAsync();
-                }),
-              ],
-            ],
-          });
-        }
-      };
-      try {
-        if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await selectXcodeDeveloperDirectoryAsync({ env, logger });
-        }
-        watchSignal.throwIfAborted();
-        if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await runOnWarmIosSimulatorAsync(
-            {
-              engine: 'argent',
-              requestedDevice: deviceIdentifier,
-              packageVersion,
-              env,
-              logger,
-              signal: watchSignal,
-            },
-            startSessionAsync
-          );
-        } else {
-          await startSessionAsync();
-        }
-      } catch (error) {
-        if (error !== startupWatch.stopped) {
           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,
+          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.'
+        );
+
+        await uploadRemoteSessionConfigWithLocalEgressAsync({
+          env,
+          signal,
+          ctx,
+          deviceRunSessionId,
+          remoteConfig: {
+            toolsUrl: publicToolsUrl,
+            ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
+            webPreviewUrl: webPreview.previewPageUrl,
+            previewApiUrl: webPreview.apiUrl,
+            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+          },
+          logger,
+        });
+
+        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 {
-        await startupWatch.finishAsync();
+        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,
+                    });
+                  }
+                  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();
+                }
+              })(),
+            ],
+            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
+          ],
+        });
       }
     }),
   });
@@ -550,6 +460,36 @@ 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

@@ -1,4 +1,3 @@
-import { UserError } from '@expo/eas-build-job';
 import {
   BuildFunction,
   BuildRuntimePlatform,
@@ -7,13 +6,7 @@ import {
 } from '@expo/steps';
 
 import { CustomBuildContext } from '../../customBuildContext';
-import { watchDeviceRunSessionStartup } from '../utils/deviceRunSessionStartup';
 import { startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
-import {
-  createWarmDeviceSessionServer,
-  runOnWarmIosSimulatorAsync,
-} from '../utils/warmDeviceSessionHost';
-import { type WarmIosSession } from '../utils/warmIosSession';
 import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
@@ -44,16 +37,13 @@ import {
 const STARTUP_TIMEOUT_MS = 60_000;
 
 export function createStartWebPreviewRemoteSessionBuildFunction(
-  ctx: CustomBuildContext,
-  { warm = false }: { warm?: boolean } = {}
+  ctx: CustomBuildContext
 ): BuildFunction {
   return new BuildFunction({
     namespace: 'eas',
-    id: warm ? 'start_warm_serve_sim_remote_session' : 'start_serve_sim_remote_session',
+    id: 'start_serve_sim_remote_session',
     name: 'Start web preview remote session',
-    __metricsId: warm
-      ? 'eas/start_warm_serve_sim_remote_session'
-      : 'eas/start_serve_sim_remote_session',
+    __metricsId: 'eas/start_serve_sim_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
       ...createIosSessionStartupInputProviders(),
@@ -67,11 +57,6 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
-      BuildStepInput.createProvider({
-        id: 'max_idle_time_minutes',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
       BuildStepInput.createProvider({
         id: 'max_duration_seconds',
         required: false,
@@ -83,169 +68,95 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
       const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(stepEnv);
       const ngrokAuthtoken = getNgrokAuthtokenOrThrow(stepEnv);
       const env = omitNgrokAuthtoken(stepEnv);
-      const maxIdleTimeMinutes = inputs.max_idle_time_minutes?.value as number | undefined;
       const maxDurationSeconds = inputs.max_duration_seconds?.value as number | undefined;
       const packageVersion = inputs.package_version?.value as string | undefined;
       const { runtimePlatform } = global;
-      if (
-        maxIdleTimeMinutes !== undefined &&
-        maxIdleTimeMinutes > 0 &&
-        runtimePlatform !== BuildRuntimePlatform.DARWIN
-      ) {
-        throw new UserError(
-          'UNSUPPORTED_WEB_PREVIEW_IDLE_TIMEOUT',
-          'Web preview idle timeouts require iOS preview activity reporting. Omit max_idle_time_minutes for Android sessions.'
-        );
+      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await selectXcodeDeveloperDirectoryAsync({ env, logger });
       }
-      const startupStop = new AbortController();
-      const watchSignal = signal
-        ? AbortSignal.any([signal, startupStop.signal])
-        : startupStop.signal;
-      const startupWatch = watchDeviceRunSessionStartup({
-        ctx,
-        deviceRunSessionId,
+      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,
-        startup: { signal: watchSignal, abort: reason => startupStop.abort(reason) },
+        signal,
       });
-      const deviceIdentifier = inputs.device_identifier?.value as string | undefined;
-      const startSessionAsync = async (warmSession?: WarmIosSession): Promise<void> => {
-        const startupAbortController = new AbortController();
-        const startupSignal = AbortSignal.any([watchSignal, startupAbortController.signal]);
-        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,
-          signal: startupSignal,
-        });
-        const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
-          {
-            networkCapture: inputs.network_capture?.value,
-            networkCaptureFields: inputs.network_capture_fields?.value,
-          },
-          { runtimePlatform }
-        );
+      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);
-        }
+      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,
-            preview: { baseDomain: ngrokTunnelDomain, authtoken: ngrokAuthtoken },
-            signal: startupSignal,
-            onStartupError: error => startupAbortController.abort(error),
-            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)] : [])
-        ).catch(error => {
-          if (startupSignal.reason === startupWatch.stopped && !(error instanceof AggregateError)) {
-            throw startupWatch.stopped;
-          }
-          throw error;
-        });
+      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 {
-          startupSignal.throwIfAborted();
-          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: startupSignal,
-            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 startupWatch.completeAsync();
-          await waitForDeviceRunSessionStoppedAsync({
-            ctx,
-            deviceRunSessionId,
-            logger,
-            maxDurationSeconds,
-            signal,
-            idleTimeout:
-              maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-                ? {
-                    maxIdleTimeMinutes,
-                    getLastEventObservedAt: () => undefined,
-                    getLastPreviewActivityAt: () => sessionHost.getLastPreviewActivityAt(),
-                  }
-                : undefined,
-          });
-        } finally {
-          await sessionHost.finishAsync();
-        }
-      };
       try {
-        if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await selectXcodeDeveloperDirectoryAsync({ env, logger });
-        }
-        watchSignal.throwIfAborted();
-        if (warm && runtimePlatform === BuildRuntimePlatform.DARWIN) {
-          await runOnWarmIosSimulatorAsync(
-            {
-              engine: 'serve-sim',
-              requestedDevice: deviceIdentifier,
-              packageVersion,
-              env,
-              logger,
-              signal: watchSignal,
-            },
-            startSessionAsync
-          );
-        } else {
-          await startSessionAsync();
-        }
-      } catch (error) {
-        if (error !== startupWatch.stopped) {
-          throw error;
-        }
+        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.'
+        );
+        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,
+        });
+
+        await waitForDeviceRunSessionStoppedAsync({
+          ctx,
+          deviceRunSessionId,
+          logger,
+          maxDurationSeconds,
+          signal,
+        });
       } finally {
-        await startupWatch.finishAsync();
+        await sessionHost.finishAsync();
       }
     }),
   });

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

@@ -1,224 +0,0 @@
-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/functions/updateTestFlightMetadata.ts

@@ -93,7 +93,7 @@ export async function updateTestFlightMetadataAsync({
   if (upload.attributes?.state?.state !== 'COMPLETE' || !buildId) {
     throw new UserError(
       'EAS_TESTFLIGHT_BUILD_NOT_READY',
-      'The uploaded build is not ready for TestFlight metadata. Run eas/upload_to_asc with wait_for_processing: true first.'
+      'The uploaded build is not ready for TestFlight metadata. Run eas/wait_for_asc_build_processing first.'
     );
   }
   logger.info(`Updating TestFlight metadata for Apple build ${buildId}...`);

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

@@ -1,4 +1,3 @@
-import { UserError } from '@expo/eas-build-job';
 import { asyncResult } from '@expo/results';
 import {
   BuildFunction,
@@ -49,12 +48,6 @@ export function createUploadToAscBuildFunction(): BuildFunction {
         required: true,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
-      BuildStepInput.createProvider({
-        id: 'wait_for_processing',
-        required: false,
-        defaultValue: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-      }),
     ],
     outputProviders: [
       BuildStepOutput.createProvider({
@@ -72,7 +65,6 @@ export function createUploadToAscBuildFunction(): BuildFunction {
       const appleAppIdentifier = z.string().parse(inputs.apple_app_identifier.value);
       const bundleVersion = z.string().parse(inputs.bundle_version.value);
       const bundleShortVersion = z.string().parse(inputs.bundle_short_version.value);
-      const waitForProcessing = Boolean(inputs.wait_for_processing.value);
 
       const ipaPath = path.resolve(stepsCtx.workingDirectory, ipaPathInput);
       if (!(await fs.pathExists(ipaPath))) {
@@ -184,10 +176,10 @@ export function createUploadToAscBuildFunction(): BuildFunction {
 
         const { errors = [], warnings = [] } = assetDeliveryState;
         if (warnings.length > 0) {
-          stepsCtx.logger.warn(`Warnings:\n${itemizeMessages(warnings)}\n`);
+          stepsCtx.logger.warn(`Warnings:\n${AscApiUtils.itemizeMessages(warnings)}\n`);
         }
         if (errors.length > 0) {
-          stepsCtx.logger.error(`Errors:\n${itemizeMessages(errors)}\n`);
+          stepsCtx.logger.error(`Errors:\n${AscApiUtils.itemizeMessages(errors)}\n`);
         }
 
         if (assetDeliveryState.state === 'FAILED') {
@@ -202,225 +194,10 @@ export function createUploadToAscBuildFunction(): BuildFunction {
       }
 
       stepsCtx.logger.info(`See your build in App Store Connect: ${buildUploadUrl}`);
-
-      if (!waitForProcessing) {
-        stepsCtx.logger.info('Skipping waiting for processing.');
-        return;
-      }
-
-      stepsCtx.logger.info('Checking build upload status...');
-      const waitingForBuildStartedAt = Date.now();
-      const waitingLogIntervalMs = 10 * 1000;
-      let lastWaitLogTime = 0;
-      let lastWaitLogState: string | null = null;
-      while (Date.now() - waitingForBuildStartedAt < 30 * 60 * 1000 /* 30 minutes */) {
-        const {
-          data: {
-            attributes: { state },
-          },
-        } = await client.getAsync(
-          `/v1/buildUploads/:id`,
-          { 'fields[buildUploads]': ['state', 'build'], include: ['build'] },
-          { id: buildUploadId }
-        );
-
-        if (state.state === 'AWAITING_UPLOAD' || state.state === 'PROCESSING') {
-          const now = Date.now();
-          if (lastWaitLogState !== state.state || now - lastWaitLogTime >= waitingLogIntervalMs) {
-            stepsCtx.logger.info(
-              `Waiting for build upload to complete... (status = ${state.state})`
-            );
-            lastWaitLogTime = now;
-            lastWaitLogState = state.state;
-          }
-          await setTimeout(2000);
-          continue;
-        }
-
-        stepsCtx.logger.info('\n');
-
-        const { errors = [], warnings = [], infos = [] } = state;
-        if (infos.length > 0) {
-          stepsCtx.logger.info(`Infos:\n${itemizeMessages(infos)}\n`);
-        }
-        if (warnings.length > 0) {
-          stepsCtx.logger.warn(`Warnings:\n${itemizeMessages(warnings)}\n`);
-        }
-        if (errors.length > 0) {
-          stepsCtx.logger.error(`Errors:\n${itemizeMessages(errors)}\n`);
-        }
-
-        if (state.state === 'FAILED') {
-          if (isSdkVersionIssueError(errors)) {
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_SDK_VERSION_ISSUE',
-              'Build upload was rejected by App Store Connect because the IPA was built with an iOS SDK that is too old for current App Store Connect requirements. ' +
-                'In an Expo project, this usually means the build used an outdated EAS iOS image or the project still depends on an Expo SDK / native setup that does not support the required Xcode toolchain. ' +
-                'Upgrade to a supported Expo SDK if needed and/or select a newer iOS image in `eas.json`, rebuild, and submit again.',
-              {
-                docsUrl: 'https://docs.expo.dev/workflow/upgrading-expo-sdk-walkthrough/',
-              }
-            );
-          }
-          if (isRedundantBinaryUploadError(errors)) {
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_VERSION_DUPLICATE',
-              `Increment Build Number: Build number ${bundleVersion} for app version ${bundleShortVersion} has already been used. ` +
-                'App Store Connect requires unique build numbers within each app version (version train). ' +
-                'Increment it by setting ios.buildNumber in app.json, or set "autoIncrement": true in eas.json (recommended). Then rebuild and resubmit.' +
-                `\n\nApp Store Connect errors:\n${itemizeMessages(errors)}`,
-              {
-                docsUrl: 'https://docs.expo.dev/build-reference/app-versions/',
-                cause: state,
-              }
-            );
-          }
-          if (isMissingBackgroundTaskIdentifiersError(errors)) {
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_MISSING_BG_TASK_IDENTIFIERS',
-              'Build upload was rejected by App Store Connect because Info.plist is missing `BGTaskSchedulerPermittedIdentifiers` while `UIBackgroundModes` includes `processing`. ' +
-                'In an Expo project, add `BGTaskSchedulerPermittedIdentifiers` to `ios.infoPlist` in your app config and include every background task identifier the app schedules. ' +
-                'If you do not use Continuous Native Generation (CNG), add the same key to the native target Info.plist. Then rebuild and submit again.' +
-                `\n\nApp Store Connect errors:\n${itemizeMessages(errors)}`,
-              {
-                docsUrl: 'https://docs.expo.dev/versions/latest/config/app/#infoplist',
-                cause: state,
-              }
-            );
-          }
-          if (isMissingAppIconsError(errors)) {
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_MISSING_APP_ICONS',
-              'Build upload was rejected by App Store Connect because required app icons are missing or misconfigured in one of the iOS bundles. ' +
-                'In an Expo project, check your icon config (`expo.icon`, `ios.icon`) and any custom native targets or plugins that create extra bundles, such as watch extensions. ' +
-                'Make sure the affected target has the required icon assets and Info.plist icon keys (for example `CFBundleIconName` / `CFBundleIconFiles`), then rebuild and submit again.' +
-                `\n\nApp Store Connect errors:\n${itemizeMessages(errors)}`,
-              {
-                docsUrl: 'https://docs.expo.dev/develop/user-interface/splash-screen-and-app-icon/',
-                cause: state,
-              }
-            );
-          }
-          if (isInvalidBundleIdentifierError(errors)) {
-            const ipaInfoResult = await asyncResult(readIpaInfoAsync(ipaPath));
-            const ipaBundleIdentifier = ipaInfoResult.ok
-              ? ipaInfoResult.value.bundleIdentifier
-              : null;
-
-            let visibleAppsSummary: string | null = null;
-            try {
-              const apps = await AscApiUtils.getAppsAsync({ client, limit: 5 });
-              visibleAppsSummary = AscApiUtils.formatAppsList(apps);
-            } catch {
-              // Ok to fail, this is just trying to be helpful.
-            }
-
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_INVALID_BUNDLE_ID',
-              `Build upload was rejected by App Store Connect because the app bundle identifier in the IPA does not match the selected App Store Connect app.\n\n` +
-                `IPA bundle identifier: ${ipaBundleIdentifier ?? '(unavailable)'}\n` +
-                `App Store Connect app bundle identifier: ${ascAppBundleIdentifier}\n\n` +
-                'Bundle identifier cannot be changed for an existing App Store Connect app. ' +
-                'If you selected the wrong app, change the Apple app identifier in the submit profile. ' +
-                'If you selected the right app, you may want to select a different build to upload (or rebuild with a different profile).' +
-                '\n\nOther App Store Connect apps visible to this API key:\n' +
-                (visibleAppsSummary ?? '  (unable to retrieve)'),
-              {
-                docsUrl: 'https://expo.fyi/asc-app-id',
-              }
-            );
-          }
-          if (isMissingPurposeStringError(errors)) {
-            const missingUsageDescriptionKeys = parseMissingUsageDescriptionKeys(errors);
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_MISSING_PURPOSE_STRING',
-              `Build upload was rejected by App Store Connect because Info.plist is missing one or more privacy purpose strings.\n\n` +
-                `${
-                  missingUsageDescriptionKeys.length > 0
-                    ? `Missing keys reported by App Store Connect:\n- ${missingUsageDescriptionKeys.join(
-                        '\n- '
-                      )}\n\n`
-                    : ''
-                }` +
-                'Add the missing keys with clear user-facing explanations, then rebuild and submit again.\n' +
-                'If you use Continuous Native Generation (CNG), update `ios.infoPlist` in app.json/app.config.js.\n' +
-                'If you do not use CNG, update your app target Info.plist directly.',
-              {
-                docsUrl: 'https://docs.expo.dev/guides/permissions/#ios',
-              }
-            );
-          }
-          if (isClosedVersionTrainError(errors)) {
-            throw new UserError(
-              'EAS_UPLOAD_TO_ASC_CLOSED_VERSION_TRAIN',
-              `Build upload was rejected by App Store Connect because the ${bundleShortVersion} app version is not accepted for new build submissions. ` +
-                'This usually means the version train is closed or lower than a previously approved version. ' +
-                'Bump the iOS app version (CFBundleShortVersionString, e.g. expo.version) to a higher version, then rebuild and submit again.'
-            );
-          }
-          throw new Error(`Build upload (ID: ${buildUploadId}) failed.`);
-        } else if (state.state === 'COMPLETE') {
-          stepsCtx.logger.info(`Build upload (ID: ${buildUploadId}) complete!`);
-        }
-        break;
-      }
     },
   });
 }
 
-function itemizeMessages(messages: { description: string; code: string }[]): string {
-  return `- ${messages.map(m => `${m.description} (${m.code})`).join('\n- ')}`;
-}
-
-export function isClosedVersionTrainError(messages: { code: string }[]): boolean {
-  return (
-    messages.length > 0 &&
-    messages.every(message => ['90062', '90186', '90478'].includes(message.code))
-  );
-}
-
-export function isSdkVersionIssueError(messages: { code: string }[]): boolean {
-  return messages.length > 0 && messages.every(message => message.code === '90725');
-}
-
-export function isRedundantBinaryUploadError(messages: { code: string }[]): boolean {
-  return messages.length > 0 && messages.every(message => message.code === '90189');
-}
-
-export function isMissingBackgroundTaskIdentifiersError(messages: { code: string }[]): boolean {
-  return messages.length > 0 && messages.every(message => message.code === '90771');
-}
-
-export function isMissingAppIconsError(messages: { code: string }[]): boolean {
-  return (
-    messages.length > 0 &&
-    messages.every(message => ['90022', '90023', '90391', '90713'].includes(message.code))
-  );
-}
-
-export function isInvalidBundleIdentifierError(messages: { code: string }[]): boolean {
-  return (
-    messages.length > 0 && messages.every(message => ['90054', '90055'].includes(message.code))
-  );
-}
-
-export function isMissingPurposeStringError(messages: { code: string }[]): boolean {
-  return messages.length > 0 && messages.every(message => message.code === '90683');
-}
-
-export function parseMissingUsageDescriptionKeys(messages: { description: string }[]): string[] {
-  const usageDescriptionKeyRegex = /\b(\w+UsageDescription)\b/g;
-  const keys = new Set<string>();
-  for (const message of messages) {
-    const matches = message.description.matchAll(usageDescriptionKeyRegex);
-    for (const match of matches) {
-      keys.add(match[1]);
-    }
-  }
-
-  return [...keys];
-}
-
 async function uploadChunksAsync({
   uploadOperations,
   ipaPath,

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

@@ -1,6 +1,9 @@
 import { BuildFunction } from '@expo/steps';
+import fs from 'fs-extra';
+import path from 'path';
 
-import { setUpNpmrcAsync } from '../../utils/npmrc';
+import { NpmrcTemplate } from '../../templates/npmrc';
+import { findPackagerRootDir } from '../../utils/packageManager';
 
 export function createSetUpNpmrcBuildFunction(): BuildFunction {
   return new BuildFunction({
@@ -9,12 +12,28 @@ export function createSetUpNpmrcBuildFunction(): BuildFunction {
     name: 'Use NPM_TOKEN',
     __metricsId: 'eas/use_npm_token',
     fn: async (stepCtx, { env }) => {
-      await setUpNpmrcAsync({
-        projectTargetDirectory: stepCtx.global.projectTargetDirectory,
-        workingDirectory: stepCtx.workingDirectory,
-        env,
-        logger: stepCtx.logger,
-      });
+      const { logger } = stepCtx;
+      if (env.NPM_TOKEN) {
+        logger.info('We detected that you set the NPM_TOKEN environment variable');
+        const projectNpmrcPath = path.join(stepCtx.global.projectTargetDirectory, '.npmrc');
+        if (await fs.pathExists(projectNpmrcPath)) {
+          logger.info('.npmrc already exists in your project directory, skipping generation');
+        } else {
+          logger.info('Creating .npmrc in your project directory with the following contents:');
+          logger.info(NpmrcTemplate);
+          await fs.writeFile(projectNpmrcPath, NpmrcTemplate);
+        }
+      } else {
+        const projectNpmrcPath = path.join(findPackagerRootDir(stepCtx.workingDirectory), '.npmrc');
+        if (await fs.pathExists(projectNpmrcPath)) {
+          logger.info(
+            `.npmrc found at ${path.relative(
+              stepCtx.global.projectTargetDirectory,
+              projectNpmrcPath
+            )}`
+          );
+        }
+      }
     },
   });
 }

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

@@ -0,0 +1,222 @@
+import { UserError } from '@expo/eas-build-job';
+import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@expo/steps';
+import path from 'node:path';
+import { setTimeout } from 'node:timers/promises';
+import { z } from 'zod';
+
+import { AscApiClient } from '../utils/ios/AscApiClient';
+import { AscApiUtils } from '../utils/ios/AscApiUtils';
+
+export function createWaitForAscBuildProcessingBuildFunction(): BuildFunction {
+  return new BuildFunction({
+    namespace: 'eas',
+    id: 'wait_for_asc_build_processing',
+    name: 'Wait for App Store Connect processing',
+    __metricsId: 'eas/wait_for_asc_build_processing',
+    inputProviders: [
+      BuildStepInput.createProvider({
+        id: 'asc_api_key_path',
+        required: true,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+      BuildStepInput.createProvider({
+        id: 'build_upload_id',
+        required: true,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+      BuildStepInput.createProvider({
+        id: 'bundle_identifier',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+      BuildStepInput.createProvider({
+        id: 'apple_app_identifier',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+      BuildStepInput.createProvider({
+        id: 'bundle_short_version',
+        required: false,
+        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
+      }),
+    ],
+    fn: async (ctx, { inputs }) => {
+      const parsedInputs = z
+        .object({
+          asc_api_key_path: z.string(),
+          build_upload_id: z.string(),
+          bundle_identifier: z.string().optional(),
+          apple_app_identifier: z.string().optional(),
+          bundle_short_version: z.string().optional(),
+        })
+        .parse({
+          asc_api_key_path: inputs.asc_api_key_path.value,
+          build_upload_id: inputs.build_upload_id.value,
+          bundle_identifier: inputs.bundle_identifier.value,
+          apple_app_identifier: inputs.apple_app_identifier.value,
+          bundle_short_version: inputs.bundle_short_version.value,
+        });
+      const keyPath = path.resolve(ctx.workingDirectory, parsedInputs.asc_api_key_path);
+      const key = await AscApiUtils.loadApiKeyAsync({ keyPath });
+      const client = new AscApiClient({ key, logger: ctx.logger });
+      const buildUploadId = parsedInputs.build_upload_id;
+      const ipaBundleIdentifier = parsedInputs.bundle_identifier;
+      const appleAppIdentifier = parsedInputs.apple_app_identifier;
+      const bundleShortVersion = parsedInputs.bundle_short_version;
+      const logger = ctx.logger;
+      let ascAppBundleIdentifier: string | undefined;
+      logger.info('Checking build upload status...');
+      const waitingForBuildStartedAt = Date.now();
+      const waitingLogIntervalMs = 10 * 1000;
+      let lastWaitLogTime = 0;
+      let lastWaitLogState: string | null = null;
+      while (Date.now() - waitingForBuildStartedAt < 30 * 60 * 1000 /* 30 minutes */) {
+        const {
+          data: {
+            attributes: { state },
+          },
+        } = await client.getAsync(
+          `/v1/buildUploads/:id`,
+          { 'fields[buildUploads]': ['state', 'build'], include: ['build'] },
+          { id: buildUploadId }
+        );
+
+        if (state.state === 'AWAITING_UPLOAD' || state.state === 'PROCESSING') {
+          const now = Date.now();
+          if (lastWaitLogState !== state.state || now - lastWaitLogTime >= waitingLogIntervalMs) {
+            logger.info(`Waiting for build upload to complete... (status = ${state.state})`);
+            lastWaitLogTime = now;
+            lastWaitLogState = state.state;
+          }
+          await setTimeout(2000);
+          continue;
+        }
+
+        logger.info('\n');
+
+        const { errors = [], warnings = [], infos = [] } = state;
+        if (infos.length > 0) {
+          logger.info(`Infos:\n${AscApiUtils.itemizeMessages(infos)}\n`);
+        }
+        if (warnings.length > 0) {
+          logger.warn(`Warnings:\n${AscApiUtils.itemizeMessages(warnings)}\n`);
+        }
+        if (errors.length > 0) {
+          logger.error(`Errors:\n${AscApiUtils.itemizeMessages(errors)}\n`);
+        }
+
+        if (state.state === 'FAILED') {
+          if (isSdkVersionIssueError(errors)) {
+            throw new UserError(
+              'EAS_UPLOAD_TO_ASC_SDK_VERSION_ISSUE',
+              'Build upload was rejected by App Store Connect because the IPA was built with an iOS SDK that is too old for current App Store Connect requirements. ' +
+                'In an Expo project, this usually means the build used an outdated EAS iOS image or the project still depends on an Expo SDK / native setup that does not support the required Xcode toolchain. ' +
+                'Upgrade to a supported Expo SDK if needed and/or select a newer iOS image in `eas.json`, rebuild, and submit again.',
+              {
+                docsUrl: 'https://docs.expo.dev/workflow/upgrading-expo-sdk-walkthrough/',
+              }
+            );
+          }
+          if (isInvalidBundleIdentifierError(errors)) {
+            if (!ascAppBundleIdentifier && appleAppIdentifier) {
+              try {
+                const app = await AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
+                ascAppBundleIdentifier = app.data.attributes.bundleId;
+              } catch {
+                // Keep the processing error if app details are unavailable.
+              }
+            }
+            let visibleAppsSummary: string | null = null;
+            try {
+              const apps = await AscApiUtils.getAppsAsync({ client, limit: 5 });
+              visibleAppsSummary = AscApiUtils.formatAppsList(apps);
+            } catch {
+              // Ok to fail, this is just trying to be helpful.
+            }
+
+            throw new UserError(
+              'EAS_UPLOAD_TO_ASC_INVALID_BUNDLE_ID',
+              `Build upload was rejected by App Store Connect because the app bundle identifier in the IPA does not match the selected App Store Connect app.\n\n` +
+                `IPA bundle identifier: ${ipaBundleIdentifier ?? '(unavailable)'}\n` +
+                `App Store Connect app bundle identifier: ${ascAppBundleIdentifier ?? '(unavailable)'}\n\n` +
+                'Bundle identifier cannot be changed for an existing App Store Connect app. ' +
+                'If you selected the wrong app, change the Apple app identifier in the submit profile. ' +
+                'If you selected the right app, you may want to select a different build to upload (or rebuild with a different profile).' +
+                '\n\nOther App Store Connect apps visible to this API key:\n' +
+                (visibleAppsSummary ?? '  (unable to retrieve)'),
+              {
+                docsUrl: 'https://expo.fyi/asc-app-id',
+              }
+            );
+          }
+          if (isMissingPurposeStringError(errors)) {
+            const missingUsageDescriptionKeys = parseMissingUsageDescriptionKeys(errors);
+            throw new UserError(
+              'EAS_UPLOAD_TO_ASC_MISSING_PURPOSE_STRING',
+              `Build upload was rejected by App Store Connect because Info.plist is missing one or more privacy purpose strings.\n\n` +
+                `${
+                  missingUsageDescriptionKeys.length > 0
+                    ? `Missing keys reported by App Store Connect:\n- ${missingUsageDescriptionKeys.join(
+                        '\n- '
+                      )}\n\n`
+                    : ''
+                }` +
+                'Add the missing keys with clear user-facing explanations, then rebuild and submit again.\n' +
+                'If you use Continuous Native Generation (CNG), update `ios.infoPlist` in app.json/app.config.js.\n' +
+                'If you do not use CNG, update your app target Info.plist directly.',
+              {
+                docsUrl: 'https://docs.expo.dev/guides/permissions/#ios',
+              }
+            );
+          }
+          if (isClosedVersionTrainError(errors)) {
+            throw new UserError(
+              'EAS_UPLOAD_TO_ASC_CLOSED_VERSION_TRAIN',
+              `Build upload was rejected by App Store Connect because the ${bundleShortVersion ?? 'selected'} app version is not accepted for new build submissions. ` +
+                'This usually means the version train is closed or lower than a previously approved version. ' +
+                'Bump the iOS app version (CFBundleShortVersionString, e.g. expo.version) to a higher version, then rebuild and submit again.'
+            );
+          }
+          throw new Error(`Build upload (ID: ${buildUploadId}) failed.`);
+        } else if (state.state === 'COMPLETE') {
+          logger.info(`Build upload (ID: ${buildUploadId}) complete!`);
+        }
+        break;
+      }
+    },
+  });
+}
+
+function isClosedVersionTrainError(messages: { code: string }[]): boolean {
+  return (
+    messages.length > 0 &&
+    messages.every(message => ['90062', '90186', '90478'].includes(message.code))
+  );
+}
+
+function isSdkVersionIssueError(messages: { code: string }[]): boolean {
+  return messages.length > 0 && messages.every(message => message.code === '90725');
+}
+
+function isInvalidBundleIdentifierError(messages: { code: string }[]): boolean {
+  return (
+    messages.length > 0 && messages.every(message => ['90054', '90055'].includes(message.code))
+  );
+}
+
+function isMissingPurposeStringError(messages: { code: string }[]): boolean {
+  return messages.length > 0 && messages.every(message => message.code === '90683');
+}
+
+function parseMissingUsageDescriptionKeys(messages: { description: string }[]): string[] {
+  const usageDescriptionKeyRegex = /\b(\w+UsageDescription)\b/g;
+  const keys = new Set<string>();
+  for (const message of messages) {
+    const matches = message.description.matchAll(usageDescriptionKeyRegex);
+    for (const match of matches) {
+      keys.add(match[1]);
+    }
+  }
+
+  return [...keys];
+}

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

@@ -36,7 +36,7 @@ const SERVE_SIM_LEASE_FINALIZE_TIMEOUT_MS =
 const SERVE_SIM_FINISH_TIMEOUT_MS =
   SERVE_SIM_CONTROL_REQUEST_TIMEOUT_MS + SERVE_SIM_LEASE_FINALIZE_TIMEOUT_MS;
 const SERVE_SIM_FORCE_STOP_TIMEOUT_MS = 5_000;
-const SERVE_SIM_RECORDING_STARTED_LINE = /(?:^|\n)serve-sim:recording-started\r?\n/;
+const SERVE_SIM_RECORDING_STARTED = 'serve-sim:recording-started';
 // The serve-sim package the session host started; every recorder runs `record-video` from it.
 let serveSimPackageSpec: string | null = null;
 
@@ -57,19 +57,11 @@ 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. */
@@ -89,52 +81,6 @@ 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.');
@@ -149,8 +95,6 @@ export namespace IosSimulatorRecordingUtils {
       logger,
       recordingsRootDirectory,
       activeRecordings: new Map(),
-      adoptedRecordings: new Map(),
-      runtimeDisplayNames: new Map(),
       completedRecordings: [],
       recordingFailureCounts: new Map(),
       failedAttemptCounts: new Map(),
@@ -246,17 +190,6 @@ 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()
     );
@@ -310,9 +243,6 @@ 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] : []
@@ -332,14 +262,7 @@ async function pollIosSimulatorRecordingsAsync(
       for (const device of bootedDevices) {
         const token = readyServers.get(device.udid);
         const packageSpec = serveSimPackageSpec;
-        if (
-          !token ||
-          !packageSpec ||
-          [...session.adoptedRecordings.values()].some(
-            recording =>
-              recording.udid === device.udid.toUpperCase() && recording.serverToken === token
-          )
-        ) {
+        if (!token || !packageSpec) {
           continue;
         }
         if (session.serveBearerTokens.get(device.udid) !== token) {
@@ -584,19 +507,14 @@ function captureProcessOutput(recordingProcess: ChildProcess): {
 } {
   let output = '';
   let started = false;
-  const captureStreamOutput = (stream: ChildProcess['stdout']): void => {
-    let streamOutput = '';
-    stream?.on('data', (chunk: Buffer | string) => {
-      const text = chunk.toString();
-      output = `${output}${text}`.slice(-16_384);
-      streamOutput = `${streamOutput}${text}`;
-      if (SERVE_SIM_RECORDING_STARTED_LINE.test(streamOutput)) {
-        started = true;
-      }
-      streamOutput = streamOutput.slice(-16_384);
-    });
+  const appendChunk = (chunk: Buffer | string): void => {
+    output = `${output}${chunk.toString()}`;
+    if (output.includes(SERVE_SIM_RECORDING_STARTED)) {
+      started = true;
+    }
+    output = output.slice(-16_384);
   };
-  captureStreamOutput(recordingProcess.stdout);
-  captureStreamOutput(recordingProcess.stderr);
+  recordingProcess.stdout?.on('data', appendChunk);
+  recordingProcess.stderr?.on('data', appendChunk);
   return { getOutput: () => output, hasStarted: () => started };
 }

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

@@ -3,20 +3,18 @@ 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 { readFile, rm, writeFile } from 'node:fs/promises';
+import { 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(),
@@ -146,10 +144,7 @@ test('starts serve-sim record-video and returns only a finalized recording', asy
   const finishing = IosSimulatorRecordingUtils.finishAsync({ logger });
   await setTimeout(20);
   expect(child.kill).not.toHaveBeenCalled();
-  child.stdout?.emit('data', 'Downloading');
-  stderr.write('serve-sim:recording-');
-  child.stdout?.emit('data', ' package');
-  stderr.write('started\r\n');
+  stderr.write('serve-sim:recording-started\n');
   stderr.write('x'.repeat(17_000));
   const recordings = await finishing;
 
@@ -367,32 +362,6 @@ test('keeps a recorder active after its package-manager wrapper exits', async ()
   expect(recordings).toHaveLength(1);
 });
 
-test('does not mistake bundled source in an error for a recording start', async () => {
-  let currentTime = Date.now();
-  jest.spyOn(Date, 'now').mockImplementation(() => currentTime);
-  jest
-    .mocked(readServeSimServersAsync)
-    .mockResolvedValue([{ udid, url: 'http://127.0.0.1:43563', token: 'session-token' }]);
-  const recorder = mockRecorder();
-
-  await IosSimulatorRecordingUtils.startAsync({ env, logger });
-  await waitForRecorderSpawnAsync();
-  recorder.child.stderr?.emit(
-    'data',
-    'const marker = "serve-sim:recording-started";\nError: No running serve-sim session found.\n'
-  );
-  recorder.fail(new Error('recorder exited before connecting'));
-
-  const finishing = IosSimulatorRecordingUtils.finishAsync({ logger });
-  try {
-    expect(await Promise.race([finishing.then(() => true), setTimeout(250, false)])).toBe(true);
-  } finally {
-    currentTime += 311_000;
-    await finishing;
-  }
-  expect(recorder.child.kill).not.toHaveBeenCalled();
-});
-
 test('does not signal a recorder that exits before it reports its start', async () => {
   let currentTime = Date.now();
   jest.spyOn(Date, 'now').mockImplementation(() => currentTime);
@@ -568,171 +537,3 @@ 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,7 +1,6 @@
 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';
@@ -16,7 +15,6 @@ 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> {
@@ -278,14 +276,6 @@ 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();
@@ -294,257 +284,6 @@ 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__/agentRun.test.ts

@@ -186,7 +186,6 @@ describe(runAgentAsync, () => {
         '--package-lock=false',
         '--no-audit',
         '--no-fund',
-        '--no-update-notifier',
         '--registry',
         'https://npm-cache.expo.test',
         '@anthropic-ai/[email protected]',

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

@@ -1,240 +0,0 @@
-import { type BuildStepGlobalContext } from '@expo/steps';
-import { once } from 'node:events';
-import fsPromises, {
-  mkdir,
-  mkdtemp,
-  readFile,
-  readdir,
-  rm,
-  symlink,
-  writeFile,
-} from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { PassThrough, Readable } from 'node:stream';
-
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { type CustomBuildContext } from '../../../customBuildContext';
-import { MAX_ANDROID_LOG_BYTES_PER_SOURCE } from '../../../utils/androidEmulatorLogCapture';
-import { type AndroidEmulatorLogSource } from '../../../utils/androidEmulatorLogSources';
-import {
-  collectAndroidEmulatorLogsAsync,
-  getAndroidEmulatorLogCapture,
-} from '../androidEmulatorLogs';
-import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
-
-jest.mock('../deviceRunSessionArtifacts');
-jest.unmock('fs');
-jest.unmock('node:fs');
-jest.unmock('fs/promises');
-jest.unmock('node:fs/promises');
-
-const ctx = {} as CustomBuildContext;
-const upload = jest.mocked(uploadDeviceRunSessionArtifactAsync);
-let directory: string;
-let emulatorPath: string;
-let logcatPath: string;
-let global: BuildStepGlobalContext;
-let logger: ReturnType<typeof createMockLogger>;
-let uploadedContents: Map<string, string>;
-
-beforeEach(async () => {
-  global = {} as BuildStepGlobalContext;
-  logger = createMockLogger();
-  uploadedContents = new Map();
-  directory = await mkdtemp(path.join(os.tmpdir(), 'android-log-collection-'));
-  emulatorPath = path.join(directory, 'device-attempt-1-emulator.log');
-  logcatPath = path.join(directory, 'device-attempt-1-logcat.log');
-  upload.mockReset().mockImplementation(async (_ctx, { filename, openStream }) => {
-    const chunks: Buffer[] = [];
-    for await (const chunk of openStream()) {
-      chunks.push(Buffer.from(chunk));
-    }
-    uploadedContents.set(filename, Buffer.concat(chunks).toString());
-  });
-});
-
-afterEach(async () => {
-  jest.restoreAllMocks();
-  await rm(directory, { recursive: true, force: true });
-});
-
-async function captureLog(
-  filePath: string,
-  source: AndroidEmulatorLogSource,
-  text: string,
-  workflow = global
-): Promise<void> {
-  const capture = getAndroidEmulatorLogCapture(workflow, { DEVICE_RUN_SESSION_ID: 'session' });
-  const input = Readable.from([Buffer.from(text)]);
-  capture.attach(input, filePath, source);
-  await once(input, 'end');
-  await capture.finishFileAsync(filePath);
-}
-
-function collect(): Promise<void> {
-  return collectAndroidEmulatorLogsAsync(ctx, {
-    global,
-    deviceRunSessionId: 'session',
-    logger,
-  });
-}
-
-it.each([
-  { env: {}, expectedBytes: 20 * 1024 * 1024 + 1 },
-  { env: { DEVICE_RUN_SESSION_ID: 'session' }, expectedBytes: 20 * 1024 * 1024 },
-])('retains $expectedBytes with workflow environment $env', async ({ env, expectedBytes }) => {
-  const capture = getAndroidEmulatorLogCapture(global, env);
-  const input = Readable.from([Buffer.alloc(20 * 1024 * 1024 + 1, 'x')]);
-  capture.attach(input, emulatorPath, 'emulator-output');
-  await once(input, 'end');
-  await capture.finishAsync();
-  expect((await fsPromises.stat(emulatorPath)).size).toBe(expectedBytes);
-});
-
-it('uses captured source records and ignores files outside the capture inventory', async () => {
-  const first = path.join(directory, 'first.txt');
-  const second = path.join(directory, 'second.txt');
-  await captureLog(first, 'emulator-output', 'host output');
-  await captureLog(second, 'device-logcat', 'Android output');
-  await captureLog(path.join(directory, 'retry.txt'), 'emulator-output', 'retry output');
-  await writeFile(emulatorPath, 'not captured');
-  const elsewhere = path.join(directory, 'elsewhere');
-  await mkdir(elsewhere);
-  await writeFile(path.join(elsewhere, 'other-emulator.log'), 'another job');
-  await symlink(path.join(elsewhere, 'other-emulator.log'), logcatPath);
-  await collect();
-
-  expect([...uploadedContents.values()]).toEqual(['host output', 'Android output', 'retry output']);
-  expect(upload).toHaveBeenCalledWith(
-    ctx,
-    expect.objectContaining({
-      filename: 'first.txt',
-      kind: 'simulator-log',
-      metadata: expect.objectContaining({
-        platform: 'android',
-        source: 'emulator-output',
-        scope: 'emulator-process',
-        originalSizeBytes: 11,
-        omittedBytes: 0,
-        truncated: false,
-      }),
-      signal: expect.any(AbortSignal),
-      attempts: 2,
-    })
-  );
-  expect(upload).toHaveBeenCalledWith(
-    ctx,
-    expect.objectContaining({
-      filename: 'second.txt',
-      metadata: expect.objectContaining({ source: 'device-logcat', scope: 'device' }),
-    })
-  );
-});
-
-it('seals a live producer before upload and keeps retry bodies identical without copying files', async () => {
-  const input = new PassThrough();
-  const capture = getAndroidEmulatorLogCapture(global, { DEVICE_RUN_SESSION_ID: 'session' });
-  capture.attach(input, emulatorPath, 'emulator-output');
-  input.write('before');
-  const contents: string[] = [];
-  upload.mockImplementationOnce(async (_ctx, { size, openStream, metadata }) => {
-    expect(size).toBe(6);
-    expect(metadata).toEqual(expect.objectContaining({ originalSizeBytes: 6, truncated: false }));
-    for (let attempt = 0; attempt < 2; attempt++) {
-      input.write(' ignored after finalization');
-      const chunks: Buffer[] = [];
-      for await (const chunk of openStream()) {
-        chunks.push(Buffer.from(chunk));
-      }
-      contents.push(Buffer.concat(chunks).toString());
-    }
-  });
-  try {
-    await collect();
-    expect(contents).toEqual(['before', 'before']);
-    expect(await readFile(emulatorPath, 'utf8')).toBe('before');
-    expect(await readdir(directory)).toEqual([path.basename(emulatorPath)]);
-    expect(input.readableFlowing).toBe(true);
-    const late = new PassThrough();
-    capture.attach(late, logcatPath, 'device-logcat');
-    late.end('not captured');
-    expect(late.readableFlowing).toBe(true);
-    await expect(fsPromises.stat(logcatPath)).rejects.toMatchObject({ code: 'ENOENT' });
-  } finally {
-    input.end();
-  }
-});
-
-it('continues with the other log after a failed upload and never repeats the collection', async () => {
-  await captureLog(emulatorPath, 'emulator-output', 'host output');
-  await captureLog(logcatPath, 'device-logcat', 'Android output');
-  upload.mockRejectedValueOnce(new Error('storage unavailable'));
-  await Promise.all([collect(), collect()]);
-  await collect();
-  expect(upload).toHaveBeenCalledTimes(2);
-  expect(uploadedContents.get(path.basename(logcatPath))).toBe('Android output');
-  expect(logger.warn).toHaveBeenCalledTimes(1);
-  expect(logger.warn).toHaveBeenCalledWith(
-    expect.anything(),
-    expect.stringContaining('other logs will continue')
-  );
-});
-
-it('uses a fresh 30 second budget for the next file after an upload times out', async () => {
-  await captureLog(emulatorPath, 'emulator-output', 'host output');
-  await captureLog(logcatPath, 'device-logcat', 'Android output');
-  const controllers: AbortController[] = [];
-  const timeout = jest.spyOn(AbortSignal, 'timeout').mockImplementation(() => {
-    const controller = new AbortController();
-    controllers.push(controller);
-    return controller.signal;
-  });
-  upload.mockImplementationOnce(async (_ctx, { signal }) => {
-    controllers[0].abort(new Error('upload timed out'));
-    signal?.throwIfAborted();
-  });
-  await expect(collect()).resolves.toBeUndefined();
-  expect(uploadedContents.get(path.basename(logcatPath))).toBe('Android output');
-  expect(timeout.mock.calls).toEqual([[30_000], [30_000]]);
-  expect(upload.mock.calls[1][1].signal?.aborted).toBe(false);
-});
-
-it('does not collect another workflow and warns when a captured file disappears', async () => {
-  await captureLog(emulatorPath, 'emulator-output', 'other workflow', {} as BuildStepGlobalContext);
-  await collect();
-  expect(upload).not.toHaveBeenCalled();
-  await captureLog(path.join(directory, 'missing.log'), 'emulator-output', 'removed');
-  await rm(path.join(directory, 'missing.log'));
-  await expect(collect()).resolves.toBeUndefined();
-  expect(upload).not.toHaveBeenCalled();
-  expect(logger.warn).toHaveBeenCalledWith(
-    expect.anything(),
-    expect.stringContaining('missing.log')
-  );
-});
-
-it('uploads the tail of a truncated log with the retained size and omission metadata', async () => {
-  const capture = getAndroidEmulatorLogCapture(global, { DEVICE_RUN_SESSION_ID: 'session' });
-  const input = Readable.from([
-    Buffer.concat([Buffer.from('head: '), Buffer.alloc(MAX_ANDROID_LOG_BYTES_PER_SOURCE, 'b')]),
-  ]);
-  capture.attach(input, emulatorPath, 'emulator-output');
-  await once(input, 'end');
-  await collect();
-  expect(upload).toHaveBeenCalledWith(
-    ctx,
-    expect.objectContaining({
-      size: MAX_ANDROID_LOG_BYTES_PER_SOURCE,
-      name: expect.stringContaining('truncated, last 20 MiB retained'),
-      metadata: expect.objectContaining({
-        originalSizeBytes: MAX_ANDROID_LOG_BYTES_PER_SOURCE + 6,
-        omittedBytes: 6,
-        truncated: true,
-      }),
-    })
-  );
-  const uploaded = uploadedContents.get(path.basename(emulatorPath));
-  expect(uploaded).toHaveLength(MAX_ANDROID_LOG_BYTES_PER_SOURCE);
-  expect(uploaded).not.toContain('head');
-});

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

@@ -1,57 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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__/deviceRunSessionStartup.test.ts

@@ -1,102 +0,0 @@
-import { bunyan } from '@expo/logger';
-
-import { CustomBuildContext } from '../../../customBuildContext';
-import { watchDeviceRunSessionStartup } from '../deviceRunSessionStartup';
-import {
-  DeviceRunSessionStoppedError,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../remoteDeviceRunSession';
-import { createStartupTasks } from '../startupTasks';
-
-jest.mock('../remoteDeviceRunSession', () => ({
-  ...jest.requireActual('../remoteDeviceRunSession'),
-  waitForDeviceRunSessionStoppedAsync: jest.fn(),
-}));
-
-const ctx = {} as CustomBuildContext;
-const logger = {
-  info: jest.fn(),
-  warn: jest.fn(),
-  child: jest.fn().mockReturnThis(),
-} as unknown as bunyan;
-
-/** Makes the status poll settle only when the test says so, or end when its signal aborts. */
-function holdStatusPoll(): { stop: () => void; fail: (error: Error) => void } {
-  let stop!: () => void;
-  let fail!: (error: Error) => void;
-  jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(
-    ({ signal }) =>
-      new Promise<void>((resolve, reject) => {
-        stop = resolve;
-        fail = reject;
-        signal?.addEventListener('abort', () => resolve(), { once: true });
-      })
-  );
-  return { stop: () => stop(), fail: error => fail(error) };
-}
-
-function watch(startup = createStartupTasks(logger)) {
-  return {
-    startup,
-    watch: watchDeviceRunSessionStartup({ ctx, deviceRunSessionId: 'drs-id', logger, startup }),
-  };
-}
-
-describe(watchDeviceRunSessionStartup, () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('aborts startup when the session is stopped', async () => {
-    const poll = holdStatusPoll();
-    const { startup, watch: startupWatch } = watch();
-    poll.stop();
-    await new Promise(resolve => setImmediate(resolve));
-    expect(startupWatch.stopped).toBeInstanceOf(DeviceRunSessionStoppedError);
-    expect(startup.signal.reason).toBe(startupWatch.stopped);
-    expect(startupWatch.isStopped()).toBe(true);
-    expect(logger.info).toHaveBeenCalledWith(
-      'Device run session drs-id was stopped during startup.'
-    );
-    await expect(startupWatch.completeAsync()).rejects.toBe(startupWatch.stopped);
-  });
-
-  it('ends the poll when startup completes, without aborting startup', async () => {
-    holdStatusPoll();
-    const { startup, watch: startupWatch } = watch();
-    await expect(startupWatch.completeAsync()).resolves.toBeUndefined();
-    const [{ signal }] = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0];
-    expect(signal?.aborted).toBe(true);
-    expect(startup.signal.aborted).toBe(false);
-    expect(startupWatch.isStopped()).toBe(false);
-  });
-
-  it('aborts startup with a status poll failure', async () => {
-    const poll = holdStatusPoll();
-    const { startup, watch: startupWatch } = watch();
-    const failed = new Error('status poll failed');
-    poll.fail(failed);
-    await new Promise(resolve => setImmediate(resolve));
-    expect(startup.signal.reason).toBe(failed);
-    expect(startupWatch.isStopped()).toBe(false);
-  });
-
-  it('keeps the first abort reason when startup ends for another reason', async () => {
-    holdStatusPoll();
-    const { startup, watch: startupWatch } = watch();
-    const failed = new Error('host startup failed');
-    startup.abort(failed);
-    await startupWatch.finishAsync();
-    expect(startup.signal.reason).toBe(failed);
-    expect(startupWatch.isStopped()).toBe(false);
-    expect(logger.info).not.toHaveBeenCalled();
-  });
-
-  it('follows the step signal', async () => {
-    holdStatusPoll();
-    const step = new AbortController();
-    const { startup, watch: startupWatch } = watch(createStartupTasks(logger, step.signal));
-    step.abort(new Error('step cancelled'));
-    await startupWatch.finishAsync();
-    expect(startup.signal.aborted).toBe(true);
-    expect(startupWatch.isStopped()).toBe(false);
-  });
-});

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

@@ -13,7 +13,6 @@ import type { CustomBuildContext } from '../../../customBuildContext';
 import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
 import { findUnlistedDeviceScreenRecordingsAsync } from '../deviceRunSessionScreenRecordings';
 import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
-import { uploadDeviceRunSessionFileAsync } from '../uploadDeviceRunSessionFile';
 
 jest.unmock('node-fetch');
 jest.unmock('node:fs');
@@ -124,41 +123,6 @@ it('replays the full file after a transient PUT failure without recreating the u
   expect(streams.every(stream => stream.destroyed)).toBe(true);
 });
 
-it('retries a PUT that fails before reading the body without aborting the file stream', async () => {
-  let puts = 0;
-  let replayed = 0;
-  handle = (request, response) => {
-    puts++;
-    if (puts === 1) {
-      response.statusCode = 503;
-      response.flushHeaders();
-      return;
-    }
-    request.on('data', chunk => {
-      replayed += chunk.length;
-    });
-    request.on('end', () => response.end());
-  };
-  const file = path.join(directory, 'emulator.log');
-  const payload = Buffer.alloc(8 * 1024 * 1024, '*');
-  await writeFile(file, payload);
-  await expect(
-    uploadDeviceRunSessionFileAsync(ctx, {
-      filePath: file,
-      describe: () => ({
-        deviceRunSessionId: 'drs-id',
-        artifactId: 'log-id',
-        name: 'Emulator log',
-        filename: 'emulator.log',
-        kind: 'simulator-log',
-      }),
-      attempts: 2,
-    })
-  ).resolves.toBe(true);
-  expect(puts).toBe(2);
-  expect(replayed).toBe(payload.length);
-});
-
 it('keeps a slow PUT alive while its body is still flowing', async () => {
   jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate', 'queueMicrotask'] });
   let received = 0;

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

@@ -7,7 +7,6 @@ import { setImmediate } from 'node:timers/promises';
 
 import { type CustomBuildContext } from '../../../customBuildContext';
 import RemoteLoggerStream from '../../../logging/RemoteLoggerStream';
-import { Sentry } from '../../../sentry';
 import { turtleFetch } from '../../../utils/turtleFetch';
 import { downloadBuildAsync } from '../../functions/downloadBuild';
 import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
@@ -171,53 +170,6 @@ describe('with a device run session token', () => {
     expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('handles the structured stopped code without matching the message', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse(
-        {
-          errors: [
-            { code: 'DEVICE_RUN_SESSION_ALREADY_STOPPED', message: 'A different explanation.' },
-          ],
-        },
-        400
-      )
-    );
-    await expect(
-      uploadRemoteSessionConfigAsync({
-        ctx,
-        deviceRunSessionId: 'drs-id',
-        remoteConfig: {},
-        logger,
-      })
-    ).resolves.toBe('stopped');
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith(
-      'Device run session drs-id was stopped during startup.'
-    );
-  });
-
-  it.each([undefined, 'VALIDATION_ERROR'])('preserves an ordinary 400 with code %s', async code => {
-    const ctx = createCtx({ withToken: true });
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(
-        jsonResponse(
-          { errors: [{ code, message: 'Device run session has already stopped.' }] },
-          400
-        )
-      );
-    await expect(
-      uploadRemoteSessionConfigAsync({
-        ctx,
-        deviceRunSessionId: 'drs-id',
-        remoteConfig: {},
-        logger,
-      })
-    ).rejects.toBeInstanceOf(SystemError);
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-
   it('fails the start with a system error that does not contain the token', async () => {
     const ctx = createCtx({ withToken: true });
     jest
@@ -267,48 +219,6 @@ describe('with a device run session token', () => {
     expect(jest.mocked(turtleFetch)).toHaveBeenCalledTimes(1);
   });
 
-  it('handles a stopped-session TURN response without a warning or retry', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(
-        jsonResponse(
-          { errors: [{ code: 'DEVICE_RUN_SESSION_ALREADY_STOPPED', message: 'Stopped.' }] },
-          400
-        )
-      );
-
-    await expect(fetchWebPreviewTurnArgsAsync(ctx, { logger })).resolves.toEqual([]);
-
-    expect(logger.info).toHaveBeenCalledWith(
-      'Device run session was stopped before TURN credentials were fetched.'
-    );
-    expect(logger.warn).not.toHaveBeenCalled();
-    expect(Sentry.capture).not.toHaveBeenCalled();
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([undefined, 'VALIDATION_ERROR'])(
-    'still warns on a TURN failure with code %s',
-    async code => {
-      const ctx = createCtx({ withToken: true });
-      jest
-        .mocked(turtleFetch)
-        .mockResolvedValueOnce(
-          jsonResponse(
-            { errors: [{ code, message: 'Device run session has already stopped.' }] },
-            400
-          )
-        );
-
-      await expect(fetchWebPreviewTurnArgsAsync(ctx, { logger })).resolves.toEqual([]);
-
-      expect(logger.warn).toHaveBeenCalled();
-      expect(Sentry.capture).toHaveBeenCalled();
-      expect(turtleFetch).toHaveBeenCalledTimes(1);
-    }
-  );
-
   it('creates artifact upload sessions through the worker API', async () => {
     const ctx = createCtx({ withToken: true });
     jest.mocked(turtleFetch).mockResolvedValueOnce(
@@ -454,9 +364,7 @@ describe('with a device run session token', () => {
         robotAccessToken: ROBOT_ACCESS_TOKEN,
         extensions: ['app'],
       })
-    ).rejects.toThrow(
-      `Failed to download the application archive for build ${BUILD_ID} (HTTP 500): stop here`
-    );
+    ).rejects.toThrow('Unexpected response from server (500): stop here');
 
     expectWorkerApiCall('application', 'GET');
     expect(jest.mocked(fetch)).toHaveBeenCalledWith(
@@ -681,9 +589,7 @@ describe('without a device run session token', () => {
         robotAccessToken: ROBOT_ACCESS_TOKEN,
         extensions: ['app'],
       })
-    ).rejects.toThrow(
-      `Failed to download the application archive for build ${BUILD_ID} (HTTP 500): stop here`
-    );
+    ).rejects.toThrow('Unexpected response from server (500)');
 
     expect(ctx.graphqlClient.query).toHaveBeenCalled();
     expect(jest.mocked(fetch)).toHaveBeenCalledWith(

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 { isPreinstalledExpoGoAsync, readIosApplicationIdentifierAsync } from '../iosAppArtifact';
+import { readIosApplicationIdentifierAsync } from '../iosAppArtifact';
 
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
 jest.unmock('fs');
@@ -61,59 +61,3 @@ 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__/iosSimulatorSession.test.ts

@@ -155,53 +155,6 @@ describe('serve-sim Simulator preparation', () => {
     }
   );
 
-  it('preserves the Stop reason when Simulator shutdown rejects after cancellation', async () => {
-    const controller = new AbortController();
-    const stopped = new Error('Session stopped');
-    const wrapped = new Error('Shutdown process aborted', { cause: stopped });
-    let shutdownEntered!: () => void;
-    const entered = new Promise<void>(resolve => {
-      shutdownEntered = resolve;
-    });
-    jest
-      .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
-      .mockResolvedValue({ SERVE_SIM_ADDITIONAL_DYLIBS: '/guard.dylib' });
-    mockedUtils.getDeviceAsync.mockResolvedValue({ state: 'Booted' } as never);
-    mockedSpawn.mockImplementationOnce((_command, _args, options) => {
-      shutdownEntered();
-      return new Promise((_resolve, reject) =>
-        options!.signal!.addEventListener('abort', () => reject(wrapped), { once: true })
-      ) as ReturnType<typeof spawn>;
-    });
-    const running = resolveIosSessionStartupAsync({
-      ...hostOptions,
-      bootSimulator: true,
-      signal: controller.signal,
-    });
-    running.catch(() => {});
-    await entered;
-    controller.abort(stopped);
-    await expect(running).rejects.toBe(stopped);
-    expect(startLocalEgressGuardRelayAsync).not.toHaveBeenCalled();
-  });
-
-  it('preserves a genuine Simulator shutdown failure', async () => {
-    const failure = new Error('Could not shut down Simulator');
-    jest
-      .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
-      .mockResolvedValue({ SERVE_SIM_ADDITIONAL_DYLIBS: '/guard.dylib' });
-    mockedUtils.getDeviceAsync.mockResolvedValue({ state: 'Booted' } as never);
-    mockedSpawn.mockRejectedValueOnce(failure);
-    await expect(
-      resolveIosSessionStartupAsync({
-        ...hostOptions,
-        bootSimulator: true,
-        signal: new AbortController().signal,
-      })
-    ).rejects.toBe(failure);
-    expect(startLocalEgressGuardRelayAsync).not.toHaveBeenCalled();
-  });
-
   it('resolves an explicit Simulator without booting or configuring it', async () => {
     const startup = await resolveIosSessionStartupAsync({
       ...hostOptions,

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

@@ -1,873 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import * as ngrok from '@ngrok/ngrok';
-import { once } from 'node:events';
-import { createServer } from 'node:http';
-import WebSocket, { WebSocketServer } from 'ws';
-import { type AddressInfo, createConnection, createServer as createTcpServer } from 'node:net';
-
-import { turtleFetch } from '../../../utils/turtleFetch';
-import { startNgrokTunnelAsync } from '../ngrokTunnel';
-
-jest.mock('@ngrok/ngrok');
-jest.mock('node:timers', () => ({
-  setTimeout: (...args: Parameters<typeof setTimeout>) => setTimeout(...args),
-  clearTimeout: (...args: Parameters<typeof clearTimeout>) => clearTimeout(...args),
-}));
-jest.mock('../../../utils/turtleFetch');
-
-const { Response } = jest.requireActual<typeof import('node-fetch')>('node-fetch');
-const url = 'https://web-preview-fixed.example.test';
-const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-const options = {
-  port: 4321,
-  subdomainPrefix: 'web-preview',
-  subdomainId: 'fixed',
-  baseDomain: 'example.test',
-  authtoken: 'token',
-  rewriteHostHeader: true,
-  healthCheck: { path: '/healthz' },
-  logger,
-};
-
-function listener(publicUrl = url) {
-  return { url: () => publicUrl, close: jest.fn().mockResolvedValue(undefined) };
-}
-
-let initial: ReturnType<typeof listener>;
-let replacement: ReturnType<typeof listener>;
-
-beforeEach(() => {
-  jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate'] });
-  jest.clearAllMocks();
-  initial = listener();
-  replacement = listener();
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockResolvedValue(replacement as never);
-  jest
-    .mocked(turtleFetch)
-    .mockReset()
-    .mockResolvedValue(new Response(undefined, { status: 200 }));
-});
-
-afterEach(() => {
-  jest.useRealTimers();
-});
-
-function failPublicProbes() {
-  jest.mocked(turtleFetch).mockImplementation(
-    async target =>
-      new Response(undefined, {
-        status: target.startsWith('https:') ? 503 : 200,
-      })
-  );
-}
-
-it('keeps tunnels without a health check unsupervised and closes them on stop', async () => {
-  const tunnel = await startNgrokTunnelAsync({ ...options, healthCheck: undefined });
-  await jest.advanceTimersByTimeAsync(90_000);
-  expect(turtleFetch).not.toHaveBeenCalled();
-  expect(ngrok.forward).toHaveBeenCalledTimes(1);
-  await tunnel.stopAsync();
-  expect(initial.close).toHaveBeenCalledTimes(1);
-});
-
-it('probes the public service and keeps a healthy listener open', async () => {
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(turtleFetch).toHaveBeenCalledTimes(3);
-    expect(turtleFetch).toHaveBeenCalledWith(
-      `${url}/healthz`,
-      'GET',
-      expect.objectContaining({
-        retries: 0,
-        redirect: 'manual',
-        headers: expect.objectContaining({ 'ngrok-skip-browser-warning': 'true' }),
-      })
-    );
-    expect(ngrok.forward).toHaveBeenCalledTimes(1);
-  } finally {
-    await tunnel.stopAsync();
-  }
-  expect(initial.close).toHaveBeenCalledTimes(1);
-  await jest.advanceTimersByTimeAsync(60_000);
-  expect(turtleFetch).toHaveBeenCalledTimes(3);
-});
-
-it('reopens after three failed public probes with a healthy local service, preserving the endpoint', async () => {
-  failPublicProbes();
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(30_000);
-    expect(initial.close).not.toHaveBeenCalled();
-    await jest.advanceTimersByTimeAsync(15_000);
-    expect(initial.close).toHaveBeenCalledTimes(1);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    expect(jest.mocked(ngrok.forward).mock.calls[1][0]).toEqual({
-      addr: expect.any(Number),
-      authtoken: 'token',
-      domain: 'web-preview-fixed.example.test',
-      request_header_add: ['Host:localhost:4321'],
-      force_new_session: true,
-    });
-    expect(tunnel.url).toBe(url);
-    jest.mocked(turtleFetch).mockResolvedValue(new Response(undefined, { status: 200 }));
-    await jest.advanceTimersByTimeAsync(15_000);
-    expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('healthy again'));
-  } finally {
-    await tunnel.stopAsync();
-  }
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('does not reopen when the local service is unhealthy', async () => {
-  jest.mocked(turtleFetch).mockResolvedValue(new Response(undefined, { status: 503 }));
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(90_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(1);
-    expect(initial.close).not.toHaveBeenCalled();
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('resets consecutive failures after a successful public probe', async () => {
-  failPublicProbes();
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(30_000);
-    jest.mocked(turtleFetch).mockResolvedValueOnce(new Response(undefined, { status: 200 }));
-    await jest.advanceTimersByTimeAsync(15_000);
-    await jest.advanceTimersByTimeAsync(30_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(1);
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('retries a failed reopen with backoff', async () => {
-  failPublicProbes();
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockRejectedValueOnce(new Error('offline'))
-    .mockResolvedValue(replacement as never);
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    await jest.advanceTimersByTimeAsync(1_999);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    await jest.advanceTimersByTimeAsync(1);
-    expect(ngrok.forward).toHaveBeenCalledTimes(3);
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('closes a listener that finishes opening after shutdown, with idempotent cleanup', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(
-      new Promise(resolve => {
-        resolveOpening = resolve;
-      })
-    );
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const stopping = tunnel.stopAsync();
-  expect(tunnel.stopAsync()).toBe(stopping);
-  const stopped = jest.fn();
-  void stopping.then(stopped);
-  await jest.advanceTimersByTimeAsync(0);
-  expect(stopped).not.toHaveBeenCalled();
-  resolveOpening(replacement as never);
-  await stopping;
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-  await jest.advanceTimersByTimeAsync(120_000);
-  expect(ngrok.forward).toHaveBeenCalledTimes(2);
-});
-
-it('waits for a replacement acquired during shutdown to finish closing', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  let resolveClose!: () => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  replacement.close.mockReturnValue(new Promise<void>(resolve => (resolveClose = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  let stopped = false;
-  const stopping = tunnel.stopAsync().then(() => {
-    stopped = true;
-  });
-  await jest.advanceTimersByTimeAsync(0);
-  resolveOpening(replacement as never);
-  await jest.advanceTimersByTimeAsync(0);
-  const stoppedBeforeClose = stopped;
-  resolveClose();
-  await jest.advanceTimersByTimeAsync(250);
-  await stopping;
-  expect(stoppedBeforeClose).toBe(false);
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it.each([0, 4, 5, 10])('retires a reopen cancelled after %s promise turns', async turns => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  resolveOpening(replacement as never);
-  for (let turn = 0; turn < turns; turn++) {
-    await Promise.resolve();
-  }
-  await tunnel.stopAsync();
-  await jest.advanceTimersByTimeAsync(0);
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('retries a rejected close when a reopen finishes after shutdown', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const stopping = tunnel.stopAsync();
-  replacement.close.mockRejectedValueOnce(new Error('temporary unlisten failure'));
-  resolveOpening(replacement as never);
-  await jest.advanceTimersByTimeAsync(250);
-  await stopping;
-  expect(replacement.close).toHaveBeenCalledTimes(2);
-  const warnings = jest.mocked(logger.warn).mock.calls.length;
-  await jest.advanceTimersByTimeAsync(120_000);
-  expect(logger.warn).toHaveBeenCalledTimes(warnings);
-});
-
-it('fails stop if an in-flight reopen still has not settled by the stop deadline', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const rejected = expect(tunnel.stopAsync()).rejects.toThrow(
-    'Ngrok tunnel web-preview-fixed.example.test stop timed out after 4000ms'
-  );
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  expect(ngrok.forward).toHaveBeenCalledTimes(2);
-  resolveOpening(replacement as never);
-  await jest.advanceTimersByTimeAsync(0);
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('retries an old listener while a reopen outlasts shutdown', async () => {
-  failPublicProbes();
-  initial.close.mockRejectedValueOnce(new Error('agent disconnected'));
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  expect(initial.close).toHaveBeenCalledTimes(1);
-  const rejected = expect(tunnel.stopAsync()).rejects.toThrow(
-    'Ngrok tunnel web-preview-fixed.example.test stop timed out after 4000ms'
-  );
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  const oldCloseCalls = initial.close.mock.calls.length;
-  resolveOpening(replacement as never);
-  await jest.advanceTimersByTimeAsync(0);
-  expect(oldCloseCalls).toBe(2);
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-  expect(ngrok.forward).toHaveBeenCalledTimes(2);
-});
-
-it('fails stop if a pending reopen arrives but cannot be retired', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  replacement.close.mockRejectedValue(new Error('unlisten failed'));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const rejected = expect(tunnel.stopAsync()).rejects.toThrow(
-    'Ngrok tunnel web-preview-fixed.example.test stop timed out'
-  );
-  resolveOpening(replacement as never);
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  expect(replacement.close.mock.calls.length).toBeGreaterThan(1);
-  expect(logger.warn).toHaveBeenCalledWith(
-    expect.objectContaining({ err: expect.any(Error) }),
-    'Could not retire late ngrok tunnel web-preview-fixed.example.test.'
-  );
-  const warnings = jest.mocked(logger.warn).mock.calls.length;
-  await jest.advanceTimersByTimeAsync(120_000);
-  expect(logger.warn).toHaveBeenCalledTimes(warnings);
-  expect(ngrok.forward).toHaveBeenCalledTimes(2);
-});
-
-it('rejects a changed public URL and closes the replacement', async () => {
-  failPublicProbes();
-  const changed = listener('https://different.example.test');
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockResolvedValue(changed as never);
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(changed.close).toHaveBeenCalledTimes(1);
-    expect(tunnel.url).toBe(url);
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      expect.stringContaining('Could not reopen')
-    );
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('treats ngrok error responses as failures even if their status is accepted', async () => {
-  jest.mocked(turtleFetch).mockImplementation(
-    async target =>
-      new Response(undefined, {
-        status: 200,
-        headers: target.startsWith('https:') ? { 'ngrok-error-code': 'ERR_NGROK_3200' } : {},
-      })
-  );
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('reopens on a fresh agent session even if closing the old listener fails', async () => {
-  failPublicProbes();
-  initial.close.mockRejectedValueOnce(new Error('agent disconnected'));
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    expect(ngrok.forward).toHaveBeenLastCalledWith(
-      expect.objectContaining({ force_new_session: true })
-    );
-    expect(ngrok.disconnect).not.toHaveBeenCalled();
-  } finally {
-    await tunnel.stopAsync();
-  }
-  expect(initial.close).toHaveBeenCalledTimes(2);
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('retries a rejected close before reopening an endpoint that remains bound', async () => {
-  failPublicProbes();
-  let domainOccupied = true;
-  initial.close
-    .mockRejectedValueOnce(new Error('agent disconnected'))
-    .mockImplementation(async () => {
-      domainOccupied = false;
-    });
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockImplementation(async () => {
-      if (domainOccupied) {
-        throw new Error('endpoint is still bound');
-      }
-      return replacement as never;
-    });
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(initial.close).toHaveBeenCalledTimes(1);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    await jest.advanceTimersByTimeAsync(2_000);
-    expect(initial.close).toHaveBeenCalledTimes(2);
-    expect(ngrok.forward).toHaveBeenCalledTimes(3);
-    expect(tunnel.url).toBe(url);
-  } finally {
-    await tunnel.stopAsync();
-  }
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('retires an old listener even after its replacement is healthy', async () => {
-  failPublicProbes();
-  initial.close.mockRejectedValueOnce(new Error('agent disconnected'));
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(45_000);
-    expect(initial.close).toHaveBeenCalledTimes(1);
-    jest.mocked(turtleFetch).mockResolvedValue(new Response(undefined, { status: 200 }));
-    await jest.advanceTimersByTimeAsync(15_000);
-    expect(initial.close).toHaveBeenCalledTimes(2);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-  } finally {
-    await tunnel.stopAsync();
-  }
-});
-
-it('retries an old listener without repeating its close warning on every probe', async () => {
-  failPublicProbes();
-  initial.close.mockRejectedValue(new Error('old session disconnected'));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const warnings = jest.mocked(logger.warn).mock.calls.length;
-  expect(warnings).toBeGreaterThan(0);
-  jest.mocked(turtleFetch).mockResolvedValue(new Response(undefined, { status: 200 }));
-  await jest.advanceTimersByTimeAsync(120_000);
-  expect(initial.close.mock.calls.length).toBeGreaterThan(1);
-  expect(ngrok.forward).toHaveBeenCalledTimes(2);
-  expect(logger.warn).toHaveBeenCalledTimes(warnings);
-  const rejected = expect(tunnel.stopAsync()).rejects.toThrow(
-    'Ngrok tunnel web-preview-fixed.example.test stop timed out'
-  );
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('retries a rejected close during shutdown', async () => {
-  const failure = new Error('agent disconnected');
-  initial.close.mockRejectedValueOnce(failure);
-  const tunnel = await startNgrokTunnelAsync(options);
-  const stopping = tunnel.stopAsync();
-  await jest.advanceTimersByTimeAsync(250);
-  await stopping;
-  expect(initial.close).toHaveBeenCalledTimes(2);
-  expect(logger.warn).toHaveBeenCalledTimes(1);
-  expect(logger.warn).toHaveBeenCalledWith(
-    { err: failure },
-    'Could not stop ngrok tunnel web-preview-fixed.example.test.'
-  );
-});
-
-it('logs the first close rejection once while bounded shutdown retries it', async () => {
-  const failure = new Error('agent disconnected');
-  initial.close.mockRejectedValue(failure);
-  const tunnel = await startNgrokTunnelAsync(options);
-  const rejected = expect(tunnel.stopAsync()).rejects.toThrow('stop timed out');
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  expect(initial.close.mock.calls.length).toBeGreaterThan(1);
-  expect(logger.warn).toHaveBeenCalledTimes(1);
-  expect(logger.warn).toHaveBeenCalledWith(
-    { err: failure },
-    'Could not stop ngrok tunnel web-preview-fixed.example.test.'
-  );
-});
-
-it('bounds shutdown during recovery without duplicating a pending native close', async () => {
-  failPublicProbes();
-  let finishClose!: () => void;
-  initial.close.mockReturnValueOnce(new Promise<void>(resolve => (finishClose = resolve)));
-  const tunnel = await startNgrokTunnelAsync(options);
-  await jest.advanceTimersByTimeAsync(45_000);
-  const stopping = tunnel.stopAsync();
-  expect(tunnel.stopAsync()).toBe(stopping);
-  const rejected = expect(stopping).rejects.toThrow(
-    'Ngrok tunnel web-preview-fixed.example.test stop timed out after 4000ms'
-  );
-  await jest.advanceTimersByTimeAsync(4_000);
-  await rejected;
-  expect(initial.close).toHaveBeenCalledTimes(1);
-  expect(ngrok.forward).toHaveBeenCalledTimes(1);
-  const warnings = jest.mocked(logger.warn).mock.calls.length;
-  finishClose();
-  await jest.advanceTimersByTimeAsync(120_000);
-  expect(logger.warn).toHaveBeenCalledTimes(warnings);
-  expect(initial.close).toHaveBeenCalledTimes(1);
-});
-
-it('bounds a stalled listener close before reopening', async () => {
-  failPublicProbes();
-  initial.close.mockImplementationOnce(async () => await new Promise(() => {}));
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(49_999);
-    expect(ngrok.forward).toHaveBeenCalledTimes(1);
-    await jest.advanceTimersByTimeAsync(1);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-  } finally {
-    const stopping = tunnel.stopAsync();
-    const rejected = expect(stopping).rejects.toThrow(
-      'Ngrok tunnel web-preview-fixed.example.test stop timed out'
-    );
-    await jest.advanceTimersByTimeAsync(4_000);
-    await rejected;
-  }
-});
-
-it('does not queue more native opens while a timed-out open is still pending', async () => {
-  failPublicProbes();
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(
-      new Promise(resolve => {
-        resolveOpening = resolve;
-      })
-    )
-    .mockResolvedValue(replacement as never);
-  const tunnel = await startNgrokTunnelAsync(options);
-  const late = listener();
-  try {
-    await jest.advanceTimersByTimeAsync(180_000);
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    resolveOpening(late as never);
-    await jest.advanceTimersByTimeAsync(30_000);
-    expect(late.close).toHaveBeenCalledTimes(1);
-    expect(ngrok.forward).toHaveBeenCalledTimes(3);
-  } finally {
-    await tunnel.stopAsync();
-  }
-  expect(replacement.close).toHaveBeenCalledTimes(1);
-});
-
-it('bounds initial tunnel creation and retires a late listener', async () => {
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockReturnValueOnce(
-      new Promise(resolve => {
-        resolveOpening = resolve;
-      })
-    );
-  const opening = startNgrokTunnelAsync(options);
-  const rejected = expect(opening).rejects.toThrow('Ngrok tunnel open timed out');
-  await jest.advanceTimersByTimeAsync(15_000);
-  await rejected;
-  resolveOpening(initial as never);
-  await jest.advanceTimersByTimeAsync(0);
-  expect(initial.close).toHaveBeenCalledTimes(1);
-});
-
-it('retries a rejected close after initial tunnel creation timed out', async () => {
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)));
-  const opening = startNgrokTunnelAsync(options);
-  const rejected = expect(opening).rejects.toThrow('Ngrok tunnel open timed out');
-  await jest.advanceTimersByTimeAsync(15_000);
-  await rejected;
-  initial.close.mockRejectedValueOnce(new Error('temporary unlisten failure'));
-  resolveOpening(initial as never);
-  await jest.advanceTimersByTimeAsync(250);
-  expect(initial.close).toHaveBeenCalledTimes(2);
-});
-
-it('retires only the late listener without blaming it for an older stuck listener', async () => {
-  failPublicProbes();
-  initial.close.mockRejectedValue(new Error('old session disconnected'));
-  let resolveOpening!: (value: ngrok.Listener) => void;
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(initial as never)
-    .mockReturnValueOnce(new Promise(resolve => (resolveOpening = resolve)))
-    .mockResolvedValue(replacement as never);
-  const tunnel = await startNgrokTunnelAsync(options);
-  try {
-    await jest.advanceTimersByTimeAsync(60_000);
-    const late = listener();
-    resolveOpening(late as never);
-    jest.mocked(turtleFetch).mockResolvedValue(new Response(undefined, { status: 200 }));
-    await jest.advanceTimersByTimeAsync(4_000);
-    expect(late.close).toHaveBeenCalledTimes(1);
-    expect(
-      jest
-        .mocked(logger.warn)
-        .mock.calls.some(([, message]) => message?.includes('Could not retire late'))
-    ).toBe(false);
-  } finally {
-    initial.close.mockResolvedValue(undefined);
-    await tunnel.stopAsync();
-  }
-});
-
-it('recovers using actual HTTP health probes with a local ngrok adapter', async () => {
-  const actualFetch = jest.requireActual<typeof import('node-fetch')>('node-fetch').default;
-  const realSetTimeout = jest.requireActual<typeof import('node:timers')>('node:timers').setTimeout;
-  let broken = true;
-  const local = createServer((_req, res) => {
-    res.writeHead(200);
-    res.end('healthy');
-  });
-  const publicServer = createServer((_req, res) => {
-    res.writeHead(broken ? 503 : 200);
-    res.end('probe');
-  });
-  await Promise.all(
-    [local, publicServer].map(
-      server => new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve))
-    )
-  );
-  const publicUrl = `http://127.0.0.1:${(publicServer.address() as AddressInfo).port}`;
-  let completedRequests = 0;
-  jest.mocked(turtleFetch).mockImplementation(async (target, method, requestOptions) => {
-    const response = await actualFetch(target, { ...requestOptions, method });
-    completedRequests++;
-    return response;
-  });
-  const first = listener(publicUrl);
-  const next = listener(publicUrl);
-  jest
-    .mocked(ngrok.forward)
-    .mockReset()
-    .mockResolvedValueOnce(first as never)
-    .mockImplementation(async () => {
-      broken = false;
-      return next as never;
-    });
-  const tunnel = await startNgrokTunnelAsync({
-    ...options,
-    port: (local.address() as AddressInfo).port,
-  });
-  try {
-    for (let count = 0; count < 3; count++) {
-      await jest.advanceTimersByTimeAsync(15_000);
-      for (let turns = 0; turns < 50 && completedRequests < (count + 1) * 2; turns++) {
-        await new Promise(resolve => realSetTimeout(resolve, 10));
-      }
-      expect(completedRequests).toBe((count + 1) * 2);
-    }
-    expect(ngrok.forward).toHaveBeenCalledTimes(2);
-    expect(first.close).toHaveBeenCalledTimes(1);
-    expect((await actualFetch(`${tunnel.url}/healthz`)).status).toBe(200);
-  } finally {
-    await tunnel.stopAsync();
-    await Promise.all(
-      [local, publicServer].map(
-        server =>
-          new Promise<void>((resolve, reject) =>
-            server.close(err => (err ? reject(err) : resolve()))
-          )
-      )
-    );
-  }
-  expect(next.close).toHaveBeenCalledTimes(1);
-});
-
-it('blocks HTTP and existing WebSockets on Stop even when ngrok cannot close', async () => {
-  jest.useRealTimers();
-  const actualFetch = jest.requireActual<typeof import('node-fetch')>('node-fetch').default;
-  let requests = 0;
-  let messages = 0;
-  const backend = createServer((_request, response) => {
-    requests++;
-    response.end('owned backend');
-  });
-  const websockets = new WebSocketServer({ server: backend });
-  websockets.on('connection', socket => {
-    socket.on('message', data => {
-      messages++;
-      socket.send(data);
-    });
-  });
-  backend.listen(0, '127.0.0.1');
-  await once(backend, 'listening');
-  const backendPort = (backend.address() as AddressInfo).port;
-  const tunnel = await startNgrokTunnelAsync({
-    ...options,
-    port: backendPort,
-    healthCheck: undefined,
-  });
-  const targetPort = (jest.mocked(ngrok.forward).mock.calls[0][0] as ngrok.Config).addr;
-  const targetUrl = `http://127.0.0.1:${targetPort}`;
-  const socket = new WebSocket(`ws://127.0.0.1:${targetPort}`);
-  const opened = once(socket, 'open');
-  try {
-    expect(await (await actualFetch(targetUrl)).text()).toBe('owned backend');
-    await opened;
-    const echoed = once(socket, 'message');
-    socket.send('before-stop');
-    expect((await echoed)[0].toString()).toBe('before-stop');
-    const closed = once(socket, 'close');
-    initial.close.mockRejectedValue(new Error('agent disconnected'));
-    const stopping = tunnel.stopAsync();
-    const rejected = expect(stopping).rejects.toThrow('stop timed out after 4000ms');
-    await expect(actualFetch(targetUrl, { timeout: 1_000 })).rejects.toThrow();
-    await closed;
-    expect(requests).toBe(1);
-    expect(messages).toBe(1);
-    expect(await (await actualFetch(`http://127.0.0.1:${backendPort}`)).text()).toBe(
-      'owned backend'
-    );
-    await rejected;
-    await expect(actualFetch(targetUrl, { timeout: 1_000 })).rejects.toThrow();
-    expect(requests).toBe(2);
-    expect(messages).toBe(1);
-    const competing = createTcpServer();
-    const conflict = once(competing, 'error');
-    competing.listen(targetPort as number, '127.0.0.1');
-    expect((await conflict)[0]).toMatchObject({ code: 'EADDRINUSE' });
-  } finally {
-    socket.terminate();
-    for (const client of websockets.clients) {
-      client.terminate();
-    }
-    websockets.close();
-    backend.closeAllConnections();
-    await new Promise<void>(resolve => backend.close(() => resolve()));
-    await tunnel.stopAsync().catch(() => {});
-  }
-});
-
-it('releases its local target when initial tunnel creation fails', async () => {
-  jest.useRealTimers();
-  jest.mocked(ngrok.forward).mockReset().mockRejectedValue(new Error('forward failed'));
-  await expect(startNgrokTunnelAsync(options)).rejects.toThrow('forward failed');
-  const targetPort = (jest.mocked(ngrok.forward).mock.calls[0][0] as ngrok.Config).addr;
-  const server = createServer();
-  server.listen(targetPort as number, '127.0.0.1');
-  await once(server, 'listening');
-  await new Promise<void>(resolve => server.close(() => resolve()));
-});
-
-it('preserves a full response for a half-closed slow reader', async () => {
-  jest.useRealTimers();
-  const payload = Buffer.alloc(4 * 1024 * 1024, 37);
-  const backend = createTcpServer({ allowHalfOpen: true }, socket => {
-    socket.resume();
-    socket.on('end', () => socket.end(payload));
-  });
-  backend.listen(0, '127.0.0.1');
-  await once(backend, 'listening');
-  const tunnel = await startNgrokTunnelAsync({
-    ...options,
-    port: (backend.address() as AddressInfo).port,
-    healthCheck: undefined,
-  });
-  const targetPort = (jest.mocked(ngrok.forward).mock.calls[0][0] as ngrok.Config).addr as number;
-  const socket = createConnection({ host: '127.0.0.1', port: targetPort, allowHalfOpen: true });
-  try {
-    const chunks: Buffer[] = [];
-    socket.on('data', chunk => chunks.push(chunk));
-    const ended = once(socket, 'end');
-    socket.pause();
-    socket.end('request');
-    await new Promise(resolve => setTimeout(resolve, 100));
-    socket.resume();
-    await ended;
-    expect(Buffer.concat(chunks).equals(payload)).toBe(true);
-  } finally {
-    socket.destroy();
-    await tunnel.stopAsync();
-    await new Promise<void>(resolve => backend.close(() => resolve()));
-  }
-});
-
-it.each(['resolve', 'reject'])(
-  'releases the target after timed-out startup later %s',
-  async outcome => {
-    let resolveOpening!: (value: ngrok.Listener) => void;
-    let rejectOpening!: (error: Error) => void;
-    jest
-      .mocked(ngrok.forward)
-      .mockReset()
-      .mockReturnValue(
-        new Promise((resolve, reject) => {
-          resolveOpening = resolve;
-          rejectOpening = reject;
-        })
-      );
-    const opening = startNgrokTunnelAsync(options);
-    const rejected = expect(opening).rejects.toThrow('open timed out');
-    await new Promise<void>(resolve => setImmediate(resolve));
-    await jest.advanceTimersByTimeAsync(15_000);
-    await rejected;
-    const targetPort = (jest.mocked(ngrok.forward).mock.calls[0][0] as ngrok.Config).addr as number;
-    if (outcome === 'resolve') {
-      resolveOpening(replacement as never);
-    } else {
-      rejectOpening(new Error('forward failed'));
-    }
-    await jest.advanceTimersByTimeAsync(0);
-    const server = createTcpServer();
-    server.listen(targetPort, '127.0.0.1');
-    await once(server, 'listening');
-    await new Promise<void>(resolve => server.close(() => resolve()));
-  }
-);
-
-it('drains a full upload when the backend ends its response early', async () => {
-  jest.useRealTimers();
-  const payload = Buffer.alloc(4 * 1024 * 1024, 51);
-  let received!: Buffer;
-  let receivedRequest!: () => void;
-  const completed = new Promise<void>(resolve => {
-    receivedRequest = resolve;
-  });
-  const backend = createTcpServer({ allowHalfOpen: true }, socket => {
-    const chunks: Buffer[] = [];
-    socket.on('data', chunk => chunks.push(chunk));
-    socket.on('end', () => {
-      received = Buffer.concat(chunks);
-      receivedRequest();
-    });
-    socket.pause();
-    socket.end('early response');
-    setTimeout(() => socket.resume(), 100);
-  });
-  backend.listen(0, '127.0.0.1');
-  await once(backend, 'listening');
-  const tunnel = await startNgrokTunnelAsync({
-    ...options,
-    port: (backend.address() as AddressInfo).port,
-    healthCheck: undefined,
-  });
-  const targetPort = (jest.mocked(ngrok.forward).mock.calls[0][0] as ngrok.Config).addr as number;
-  const socket = createConnection({ host: '127.0.0.1', port: targetPort, allowHalfOpen: true });
-  try {
-    socket.resume();
-    socket.end(payload);
-    await completed;
-    expect(received.equals(payload)).toBe(true);
-  } finally {
-    socket.destroy();
-    await tunnel.stopAsync();
-    await new Promise<void>(resolve => backend.close(() => resolve()));
-  }
-});

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

@@ -530,22 +530,6 @@ describe(describeServeSimLaunch, () => {
   });
 });
 
-it('only pins hosts when a valid device ID is supplied', () => {
-  const udid = 'AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA';
-  expect(createServeSimArgs({ port: 4321, iosSimulatorUdid: udid })).toEqual(
-    expect.arrayContaining(['--single-device', udid])
-  );
-  for (const iosSimulatorUdid of [undefined, '', 'booted', 'iPhone 17']) {
-    expect(createServeSimArgs({ port: 4321, iosSimulatorUdid })).not.toContain('--single-device');
-  }
-  expect(createExpoDeviceHubArgs({ port: 4321, device: 'emulator-5554' })).toEqual(
-    expect.arrayContaining(['--single-device', 'emulator-5554'])
-  );
-  for (const device of [undefined, '', 'all', 'booted', 'invalid serial']) {
-    expect(createExpoDeviceHubArgs({ port: 4321, device })).not.toContain('--single-device');
-  }
-});
-
 describe(createServeSimArgs, () => {
   it('uses the latest Expo package and applies the EAS streaming policy', () => {
     expect(
@@ -932,7 +916,7 @@ describe(waitForWebPreviewReadyAsync, () => {
 
 describe(startNgrokTunnelAsync, () => {
   it.each(['rejected', 'stalled'] as const)(
-    'bounds %s listener retirement and reuses the stop promise',
+    'retains a %s close failure on repeated stops',
     async mode => {
       jest.useFakeTimers();
       try {
@@ -954,12 +938,14 @@ describe(startNgrokTunnelAsync, () => {
           logger: createLoggerMock(),
         });
         const stopping = tunnel.stopAsync();
-        const assertion = expect(stopping).rejects.toThrow(/stop timed out after 4000ms/);
+        const assertion = expect(stopping).rejects.toThrow(
+          mode === 'rejected' ? 'close failed' : 'Ngrok tunnel stop timed out after 4000ms.'
+        );
         expect(tunnel.stopAsync()).toBe(stopping);
         await jest.advanceTimersByTimeAsync(4_000);
         await assertion;
         await expect(tunnel.stopAsync()).rejects.toThrow();
-        expect(close).toHaveBeenCalled();
+        expect(close).toHaveBeenCalledTimes(1);
       } finally {
         jest.useRealTimers();
       }
@@ -983,7 +969,7 @@ describe(startNgrokTunnelAsync, () => {
 
     expect(ngrok.forward).toHaveBeenCalledWith(
       expect.objectContaining({
-        addr: expect.any(Number),
+        addr: 4321,
         authtoken: 'token',
         domain: expect.stringMatching(/^web-preview-[a-f0-9]{32}\.eas-simulator\.ngrok\.dev$/),
       })
@@ -1087,13 +1073,7 @@ describe(startDeviceSessionHostAsync, () => {
   beforeEach(() => {
     jest.mocked(uploadDeviceRunSessionScreenRecordingsAsync).mockReset();
     jest.mocked(spawn).mockReset();
-    jest
-      .mocked(ngrok.forward)
-      .mockReset()
-      .mockResolvedValue({
-        url: () => 'https://preview.example.test',
-        close: jest.fn().mockResolvedValue(undefined),
-      } as never);
+    jest.mocked(ngrok.forward).mockReset();
     jest.mocked(turtleFetch).mockReset();
     jest
       .mocked(readServeSimServersAsync)
@@ -1156,7 +1136,6 @@ 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(),
@@ -1174,7 +1153,6 @@ 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(),
@@ -1203,7 +1181,6 @@ 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(),
@@ -1211,7 +1188,7 @@ describe(startDeviceSessionHostAsync, () => {
       disableShare: true,
       privatePreviewUrl,
     });
-    const preview = await host.openPreviewAsync();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const serveSimArgs = jest
       .mocked(spawn)
@@ -1231,14 +1208,13 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const serveSimArgs = jest
       .mocked(spawn)
@@ -1265,14 +1241,13 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const spawnCalls = jest.mocked(spawn).mock.calls;
     expect(spawnCalls[0]).toEqual([
@@ -1311,10 +1286,7 @@ describe(startDeviceSessionHostAsync, () => {
         recordingDirectory,
       }),
     ]);
-    expect(ngrok.forward).toHaveBeenCalledWith(
-      expect.objectContaining({ addr: expect.any(Number) })
-    );
-    expect(ngrok.forward).not.toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
+    expect(ngrok.forward).toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
     expect(preview.apiUrl).toBe('https://android-preview.example.test');
 
     await host.finishAsync();
@@ -1329,13 +1301,12 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     expect(preview.previewToken).toBe('tok-1');
     expect(preview.apiUrl).toBe('https://preview.example.test');
@@ -1365,13 +1336,12 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     expect(preview.previewPageUrl).toMatch(
       /^https:\/\/staging\.expo\.dev\/simulator-preview\/[a-f0-9]{32}$/
@@ -1391,7 +1361,6 @@ describe(startDeviceSessionHostAsync, () => {
 
     await expect(
       startDeviceSessionHostAsync(createCtxMock(), {
-        preview: { baseDomain, authtoken },
         runtimePlatform: BuildRuntimePlatform.DARWIN,
         env,
         logger: createLoggerMock(),
@@ -1409,13 +1378,12 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     expect(preview.previewToken).toBe('hub-token');
     const [, args] = jest.mocked(spawn).mock.calls.find(([command]) => command === 'npx')!;
@@ -1432,14 +1400,13 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1455,10 +1422,7 @@ describe(startDeviceSessionHostAsync, () => {
         packageVersion,
       }),
     ]);
-    expect(ngrok.forward).toHaveBeenCalledWith(
-      expect.objectContaining({ addr: expect.any(Number) })
-    );
-    expect(ngrok.forward).not.toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
+    expect(ngrok.forward).toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
     expect(preview.apiUrl).toBe('https://ios-preview.example.test');
 
     await host.finishAsync();
@@ -1475,14 +1439,13 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1511,13 +1474,12 @@ 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();
+    const preview = await host.openPreviewAsync({ baseDomain, authtoken });
 
     const [command, args] = jest.mocked(spawn).mock.calls[0];
     const port = Number(args[args.indexOf('--port') + 1]);
@@ -1543,7 +1505,6 @@ describe(startDeviceSessionHostAsync, () => {
     } as never);
 
     const host = await startDeviceSessionHostAsync(createCtxMock(), {
-      preview: { baseDomain, authtoken },
       runtimePlatform: BuildRuntimePlatform.DARWIN,
       env,
       logger: createLoggerMock(),
@@ -1570,7 +1531,6 @@ 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(),
@@ -1851,23 +1811,6 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
   });
 
-  it('preserves an errored status when the duration timer fires during the response', async () => {
-    const ctx = createStatusCtxMock([]);
-    jest.mocked(turtleFetch).mockImplementationOnce(async () => {
-      (jest.mocked(setTimeoutCallback).mock.calls[0][0] as () => void)();
-      return workerApiResponse({ id: 'drs-id', status: 'errored' });
-    });
-    await expect(
-      waitForDeviceRunSessionStoppedAsync({
-        ctx,
-        deviceRunSessionId: 'drs-id',
-        logger: createLoggerMock(),
-        maxDurationSeconds: 30,
-      })
-    ).rejects.toThrow('Device run session drs-id errored.');
-    expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
-  });
-
   it('clears the duration timeout when the build step is aborted', async () => {
     const ctx = createStatusCtxMock([{ status: 'in-progress' }]);
     const abortController = new AbortController();
@@ -1886,33 +1829,6 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
   });
 
-  it('does not warn when retiring a watch aborts its pending status request', async () => {
-    const controller = new AbortController();
-    const logger = createLoggerMock();
-    const ctx = createCtxMock();
-    ctx.env.EAS_DEVICE_RUN_SESSION_TOKEN = 'worker-token';
-    jest.mocked(turtleFetch).mockImplementation(
-      async (_url, _method, options) =>
-        new Promise((_resolve, reject) => {
-          options!.signal!.addEventListener('abort', () => reject(new Error('request aborted')), {
-            once: true,
-          });
-        })
-    );
-    const waiting = waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger,
-      signal: controller.signal,
-    });
-
-    controller.abort();
-    await waiting;
-
-    expect(logger.warn).not.toHaveBeenCalled();
-    expect(Sentry.capture).not.toHaveBeenCalled();
-  });
-
   it('logs and retries transient polling errors', async () => {
     const ctx = createStatusCtxMock([{ error: new Error('network down') }, { status: 'stopped' }]);
     const logger = createLoggerMock();
@@ -2094,65 +2010,6 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
   });
 });
 
-describe('remote configuration cancellation', () => {
-  beforeEach(() => jest.mocked(turtleFetch).mockReset());
-
-  it('does not report readiness for an already stopped startup', async () => {
-    const controller = new AbortController();
-    const stopped = new Error('startup stopped');
-    controller.abort(stopped);
-
-    await expect(
-      remoteDeviceRunSession.uploadRemoteSessionConfigAsync({
-        ctx: createCtxMock(),
-        deviceRunSessionId: 'drs-id',
-        remoteConfig: {},
-        logger: createLoggerMock(),
-        signal: controller.signal,
-      })
-    ).rejects.toBe(stopped);
-    expect(turtleFetch).not.toHaveBeenCalled();
-  });
-
-  it('forwards cancellation to the in-flight readiness HTTP request', async () => {
-    const controller = new AbortController();
-    const ctx = createCtxMock();
-    ctx.env.EAS_DEVICE_RUN_SESSION_TOKEN = 'worker-token';
-    const stopped = new Error('session cancelled');
-    let entered!: () => void;
-    const requested = new Promise<void>(resolve => {
-      entered = resolve;
-    });
-    let requestAborted = false;
-    jest.mocked(turtleFetch).mockImplementation(
-      async (_url, _method, options) =>
-        new Promise((_resolve, reject) => {
-          entered();
-          options!.signal!.addEventListener(
-            'abort',
-            () => {
-              requestAborted = true;
-              reject(new Error('ready request aborted'));
-            },
-            { once: true }
-          );
-        })
-    );
-    const reporting = remoteDeviceRunSession.uploadRemoteSessionConfigAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      remoteConfig: {},
-      logger: createLoggerMock(),
-      signal: controller.signal,
-    });
-    await requested;
-    controller.abort(stopped);
-
-    await expect(reporting).rejects.toBe(stopped);
-    expect(requestAborted).toBe(true);
-  });
-});
-
 describe(ensureFfmpegInstalledOnceAsync, () => {
   const spawnMock = jest.mocked(spawn);
   let binDirectory: string;

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

@@ -22,17 +22,29 @@ it('uploads NDJSON with explicit user-app scope', async () => {
       kind: 'simulator-log',
       filename: 'app-logs.ndjson',
       size: 11,
-      attempts: 1,
       metadata: expect.objectContaining({ scope: 'user-apps', udid: 'A' }),
     })
   );
 });
 
-it('warns and resolves when the upload fails', async () => {
+it('skips empty and missing files', async () => {
+  await uploadServeSimLogsFileAsync(ctx, args);
+  await writeFile(filePath, '');
+  await uploadServeSimLogsFileAsync(ctx, args);
+  expect(uploadDeviceRunSessionArtifactAsync).not.toHaveBeenCalled();
+});
+
+it('aborts the upload on a file read error without an unhandled error', async () => {
   await writeFile(filePath, '{}\n');
   jest
     .mocked(uploadDeviceRunSessionArtifactAsync)
-    .mockRejectedValueOnce(new Error('storage unavailable'));
+    .mockImplementationOnce(async (_ctx, { openStream, signal }) => {
+      const aborted = new Promise<void>((_resolve, reject) => {
+        signal!.addEventListener('abort', () => reject(signal!.reason), { once: true });
+      });
+      openStream().destroy(new Error('read failure'));
+      await aborted;
+    });
   await expect(uploadServeSimLogsFileAsync(ctx, args)).resolves.toBeUndefined();
   expect(logger.warn).toHaveBeenCalledWith(
     expect.objectContaining({ err: expect.any(Error) }),