[worker] Revert Xcode build tool prewarming

[worker] Prewarm Xcode interface build tools
[build-tools] Add local Xcode compilation cache
2026-11-14 10:08:06 -10:00 · 2026-08-14 20:50:13 +02:00 · 2026-08-14 20:33:26 +02:00 · 2026-08-14 18:14:57 +02:00
396 changed files with 8750 additions and 43460 deletions
@@ -27,9 +27,6 @@ jobs:

      - uses: ./.github/actions/setup-mise

-      - name: Install eas-cli
-        run: npm install --global eas-cli@latest
-
      - uses: ./.github/internal-actions/setup-gcloud

      - name: Check if worker already exists
@@ -64,7 +61,7 @@ jobs:
          SHOULD_UPLOAD_ARTIFACT="${{ inputs.environment != '' && steps.check_worker_exists.outputs.worker_exists == 'false' }}"

          # Run workflow and capture output (includes run ID)
-          WORKFLOW_OUTPUT=$(eas workflow:run build-worker.yml \
+          WORKFLOW_OUTPUT=$(npx -y eas-cli@latest workflow:run build-worker.yml \
            --ref ${{ github.sha }} \
            --input upload_artifact=$SHOULD_UPLOAD_ARTIFACT \
            --non-interactive \
@@ -99,7 +96,7 @@ jobs:
          SHOULD_UPLOAD_ARTIFACT="${{ inputs.environment != '' && steps.check_worker_exists.outputs.worker_exists == 'false' }}"

          while true; do
-            VIEW_OUTPUT=$(eas workflow:view "$WORKFLOW_RUN_ID" \
+            VIEW_OUTPUT=$(npx -y eas-cli@latest workflow:view "$WORKFLOW_RUN_ID" \
              --non-interactive \
              --json)
            STATUS=$(echo "$VIEW_OUTPUT" | jq -r '.status')
@@ -184,7 +181,7 @@ jobs:

          WORKFLOW_RUN_ID="${{ steps.eas_workflow.outputs.workflow_run_id }}"
          if [ -n "$WORKFLOW_RUN_ID" ]; then
-            eas workflow:cancel "$WORKFLOW_RUN_ID" --non-interactive
+            npx -y eas-cli@latest workflow:cancel "$WORKFLOW_RUN_ID" --non-interactive
          fi

      - name: Upload worker tarballs to GCP
@@ -31,9 +31,7 @@ jobs:
          script: |
            core.setFailed('Please add a changelog entry!')
      - uses: mshick/add-pr-comment@b8f338c590a895d50bcbfa6c5859251edc8952fc # v2.8.2
-        if: >-
-          always() &&
-          (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository)
+        if: always()
        with:
          message-id: changelog-entry-check
          refresh-message-position: true
@@ -37,6 +37,20 @@ jobs:
        run: yarn build
      - name: Publish packages to npm
        run: yarn run -T lerna publish from-package --yes --no-verify-access
+      - name: Verify eas-cli was published as latest on npm
+        run: |
+          expected="$(jq -r .version lerna.json)"
+          for attempt in $(seq 1 10); do
+            published="$(npm view eas-cli@latest version 2>/dev/null || true)"
+            if [ "$published" = "$expected" ]; then
+              echo "Verified eas-cli@$expected is latest on npm."
+              exit 0
+            fi
+            echo "Attempt $attempt: npm latest is '$published', expected '$expected'. Retrying in 15s..."
+            sleep 15
+          done
+          echo "eas-cli@$expected was not published as latest on npm; the publish step failed." >&2
+          exit 1
  release-changelog:
    name: Update changelog and publish release
    runs-on: ubuntu-latest
@@ -53,10 +67,6 @@ jobs:
        run: yarn install --immutable
      - name: Resolve version
        run: echo "EAS_CLI_VERSION=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_ENV"
-      - name: Configure git
-        run: |
-          git config user.email "[email protected]"
-          git config user.name "Expo CI"
      - name: Update changelog
        working-directory: ./scripts
        run: yarn release-changelog "$EAS_CLI_VERSION" > /tmp/current-changelog
@@ -64,52 +74,17 @@ jobs:
        run: gh release edit "v$EAS_CLI_VERSION" --draft=false -F /tmp/current-changelog
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Commit and push changelog
+      - name: Commit and push
        run: |
          git fetch
          git checkout main
-          git add CHANGELOG.md
-          git commit --allow-empty -m "update CHANGELOG.md for v$EAS_CLI_VERSION"
-          git push
-      - name: Verify eas-cli is available on npm
-        run: |
-          availability_deadline_epoch=$(( $(date +%s) + 600 ))
-
-          while true; do
-            published="$(npm view "eas-cli@$EAS_CLI_VERSION" version --prefer-online 2>/dev/null || true)"
-            if [ "$published" = "$EAS_CLI_VERSION" ]; then
-              echo "Verified eas-cli@$EAS_CLI_VERSION is available on npm."
-              exit 0
-            fi
-
-            current_epoch=$(date +%s)
-            if [ "$current_epoch" -ge "$availability_deadline_epoch" ]; then
-              break
-            fi
-
-            retry_delay=$((availability_deadline_epoch - current_epoch))
-            if [ "$retry_delay" -gt 10 ]; then
-              retry_delay=10
-            fi
-            echo "eas-cli@$EAS_CLI_VERSION is not available on npm yet. Retrying in ${retry_delay}s."
-            sleep "$retry_delay"
-          done
-
-          echo "eas-cli@$EAS_CLI_VERSION was not available on npm after 10 minutes." >&2
-          exit 1
-      - name: Bump STAGING and PRODUCTION
-        run: |
-          git pull --rebase --autostash origin main
          jq --arg version "$EAS_CLI_VERSION" '.STAGING = $version' \
            cli-versions.json > cli-versions.json.tmp
          mv cli-versions.json.tmp cli-versions.json
-          jq --arg version "$EAS_CLI_VERSION" '.PRODUCTION = $version' \
-            cli-versions.json > cli-versions.json.tmp
-          mv cli-versions.json.tmp cli-versions.json
-      - name: Commit and push version update
-        run: |
-          git add cli-versions.json
-          git commit --allow-empty -m "bump STAGING and PRODUCTION to $EAS_CLI_VERSION in cli-versions.json"
+          git config --global user.email "[email protected]"
+          git config --global user.name "Expo CI"
+          git add cli-versions.json CHANGELOG.md
+          git commit --allow-empty -m "update CHANGELOG.md and bump STAGING in cli-versions.json"
          git push
      - name: Prepare changelog for Slack
        run: |
@@ -1,90 +0,0 @@
-name: Update Appium command list
-
-on:
-  schedule:
-    - cron: '0 6 * * 1' # Every Monday at 06:00 UTC
-  push:
-    branches:
-      - main
-    paths:
-      - .github/workflows/update-appium-commands.yml
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  generate:
-    runs-on: ubuntu-latest
-    name: Regenerate Appium command list
-    outputs:
-      changed: ${{ steps.diff.outputs.changed }}
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          persist-credentials: false
-      - name: Setup tools
-        uses: ./.github/actions/setup-mise
-      - name: Install dependencies
-        run: yarn install --immutable
-      - name: Regenerate the Appium command list
-        # The generator installs Appium, XCUITest, and UiAutomator2 on demand,
-        # so it always picks up the latest supported command sets.
-        run: yarn workspace @expo/build-tools generate-appium-commands
-      - name: Check whether the command list changed
-        id: diff
-        run: |
-          if git diff --quiet -- packages/build-tools/src/steps/utils/appiumCommands.generated.ts; then
-            echo 'changed=false' >> "$GITHUB_OUTPUT"
-          else
-            echo 'changed=true' >> "$GITHUB_OUTPUT"
-          fi
-      - name: Upload the generated command list
-        if: steps.diff.outputs.changed == 'true'
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: appium-command-list
-          path: packages/build-tools/src/steps/utils/appiumCommands.generated.ts
-          if-no-files-found: error
-          retention-days: 1
-
-  publish:
-    needs: generate
-    if: needs.generate.outputs.changed == 'true'
-    runs-on: ubuntu-latest
-    name: Publish Appium command list update
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          persist-credentials: false
-      - name: Download the generated command list
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
-        with:
-          name: appium-command-list
-          path: packages/build-tools/src/steps/utils
-      - name: Open a pull request
-        env:
-          GH_TOKEN: ${{ secrets.EXPO_BOT_PAT }}
-        run: |
-          branch=bot/update-appium-commands
-          title='[build-tools] Update Appium command list'
-          body=$'Automated update of the Appium, XCUITest, and UiAutomator2 command list.\n\nIf this PR adds new commands, typechecking will fail until a curated summary is added for each of them in `packages/build-tools/src/steps/utils/appiumCommandSummary.ts`.'
-
-          gh auth setup-git
-          if git ls-remote --exit-code --heads origin "$branch" >/dev/null; then
-            git fetch origin "refs/heads/$branch:refs/remotes/origin/$branch"
-          fi
-
-          git config user.name 'Expo Bot'
-          git config user.email [email protected]
-          git checkout -B "$branch"
-          git add packages/build-tools/src/steps/utils/appiumCommands.generated.ts
-          git commit -m "$title"
-          git push --force-with-lease origin "$branch"
-
-          if gh pr view "$branch" --json state --jq '.state' 2>/dev/null | grep -q OPEN; then
-            gh pr edit "$branch" --title "$title" --body "$body" --add-reviewer sjchmiela
-          else
-            gh pr create --base main --head "$branch" --title "$title" --body "$body" \
-              --label 'no changelog' --reviewer sjchmiela
-          fi
@@ -15,15 +15,12 @@ jobs:

      - uses: ./.github/actions/setup-mise

-      - name: Install eas-cli
-        run: npm install --global eas-cli@latest
-
      - name: Create test app
        run: npx -y create-expo-app@latest ${{ runner.temp }}/test-app --template tabs

      - name: Link to EAS project
        working-directory: ${{ runner.temp }}/test-app
-        run: eas init --id 6ae8028d-4e6d-4912-8eb2-87d4e6122880 --force --non-interactive
+        run: npx -y eas-cli@latest init --id 6ae8028d-4e6d-4912-8eb2-87d4e6122880 --force --non-interactive

      - name: Add bundle identifiers to app.json
        working-directory: ${{ runner.temp }}/test-app
@@ -33,7 +30,7 @@ jobs:

      - name: Configure EAS Build
        working-directory: ${{ runner.temp }}/test-app
-        run: eas build:configure --platform all
+        run: npx -y eas-cli@latest build:configure --platform all

      - name: Add system-test profile to eas.json
        working-directory: ${{ runner.temp }}/test-app
@@ -52,7 +49,7 @@ jobs:
        run: |
          set -euo pipefail

-          BUILD_JSON=$(eas build --platform ios --profile system-test --non-interactive --no-wait --json)
+          BUILD_JSON=$(npx -y eas-cli@latest build --platform ios --profile system-test --non-interactive --no-wait --json)
          BUILD_ID=$(echo "$BUILD_JSON" | jq -r 'if type=="array" then .[0].id // .[0].build.id // .[0].buildId else .id // .build.id // .buildId end // empty')
          if [ -z "$BUILD_ID" ]; then
            echo "Error: could not determine build ID"
@@ -62,7 +59,7 @@ jobs:
          echo "BUILD_ID=$BUILD_ID" >> "$GITHUB_ENV"
          echo "Resolved BUILD_ID=$BUILD_ID"

-          WORKFLOW_JSON=$(eas workflow:run build-android.yml --non-interactive --no-wait --json)
+          WORKFLOW_JSON=$(npx -y eas-cli@latest workflow:run build-android.yml --non-interactive --no-wait --json)
          WORKFLOW_RUN_ID=$(echo "$WORKFLOW_JSON" | jq -r '.id // .workflowRun.id // .workflowRunId // empty')
          if [ -z "$WORKFLOW_RUN_ID" ]; then
            echo "Error: could not determine workflow run ID"
@@ -98,8 +95,8 @@ jobs:
              exit 1
            fi

-            BUILD_STATUS=$(eas build:view "$BUILD_ID" --json | jq -r '.status // empty')
-            WORKFLOW_STATUS=$(eas workflow:view "$WORKFLOW_RUN_ID" --non-interactive --json | jq -r '.status // empty')
+            BUILD_STATUS=$(npx -y eas-cli@latest build:view "$BUILD_ID" --json | jq -r '.status // empty')
+            WORKFLOW_STATUS=$(npx -y eas-cli@latest workflow:view "$WORKFLOW_RUN_ID" --non-interactive --json | jq -r '.status // empty')

            echo "iOS build status: $BUILD_STATUS"
            echo "Android workflow status: $WORKFLOW_STATUS"
@@ -133,13 +130,13 @@ jobs:

          if [ -n "${BUILD_ID:-}" ]; then
            echo "Canceling EAS build: $BUILD_ID"
-            BUILD_CANCEL_OUTPUT=$(eas build:cancel "$BUILD_ID" --non-interactive 2>&1 || true)
+            BUILD_CANCEL_OUTPUT=$(npx -y eas-cli@latest build:cancel "$BUILD_ID" --non-interactive 2>&1 || true)
            if [ -n "$BUILD_CANCEL_OUTPUT" ]; then
              echo "$BUILD_CANCEL_OUTPUT"
            else
              echo "build:cancel produced no output"
            fi
-            BUILD_STATUS=$(eas build:view "$BUILD_ID" --json 2>/dev/null | jq -r '.status // empty' || true)
+            BUILD_STATUS=$(npx -y eas-cli@latest build:view "$BUILD_ID" --json 2>/dev/null | jq -r '.status // empty' || true)
            if [ -n "$BUILD_STATUS" ]; then
              echo "Post-cancel build status: $BUILD_STATUS"
            else
@@ -148,13 +145,13 @@ jobs:
          fi
          if [ -n "${WORKFLOW_RUN_ID:-}" ]; then
            echo "Canceling EAS workflow run: $WORKFLOW_RUN_ID"
-            WORKFLOW_CANCEL_OUTPUT=$(eas workflow:cancel "$WORKFLOW_RUN_ID" --non-interactive 2>&1 || true)
+            WORKFLOW_CANCEL_OUTPUT=$(npx -y eas-cli@latest workflow:cancel "$WORKFLOW_RUN_ID" --non-interactive 2>&1 || true)
            if [ -n "$WORKFLOW_CANCEL_OUTPUT" ]; then
              echo "$WORKFLOW_CANCEL_OUTPUT"
            else
              echo "workflow:cancel produced no output"
            fi
-            WORKFLOW_STATUS=$(eas workflow:view "$WORKFLOW_RUN_ID" --non-interactive --json 2>/dev/null | jq -r '.status // empty' || true)
+            WORKFLOW_STATUS=$(npx -y eas-cli@latest workflow:view "$WORKFLOW_RUN_ID" --non-interactive --json 2>/dev/null | jq -r '.status // empty' || true)
            if [ -n "$WORKFLOW_STATUS" ]; then
              echo "Post-cancel workflow status: $WORKFLOW_STATUS"
            else
@@ -8,191 +8,16 @@ This is the log of notable changes to EAS CLI and related packages.

 ### 🎉 New features

-### 🐛 Bug fixes
-
- [eas-cli] Shorten the local egress banner printed by `eas simulator:start` and stop mentioning `eas simulator:egress` in interactive mode, where the client runs in the same terminal. ([#4383](https://github.com/expo/eas-cli/pull/4383) by [@brentvatne](https://github.com/brentvatne))
-
-### 🧹 Chores
-
-## [24.1.1](https://github.com/expo/eas-cli/releases/tag/v24.1.1) - 2026-09-11
-
-### 🐛 Bug fixes
-
- [eas-cli] Stop telling interactive `eas simulator:start --egress local` users to run `eas simulator:egress` when the egress client already runs in the same terminal. ([#4382](https://github.com/expo/eas-cli/pull/4382) by [@brentvatne](https://github.com/brentvatne))
-
-## [24.1.0](https://github.com/expo/eas-cli/releases/tag/v24.1.0) - 2026-09-10
-
-### 🎉 New features
-
- [eas-cli] Add `--egress-allow <host:port>` to `eas simulator:start` so local egress sessions can reach dev servers on this machine or its network. ([#4369](https://github.com/expo/eas-cli/pull/4369) by [@brentvatne](https://github.com/brentvatne))
- [eas-cli][build-tools] Forward `--egress-allow localhost:<port>` and `127.0.0.1:<port>` entries from the simulator host's loopback interface to this machine (like `adb reverse`), so dev server URLs that use `127.0.0.1` work through local egress. ([#4369](https://github.com/expo/eas-cli/pull/4369) by [@brentvatne](https://github.com/brentvatne))
- [build-tools] Add the `eas/start_local_egress` step for iOS simulator sessions with local egress: the device host's system proxy points at a reverse tunnel to the EAS CLI machine, so HTTP(S) requests that honor it exit from that machine and third parties see its IP. ([#4364](https://github.com/expo/eas-cli/pull/4364) by [@brentvatne](https://github.com/brentvatne))
- [eas-cli] Add `--egress local` to `eas simulator:start` and the `eas simulator:egress` command, which run the local egress client for the session. ([#4364](https://github.com/expo/eas-cli/pull/4364) by [@brentvatne](https://github.com/brentvatne))
- [build-tools] Require the serve-sim session token for device run session previews, so the tunnel no longer exposes the shell-exec route. ([#4306](https://github.com/expo/eas-cli/pull/4306) by [@gwdp](https://github.com/gwdp))
-
-### 🐛 Bug fixes
-
- [build-tools] Report a system error when project source refresh fails for a remote build. ([#4359](https://github.com/expo/eas-cli/pull/4359) by [@sjchmiela](https://github.com/sjchmiela))
-
-## [24.0.0](https://github.com/expo/eas-cli/releases/tag/v24.0.0) - 2026-09-09
-
-### 🛠 Breaking changes
-
- [eas-cli] Align the `eas observe:*` commands with the renamed Observe GraphQL schema. `--json` output now uses `name`/`value` instead of `metricName`/`metricValue` (metrics) and `name` instead of `eventName` (log events and event-name summaries), and `eas observe:events` now lists user-defined events only — exceptions moved to the new `eas observe:errors`. ([#4338](https://github.com/expo/eas-cli/pull/4338) by [@douglowder](https://github.com/douglowder))
-
-### 🎉 New features
-
- [build-tools] Add `lcd_width`, `lcd_height`, and `lcd_density` inputs to configure the Android emulator display. ([#4349](https://github.com/expo/eas-cli/pull/4349) by [@krystofwoldrich-agent](https://github.com/krystofwoldrich-agent))
- [eas-cli] Add `eas channel:protect` and `eas channel:unprotect` to manage EAS Update channel protection, and show protection in channel list and view output. ([#4319](https://github.com/expo/eas-cli/pull/4319) by [@sjkim-expo](https://github.com/sjkim-expo))
- [eas-cli] Add `eas observe:errors` to display error and exception issue groups (grouped by fingerprint), with `--fingerprint <fingerprint>` to drill into a group's individual occurrences and stack traces. ([#4339](https://github.com/expo/eas-cli/pull/4339) by [@douglowder](https://github.com/douglowder))
- [eas-cli] Add `eas observe:event` to display a single Observe event (metric, log, or error) by its ID. ([#4252](https://github.com/expo/eas-cli/pull/4252) by [@douglowder](https://github.com/douglowder))
-
-### 🐛 Bug fixes
-
- [build-tools] Start Argent remote sessions with `bun x` so they work when the `bunx` symlink is missing. ([491b372a](https://github.com/expo/eas-cli/commit/491b372a) by [@krystofwoldrich](https://github.com/krystofwoldrich))
- [build-tools] Reduce `expo-device-hub` preview resolution from 1280 px to 960 px to match `serve-sim` and lower streaming bandwidth. ([#4326](https://github.com/expo/eas-cli/pull/4326) by [@krystofwoldrich-agent](https://github.com/krystofwoldrich-agent))
- [build-tools] Install FFmpeg before launching `expo-device-hub` in Android device sessions. ([#4332](https://github.com/expo/eas-cli/pull/4332) by [@krystofwoldrich-agent](https://github.com/krystofwoldrich-agent))
- [eas-cli] Print the session token in simulator preview links, so they still open once the preview is gated. ([#4312](https://github.com/expo/eas-cli/pull/4312) by [@gwdp](https://github.com/gwdp))
-
-### 🧹 Chores
-
- [eas-cli] Make ASC API key issuer identifier optional in GraphQL and credentials types. ([#4248](https://github.com/expo/eas-cli/pull/4248) by [@sswrk](https://github.com/sswrk))
-
-## [23.2.0](https://github.com/expo/eas-cli/releases/tag/v23.2.0) - 2026-08-31
-
-### 🎉 New features
-
- [eas-cli] Add `--tag` to `eas simulator` and `eas simulator:list` to group and filter simulator sessions by app variant. ([#4318](https://github.com/expo/eas-cli/pull/4318) by [@tchayen](https://github.com/tchayen))
- [eas-cli] Update workflow run logs in real time, instead of every 10 seconds. ([#4228](https://github.com/expo/eas-cli/pull/4228) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
- [build-tools] Add `expo-device-hub` web previews to Android web-preview-only, Agent Device, Argent, and Appium remote sessions. ([#4304](https://github.com/expo/eas-cli/pull/4304) by [@krystofwoldrich](https://github.com/krystofwoldrich))
- [eas-cli] Add `eas workflow:ssh <workflow-job-id> [command...]` to open an ssh session on the worker running a workflow job. ([#4032](https://github.com/expo/eas-cli/pull/4032) by [@gwdp](https://github.com/gwdp))
- [eas-cli] Add `--ssh` (and `--ssh-idle-timeout`) to `eas workflow:run` to enable ssh on the run's VM jobs. ([#4033](https://github.com/expo/eas-cli/pull/4033) by [@gwdp](https://github.com/gwdp))
-
-### 🧹 Chores
-
- [eas-cli] Warn when starting Android EAS Simulator sessions that support is still in development and iOS parity is coming soon. ([#4320](https://github.com/expo/eas-cli/pull/4320) by [@szdziedzic](https://github.com/szdziedzic))
-
-## [23.1.0](https://github.com/expo/eas-cli/releases/tag/v23.1.0) - 2026-08-31
-
-### 🎉 New features
-
- [eas-cli] Prompt for the Expo SDK version in `eas new` and add a `--sdk-version` flag. The template now downloads from npm instead of GitHub to support SDK-specific versions. ([#4301](https://github.com/expo/eas-cli/pull/4301) by [@brentvatne](https://github.com/brentvatne))
- [eas-cli] Clean up template metadata in projects created with `eas new`: remove the template LICENSE file and reset the package.json name, version, and license fields. ([#4301](https://github.com/expo/eas-cli/pull/4301) by [@brentvatne](https://github.com/brentvatne))
- [build-tools] Support `EAS_PNPM_FILTER_WORKSPACE` to install only the selected workspace's dependencies with `pnpm install --filter`. ([#4302](https://github.com/expo/eas-cli/pull/4302) by [@robingullo](https://github.com/robingullo))
-
-### 🐛 Bug fixes
-
- [build-tools] Normalize extracted project permissions so source archives cannot leave files unreadable by EAS workers. ([#4287](https://github.com/expo/eas-cli/pull/4287) by [@AbbanMustafa](https://github.com/AbbanMustafa))
- [eas-cli] Add dynamic retries to deploy command that scale up more generously, depending on deployment size ([#4299](https://github.com/expo/eas-cli/pull/4299) by [@kitten](https://github.com/kitten))
-
-### 🧹 Chores
-
- [eas-cli] Add regression coverage for the bundled iOS entitlement introspection fallback. ([#4285](https://github.com/expo/eas-cli/pull/4285) by [@brentvatne](https://github.com/brentvatne))
- [local-build-plugin] Replace `bunyan` with `@expo/bunyan` while preserving the Steps formatter binary. ([#4284](https://github.com/expo/eas-cli/pull/4284) by [@brentvatne](https://github.com/brentvatne))
- [steps] Replace deprecated `lodash.get` with a local helper. ([#4283](https://github.com/expo/eas-cli/pull/4283) by [@brentvatne](https://github.com/brentvatne))
- [eas-cli][steps] Bump `uuid` to v11 and remove the redundant `@types/uuid` dependency. ([#4282](https://github.com/expo/eas-cli/pull/4282) by [@brentvatne](https://github.com/brentvatne))
- [eas-cli] Bump `minizlib` to 3.1.0 to drop its deprecated `rimraf@5` transitive dependency. ([#4281](https://github.com/expo/eas-cli/pull/4281) by [@brentvatne](https://github.com/brentvatne))
-
-## [23.0.0](https://github.com/expo/eas-cli/releases/tag/v23.0.0) - 2026-08-28
-
-### 🛠 Breaking changes
-
- [eas-cli] Rename the EAS Simulator preview-only session type from `--type serve-sim` to `--type web-preview-only`. ([#4298](https://github.com/expo/eas-cli/pull/4298) by [@szdziedzic](https://github.com/szdziedzic))
-
-### 🎉 New features
-
- [build-tools] Cache CocoaPods dependencies between iOS builds. ([#4266](https://github.com/expo/eas-cli/pull/4266) by [@AbbanMustafa](https://github.com/AbbanMustafa))
- [build-tools] Support `EAS_BUN_FILTER_WORKSPACE` to install only the selected workspace's dependencies with `bun install --filter`. ([#4292](https://github.com/expo/eas-cli/pull/4292) by [@konrad-armatys](https://github.com/konrad-armatys))
- [eas-cli] Add `eas project:status` (alias `eas status`) command that prints a snapshot of the project's recent builds, development builds, workflow runs, submissions, and updates, with agent-friendly JSON metadata, activity links, structured errors, submission-to-build correlation, and `--non-interactive` support. ([#4006](https://github.com/expo/eas-cli/pull/4006) by [@jonsamp](https://github.com/jonsamp))
-
-### 🐛 Bug fixes
-
- [build-tools] Prevent user npm minimum release age settings from applying to internal EAS CLI commands. ([#4296](https://github.com/expo/eas-cli/pull/4296) by [@sjchmiela](https://github.com/sjchmiela))
- [build-tools] Reduce serve-sim preview resolution from 1280 px to 960 px to lower streaming bandwidth. ([#4297](https://github.com/expo/eas-cli/pull/4297) by [@szdziedzic](https://github.com/szdziedzic))
-
-### 🧹 Chores
-
- [worker] Use turtle cache upload and download URLs for eas.json build cache restore and save. ([#3860](https://github.com/expo/eas-cli/pull/3860) by [@sjchmiela](https://github.com/sjchmiela))
- [ci] Bump both STAGING and PRODUCTION cli-versions in release workflow. ([#4290](https://github.com/expo/eas-cli/pull/4290) by [@douglowder](https://github.com/douglowder))
-
-## [22.6.0](https://github.com/expo/eas-cli/releases/tag/v22.6.0) - 2026-08-26
-
-### 🎉 New features
-
- [eas-cli] Add an opt-in `--max-idle-time-minutes` flag to `eas simulator`; the session stops automatically after that many minutes without activity. ([#4156](https://github.com/expo/eas-cli/pull/4156) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-cli] Add experimental `--resource-class` flag to `eas simulator`. ([#4268](https://github.com/expo/eas-cli/pull/4268) by [@gwdp](https://github.com/gwdp))
- [build-tools] Add worker-side SSH session helpers (upterm relay + session create/report/close). ([#4030](https://github.com/expo/eas-cli/pull/4030) by [@gwdp](https://github.com/gwdp))
- [worker] Wire an SSH session into the build lifecycle behind the workflow ssh flag. ([#4031](https://github.com/expo/eas-cli/pull/4031) by [@gwdp](https://github.com/gwdp))
-
-### 🐛 Bug fixes
-
- [build-tools] Increase the serve-sim video bitrate to 6 Mbps for higher-quality simulator previews. ([#4291](https://github.com/expo/eas-cli/pull/4291) by [@szdziedzic](https://github.com/szdziedzic))
- [build-tools] Preapprove custom URL schemes before opening them in iOS Simulator sessions to avoid the first-use confirmation prompt. ([#4274](https://github.com/expo/eas-cli/pull/4274) by [@szdziedzic](https://github.com/szdziedzic))
-
-## [22.4.0](https://github.com/expo/eas-cli/releases/tag/v22.4.0) - 2026-08-24
-
-### 🎉 New features
-
- [eas-cli] Add `--launch-arg`, `--open-url`, and Expo Go `--sdk-version` options to `eas simulator`. ([#4264](https://github.com/expo/eas-cli/pull/4264) by [@szdziedzic](https://github.com/szdziedzic))
- [build-tools] Pass launch arguments and a URL to open when launching applications in simulator sessions. ([#4263](https://github.com/expo/eas-cli/pull/4263) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-cli] Add `eas billing:subscribe <plan>` to start a Stripe checkout for an EAS plan, and `eas billing:manage` to open the Stripe customer portal. ([#4007](https://github.com/expo/eas-cli/pull/4007) by [@jonsamp](https://github.com/jonsamp))
-
-### 🐛 Bug fixes
-
- [build-tools] Support downloading iOS simulator archives whose app bundle contents are stored at the archive root. ([#4262](https://github.com/expo/eas-cli/pull/4262) by [@szdziedzic](https://github.com/szdziedzic))
-
-## [22.3.0](https://github.com/expo/eas-cli/releases/tag/v22.3.0) - 2026-08-24
-
-### 🎉 New features
-
- [build-tools] Add `ios_signing_backend` option to the repack step. ([#4239](https://github.com/expo/eas-cli/pull/4239) by [@gabrieldonadel](https://github.com/gabrieldonadel))
- [build-tools] Support an optional `package_version` input on `eas/start_serve_sim_remote_session`, so a simulator session can pin the `@expo/serve-sim` version instead of always running `latest`. ([#4253](https://github.com/expo/eas-cli/pull/4253) by [@gwdp](https://github.com/gwdp))
- [build-tools] Add composable custom build functions for downloading, installing, and launching application archives in simulator sessions. ([#4222](https://github.com/expo/eas-cli/pull/4222) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-cli] Add `--build-id`, `--application-archive-url`, and `--expo-go` to `eas simulator` to install and launch an application before the session is ready. ([#4223](https://github.com/expo/eas-cli/pull/4223) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-cli] Add `--environment` flag to the `eas observe:*` commands. ([#4275](https://github.com/expo/eas-cli/pull/4275) by [@kadikraman](https://github.com/kadikraman))
- [eas-cli] Add `apple` value to the `--platform` flag of the `eas observe:*` commands. ([#4276](https://github.com/expo/eas-cli/pull/4276) by [@kadikraman](https://github.com/kadikraman))
- [eas-cli] Add `--build-number` flag to `eas observe:metrics` and `eas observe:events`. ([#4278](https://github.com/expo/eas-cli/pull/4278) by [@kadikraman](https://github.com/kadikraman))
-
-### 🐛 Bug fixes
-
- [build-tools] Upload tvOS (and other non-iOS) IPAs to the App Store Connect platform declared in the bundle's `DTPlatformName`, instead of always uploading to the iOS train. ([#4234](https://github.com/expo/eas-cli/pull/4234) by [@douglowder](https://github.com/douglowder))
-
-## [22.2.0](https://github.com/expo/eas-cli/releases/tag/v22.2.0) - 2026-08-20
-
-### 🎉 New features
-
- [eas-cli] Add `--device` flag to `eas simulator` for selecting the virtual device to start. ([#4172](https://github.com/expo/eas-cli/pull/4172) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-cli] Add support for Appium EAS Simulator sessions. ([#4190](https://github.com/expo/eas-cli/pull/4190) by [@sjchmiela](https://github.com/sjchmiela))
-
-### 🐛 Bug fixes
-
- [eas-cli] Disallow 0-length uploads. ([#4192](https://github.com/expo/eas-cli/pull/4192) by [@wschurman](https://github.com/wschurman))
- [eas-cli] Send the expected `Content-MD5` checksum with GCS signed URL uploads so GCS rejects corrupted uploads. ([#4208](https://github.com/expo/eas-cli/pull/4208) by [@wschurman](https://github.com/wschurman))
- [eas-cli] Resolve the `eas go` SDK version to its repack target, so `--sdk-version 57` no longer fails with "No Expo Go repack target is published for SDK 57". ([#4215](https://github.com/expo/eas-cli/pull/4215) by [@gwdp](https://github.com/gwdp))
- [eas-cli] Handle missing fingerprint source in fingerprint:compare command. ([#4210](https://github.com/expo/eas-cli/pull/4210) by [@wschurman](https://github.com/wschurman))
-
-### 🧹 Chores
-
- [eas-cli] Fix lint and enforce max-warnings=0. ([#4219](https://github.com/expo/eas-cli/pull/4219) by [@wschurman](https://github.com/wschurman))
- [build-tools] Rename serve-sim ngrok preview URLs to use the `web-preview` prefix. ([#4231](https://github.com/expo/eas-cli/pull/4231) by [@szdziedzic](https://github.com/szdziedzic))
-
-## [22.0.0](https://github.com/expo/eas-cli/releases/tag/v22.0.0) - 2026-08-14
-
-### 🛠 Breaking changes
-
- [eas-cli] Build objects in `--json` output (`eas build`, `eas build:list`, `eas build:view`, `eas build:resign`) now have `app`, `updateChannel` (object with `id` and `name`), and `runtime` (object with `id` and `version`) instead of `project`, `channel`, and `runtimeVersion`. `eas update:republish --json` output likewise has `runtime` instead of `runtimeVersion`. Other update commands' `--json` output and `eas-update-metadata.json` are unchanged. ([#4021](https://github.com/expo/eas-cli/pull/4021) by [@tchayen](https://github.com/tchayen))
-
-### 🎉 New features
-
 - [build-tools] Upload JavaScript source maps generated by builds. ([#4170](https://github.com/expo/eas-cli/pull/4170) by [@AbbanMustafa](https://github.com/AbbanMustafa))
 - [eas-cli] Set the project icon on the EAS dashboard from the app config when running `eas init`, if the project does not have one yet. ([#4177](https://github.com/expo/eas-cli/pull/4177) by [@tchayen](https://github.com/tchayen))

 ### 🐛 Bug fixes

- [eas-cli] Report EAS Simulator as available to Expo admins in `eas simulator:availability`, even when the project account's feature gate is disabled. ([#4181](https://github.com/expo/eas-cli/pull/4181) by [@szdziedzic](https://github.com/szdziedzic))
 - [eas-cli] Make the non-interactive "EAS project not configured" error actionable on every path: list the exact `eas init --id` / `eas init --account` commands and the accounts you can create projects in, instead of suggesting bare `eas init`, which fails the same way. ([#4153](https://github.com/expo/eas-cli/pull/4153) by [@williamgrosset](https://github.com/williamgrosset))
 - [eas-cli] Set up the internal TestFlight group and invite admin testers when submitting interactively with an existing `ascAppId`, with `--no-auto-testflight-setup` to disable it, and fix the TestFlight group URL printed when adding testers partially fails. ([#4136](https://github.com/expo/eas-cli/pull/4136) by [@tchayen](https://github.com/tchayen))

+### 🧹 Chores
+
 ## [21.8.0](https://github.com/expo/eas-cli/releases/tag/v21.8.0) - 2026-08-11

 ### 🎉 New features
@@ -254,7 +79,6 @@ This is the log of notable changes to EAS CLI and related packages.

 ### 🐛 Bug fixes

- [build-tools] Soft-stop EAS Simulator sessions before the backing job times out so cleanup can finish. ([#4117](https://github.com/expo/eas-cli/pull/4117) by [@sjchmiela](https://github.com/sjchmiela))
 - [eas-cli] clean up error handling in local builds. ([#4105](https://github.com/expo/eas-cli/pull/4105) by [@douglowder](https://github.com/douglowder))
 - [build-tools] Install ffmpeg when it is missing so Argent screen recording works in EAS Simulator sessions. ([#4110](https://github.com/expo/eas-cli/pull/4110) by [@szdziedzic](https://github.com/szdziedzic))
 - [eas-cli] Stop simulator job runs when `eas simulator:start` is canceled before the session is ready. ([#4113](https://github.com/expo/eas-cli/pull/4113) by [@sjchmiela](https://github.com/sjchmiela))
@@ -1,4 +1,4 @@
 {
-  "STAGING": "24.1.1",
-  "PRODUCTION": "24.1.1"
+  "STAGING": "21.8.0",
+  "PRODUCTION": "21.5.0"
 }
@@ -1,5 +1,5 @@
 {
  "npmClient": "yarn",
-  "version": "24.1.2",
+  "version": "21.8.0",
  "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }
@@ -12,7 +12,7 @@
    "watch": "yarn start",
    "eas": "packages/eas-cli/bin/run",
    "actionlint": "actionlint",
-    "lint": "oxlint --type-aware --import-plugin --max-warnings=0 --tsconfig ./tsconfig.oxlint.json .",
+    "lint": "oxlint --type-aware --import-plugin --tsconfig ./tsconfig.oxlint.json .",
    "fmt": "oxfmt .",
    "fmt:check": "oxfmt --check .",
    "lint-changelog": "./scripts/bin/run lint-changelog",
@@ -1,6 +1,6 @@
 {
  "name": "@expo/build-tools",
-  "version": "24.1.0",
+  "version": "21.8.0",
  "bugs": "https://github.com/expo/eas-cli/issues",
  "license": "BUSL-1.1",
  "author": "Expo <[email protected]>",
@@ -25,7 +25,6 @@
    "build": "tsc",
    "build:record-sim": "mkdir -p bin && record_sim_bin_path=$(swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build --show-bin-path) && swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build && cp \"$record_sim_bin_path/record-sim\" bin/record-sim && chmod +x bin/record-sim",
    "typecheck": "tsc",
-    "generate-appium-commands": "mise exec [email protected] -- node scripts/generate-appium-commands.js",
    "prepack": "rimraf dist \"*.tsbuildinfo\" && yarn gql && tsc -p tsconfig.build.json",
    "jest-unit": "jest --config jest/unit-config.ts",
    "jest-integration": "jest --config jest/integration-config.ts",
@@ -39,23 +38,22 @@
  "dependencies": {
    "@expo/config": "55.0.10",
    "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "24.0.0",
-    "@expo/eas-build-job": "24.0.0",
+    "@expo/downloader": "21.0.0",
+    "@expo/eas-build-job": "21.6.0",
    "@expo/env": "^0.4.0",
-    "@expo/logger": "24.0.0",
+    "@expo/logger": "21.0.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": "24.0.0",
-    "@expo/template-file": "24.0.0",
-    "@expo/turtle-spawn": "24.0.0",
+    "@expo/steps": "21.7.1",
+    "@expo/template-file": "21.0.2",
+    "@expo/turtle-spawn": "21.0.0",
    "@expo/xcpretty": "^4.3.1",
    "@ngrok/ngrok": "1.7.0",
    "@sentry/node": "7.77.0",
    "@urql/core": "^6.0.1",
    "bplist-parser": "0.3.2",
-    "content-disposition": "1.0.1",
    "fast-glob": "^3.3.2",
    "fast-xml-parser": "^4.4.1",
    "fs-extra": "^11.2.0",
@@ -79,8 +77,7 @@
    "zod": "^4.3.5"
  },
  "devDependencies": {
-    "@expo/repack-app": "~0.9.0",
-    "@types/content-disposition": "0.5.9",
+    "@expo/repack-app": "~0.6.1",
    "@types/fs-extra": "^11.0.4",
    "@types/jest": "^29.5.12",
    "@types/lodash": "^4.17.4",
@@ -92,6 +89,7 @@
    "@types/retry": "^0.12.5",
    "@types/semver": "^7.5.8",
    "@types/uuid": "^9.0.8",
+    "bunyan": "^1.8.15",
    "jest": "^29.7.0",
    "memfs": "^4.17.1",
    "nock": "13.4.0",
@@ -0,0 +1,296 @@
+#include <dlfcn.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * Xcode loads one plugin that implements the llcas_* API. This small shim loads
+ * Apple's local CAS plugin and forwards every API call to it. The only exception
+ * is the "remote-service-path" option: Xcode needs that option to schedule C and
+ * Objective-C cache tasks, but Apple's local plugin does not need a remote service.
+ * The shim accepts and discards that option. No cache data leaves the machine.
+ */
+
+typedef void *llcas_cas_options_t;
+typedef void *llcas_cas_t;
+typedef void *llcas_cancellable_t;
+typedef uint32_t llcas_lookup_result_t;
+
+typedef struct {
+  const uint8_t *data;
+  size_t size;
+} llcas_digest_t;
+
+typedef struct {
+  const void *data;
+  size_t size;
+} llcas_data_t;
+
+typedef struct {
+  uint64_t opaque;
+} llcas_objectid_t;
+
+typedef struct {
+  uint64_t opaque;
+} llcas_loaded_object_t;
+
+typedef struct {
+  uint64_t opaque_b;
+  uint64_t opaque_e;
+} llcas_object_refs_t;
+
+typedef void (*llcas_cas_load_object_cb)(void *, llcas_lookup_result_t,
+                                         llcas_loaded_object_t, char *);
+typedef void (*llcas_actioncache_get_cb)(void *, llcas_lookup_result_t,
+                                         llcas_objectid_t, char *);
+typedef void (*llcas_actioncache_put_cb)(void *, bool, char *);
+
+static void *apple_plugin_handle;
+
+static void *apple_plugin_symbol(const char *name) {
+  if (apple_plugin_handle == NULL) {
+    const char *path = getenv("EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN");
+    if (path == NULL || path[0] == '\0') {
+      path = "/Applications/Xcode.app/Contents/Developer/usr/lib/"
+             "libToolchainCASPlugin.dylib";
+    }
+    apple_plugin_handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+    if (apple_plugin_handle == NULL) {
+      fprintf(stderr, "EAS local CAS plugin could not load %s: %s\n", path,
+              dlerror());
+      abort();
+    }
+  }
+
+  void *symbol = dlsym(apple_plugin_handle, name);
+  if (symbol == NULL) {
+    fprintf(stderr, "EAS local CAS plugin could not find %s: %s\n", name,
+            dlerror());
+    abort();
+  }
+  return symbol;
+}
+
+#define APPLE_PLUGIN(name, type) ((type)apple_plugin_symbol(#name))
+
+void llcas_get_plugin_version(uint32_t *major, uint32_t *minor) {
+  typedef void (*fn_t)(uint32_t *, uint32_t *);
+  APPLE_PLUGIN(llcas_get_plugin_version, fn_t)(major, minor);
+}
+
+void llcas_string_dispose(char *value) {
+  typedef void (*fn_t)(char *);
+  APPLE_PLUGIN(llcas_string_dispose, fn_t)(value);
+}
+
+void llcas_cancellable_cancel(llcas_cancellable_t token) {
+  typedef void (*fn_t)(llcas_cancellable_t);
+  APPLE_PLUGIN(llcas_cancellable_cancel, fn_t)(token);
+}
+
+void llcas_cancellable_dispose(llcas_cancellable_t token) {
+  typedef void (*fn_t)(llcas_cancellable_t);
+  APPLE_PLUGIN(llcas_cancellable_dispose, fn_t)(token);
+}
+
+llcas_cas_options_t llcas_cas_options_create(void) {
+  typedef llcas_cas_options_t (*fn_t)(void);
+  return APPLE_PLUGIN(llcas_cas_options_create, fn_t)();
+}
+
+void llcas_cas_options_dispose(llcas_cas_options_t options) {
+  typedef void (*fn_t)(llcas_cas_options_t);
+  APPLE_PLUGIN(llcas_cas_options_dispose, fn_t)(options);
+}
+
+void llcas_cas_options_set_client_version(llcas_cas_options_t options,
+                                          uint32_t major, uint32_t minor) {
+  typedef void (*fn_t)(llcas_cas_options_t, uint32_t, uint32_t);
+  APPLE_PLUGIN(llcas_cas_options_set_client_version, fn_t)(options, major, minor);
+}
+
+void llcas_cas_options_set_ondisk_path(llcas_cas_options_t options,
+                                       const char *path) {
+  typedef void (*fn_t)(llcas_cas_options_t, const char *);
+  APPLE_PLUGIN(llcas_cas_options_set_ondisk_path, fn_t)(options, path);
+}
+
+bool llcas_cas_options_set_option(llcas_cas_options_t options, const char *name,
+                                  const char *value, char **error) {
+  if (name != NULL && strcmp(name, "remote-service-path") == 0) {
+    if (error != NULL) {
+      *error = NULL;
+    }
+    return false;
+  }
+  typedef bool (*fn_t)(llcas_cas_options_t, const char *, const char *,
+                       char **);
+  return APPLE_PLUGIN(llcas_cas_options_set_option, fn_t)(options, name, value,
+                                                          error);
+}
+
+llcas_cas_t llcas_cas_create(llcas_cas_options_t options, char **error) {
+  typedef llcas_cas_t (*fn_t)(llcas_cas_options_t, char **);
+  return APPLE_PLUGIN(llcas_cas_create, fn_t)(options, error);
+}
+
+void llcas_cas_dispose(llcas_cas_t cas) {
+  typedef void (*fn_t)(llcas_cas_t);
+  APPLE_PLUGIN(llcas_cas_dispose, fn_t)(cas);
+}
+
+int64_t llcas_cas_get_ondisk_size(llcas_cas_t cas, char **error) {
+  typedef int64_t (*fn_t)(llcas_cas_t, char **);
+  return APPLE_PLUGIN(llcas_cas_get_ondisk_size, fn_t)(cas, error);
+}
+
+bool llcas_cas_set_ondisk_size_limit(llcas_cas_t cas, int64_t size,
+                                     char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, int64_t, char **);
+  return APPLE_PLUGIN(llcas_cas_set_ondisk_size_limit, fn_t)(cas, size, error);
+}
+
+bool llcas_cas_prune_ondisk_data(llcas_cas_t cas, char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, char **);
+  return APPLE_PLUGIN(llcas_cas_prune_ondisk_data, fn_t)(cas, error);
+}
+
+char *llcas_cas_get_hash_schema_name(llcas_cas_t cas) {
+  typedef char *(*fn_t)(llcas_cas_t);
+  return APPLE_PLUGIN(llcas_cas_get_hash_schema_name, fn_t)(cas);
+}
+
+uint32_t llcas_digest_parse(llcas_cas_t cas, const char *printed,
+                            uint8_t *bytes, size_t bytes_size, char **error) {
+  typedef uint32_t (*fn_t)(llcas_cas_t, const char *, uint8_t *, size_t,
+                           char **);
+  return APPLE_PLUGIN(llcas_digest_parse, fn_t)(cas, printed, bytes,
+                                                bytes_size, error);
+}
+
+bool llcas_digest_print(llcas_cas_t cas, llcas_digest_t digest, char **printed,
+                        char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, llcas_digest_t, char **, char **);
+  return APPLE_PLUGIN(llcas_digest_print, fn_t)(cas, digest, printed, error);
+}
+
+bool llcas_cas_get_objectid(llcas_cas_t cas, llcas_digest_t digest,
+                            llcas_objectid_t *object, char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, llcas_digest_t, llcas_objectid_t *,
+                       char **);
+  return APPLE_PLUGIN(llcas_cas_get_objectid, fn_t)(cas, digest, object, error);
+}
+
+llcas_digest_t llcas_objectid_get_digest(llcas_cas_t cas,
+                                         llcas_objectid_t object) {
+  typedef llcas_digest_t (*fn_t)(llcas_cas_t, llcas_objectid_t);
+  return APPLE_PLUGIN(llcas_objectid_get_digest, fn_t)(cas, object);
+}
+
+llcas_lookup_result_t llcas_cas_contains_object(llcas_cas_t cas,
+                                                llcas_objectid_t object,
+                                                bool globally, char **error) {
+  typedef llcas_lookup_result_t (*fn_t)(llcas_cas_t, llcas_objectid_t, bool,
+                                        char **);
+  return APPLE_PLUGIN(llcas_cas_contains_object, fn_t)(cas, object, globally,
+                                                       error);
+}
+
+llcas_lookup_result_t llcas_cas_load_object(llcas_cas_t cas,
+                                            llcas_objectid_t object,
+                                            llcas_loaded_object_t *loaded,
+                                            char **error) {
+  typedef llcas_lookup_result_t (*fn_t)(llcas_cas_t, llcas_objectid_t,
+                                        llcas_loaded_object_t *, char **);
+  return APPLE_PLUGIN(llcas_cas_load_object, fn_t)(cas, object, loaded, error);
+}
+
+void llcas_cas_load_object_async(llcas_cas_t cas, llcas_objectid_t object,
+                                 void *context,
+                                 llcas_cas_load_object_cb callback,
+                                 llcas_cancellable_t *cancellable) {
+  typedef void (*fn_t)(llcas_cas_t, llcas_objectid_t, void *,
+                       llcas_cas_load_object_cb, llcas_cancellable_t *);
+  APPLE_PLUGIN(llcas_cas_load_object_async,
+               fn_t)(cas, object, context, callback, cancellable);
+}
+
+bool llcas_cas_store_object(llcas_cas_t cas, llcas_data_t data,
+                            const llcas_objectid_t *refs, size_t refs_count,
+                            llcas_objectid_t *stored, char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, llcas_data_t, const llcas_objectid_t *,
+                       size_t, llcas_objectid_t *, char **);
+  return APPLE_PLUGIN(llcas_cas_store_object,
+                      fn_t)(cas, data, refs, refs_count, stored, error);
+}
+
+llcas_data_t llcas_loaded_object_get_data(llcas_cas_t cas,
+                                          llcas_loaded_object_t object) {
+  typedef llcas_data_t (*fn_t)(llcas_cas_t, llcas_loaded_object_t);
+  return APPLE_PLUGIN(llcas_loaded_object_get_data, fn_t)(cas, object);
+}
+
+llcas_object_refs_t llcas_loaded_object_get_refs(llcas_cas_t cas,
+                                                 llcas_loaded_object_t object) {
+  typedef llcas_object_refs_t (*fn_t)(llcas_cas_t, llcas_loaded_object_t);
+  return APPLE_PLUGIN(llcas_loaded_object_get_refs, fn_t)(cas, object);
+}
+
+size_t llcas_object_refs_get_count(llcas_cas_t cas, llcas_object_refs_t refs) {
+  typedef size_t (*fn_t)(llcas_cas_t, llcas_object_refs_t);
+  return APPLE_PLUGIN(llcas_object_refs_get_count, fn_t)(cas, refs);
+}
+
+llcas_objectid_t llcas_object_refs_get_id(llcas_cas_t cas,
+                                          llcas_object_refs_t refs,
+                                          size_t index) {
+  typedef llcas_objectid_t (*fn_t)(llcas_cas_t, llcas_object_refs_t, size_t);
+  return APPLE_PLUGIN(llcas_object_refs_get_id, fn_t)(cas, refs, index);
+}
+
+llcas_lookup_result_t llcas_actioncache_get_for_digest(llcas_cas_t cas,
+                                                       llcas_digest_t digest,
+                                                       llcas_objectid_t *result,
+                                                       bool globally,
+                                                       char **error) {
+  typedef llcas_lookup_result_t (*fn_t)(llcas_cas_t, llcas_digest_t,
+                                        llcas_objectid_t *, bool, char **);
+  return APPLE_PLUGIN(llcas_actioncache_get_for_digest,
+                      fn_t)(cas, digest, result, globally, error);
+}
+
+void llcas_actioncache_get_for_digest_async(llcas_cas_t cas,
+                                            llcas_digest_t digest,
+                                            bool globally, void *context,
+                                            llcas_actioncache_get_cb callback,
+                                            llcas_cancellable_t *cancellable) {
+  typedef void (*fn_t)(llcas_cas_t, llcas_digest_t, bool, void *,
+                       llcas_actioncache_get_cb, llcas_cancellable_t *);
+  APPLE_PLUGIN(llcas_actioncache_get_for_digest_async,
+               fn_t)(cas, digest, globally, context, callback, cancellable);
+}
+
+bool llcas_actioncache_put_for_digest(llcas_cas_t cas, llcas_digest_t digest,
+                                      llcas_objectid_t value, bool globally,
+                                      char **error) {
+  typedef bool (*fn_t)(llcas_cas_t, llcas_digest_t, llcas_objectid_t, bool,
+                       char **);
+  return APPLE_PLUGIN(llcas_actioncache_put_for_digest,
+                      fn_t)(cas, digest, value, globally, error);
+}
+
+void llcas_actioncache_put_for_digest_async(llcas_cas_t cas,
+                                            llcas_digest_t digest,
+                                            llcas_objectid_t value,
+                                            bool globally, void *context,
+                                            llcas_actioncache_put_cb callback,
+                                            llcas_cancellable_t *cancellable) {
+  typedef void (*fn_t)(llcas_cas_t, llcas_digest_t, llcas_objectid_t, bool,
+                       void *, llcas_actioncache_put_cb, llcas_cancellable_t *);
+  APPLE_PLUGIN(llcas_actioncache_put_for_digest_async,
+               fn_t)(cas, digest, value, globally, context, callback,
+                     cancellable);
+}
@@ -1,130 +0,0 @@
-// Regenerates src/steps/utils/appiumCommands.generated.ts from Appium and the
-// XCUITest and UiAutomator2 drivers, so TypeScript can verify that we handle
-// every command that can appear in Appium event timings.
-//
-// Appium and its drivers are NOT dependencies of this package. Like repack, we
-// install them on demand into a temp directory just for this script, so nothing
-// heavy ships with @expo/build-tools.
-//
-// Run with: yarn workspace @expo/build-tools generate-appium-commands
-const { execFileSync } = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
-
-// Track the Appium 3 line, matching the appium@^3 the worker installs for
-// simulator sessions (see startAppiumRemoteSession.ts).
-const APPIUM_VERSION = '^3';
-const DRIVERS = [
-  {
-    packageName: 'appium-xcuitest-driver',
-    exportName: 'XCUITestDriver',
-    typeName: 'XCUITestAppiumCommand',
-  },
-  {
-    packageName: 'appium-uiautomator2-driver',
-    exportName: 'AndroidUiautomator2Driver',
-    typeName: 'UiAutomator2AppiumCommand',
-  },
-];
-
-function renderCommandType(typeName, commands) {
-  return `export type ${typeName} =\n${commands.map(command => `  | ${serializeStringLiteral(command)}`).join('\n')};`;
-}
-
-function serializeStringLiteral(value) {
-  const jsonContents = JSON.stringify(value).slice(1, -1).replaceAll('\\"', '"');
-  return `'${jsonContents.replaceAll("'", "\\'")}'`;
-}
-
-function readRouteCommands(methodMap) {
-  return Object.values(methodMap).flatMap(route =>
-    Object.values(route).map(method => method.command)
-  );
-}
-
-async function readDriverCommands({ packageName, exportName }, sandbox) {
-  const packageJsonPath = require.resolve(`${packageName}/package.json`, { paths: [sandbox] });
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  const modulePath = path.join(path.dirname(packageJsonPath), packageJson.exports['.'].import);
-  const driverModule = await import(pathToFileURL(modulePath).href);
-  const Driver = driverModule[exportName];
-  return [
-    ...readRouteCommands(Driver.newMethodMap),
-    ...Object.values(Driver.executeMethodMap).map(method => method.command),
-  ];
-}
-
-async function main() {
-  const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), 'appium-command-generator-'));
-  try {
-    fs.writeFileSync(
-      path.join(sandbox, 'package.json'),
-      `${JSON.stringify({ name: 'appium-command-generator-sandbox', private: true })}\n`
-    );
-    execFileSync(
-      'npm',
-      [
-        'install',
-        '--prefix',
-        sandbox,
-        `appium@${APPIUM_VERSION}`,
-        ...DRIVERS.map(({ packageName }) => packageName),
-      ],
-      { stdio: 'inherit' }
-    );
-
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { ALL_COMMANDS } = require(require.resolve('@appium/base-driver', { paths: [sandbox] }));
-    const baseDriverCommands = [...new Set(ALL_COMMANDS)].sort();
-    const baseDriverCommandSet = new Set(baseDriverCommands);
-    const driverCommands = await Promise.all(
-      DRIVERS.map(async driver => ({
-        typeName: driver.typeName,
-        commands: [...new Set(await readDriverCommands(driver, sandbox))]
-          .filter(command => !baseDriverCommandSet.has(command))
-          .sort(),
-      }))
-    );
-    const commands = [
-      ...new Set([...baseDriverCommands, ...driverCommands.flatMap(({ commands }) => commands)]),
-    ];
-
-    const outputPath = path.join(
-      __dirname,
-      '..',
-      'src',
-      'steps',
-      'utils',
-      'appiumCommands.generated.ts'
-    );
-    const contents = `// AUTO-GENERATED. Do not edit by hand.
-// Run \`yarn workspace @expo/build-tools generate-appium-commands\` to refresh this
-// list from Appium, XCUITest, and UiAutomator2 (installed on demand by the generator).
-${renderCommandType('BaseDriverAppiumCommand', baseDriverCommands)}
-
-${driverCommands
-  .map(({ typeName, commands: commandsForDriver }) =>
-    renderCommandType(typeName, commandsForDriver)
-  )
-  .join('\n\n')}
-
-export type AppiumCommand =
-  | BaseDriverAppiumCommand
-  | XCUITestAppiumCommand
-  | UiAutomator2AppiumCommand;
-`;
-    fs.writeFileSync(outputPath, contents);
-    // eslint-disable-next-line no-console
-    console.log(`Wrote ${commands.length} Appium commands to ${outputPath}`);
-  } finally {
-    fs.rmSync(sandbox, { recursive: true, force: true });
-  }
-}
-
-main().catch(error => {
-  // eslint-disable-next-line no-console
-  console.error(error);
-  process.exitCode = 1;
-});
@@ -1,4 +1,4 @@
-import type { bunyan } from '@expo/logger';
+import bunyan from 'bunyan';

 export function createLogger(): bunyan {
  const logger = {
@@ -11,19 +11,6 @@ jest.mock('../utils/stepMetrics');
 const mockUploadStepMetricsToWwwAsync = jest.mocked(uploadStepMetricsToWwwAsync);

 describe(CustomBuildContext, () => {
-  it('copies the MCP server URL from the build context', () => {
-    const ctx = new BuildContext(createTestIosJob(), {
-      env: { __API_SERVER_URL: 'http://api.expo.test' },
-      logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
-      logger: createMockLogger(),
-      uploadArtifact: jest.fn(),
-      workingdir: '',
-      mcpServerUrl: 'ws://localhost:8787',
-    });
-
-    expect(new CustomBuildContext(ctx).mcpServerUrl).toBe('ws://localhost:8787');
-  });
-
  it('should not lose workflowInterpolationContext', () => {
    const contextUploadArtifact = jest.fn();
    const ctx = new BuildContext(
@@ -4,11 +4,9 @@ import { BuildStepGlobalContext, StepsConfigParser } from '@expo/steps';
 import { runGenericJobAsync } from '../generic';
 import { CustomBuildContext } from '../customBuildContext';
 import { uploadJobOutputsToWwwAsync } from '../utils/outputs';
-import { stopLocalEgressResourcesAsync } from '../steps/utils/localEgress';

 jest.mock('../customBuildContext');
 jest.mock('../utils/outputs');
-jest.mock('../steps/utils/localEgress', () => ({ stopLocalEgressResourcesAsync: jest.fn() }));
 jest.mock('../common/projectSources');
 jest.mock('../steps/easFunctions', () => ({ getEasFunctions: jest.fn().mockReturnValue([]) }));
 jest.mock('../steps/easFunctionGroups', () => ({
@@ -60,25 +58,6 @@ describe(runGenericJobAsync, () => {
    mockUploadJobOutputsToWwwAsync.mockResolvedValue(undefined);
  });

-  it.each(['success', 'failure'])(
-    'releases local egress after workflow %s, before uploading outputs',
-    async outcome => {
-      const executeAsync =
-        outcome === 'success'
-          ? jest.fn().mockResolvedValue(undefined)
-          : jest.fn().mockRejectedValue(new Error(outcome));
-      (StepsConfigParser as unknown as jest.Mock).mockImplementation(() => ({
-        parseAsync: jest.fn().mockResolvedValue({ executeAsync }),
-      }));
-      const { runResult } = await runGenericJobAsync(mockCtx);
-      expect(runResult.ok).toBe(outcome === 'success');
-      expect(stopLocalEgressResourcesAsync).toHaveBeenCalledWith(mockCtx.logger);
-      expect(jest.mocked(stopLocalEgressResourcesAsync).mock.invocationCallOrder[0]).toBeLessThan(
-        mockUploadJobOutputsToWwwAsync.mock.invocationCallOrder[0]
-      );
-    }
-  );
-
  it('awaits drainPendingMetricUploads in COMPLETE_JOB phase', async () => {
    const mockWorkflow = { executeAsync: jest.fn().mockResolvedValue(undefined) };
    (StepsConfigParser as unknown as jest.Mock).mockImplementation(() => ({
@@ -98,7 +98,7 @@ async function buildInnerAsync(
    await restoreCcacheAsync({
      logger: ctx.logger,
      workingDirectory,
-      target: { platform: ctx.job.platform },
+      platform: ctx.job.platform,
      env: ctx.env,
      secrets: ctx.job.secrets,
    });
@@ -238,7 +238,7 @@ async function buildInnerAsync(
    await saveCcacheAsync({
      logger: ctx.logger,
      workingDirectory,
-      target: { platform: ctx.job.platform },
+      platform: ctx.job.platform,
      evictUsedBefore,
      env: ctx.env,
      secrets: ctx.job.secrets,
@@ -21,9 +21,9 @@ import { parseAndReportXcactivitylog } from '../steps/utils/ios/xcactivitylog';
 import {
  cacheStatsAsync,
  restoreCcacheAsync,
-  restoreCocoapodsCacheAsync,
+  restoreXcodeCompilationCacheAsync,
 } from '../steps/functions/restoreBuildCache';
-import { saveCcacheAsync, saveCocoapodsCacheAsync } from '../steps/functions/saveBuildCache';
+import { saveCcacheAsync, saveXcodeCompilationCacheAsync } from '../steps/functions/saveBuildCache';
 import { uploadApplicationArchive } from '../utils/artifacts';
 import {
  configureExpoUpdatesIfInstalledAsync,
@@ -104,19 +104,21 @@ async function buildInnerAsync(
        return;
      }
      await ctx.cacheManager?.restoreCache(ctx);
-      await restoreCcacheAsync({
-        logger: ctx.logger,
-        workingDirectory,
-        target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
-        env: ctx.env,
-        secrets: ctx.job.secrets,
-      });
-      await restoreCocoapodsCacheAsync({
-        logger: ctx.logger,
-        workingDirectory,
-        env: ctx.env,
-        secrets: ctx.job.secrets,
-      });
+      await Promise.all([
+        restoreCcacheAsync({
+          logger: ctx.logger,
+          workingDirectory,
+          platform: ctx.job.platform,
+          env: ctx.env,
+          secrets: ctx.job.secrets,
+        }),
+        restoreXcodeCompilationCacheAsync({
+          logger: ctx.logger,
+          workingDirectory,
+          env: ctx.env,
+          secrets: ctx.job.secrets,
+        }),
+      ]);
    });

    await ctx.runBuildPhase(BuildPhase.INSTALL_PODS, async () => {
@@ -252,20 +254,22 @@ async function buildInnerAsync(
      return;
    }
    await ctx.cacheManager?.saveCache(ctx);
-    await saveCcacheAsync({
-      logger: ctx.logger,
-      workingDirectory,
-      target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
-      evictUsedBefore,
-      env: ctx.env,
-      secrets: ctx.job.secrets,
-    });
-    await saveCocoapodsCacheAsync({
-      logger: ctx.logger,
-      workingDirectory,
-      env: ctx.env,
-      secrets: ctx.job.secrets,
-    });
+    await Promise.all([
+      saveCcacheAsync({
+        logger: ctx.logger,
+        workingDirectory,
+        platform: ctx.job.platform,
+        evictUsedBefore,
+        env: ctx.env,
+        secrets: ctx.job.secrets,
+      }),
+      saveXcodeCompilationCacheAsync({
+        logger: ctx.logger,
+        workingDirectory,
+        env: ctx.env,
+        secrets: ctx.job.secrets,
+      }),
+    ]);
  });

  await ctx.runBuildPhase(BuildPhase.CACHE_STATS, async () => {
@@ -70,48 +70,6 @@ describe('easBuildInternal', () => {
    expect(spawn).not.toHaveBeenCalled();
  });

-  it('overrides the minimum release age only for the internal config command', async () => {
-    const logger = {
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-      child: jest.fn(),
-    } as any;
-    const ctx = {
-      logger,
-      env: {
-        FOO: 'bar',
-        NPM_CONFIG_MIN_RELEASE_AGE: '365',
-      },
-      job: { platform: 'ios', buildProfile: 'production' },
-    } as any;
-    jest.mocked(resolveEasCommandPrefixAndEnvAsync).mockResolvedValueOnce({
-      cmd: 'npx',
-      args: ['-y', 'eas-cli@latest'],
-      extraEnv: { NPM_CONFIG_MIN_RELEASE_AGE: '0' },
-    });
-    jest.mocked(spawn).mockResolvedValueOnce({
-      stdout: Buffer.from(JSON.stringify({ buildProfile: { env: {} } })),
-    } as any);
-
-    await resolveEnvFromBuildProfileAsync(ctx, { cwd: '/tmp/project' });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'npx',
-      expect.any(Array),
-      expect.objectContaining({
-        env: {
-          FOO: 'bar',
-          NPM_CONFIG_MIN_RELEASE_AGE: '0',
-        },
-      })
-    );
-    expect(ctx.env).toEqual({
-      FOO: 'bar',
-      NPM_CONFIG_MIN_RELEASE_AGE: '365',
-    });
-  });
-
  it('passes --refresh-ad-hoc-provisioning-profile to build:internal for iOS jobs with refreshAdHocProvisioningProfile', async () => {
    const logger = {
      info: jest.fn(),
@@ -3,10 +3,7 @@ import spawn, { SpawnPromise, SpawnResult } from '@expo/turtle-spawn';
 import { createMockLogger } from '../../__tests__/utils/logger';
 import { Sentry } from '../../sentry';
 import { PackageManager } from '../../utils/packageManager';
-import {
-  installDependenciesAsync,
-  installDependenciesWithNpmCacheFallbackAsync,
-} from '../installDependencies';
+import { installDependenciesWithNpmCacheFallbackAsync } from '../installDependencies';

 jest.mock('@expo/turtle-spawn', () => jest.fn());
 jest.mock('../../sentry', () => ({
@@ -239,85 +236,6 @@ describe(installDependenciesWithNpmCacheFallbackAsync, () => {
  });
 });

-describe(installDependenciesAsync, () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.mocked(spawn).mockReturnValue(createSpawnPromise(Promise.resolve(createSpawnResult())));
-  });
-
-  it('installs only the selected workspace when EAS_PNPM_FILTER_WORKSPACE is set', async () => {
-    const logger = createMockLogger();
-
-    await installDependenciesAsync({
-      packageManager: PackageManager.PNPM,
-      env: { EAS_PNPM_FILTER_WORKSPACE: 'my-app' },
-      logger,
-      cwd: '/tmp/build',
-      useFrozenLockfile: true,
-    });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'pnpm',
-      ['install', '--filter', 'my-app', '--frozen-lockfile'],
-      expect.objectContaining({ cwd: '/tmp/build' })
-    );
-  });
-
-  it('installs all workspaces when EAS_PNPM_FILTER_WORKSPACE is not set', async () => {
-    const logger = createMockLogger();
-
-    await installDependenciesAsync({
-      packageManager: PackageManager.PNPM,
-      env: {},
-      logger,
-      cwd: '/tmp/build',
-      useFrozenLockfile: true,
-    });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'pnpm',
-      ['install', '--frozen-lockfile'],
-      expect.objectContaining({ cwd: '/tmp/build' })
-    );
-  });
-
-  it('installs only the selected workspace when EAS_BUN_FILTER_WORKSPACE is set', async () => {
-    const logger = createMockLogger();
-
-    await installDependenciesAsync({
-      packageManager: PackageManager.BUN,
-      env: { EAS_BUN_FILTER_WORKSPACE: 'my-app' },
-      logger,
-      cwd: '/tmp/build',
-      useFrozenLockfile: true,
-    });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'bun',
-      ['install', '--filter', 'my-app', '--frozen-lockfile'],
-      expect.objectContaining({ cwd: '/tmp/build' })
-    );
-  });
-
-  it('installs all workspaces when EAS_BUN_FILTER_WORKSPACE is not set', async () => {
-    const logger = createMockLogger();
-
-    await installDependenciesAsync({
-      packageManager: PackageManager.BUN,
-      env: {},
-      logger,
-      cwd: '/tmp/build',
-      useFrozenLockfile: true,
-    });
-
-    expect(spawn).toHaveBeenCalledWith(
-      'bun',
-      ['install', '--frozen-lockfile'],
-      expect.objectContaining({ cwd: '/tmp/build' })
-    );
-  });
-});
-
 function createSpawnPromise(result: Promise<SpawnResult>): SpawnPromise<SpawnResult> {
  return Object.assign(result, {
    child: {
@@ -2,13 +2,10 @@ import {
  ArchiveSourceType,
  BuildMode,
  BuildTrigger,
-  ErrorCode,
  Job,
  Platform,
-  SystemError,
  Workflow,
 } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
 import { randomBytes, randomUUID } from 'crypto';
 import { vol } from 'memfs';
 import fetch, { Response } from 'node-fetch';
@@ -17,7 +14,7 @@ import { setTimeout } from 'timers/promises';
 import { createMockLogger } from '../../__tests__/utils/logger';
 import { BuildContext } from '../../context';
 import { shallowCloneRepositoryAsync } from '../git';
-import { prepareProjectSourcesAsync, unpackTarGzAsync } from '../projectSources';
+import { prepareProjectSourcesAsync } from '../projectSources';

 jest.mock('@expo/turtle-spawn');
 jest.mock('node-fetch');
@@ -26,28 +23,7 @@ jest.mock('@expo/downloader');
 jest.mock('@urql/core');

 describe('projectSources', () => {
-  it('makes extracted project sources readable and writable by the worker', async () => {
-    const logger = createMockLogger();
-
-    await unpackTarGzAsync({
-      source: '/workingdir/project.tar.gz',
-      destination: '/workingdir/build',
-      logger,
-    });
-
-    expect(spawn).toHaveBeenNthCalledWith(
-      1,
-      'tar',
-      ['-C', '/workingdir/build', '--strip-components', '1', '-zxf', '/workingdir/project.tar.gz'],
-      { logger }
-    );
-    expect(spawn).toHaveBeenNthCalledWith(2, 'chmod', ['-R', 'u+rwX', '/workingdir/build'], {
-      logger,
-    });
-    expect(logger.info).toHaveBeenCalledWith('Normalizing project source permissions');
-  });
-
-  it.each([false, true])('uses the correct repository URL (local: %s)', async isLocal => {
+  it('should use the refreshed repository URL', async () => {
    const robotAccessToken = randomUUID();
    const buildId = randomUUID();
    await vol.promises.mkdir('/workingdir/environment-secrets/', { recursive: true });
@@ -78,7 +54,7 @@ describe('projectSources', () => {
          __API_SERVER_URL: 'https://api.expo.dev',
          EXPO_TOKEN: robotAccessToken,
          EAS_BUILD_ID: buildId,
-          EAS_BUILD_RUNNER: isLocal ? 'local-build-plugin' : 'eas-build',
+          EAS_BUILD_RUNNER: 'eas-build',
        },
        workingdir: '/workingdir',
        logger: createMockLogger(),
@@ -107,88 +83,108 @@ describe('projectSources', () => {
      expect.objectContaining({
        archiveSource: {
          ...ctx.job.projectArchive,
-          repositoryUrl: isLocal
-            ? 'https://x-access-token:[email protected]/expo/eas-cli.git'
-            : 'https://x-access-token:[email protected]/expo/eas-cli.git',
+          repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
        },
      })
    );
-    if (isLocal) {
-      expect(fetchMock).not.toHaveBeenCalled();
-    }
  });

-  it.each(['http', 'network', 'json', 'schema'])(
-    'throws a system error if refresh fails (%s)',
-    async failure => {
-      const robotAccessToken = randomUUID();
-      const buildId = randomUUID();
-      await vol.promises.mkdir('/workingdir/environment-secrets/', { recursive: true });
+  it('should fallback to the original repository URL if the refresh fails', async () => {
+    const robotAccessToken = randomUUID();
+    const buildId = randomUUID();
+    await vol.promises.mkdir('/workingdir/environment-secrets/', { recursive: true });

-      const ctx = new BuildContext(
-        {
-          triggeredBy: BuildTrigger.GIT_BASED_INTEGRATION,
-          type: Workflow.MANAGED,
-          mode: BuildMode.BUILD,
-          initiatingUserId: randomUUID(),
-          appId: randomUUID(),
-          projectArchive: {
-            type: ArchiveSourceType.GIT,
-            repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
-            gitRef: 'refs/heads/main',
-            gitCommitHash: randomBytes(20).toString('hex'),
-          },
-          platform: Platform.IOS,
-          secrets: {
-            robotAccessToken,
-            environmentSecrets: [],
-          },
-        } as Job,
-        {
-          env: {
-            __API_SERVER_URL: 'https://api.expo.dev',
-            EXPO_TOKEN: robotAccessToken,
-            EAS_BUILD_ID: buildId,
-            EAS_BUILD_RUNNER: 'eas-build',
-          },
-          workingdir: '/workingdir',
-          logger: createMockLogger(),
-          logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
-          uploadArtifact: jest.fn(),
-        }
-      );
-      const fetchMock = jest.mocked(fetch);
-      const cause = new Error('Source request failed');
-      fetchMock.mockImplementation(async () => {
-        if (failure === 'network') {
-          throw cause;
-        }
-        return {
-          ok: failure !== 'http',
-          status: failure === 'http' ? 500 : 200,
-          json: async () => {
-            if (failure === 'json') {
-              throw cause;
-            }
-            return { data: { repository_url: 'https://github.com/expo/eas-cli.git' } };
-          },
-        } as Response;
-      });
-
-      const result = prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
-      await expect(result).rejects.toBeInstanceOf(SystemError);
-      await expect(result).rejects.toMatchObject({
-        errorCode: ErrorCode.SERVER_ERROR,
-        cause: expect.any(Error),
-      });
-      if (failure === 'network') {
-        await expect(result).rejects.toMatchObject({ cause });
+    const ctx = new BuildContext(
+      {
+        triggeredBy: BuildTrigger.GIT_BASED_INTEGRATION,
+        type: Workflow.MANAGED,
+        mode: BuildMode.BUILD,
+        initiatingUserId: randomUUID(),
+        appId: randomUUID(),
+        projectArchive: {
+          type: ArchiveSourceType.GIT,
+          repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
+          gitRef: 'refs/heads/main',
+          gitCommitHash: randomBytes(20).toString('hex'),
+        },
+        platform: Platform.IOS,
+        secrets: {
+          robotAccessToken,
+          environmentSecrets: [],
+        },
+      } as Job,
+      {
+        env: {
+          __API_SERVER_URL: 'https://api.expo.dev',
+          EXPO_TOKEN: robotAccessToken,
+          EAS_BUILD_ID: buildId,
+          EAS_BUILD_RUNNER: 'eas-build',
+        },
+        workingdir: '/workingdir',
+        logger: createMockLogger(),
+        logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
+        uploadArtifact: jest.fn(),
      }
-      expect(shallowCloneRepositoryAsync).not.toHaveBeenCalled();
-      expect(spawn).not.toHaveBeenCalled();
-    },
-    15_000
-  );
+    );
+    const fetchMock = jest.mocked(fetch);
+    fetchMock.mockImplementation(
+      async () =>
+        ({
+          ok: false,
+          text: async () => 'Failed to generate repository URL',
+        }) as Response
+    );
+
+    await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
+    expect(shallowCloneRepositoryAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        archiveSource: {
+          ...ctx.job.projectArchive,
+          repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
+        },
+      })
+    );
+    fetchMock.mockImplementation(
+      async () =>
+        ({
+          ok: false,
+          json: async () => ({
+            // repositoryUrl is the right key
+            repository_url: 'https://x-access-token:[email protected]/expo/eas-cli.git',
+          }),
+        }) as Response
+    );
+
+    await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
+    expect(shallowCloneRepositoryAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        archiveSource: {
+          ...ctx.job.projectArchive,
+          repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
+        },
+      })
+    );
+
+    fetchMock.mockImplementation(
+      async () =>
+        ({
+          ok: false,
+          json: () => Promise.reject(new Error('Failed to generate repository URL')),
+        }) as Response
+    );
+
+    await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
+    expect(shallowCloneRepositoryAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        archiveSource: {
+          ...ctx.job.projectArchive,
+          repositoryUrl: 'https://x-access-token:[email protected]/expo/eas-cli.git',
+        },
+      })
+    );
+
+    expect(shallowCloneRepositoryAsync).toHaveBeenCalledTimes(3);
+  }, 15_000);

  it('should retry fetching the repository URL', async () => {
    const robotAccessToken = randomUUID();
@@ -263,7 +259,7 @@ describe('projectSources', () => {
    );
  }, 15_000);

-  it(`throws a system error if refresh configuration is missing`, async () => {
+  it(`should fallback to the original repository URL if we're missing some config`, async () => {
    const robotAccessToken = randomUUID();
    await vol.promises.mkdir('/workingdir/environment-secrets/', { recursive: true });
    const logger = createMockLogger();
@@ -301,11 +297,12 @@ describe('projectSources', () => {
      }
    );

-    await expect(prepareProjectSourcesAsync(ctx, ctx.buildDirectory)).rejects.toMatchObject({
-      errorCode: ErrorCode.SERVER_ERROR,
-      cause: new Error('EAS_BUILD_ID is not set'),
-    });
-    expect(shallowCloneRepositoryAsync).not.toHaveBeenCalled();
+    await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
+
+    expect(logger.error).toHaveBeenCalledWith(
+      { err: expect.any(Error) },
+      'Failed to refresh project archive, falling back to the original one'
+    );
  });

  describe('uploadProjectMetadataAsFireAndForget', () => {
@@ -385,10 +382,6 @@ describe('projectSources', () => {

      const fetchMock = jest.mocked(fetch);
      fetchMock.mockImplementation(async () => ({ ok: true }) as Response);
-      fetchMock.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ data: ctx.job.projectArchive }),
-      } as Response);

      // Call prepareProjectSourcesAsync and don't await metadata upload
      await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
@@ -502,10 +495,6 @@ describe('projectSources', () => {

      const fetchMock = jest.mocked(fetch);
      fetchMock.mockResolvedValue({ ok: true } as Response);
-      fetchMock.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ data: ctx.job.projectArchive }),
-      } as Response);

      const startTime = Date.now();
      await prepareProjectSourcesAsync(ctx, ctx.buildDirectory);
@@ -570,10 +559,6 @@ describe('projectSources', () => {

      const fetchMock = jest.mocked(fetch);
      fetchMock.mockResolvedValue({ ok: true } as Response);
-      fetchMock.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ data: ctx.job.projectArchive }),
-      } as Response);

      // Should not throw even though upload will fail
      await expect(prepareProjectSourcesAsync(ctx, ctx.buildDirectory)).resolves.not.toThrow();
@@ -32,11 +32,7 @@ export async function installDependenciesAsync({
      break;
    }
    case PackageManager.PNPM: {
-      args = [
-        'install',
-        ...(env['EAS_PNPM_FILTER_WORKSPACE'] ? ['--filter', env['EAS_PNPM_FILTER_WORKSPACE']] : []),
-        useFrozenLockfile ? '--frozen-lockfile' : '--no-frozen-lockfile',
-      ];
+      args = ['install', useFrozenLockfile ? '--frozen-lockfile' : '--no-frozen-lockfile'];
      break;
    }
    case PackageManager.YARN: {
@@ -62,11 +58,7 @@ export async function installDependenciesAsync({
      break;
    }
    case PackageManager.BUN:
-      args = [
-        'install',
-        ...(env['EAS_BUN_FILTER_WORKSPACE'] ? ['--filter', env['EAS_BUN_FILTER_WORKSPACE']] : []),
-        ...(useFrozenLockfile ? ['--frozen-lockfile'] : []),
-      ];
+      args = ['install', ...(useFrozenLockfile ? ['--frozen-lockfile'] : [])];
      break;
    default:
      throw new Error(`Unsupported package manager: ${packageManager}`);
@@ -1,11 +1,5 @@
 import downloadFile from '@expo/downloader';
-import {
-  ArchiveSource,
-  ArchiveSourceSchemaZ,
-  ArchiveSourceType,
-  Job,
-  SystemError,
-} from '@expo/eas-build-job';
+import { ArchiveSource, ArchiveSourceSchemaZ, ArchiveSourceType, Job } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { asyncResult } from '@expo/results';
 import spawn from '@expo/turtle-spawn';
@@ -32,12 +26,13 @@ Promise<{ handled: boolean }> {
    const projectArchiveResult = await asyncResult(fetchProjectArchiveSourceAsync(ctx));

    if (!projectArchiveResult.ok) {
-      throw new SystemError('Failed to fetch project sources. Re-run the job.', {
-        cause: projectArchiveResult.reason,
-      });
+      ctx.logger.error(
+        { err: projectArchiveResult.reason },
+        'Failed to refresh project archive, falling back to the original one'
+      );
    }

-    projectArchive = projectArchiveResult.value;
+    projectArchive = projectArchiveResult.value ?? ctx.job.projectArchive;
  }

  switch (projectArchive.type) {
@@ -115,7 +110,7 @@ async function prepareProjectSourcesLocallyAsync<TJob extends Job>(
  });
 }

-export async function unpackTarGzAsync({
+async function unpackTarGzAsync({
  logger,
  source,
  destination,
@@ -127,8 +122,6 @@ export async function unpackTarGzAsync({
  await spawn('tar', ['-C', destination, '--strip-components', '1', '-zxf', source], {
    logger,
  });
-  logger.info('Normalizing project source permissions');
-  await spawn('chmod', ['-R', 'u+rwX', destination], { logger });
 }

 function uploadProjectMetadataAsFireAndForget(
@@ -68,7 +68,6 @@ export interface BuildContextOptions {
  skipNativeBuild?: boolean;
  metadata?: Metadata;
  expoApiV2BaseUrl?: string;
-  mcpServerUrl?: string;
 }

 export class SkipNativeBuildError extends Error {}
@@ -85,7 +84,6 @@ export class BuildContext<TJob extends Job = Job> {
  ) => void;
  public readonly skipNativeBuild?: boolean;
  public readonly expoApiV2BaseUrl?: string;
-  public readonly mcpServerUrl?: string;
  public artifacts: Artifacts = {};

  private readonly _isLocal: boolean;
@@ -114,7 +112,6 @@ export class BuildContext<TJob extends Job = Job> {
    this._metadata = options.metadata;
    this.skipNativeBuild = options.skipNativeBuild;
    this.expoApiV2BaseUrl = options.expoApiV2BaseUrl;
-    this.mcpServerUrl = options.mcpServerUrl;

    const environmentSecrets = this.getEnvironmentSecrets(job);
    this._env = {
@@ -63,7 +63,6 @@ export class CustomBuildContext<TJob extends Job = Job> implements ExternalBuild
  public readonly logger: bunyan;
  public readonly graphqlClient: Client;
  public readonly runtimeApi: BuilderRuntimeApi;
-  public readonly mcpServerUrl?: string;
  public job: TJob;
  public metadata?: Metadata;

@@ -85,7 +84,6 @@ export class CustomBuildContext<TJob extends Job = Job> implements ExternalBuild
    this.runtimeApi = {
      uploadArtifact: (...args) => buildCtx['uploadArtifact'](...args),
    };
-    this.mcpServerUrl = buildCtx.mcpServerUrl;
    this.expoApiV2BaseUrl = buildCtx.expoApiV2BaseUrl;
    this.startTime = new Date();
  }
@@ -16,7 +16,6 @@ import { BuildContext } from './context';
 import { CustomBuildContext } from './customBuildContext';
 import { getEasFunctionGroups } from './steps/easFunctionGroups';
 import { getEasFunctions } from './steps/easFunctions';
-import { stopLocalEgressResourcesAsync } from './steps/utils/localEgress';
 import { uploadJobOutputsToWwwAsync } from './utils/outputs';
 import { retryAsync } from './utils/retry';

@@ -83,17 +82,7 @@ export async function runGenericJobAsync(
    }
  });

-  const runResult = await asyncResult(
-    (async () => {
-      try {
-        await workflow.executeAsync();
-      } finally {
-        // The session-owning step may never run if simulator boot/setup fails,
-        // or may time out while resource acquisition is still in flight.
-        await stopLocalEgressResourcesAsync(ctx.logger);
-      }
-    })()
-  );
+  const runResult = await asyncResult(workflow.executeAsync());

  await ctx.runBuildPhase(BuildPhase.COMPLETE_JOB, async () => {
    const results = await Promise.allSettled([
@@ -5,8 +5,6 @@ import RemoteLoggerStream from './logging/RemoteLoggerStream';
 export { Builders, HttpLogStream, RemoteLoggerStream };
 export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
 export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
-export { downloadCacheAsync } from './steps/functions/restoreCache';
-export { uploadCacheAsync } from './steps/functions/saveCache';

 export {
  ArtifactToUpload,
@@ -20,9 +18,6 @@ export {

 export { PackageManager } from './utils/packageManager';

-export * as TurtleSshSession from './utils/turtleSshSession';
-export { formatSecondsForLog } from './utils/formatDuration';
-
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';

 export { Hook, runHookIfPresent } from './utils/hooks';
@@ -0,0 +1,161 @@
+import spawn from '@expo/turtle-spawn';
+import { vol } from 'memfs';
+import os from 'os';
+import path from 'path';
+
+import { createMockLogger } from '../../__tests__/utils/logger';
+import {
+  XCODE_COMPILATION_CACHE_ENV,
+  XCODE_COMPILATION_CACHE_RELATIVE_PATH,
+  compressXcodeCompilationCacheAsync,
+  decompressXcodeCompilationCacheAsync,
+  prepareXcodeCompilationCacheEnvAsync,
+} from '../compilationCache';
+
+jest.mock('@expo/turtle-spawn', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+const DEVELOPER_DIRECTORY = '/Applications/Xcode.app/Contents/Developer';
+const APPLE_PLUGIN_PATH = path.join(DEVELOPER_DIRECTORY, 'usr/lib/libToolchainCASPlugin.dylib');
+const BUNDLED_SHIM_PATH = path.resolve(
+  __dirname,
+  '../../../bin/libeas_xcode_local_cas_plugin.dylib'
+);
+
+describe(prepareXcodeCompilationCacheEnvAsync, () => {
+  test('does nothing without the explicit opt-in', async () => {
+    const result = await prepareXcodeCompilationCacheEnvAsync({
+      derivedDataPath: '/project/ios/build',
+      env: {},
+      logger: createMockLogger(),
+    });
+
+    expect(result).toEqual({});
+    expect(spawn).not.toHaveBeenCalled();
+  });
+
+  test('enables compilation caching after validating the bundled arm64 shim', async () => {
+    vol.fromJSON({
+      [BUNDLED_SHIM_PATH]: 'bundled shim',
+      [APPLE_PLUGIN_PATH]: 'Apple plugin',
+    });
+    vol.mkdirSync(os.tmpdir(), { recursive: true });
+    jest.mocked(spawn).mockResolvedValue({} as any);
+
+    const result = await prepareXcodeCompilationCacheEnvAsync({
+      derivedDataPath: '/project/ios/build',
+      env: {
+        [XCODE_COMPILATION_CACHE_ENV]: '1',
+        DEVELOPER_DIR: DEVELOPER_DIRECTORY,
+      },
+      logger: createMockLogger(),
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'xcrun',
+      expect.arrayContaining([
+        'llvm-cas',
+        `--fcas-plugin-path=${BUNDLED_SHIM_PATH}`,
+        '--fcas-plugin-option=remote-service-path=/dev/null',
+        '--ingest',
+        BUNDLED_SHIM_PATH,
+      ]),
+      expect.objectContaining({
+        env: expect.objectContaining({
+          EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN: APPLE_PLUGIN_PATH,
+        }),
+      })
+    );
+    expect(result).toEqual({
+      EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN: APPLE_PLUGIN_PATH,
+      GYM_XCARGS: `COMPILATION_CACHE_ENABLE_CACHING=YES COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS=YES COMPILATION_CACHE_ENABLE_PLUGIN=YES COMPILATION_CACHE_PLUGIN_PATH=${BUNDLED_SHIM_PATH} COMPILATION_CACHE_REMOTE_SERVICE_PATH=/dev/null`,
+      GYM_DERIVED_DATA_PATH: '/project/ios/build',
+    });
+  });
+
+  test('does not enable compilation caching when the bundled shim is missing', async () => {
+    const logger = createMockLogger();
+    vol.fromJSON({
+      [APPLE_PLUGIN_PATH]: 'Apple plugin',
+    });
+
+    const result = await prepareXcodeCompilationCacheEnvAsync({
+      derivedDataPath: '/project/ios/build',
+      env: {
+        [XCODE_COMPILATION_CACHE_ENV]: '1',
+        DEVELOPER_DIR: DEVELOPER_DIRECTORY,
+      },
+      logger,
+    });
+
+    expect(spawn).not.toHaveBeenCalled();
+    expect(result).toEqual({});
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.objectContaining({ err: expect.any(Error) }),
+      expect.stringContaining('compilation caching is disabled')
+    );
+  });
+
+  test('does not enable compilation caching when the bundled shim is incompatible', async () => {
+    const logger = createMockLogger();
+    vol.fromJSON({
+      [BUNDLED_SHIM_PATH]: 'bundled shim',
+      [APPLE_PLUGIN_PATH]: 'Apple plugin',
+    });
+    vol.mkdirSync(os.tmpdir(), { recursive: true });
+    jest.mocked(spawn).mockRejectedValue(new Error('incompatible plugin'));
+
+    const result = await prepareXcodeCompilationCacheEnvAsync({
+      derivedDataPath: '/project/ios/build',
+      env: {
+        [XCODE_COMPILATION_CACHE_ENV]: '1',
+        DEVELOPER_DIR: DEVELOPER_DIRECTORY,
+      },
+      logger,
+    });
+
+    expect(result).toEqual({});
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.objectContaining({ err: expect.any(Error) }),
+      expect.stringContaining('compilation caching is disabled')
+    );
+  });
+});
+
+describe('Xcode compilation cache archives', () => {
+  test('uses system tar to preserve sparse files', async () => {
+    const workingDirectory = '/working-directory';
+    vol.fromJSON({
+      [path.join(workingDirectory, XCODE_COMPILATION_CACHE_RELATIVE_PATH, 'cache.db')]: 'cache',
+    });
+    vol.mkdirSync(os.tmpdir(), { recursive: true });
+    jest.mocked(spawn).mockResolvedValue({} as any);
+
+    const { archivePath } = await compressXcodeCompilationCacheAsync({
+      workingDirectory,
+      env: {},
+      logger: createMockLogger(),
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'tar',
+      ['-czf', archivePath, '-C', workingDirectory, XCODE_COMPILATION_CACHE_RELATIVE_PATH],
+      expect.any(Object)
+    );
+
+    await decompressXcodeCompilationCacheAsync({
+      archivePath,
+      workingDirectory,
+      env: {},
+      logger: createMockLogger(),
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'tar',
+      ['-xzSf', archivePath, '-C', workingDirectory],
+      expect.any(Object)
+    );
+  });
+});
@@ -6,6 +6,7 @@ import path from 'path';
 import { createTestIosJob } from '../../__tests__/utils/job';
 import { createMockLogger } from '../../__tests__/utils/logger';
 import { BuildContext } from '../../context';
+import * as CompilationCache from '../compilationCache';
 import { Credentials } from '../credentials/manager';
 import { DistributionType } from '../credentials/provisioningProfile';
 import { runFastlaneGym } from '../fastlane';
@@ -23,13 +24,19 @@ const WORKING_DIR = '/workingdir';
 // BuildContext.getReactNativeProjectDirectory() nests the RN project under `${workingdir}/build`.
 const IOS_DIR = path.join(WORKING_DIR, 'build', 'ios');

-function makeIosBuildContext({ simulator }: { simulator: boolean }): BuildContext<Ios.Job> {
+function makeIosBuildContext({
+  simulator,
+  env = {},
+}: {
+  simulator: boolean;
+  env?: Record<string, string>;
+}): BuildContext<Ios.Job> {
  const job: Ios.Job = { ...createTestIosJob(), simulator };
  return new BuildContext(job, {
    workingdir: WORKING_DIR,
    logger: createMockLogger(),
    logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
-    env: { __API_SERVER_URL: 'http://api.expo.test' },
+    env: { __API_SERVER_URL: 'http://api.expo.test', ...env },
    uploadArtifact: jest.fn(),
  });
 }
@@ -71,6 +78,10 @@ describe(runFastlaneGym, () => {
    (spawn as jest.Mock).mockClear();
  });

+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
  describe.each([
    {
      name: 'archive',
@@ -125,4 +136,68 @@ describe(runFastlaneGym, () => {
      workspacePath: IOS_DIR,
    });
  });
+
+  it('enables local Swift, C, and Objective-C compilation caching', async () => {
+    jest.spyOn(CompilationCache, 'prepareXcodeCompilationCacheEnvAsync').mockResolvedValue({
+      GYM_XCARGS:
+        'OTHER_SWIFT_FLAGS=-warnings-as-errors COMPILATION_CACHE_ENABLE_CACHING=YES COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS=YES COMPILATION_CACHE_ENABLE_PLUGIN=YES COMPILATION_CACHE_PLUGIN_PATH=/workingdir/bin/libeas_xcode_local_cas_plugin.dylib COMPILATION_CACHE_REMOTE_SERVICE_PATH=/dev/null',
+      EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN:
+        '/Applications/Xcode.app/Contents/Developer/usr/lib/libToolchainCASPlugin.dylib',
+      GYM_DERIVED_DATA_PATH: path.join(IOS_DIR, 'build'),
+    });
+    const ctx = makeIosBuildContext({
+      simulator: false,
+      env: {
+        EAS_BUILD_XCODE_COMPILATION_CACHE: '1',
+        GYM_XCARGS: 'OTHER_SWIFT_FLAGS=-warnings-as-errors',
+      },
+    });
+
+    await runFastlaneGym(ctx, {
+      scheme: 'App',
+      credentials: ARCHIVE_CREDENTIALS,
+      entitlements: null,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'fastlane',
+      ['gym'],
+      expect.objectContaining({
+        env: expect.objectContaining({
+          GYM_XCARGS:
+            'OTHER_SWIFT_FLAGS=-warnings-as-errors COMPILATION_CACHE_ENABLE_CACHING=YES COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS=YES COMPILATION_CACHE_ENABLE_PLUGIN=YES COMPILATION_CACHE_PLUGIN_PATH=/workingdir/bin/libeas_xcode_local_cas_plugin.dylib COMPILATION_CACHE_REMOTE_SERVICE_PATH=/dev/null',
+          EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN:
+            '/Applications/Xcode.app/Contents/Developer/usr/lib/libToolchainCASPlugin.dylib',
+          GYM_DERIVED_DATA_PATH: path.join(IOS_DIR, 'build'),
+        }),
+      })
+    );
+  });
+
+  it('does not enable compilation caching when the local plugin cannot be prepared', async () => {
+    const ctx = makeIosBuildContext({
+      simulator: false,
+      env: {
+        EAS_BUILD_XCODE_COMPILATION_CACHE: '1',
+      },
+    });
+
+    await runFastlaneGym(ctx, {
+      scheme: 'App',
+      credentials: ARCHIVE_CREDENTIALS,
+      entitlements: null,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'fastlane',
+      ['gym'],
+      expect.objectContaining({
+        env: expect.not.objectContaining({ GYM_XCARGS: expect.any(String) }),
+      })
+    );
+    expect(ctx.logger.warn).toHaveBeenCalledWith(
+      expect.objectContaining({ err: expect.any(Error) }),
+      expect.stringContaining('compilation caching is disabled')
+    );
+  });
 });
@@ -1,46 +0,0 @@
-import { SystemError } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
-
-import { getXcodeVersionAsync } from '../xcode';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-const mockedSpawn = jest.mocked(spawn);
-
-describe(getXcodeVersionAsync, () => {
-  it('returns the Xcode version', async () => {
-    mockedSpawn.mockResolvedValue({
-      stdout: 'Xcode 26.0\nBuild version 17A324\n',
-    } as any);
-
-    await expect(getXcodeVersionAsync({ env: process.env })).resolves.toBe('26.0');
-    expect(mockedSpawn).toHaveBeenCalledWith('xcodebuild', ['-version'], {
-      stdio: 'pipe',
-      env: process.env,
-    });
-  });
-
-  it('throws when the Xcode version cannot be parsed', async () => {
-    mockedSpawn.mockResolvedValue({ stdout: 'unexpected output' } as any);
-
-    await expect(getXcodeVersionAsync({ env: process.env })).rejects.toThrow(
-      'Failed to determine Xcode version'
-    );
-  });
-
-  it('wraps errors from xcodebuild in a SystemError', async () => {
-    const cause = new Error('xcode-select: error: invalid developer directory');
-    mockedSpawn.mockRejectedValue(cause);
-
-    const promise = getXcodeVersionAsync({ env: process.env });
-
-    await expect(promise).rejects.toBeInstanceOf(SystemError);
-    await expect(promise).rejects.toMatchObject({
-      message: 'Failed to get Xcode version',
-      cause,
-    });
-  });
-});
@@ -0,0 +1,194 @@
+import { Env, Platform } from '@expo/eas-build-job';
+import { bunyan } from '@expo/logger';
+import spawn from '@expo/turtle-spawn';
+import { createHash } from 'crypto';
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+
+import { CACHE_KEY_PREFIX_BY_PLATFORM, generateDefaultBuildCacheKeyAsync } from '../utils/cacheKey';
+
+export const XCODE_COMPILATION_CACHE_ENV = 'EAS_BUILD_XCODE_COMPILATION_CACHE';
+export const XCODE_COMPILATION_CACHE_RELATIVE_PATH = 'ios/build/CompilationCache.noindex';
+
+export function getXcodeCompilationCachePath(derivedDataPath: string): string {
+  return path.join(derivedDataPath, 'CompilationCache.noindex');
+}
+
+async function prepareXcodeLocalCompilationCachePluginAsync({
+  env,
+  logger,
+}: {
+  env: Env;
+  logger: bunyan;
+}): Promise<{ pluginPath: string; applePluginPath: string }> {
+  const bundledPluginPath = path.resolve(
+    __dirname,
+    '../../bin/libeas_xcode_local_cas_plugin.dylib'
+  );
+  const developerDirectory =
+    env.DEVELOPER_DIR ??
+    (
+      await spawn('xcode-select', ['--print-path'], {
+        env,
+        logger,
+      })
+    ).stdout.trim();
+  const applePluginPath = path.join(
+    developerDirectory,
+    'usr',
+    'lib',
+    'libToolchainCASPlugin.dylib'
+  );
+
+  if (!(await fs.pathExists(applePluginPath))) {
+    throw new Error(`The Xcode CAS plugin is missing at ${applePluginPath}.`);
+  }
+  if (!(await fs.pathExists(bundledPluginPath))) {
+    throw new Error(`The EAS local CAS plugin is missing at ${bundledPluginPath}.`);
+  }
+
+  const validationDirectory = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'eas-xcode-local-cache-validation-')
+  );
+  try {
+    await spawn(
+      'xcrun',
+      [
+        'llvm-cas',
+        `--fcas-plugin-path=${bundledPluginPath}`,
+        '--fcas-plugin-option=remote-service-path=/dev/null',
+        `--cas=${path.join(validationDirectory, 'cas')}`,
+        '--ingest',
+        bundledPluginPath,
+      ],
+      {
+        env: { ...env, EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN: applePluginPath },
+        logger,
+      }
+    );
+  } finally {
+    await fs.remove(validationDirectory);
+  }
+
+  return { pluginPath: bundledPluginPath, applePluginPath };
+}
+
+export async function compressXcodeCompilationCacheAsync({
+  workingDirectory,
+  env,
+  logger,
+}: {
+  workingDirectory: string;
+  env: Env;
+  logger: bunyan;
+}): Promise<{ archivePath: string }> {
+  const cachePath = path.join(workingDirectory, XCODE_COMPILATION_CACHE_RELATIVE_PATH);
+  if (!(await fs.pathExists(cachePath))) {
+    throw new Error(`The Xcode compilation cache does not exist at ${cachePath}.`);
+  }
+
+  const archiveDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'xcode-compilation-cache-'));
+  const archivePath = path.join(archiveDirectory, 'cache.tar.gz');
+  await spawn(
+    'tar',
+    ['-czf', archivePath, '-C', workingDirectory, XCODE_COMPILATION_CACHE_RELATIVE_PATH],
+    { env, logger }
+  );
+  return { archivePath };
+}
+
+export async function decompressXcodeCompilationCacheAsync({
+  archivePath,
+  workingDirectory,
+  env,
+  logger,
+}: {
+  archivePath: string;
+  workingDirectory: string;
+  env: Env;
+  logger: bunyan;
+}): Promise<void> {
+  await fs.ensureDir(workingDirectory);
+  await spawn('tar', ['-xzSf', archivePath, '-C', workingDirectory], { env, logger });
+}
+
+export async function generateXcodeCompilationCacheKeyAsync({
+  workingDirectory,
+  env,
+  logger,
+}: {
+  workingDirectory: string;
+  env: Env;
+  logger: bunyan;
+}): Promise<{ key: string; keyPrefix: string; xcodeVersion: string }> {
+  const xcodeVersion = (
+    await spawn('xcodebuild', ['-version'], {
+      env,
+      logger,
+    })
+  ).stdout.trim();
+  const xcodeVersionHash = createHash('sha256').update(xcodeVersion).digest('hex').slice(0, 16);
+  const ccacheKey = await generateDefaultBuildCacheKeyAsync(workingDirectory, Platform.IOS);
+  const dependencyHash = ccacheKey.slice(CACHE_KEY_PREFIX_BY_PLATFORM[Platform.IOS].length);
+  const keyPrefix = `ios-xcode-compilation-cache-${xcodeVersionHash}-`;
+
+  return {
+    key: `${keyPrefix}${dependencyHash}`,
+    keyPrefix,
+    xcodeVersion: xcodeVersion.replace(/\s+/g, ' '),
+  };
+}
+
+export async function prepareXcodeCompilationCacheEnvAsync({
+  derivedDataPath,
+  env,
+  logger,
+}: {
+  derivedDataPath: string;
+  env: Env;
+  logger: bunyan;
+}): Promise<Env> {
+  if (env[XCODE_COMPILATION_CACHE_ENV] !== '1') {
+    return {};
+  }
+
+  let plugin: { pluginPath: string; applePluginPath: string };
+  try {
+    plugin = await prepareXcodeLocalCompilationCachePluginAsync({
+      env,
+      logger,
+    });
+    logger.info(`The EAS local Xcode CAS plugin is ready at ${plugin.pluginPath}.`);
+  } catch (error: any) {
+    logger.warn(
+      { err: error },
+      'The EAS local Xcode CAS plugin is missing or incompatible. Xcode compilation caching is disabled.'
+    );
+    return {};
+  }
+  logger.info(
+    `Xcode compilation caching is enabled. The cache directory is ${getXcodeCompilationCachePath(derivedDataPath)}.`
+  );
+
+  const pluginXcargs = [
+    'COMPILATION_CACHE_ENABLE_PLUGIN=YES',
+    `COMPILATION_CACHE_PLUGIN_PATH=${plugin.pluginPath}`,
+    // A non-empty remote service path makes Xcode schedule C, Objective-C,
+    // precompiled-module, and precompiled-header cache tasks. The EAS plugin
+    // consumes this option and never opens the path or performs remote I/O.
+    'COMPILATION_CACHE_REMOTE_SERVICE_PATH=/dev/null',
+  ].join(' ');
+
+  return {
+    GYM_XCARGS: [
+      env.GYM_XCARGS,
+      'COMPILATION_CACHE_ENABLE_CACHING=YES COMPILATION_CACHE_ENABLE_DIAGNOSTIC_REMARKS=YES',
+      pluginXcargs,
+    ]
+      .filter(Boolean)
+      .join(' '),
+    GYM_DERIVED_DATA_PATH: derivedDataPath,
+    EAS_XCODE_LOCAL_CAS_APPLE_PLUGIN: plugin.applePluginPath,
+  };
+}
@@ -7,6 +7,7 @@ import os from 'os';
 import path from 'path';

 import type { Credentials } from './credentials/manager';
+import * as CompilationCache from './compilationCache';
 import { createFastfileForResigningBuild } from './fastfile';
 import { createGymfileForArchiveBuild, createGymfileForSimulatorBuild } from './gymfile';
 import { isTVOS } from './tvos';
@@ -46,13 +47,18 @@ export async function runFastlaneGym<TJob extends Ios.Job>(
  if (ctx.skipNativeBuild) {
    throw new SkipNativeBuildError('Skipping fastlane build');
  }
+  const compilationCacheEnv = await CompilationCache.prepareXcodeCompilationCacheEnvAsync({
+    derivedDataPath,
+    env: ctx.env,
+    logger: ctx.logger,
+  });
  const buildLogger = new XcodeBuildLogger(ctx.logger, ctx.getReactNativeProjectDirectory());
  void buildLogger.watchLogFiles(ctx.buildLogsDirectory);
  try {
    await runFastlane(['gym'], {
      cwd: workspacePath,
      logger: ctx.logger,
-      env: { ...ctx.env, ...extraEnv },
+      env: { ...ctx.env, ...extraEnv, ...compilationCacheEnv },
    });
  } finally {
    await buildLogger.flush();
@@ -1,16 +0,0 @@
-import { SystemError } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
-
-export async function getXcodeVersionAsync({ env }: { env: NodeJS.ProcessEnv }): Promise<string> {
-  let stdout: string;
-  try {
-    ({ stdout } = await spawn('xcodebuild', ['-version'], { stdio: 'pipe', env }));
-  } catch (error) {
-    throw new SystemError('Failed to get Xcode version', { cause: error });
-  }
-  const version = /^Xcode\s+(\d+(?:\.\d+)*)$/m.exec(stdout)?.[1];
-  if (!version) {
-    throw new SystemError(`Failed to determine Xcode version from: ${stdout.trim()}`);
-  }
-  return version;
-}
@@ -19,10 +19,8 @@ import { generateGymfileFromTemplateFunction } from './functions/generateGymfile
 import { createGetCredentialsForBuildTriggeredByGithubIntegration } from './functions/getCredentialsForBuildTriggeredByGitHubIntegration';
 import { injectAndroidCredentialsFunction } from './functions/injectAndroidCredentials';
 import { createInstallMaestroBuildFunction } from './functions/installMaestro';
-import { createInstallBuildFunction } from './functions/installBuild';
 import { createInstallNodeModulesBuildFunction } from './functions/installNodeModules';
 import { createInstallPodsBuildFunction } from './functions/installPods';
-import { createLaunchApplicationFunction } from './functions/launchApplication';
 import { createPrebuildBuildFunction } from './functions/prebuild';
 import { createReadAppConfigBuildFunction } from './functions/readAppConfig';
 import { createReadIpaInfoBuildFunction } from './functions/readIpaInfo';
@@ -47,12 +45,10 @@ import { createSendSlackMessageFunction } from './functions/sendSlackMessage';
 import { createStartAgentDeviceRemoteSessionBuildFunction } from './functions/startAgentDeviceRemoteSession';
 import { createStartAndroidEmulatorBuildFunction } from './functions/startAndroidEmulator';
 import { createStartArgentRemoteSessionBuildFunction } from './functions/startArgentRemoteSession';
-import { createStartAppiumRemoteSessionBuildFunction } from './functions/startAppiumRemoteSession';
 import { createStartCuttlefishDeviceBuildFunction } from './functions/startCuttlefishDevice';
 import { createStartIosSimulatorBuildFunction } from './functions/startIosSimulator';
 import { createStartIosSimulatorRecordingsBuildFunction } from './functions/startIosSimulatorRecordings';
-import { createStartLocalEgressBuildFunction } from './functions/startLocalEgress';
-import { createStartWebPreviewRemoteSessionBuildFunction } from './functions/startWebPreviewRemoteSession';
+import { createStartServeSimRemoteSessionBuildFunction } from './functions/startServeSimRemoteSession';
 import { createStartServeSimMetricsBuildFunction } from './functions/startServeSimMetrics';
 import { createCollectServeSimMetricsBuildFunction } from './functions/collectServeSimMetrics';
 import { createUploadArtifactBuildFunction } from './functions/uploadArtifact';
@@ -77,8 +73,6 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
    createPrebuildBuildFunction(),
    createReadIpaInfoBuildFunction(),
    createDownloadBuildFunction(ctx),
-    createInstallBuildFunction(),
-    createLaunchApplicationFunction(),
    createEasExportBuildFunction(),
    createEasDeployBuildFunction(),
    createRepackBuildFunction(),
@@ -100,15 +94,13 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
    parseXcactivitylogFunction(),
    createStartAgentDeviceRemoteSessionBuildFunction(ctx),
    createStartArgentRemoteSessionBuildFunction(ctx),
-    createStartAppiumRemoteSessionBuildFunction(ctx),
    createStartAndroidEmulatorBuildFunction(),
    createStartCuttlefishDeviceBuildFunction(),
    createStartIosSimulatorBuildFunction(),
-    createStartLocalEgressBuildFunction(),
    createStartIosSimulatorRecordingsBuildFunction(),
    createFinishIosSimulatorRecordingsBuildFunction(),
    createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx),
-    createStartWebPreviewRemoteSessionBuildFunction(ctx),
+    createStartServeSimRemoteSessionBuildFunction(ctx),
    createStartServeSimMetricsBuildFunction(),
    createCollectServeSimMetricsBuildFunction(ctx),
    createInstallMaestroBuildFunction(),
@@ -162,28 +162,6 @@ describe(createEasBuildBuildFunctionGroup, () => {
      expect(installPodsStep!.ctx.relativeWorkingDirectory).toBe('./ios');
    });

-    it('restores and saves caches around an iOS simulator build', () => {
-      const buildToolsContext = createMockBuildToolsContext({
-        platform: Platform.IOS,
-        simulator: true,
-      });
-      const functionGroup = createEasBuildBuildFunctionGroup(buildToolsContext);
-      const globalCtx = createGlobalContextMock({ logger: createMockLogger() });
-
-      const steps = functionGroup.createBuildStepsFromFunctionGroupCall(globalCtx);
-      const stepNames = steps.map(step => step.displayName);
-      const restoreCacheIndex = stepNames.indexOf('Restore Cache');
-      const installPodsIndex = stepNames.indexOf('Install Pods');
-      const saveCacheIndex = stepNames.indexOf('Save Cache');
-
-      expect(restoreCacheIndex).toBeGreaterThan(-1);
-      expect(restoreCacheIndex).toBeLessThan(installPodsIndex);
-      expect(saveCacheIndex).toBeGreaterThan(installPodsIndex);
-
-      const restoreCacheStep = steps[restoreCacheIndex];
-      expect(restoreCacheStep.inputs?.find(input => input.id === 'simulator')?.rawValue).toBe(true);
-    });
-
    it('sets working directory on all steps except checkout (Android with credentials)', () => {
      const buildToolsContext = createMockBuildToolsContext({
        platform: Platform.ANDROID,
@@ -98,8 +98,6 @@ function createStepsForIosSimulatorBuild({
  buildToolsContext,
  workingDirectory,
 }: HelperFunctionsInput): BuildStep[] {
-  const evictUsedBefore = new Date();
-
  const calculateEASUpdateRuntimeVersion =
    calculateEASUpdateRuntimeVersionFunction().createBuildStepFromFunctionCall(globalCtx, {
      id: 'calculate_eas_update_runtime_version',
@@ -108,16 +106,6 @@ function createStepsForIosSimulatorBuild({
  const installPods = createInstallPodsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
    workingDirectory: workingDirectory ? path.join(workingDirectory, './ios') : './ios',
  });
-  const restoreCache = createRestoreBuildCacheFunction().createBuildStepFromFunctionCall(
-    globalCtx,
-    {
-      workingDirectory,
-      callInputs: {
-        platform: Platform.IOS,
-        simulator: true,
-      },
-    }
-  );
  const configureEASUpdate =
    configureEASUpdateIfInstalledFunction().createBuildStepFromFunctionCall(globalCtx, {
      workingDirectory,
@@ -135,16 +123,6 @@ function createStepsForIosSimulatorBuild({
        '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
    },
  });
-  const saveCache = createSaveBuildCacheFunction(evictUsedBefore).createBuildStepFromFunctionCall(
-    globalCtx,
-    {
-      workingDirectory,
-      callInputs: {
-        platform: Platform.IOS,
-        simulator: true,
-      },
-    }
-  );
  return [
    createCheckoutBuildFunction().createBuildStepFromFunctionCall(globalCtx),
    createSetUpNpmrcBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
@@ -160,7 +138,6 @@ function createStepsForIosSimulatorBuild({
    createPrebuildBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
      workingDirectory,
    }),
-    restoreCache,
    calculateEASUpdateRuntimeVersion,
    installPods,
    configureEASUpdate,
@@ -182,10 +159,6 @@ function createStepsForIosSimulatorBuild({
    createFindAndUploadBuildArtifactsBuildFunction(
      buildToolsContext
    ).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
-    saveCache,
-    createCacheStatsBuildFunction().createBuildStepFromFunctionCall(globalCtx, {
-      workingDirectory,
-    }),
  ];
 }

@@ -1,6 +1,6 @@
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { createMockLogger } from '../../../__tests__/utils/logger';
-import { createInstallMaestroBuildFunction, installIdbFromBrew } from '../installMaestro';
+import { createInstallMaestroBuildFunction } from '../installMaestro';

 jest.unmock('fs');
 jest.unmock('@expo/logger');
@@ -57,14 +57,3 @@ describe('createInstallMaestroBuildFunction', () => {
    console.log(latestStep.outputs[0].value);
  }, 180_000);
 });
-
-describe('installIdbFromBrew', () => {
-  it('installs 1.1.8 version', async () => {
-    const logger = createMockLogger({ logToConsole: true });
-
-    await installIdbFromBrew({
-      logger,
-      env: process.env,
-    });
-  });
-});
@@ -1,136 +0,0 @@
-import { spawnAsync } from '@expo/steps';
-import { vol } from 'memfs';
-
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { Datadog } from '../../../datadog';
-import {
-  compressCocoapodsCacheAsync,
-  getCocoapodsCachePaths,
-  resolveCocoapodsCacheKeyAsync,
-  restoreCocoapodsCacheArchiveAsync,
-} from '../../../utils/cocoapodsCache';
-import { downloadCacheAsync } from '../restoreCache';
-import { restoreCocoapodsCacheAsync } from '../restoreBuildCache';
-import { uploadCacheAsync } from '../saveCache';
-import { saveCocoapodsCacheAsync } from '../saveBuildCache';
-
-jest.mock('@expo/steps', () => ({
-  ...jest.requireActual('@expo/steps'),
-  spawnAsync: jest.fn(),
-}));
-jest.mock('../restoreCache', () => ({
-  decompressCacheAsync: jest.fn(),
-  downloadCacheAsync: jest.fn(),
-  downloadPublicCacheAsync: jest.fn(),
-}));
-jest.mock('../saveCache', () => ({
-  compressCacheAsync: jest.fn(),
-  uploadCacheAsync: jest.fn(),
-}));
-jest.mock('../../../utils/cocoapodsCache', () => ({
-  compressCocoapodsCacheAsync: jest.fn(),
-  getCocoapodsCachePaths: jest.fn(),
-  resolveCocoapodsCacheKeyAsync: jest.fn(),
-  restoreCocoapodsCacheArchiveAsync: jest.fn(),
-}));
-
-const logger = createMockLogger();
-const env = {
-  EAS_PODS_CACHE: '1',
-  EAS_BUILD_ID: 'build-id',
-  __API_SERVER_URL: 'https://api.expo.test',
-};
-const secrets = { robotAccessToken: 'robot-token' };
-
-describe('CocoaPods build cache', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    vol.fromJSON(
-      {
-        '/workingdir/ios/Pods/Manifest.lock': 'manifest',
-        '/workingdir/ios/Podfile.lock': 'lockfile',
-        '/tmp/cocoapods-cache.tar.gz': 'archive',
-      },
-      '/'
-    );
-    jest.mocked(getCocoapodsCachePaths).mockReturnValue({
-      iosDirectory: '/workingdir/ios',
-      podsDirectory: '/workingdir/ios/Pods',
-      podfileLockPath: '/workingdir/ios/Podfile.lock',
-    });
-    jest.mocked(resolveCocoapodsCacheKeyAsync).mockResolvedValue({
-      key: 'ios-pods-1.16.2-lock-hash',
-      keyPrefix: 'ios-pods-1.16.2-',
-    });
-    jest.mocked(spawnAsync).mockResolvedValue({ stdout: '1.16.2\n' } as any);
-  });
-
-  it('does nothing when the cache is disabled', async () => {
-    await restoreCocoapodsCacheAsync({
-      logger,
-      workingDirectory: '/workingdir',
-      env: {},
-      secrets,
-    });
-    await saveCocoapodsCacheAsync({
-      logger,
-      workingDirectory: '/workingdir',
-      env: {},
-      secrets,
-    });
-
-    expect(spawnAsync).not.toHaveBeenCalled();
-  });
-
-  it('restores the newest matching CocoaPods cache', async () => {
-    jest.mocked(downloadCacheAsync).mockResolvedValue({
-      archivePath: '/tmp/cocoapods-cache.tar.gz',
-      matchedKey: 'ios-pods-1.16.2-older-lock-hash',
-    });
-    const datadogLogSpy = jest.spyOn(Datadog, 'log');
-
-    await restoreCocoapodsCacheAsync({
-      logger,
-      workingDirectory: '/workingdir',
-      env,
-      secrets,
-    });
-
-    expect(downloadCacheAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        key: 'ios-pods-1.16.2-lock-hash',
-        keyPrefixes: ['ios-pods-1.16.2-'],
-        paths: ['/workingdir/ios/Pods'],
-      })
-    );
-    expect(restoreCocoapodsCacheArchiveAsync).toHaveBeenCalledWith({
-      archivePath: '/tmp/cocoapods-cache.tar.gz',
-      workingDirectory: '/workingdir',
-    });
-    expect(datadogLogSpy).toHaveBeenCalledWith('CocoaPods cache restored (prefix_match)', {
-      event: 'cocoapods_cache_restored',
-      cache_hit_type: 'prefix_match',
-    });
-  });
-
-  it('compresses and saves the installed Pods directory', async () => {
-    jest.mocked(compressCocoapodsCacheAsync).mockResolvedValue({
-      archivePath: '/tmp/cocoapods-cache.tar.gz',
-    });
-
-    await saveCocoapodsCacheAsync({
-      logger,
-      workingDirectory: '/workingdir',
-      env,
-      secrets,
-    });
-
-    expect(uploadCacheAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        archivePath: '/tmp/cocoapods-cache.tar.gz',
-        key: 'ios-pods-1.16.2-lock-hash',
-        paths: ['/workingdir/ios/Pods'],
-      })
-    );
-  });
-});
@@ -4,10 +4,8 @@ import { Client, CombinedError } from '@urql/core';
 import fetch, { Response } from 'node-fetch';
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { Readable } from 'node:stream';
-import * as tar from 'tar';

 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { createMockLogger } from '../../../__tests__/utils/logger';
@@ -21,9 +19,6 @@ const APP_TAR_GZ_BUFFER = Buffer.from(
  'base64'
 );

-const FLAT_APP_INFO_PLIST_BASE64 =
-  'YnBsaXN0MDDSAQIDBF8QEkNGQnVuZGxlRXhlY3V0YWJsZV8QE0NGQnVuZGxlUGFja2FnZVR5cGVXVGVzdEFwcFRBUFBMCA0iOEAAAAAAAAABAQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAARQ==';
-
 const APPLICATION_ARCHIVE_URL = `https://expo.dev/artifacts/eas/${randomUUID()}.tar.gz`;

 function createMockGraphqlClient({
@@ -56,57 +51,6 @@ function createMockGraphqlClient({
  } as unknown as Client;
 }

-function createSuccessfulResponse({
-  body,
-  url,
-  headers,
-}: {
-  body: Buffer;
-  url: string;
-  headers?: Record<string, string>;
-}): Response {
-  const normalizedHeaders = Object.fromEntries(
-    Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value])
-  );
-
-  return {
-    ok: true,
-    body: Readable.from(body),
-    url,
-    headers: {
-      get: (name: string): string | null => normalizedHeaders[name.toLowerCase()] ?? null,
-    },
-  } as unknown as Response;
-}
-
-async function createFlatAppTarGzBufferAsync(): Promise<Buffer> {
-  const sourceDirectory = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'flat-app-source-'));
-  const archivePath = path.join(os.tmpdir(), `${randomUUID()}.tar.gz`);
-
-  try {
-    await Promise.all([
-      fs.promises.writeFile(path.join(sourceDirectory, 'Info.plist'), FLAT_APP_INFO_PLIST_BASE64, {
-        encoding: 'base64',
-      }),
-      fs.promises.writeFile(path.join(sourceDirectory, 'TestApp'), 'i am executable\n'),
-    ]);
-    await tar.create(
-      {
-        cwd: sourceDirectory,
-        file: archivePath,
-        gzip: true,
-      },
-      ['Info.plist', 'TestApp']
-    );
-    return await fs.promises.readFile(archivePath);
-  } finally {
-    await Promise.all([
-      fs.promises.rm(sourceDirectory, { recursive: true, force: true }),
-      fs.promises.rm(archivePath, { force: true }),
-    ]);
-  }
-}
-
 describe('downloadBuild', () => {
  it('downloads from applicationArchiveUrl returned by GraphQL', async () => {
    const buildId = randomUUID();
@@ -114,12 +58,11 @@ describe('downloadBuild', () => {
      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
    });

-    jest.mocked(fetch).mockResolvedValue(
-      createSuccessfulResponse({
-        body: APP_TAR_GZ_BUFFER,
-        url: APPLICATION_ARCHIVE_URL,
-      })
-    );
+    jest.mocked(fetch).mockResolvedValue({
+      ok: true,
+      body: Readable.from(APP_TAR_GZ_BUFFER),
+      url: APPLICATION_ARCHIVE_URL,
+    } as unknown as Response);

    const { artifactPath } = await downloadBuildAsync({
      logger: createLogger({ name: 'test' }),
@@ -139,39 +82,17 @@ describe('downloadBuild', () => {
    );
  });

-  it('downloads an archive containing app bundle contents at its root', async () => {
-    jest.mocked(fetch).mockResolvedValue(
-      createSuccessfulResponse({
-        body: await createFlatAppTarGzBufferAsync(),
-        url: APPLICATION_ARCHIVE_URL,
-      })
-    );
-
-    const { artifactPath } = await downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-      graphqlClient: createMockGraphqlClient({}),
-      robotAccessToken: null,
-      extensions: ['app'],
-    });
-
-    expect(path.extname(artifactPath)).toBe('.app');
-    expect(await fs.promises.readFile(path.join(artifactPath, 'TestApp'), 'utf8')).toBe(
-      'i am executable\n'
-    );
-  });
-
  it('should handle a straight-up file', async () => {
    const applicationArchiveUrl = `https://expo.dev/artifacts/eas/${randomUUID()}.apk`;
    const graphqlClient = createMockGraphqlClient({
      applicationArchiveUrl,
    });

-    jest
-      .mocked(fetch)
-      .mockResolvedValue(
-        createSuccessfulResponse({ body: Buffer.from('hello'), url: applicationArchiveUrl })
-      );
+    jest.mocked(fetch).mockResolvedValue({
+      ok: true,
+      body: Readable.from(Buffer.from('hello')),
+      url: applicationArchiveUrl,
+    } as unknown as Response);

    const { artifactPath } = await downloadBuildAsync({
      logger: createLogger({ name: 'test' }),
@@ -185,128 +106,6 @@ describe('downloadBuild', () => {
    expect(await fs.promises.readFile(artifactPath, 'utf-8')).toBe('hello');
  });

-  it('downloads a direct application archive URL without querying GraphQL or forwarding the EAS token', async () => {
-    const applicationArchiveUrl = `https://artifacts.example.test/${randomUUID()}.apk`;
-    const graphqlClient = createMockGraphqlClient({
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-    });
-
-    jest
-      .mocked(fetch)
-      .mockResolvedValue(
-        createSuccessfulResponse({ body: Buffer.from('hello'), url: applicationArchiveUrl })
-      );
-
-    const { artifactPath } = await downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl,
-      graphqlClient,
-      robotAccessToken: 'scoped-eas-token',
-      extensions: ['apk'],
-    });
-
-    expect(graphqlClient.query).not.toHaveBeenCalled();
-    expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-      applicationArchiveUrl,
-      expect.objectContaining({ headers: undefined })
-    );
-    expect(await fs.promises.readFile(artifactPath, 'utf-8')).toBe('hello');
-  });
-
-  it('uses the Content-Disposition filename for an extensionless URL', async () => {
-    const applicationArchiveUrl = 'https://artifacts.example.test/download';
-    jest.mocked(fetch).mockResolvedValue(
-      createSuccessfulResponse({
-        body: Buffer.from('hello'),
-        url: applicationArchiveUrl,
-        headers: { 'content-disposition': 'attachment; filename="app.apk"' },
-      })
-    );
-
-    const { artifactPath } = await downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl,
-      graphqlClient: createMockGraphqlClient({}),
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-
-    expect(path.basename(artifactPath)).toBe('app.apk');
-    expect(await fs.promises.readFile(artifactPath, 'utf-8')).toBe('hello');
-  });
-
-  it('uses the expected extension when the URL has no filename', async () => {
-    const applicationArchiveUrl = 'https://artifacts.example.test/';
-    jest
-      .mocked(fetch)
-      .mockResolvedValue(
-        createSuccessfulResponse({ body: Buffer.from('hello'), url: applicationArchiveUrl })
-      );
-
-    const { artifactPath } = await downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl,
-      graphqlClient: createMockGraphqlClient({}),
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-
-    expect(path.basename(artifactPath)).toBe('application.apk');
-    expect(await fs.promises.readFile(artifactPath, 'utf-8')).toBe('hello');
-  });
-
-  it('rejects missing or ambiguous build sources', async () => {
-    const graphqlClient = createMockGraphqlClient({
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-    });
-
-    await expect(
-      // @ts-expect-error Verify the runtime guard for callers without TypeScript.
-      downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        graphqlClient,
-        robotAccessToken: null,
-        extensions: ['app'],
-      })
-    ).rejects.toMatchObject({
-      errorCode: 'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-      message: 'Pass buildId or applicationArchiveUrl.',
-    });
-
-    await expect(
-      // @ts-expect-error Verify the runtime guard for callers without TypeScript.
-      downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        buildId: randomUUID(),
-        applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-        graphqlClient,
-        robotAccessToken: null,
-        extensions: ['app'],
-      })
-    ).rejects.toMatchObject({
-      errorCode: 'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-      message: 'Pass only one of buildId or applicationArchiveUrl.',
-    });
-
-    expect(graphqlClient.query).not.toHaveBeenCalled();
-    expect(jest.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('rejects a non-HTTP application archive URL', async () => {
-    await expect(
-      downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        applicationArchiveUrl: 'file:///tmp/app.apk',
-        graphqlClient: createMockGraphqlClient({}),
-        robotAccessToken: null,
-        extensions: ['apk'],
-      })
-    ).rejects.toMatchObject({
-      errorCode: 'EAS_DOWNLOAD_BUILD_INVALID_APPLICATION_ARCHIVE_URL',
-      message: 'application_archive_url must be a valid HTTP or HTTPS URL.',
-    });
-  });
-
  it('throws UserError when the build has no application archive url', async () => {
    const graphqlClient = createMockGraphqlClient({ applicationArchiveUrl: null });

@@ -404,12 +203,11 @@ describe('downloadBuild', () => {
      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
    });

-    jest.mocked(fetch).mockResolvedValue(
-      createSuccessfulResponse({
-        body: APP_TAR_GZ_BUFFER,
-        url: APPLICATION_ARCHIVE_URL,
-      })
-    );
+    jest.mocked(fetch).mockResolvedValue({
+      ok: true,
+      body: Readable.from(APP_TAR_GZ_BUFFER),
+      url: APPLICATION_ARCHIVE_URL,
+    } as unknown as Response);

    await expect(
      downloadBuildAsync({
@@ -1,158 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { createInstallBuildFunction, installBuildAsync } from '../installBuild';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-const mockedSpawn = jest.mocked(spawn);
-const temporaryDirectories: string[] = [];
-
-async function makeTemporaryDirectoryAsync(): Promise<string> {
-  const temporaryDirectory = await fs.promises.mkdtemp(
-    path.join(os.tmpdir(), 'install-build-test-')
-  );
-  temporaryDirectories.push(temporaryDirectory);
-  return temporaryDirectory;
-}
-
-describe(installBuildAsync, () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-  });
-
-  afterAll(async () => {
-    await Promise.all(
-      temporaryDirectories.map(temporaryDirectory =>
-        fs.promises.rm(temporaryDirectory, { recursive: true, force: true })
-      )
-    );
-  });
-
-  it('installs an iOS Simulator .app', async () => {
-    const temporaryDirectory = await makeTemporaryDirectoryAsync();
-    const artifactPath = path.join(temporaryDirectory, 'Example.app');
-    await fs.promises.mkdir(artifactPath);
-    const logger = createMockLogger();
-    mockedSpawn.mockResolvedValueOnce({ stdout: 'com.example.app\n', stderr: '' } as any);
-
-    const result = await installBuildAsync({
-      artifactPath,
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger,
-    });
-
-    expect(result).toEqual({ applicationIdentifier: 'com.example.app' });
-    expect(mockedSpawn.mock.calls).toEqual([
-      [
-        'plutil',
-        ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', path.join(artifactPath, 'Info.plist')],
-        { stdio: 'pipe', env: {} },
-      ],
-      ['xcrun', ['simctl', 'install', 'booted', artifactPath], { env: {}, logger }],
-    ]);
-  });
-
-  it('installs an Android Emulator .apk', async () => {
-    const temporaryDirectory = await makeTemporaryDirectoryAsync();
-    const artifactPath = path.join(temporaryDirectory, 'example.apk');
-    await fs.promises.writeFile(artifactPath, 'apk');
-    const logger = createMockLogger();
-    mockedSpawn.mockResolvedValueOnce({
-      stdout:
-        "package: name='com.example.app'\nlaunchable-activity: name='com.example.app.MainActivity'\n",
-      stderr: '',
-    } as any);
-
-    const result = await installBuildAsync({
-      artifactPath,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger,
-    });
-
-    expect(result).toEqual({
-      applicationIdentifier: 'com.example.app',
-      activityName: 'com.example.app.MainActivity',
-    });
-    expect(mockedSpawn.mock.calls).toEqual([
-      ['aapt2', ['dump', 'badging', artifactPath], { stdio: 'pipe', env: {} }],
-      ['adb', ['install', '-r', artifactPath], { env: {}, logger }],
-    ]);
-  });
-
-  it.each([
-    [BuildRuntimePlatform.DARWIN, 'example.ipa'],
-    [BuildRuntimePlatform.LINUX, 'example.aab'],
-  ])('rejects an incompatible %s artifact', async (runtimePlatform, filename) => {
-    const temporaryDirectory = await makeTemporaryDirectoryAsync();
-    const artifactPath = path.join(temporaryDirectory, filename);
-    await fs.promises.writeFile(artifactPath, 'artifact');
-
-    await expect(
-      installBuildAsync({
-        artifactPath,
-        runtimePlatform,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({ errorCode: 'EAS_INSTALL_BUILD_INVALID_ARTIFACT' });
-
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('installs an Android artifact without a launchable activity', async () => {
-    const temporaryDirectory = await makeTemporaryDirectoryAsync();
-    const artifactPath = path.join(temporaryDirectory, 'example.apk');
-    await fs.promises.writeFile(artifactPath, 'apk');
-    const logger = createMockLogger();
-    mockedSpawn.mockResolvedValue({
-      stdout: "package: name='com.example.app'\n",
-      stderr: '',
-    } as any);
-
-    const result = await installBuildAsync({
-      artifactPath,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger,
-    });
-
-    expect(result).toEqual({ applicationIdentifier: 'com.example.app' });
-    expect(mockedSpawn.mock.calls).toEqual([
-      ['aapt2', ['dump', 'badging', artifactPath], { stdio: 'pipe', env: {} }],
-      ['adb', ['install', '-r', artifactPath], { env: {}, logger }],
-    ]);
-  });
-
-  it('exposes the installed application identifier and activity as step outputs', async () => {
-    const temporaryDirectory = await makeTemporaryDirectoryAsync();
-    const artifactPath = path.join(temporaryDirectory, 'example.apk');
-    await fs.promises.writeFile(artifactPath, 'apk');
-    mockedSpawn.mockResolvedValueOnce({
-      stdout:
-        "package: name='com.example.app'\nlaunchable-activity: name='com.example.app.MainActivity'\n",
-      stderr: '',
-    } as any);
-
-    const installBuild = createInstallBuildFunction();
-    const buildStep = installBuild.createBuildStepFromFunctionCall(
-      createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX }),
-      { callInputs: { artifact_path: artifactPath } }
-    );
-    await buildStep.executeAsync();
-
-    expect(buildStep.outputById.application_identifier.value).toBe('com.example.app');
-    expect(buildStep.outputById.activity_name.value).toBe('com.example.app.MainActivity');
-  });
-});
@@ -1,10 +1,4 @@
-import downloadFile from '@expo/downloader';
-import { SystemError, UserError } from '@expo/eas-build-job';
 import spawn from '@expo/turtle-spawn';
-import { BuildRuntimePlatform } from '@expo/steps';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';

 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { Datadog } from '../../../datadog';
@@ -15,11 +9,6 @@ jest.mock('@expo/turtle-spawn', () => ({
  default: jest.fn(),
 }));

-jest.mock('@expo/downloader', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
 jest.mock('../../../datadog', () => ({
  Datadog: {
    distribution: jest.fn(),
@@ -27,24 +16,10 @@ jest.mock('../../../datadog', () => ({
 }));

 const mockedSpawn = jest.mocked(spawn);
-const mockedDownloadFile = jest.mocked(downloadFile);
-
-async function writeInstalledWdaVersion(homeDirectory: string, version: string): Promise<void> {
-  const wdaDirectory = path.join(
-    homeDirectory,
-    '.maestro-runner',
-    'drivers',
-    'ios',
-    'WebDriverAgent'
-  );
-  await fs.promises.mkdir(wdaDirectory, { recursive: true });
-  await fs.promises.writeFile(path.join(wdaDirectory, 'package.json'), JSON.stringify({ version }));
-}

 describe('createInstallMaestroBuildFunction', () => {
  beforeEach(() => {
    jest.clearAllMocks();
-    mockedDownloadFile.mockResolvedValue(undefined);
    // `maestro --version` reports an installed version; `java -version` succeeds.
    // With no requested version and Maestro present, the step skips installation.
    mockedSpawn.mockImplementation((async (command: string) => ({
@@ -204,7 +179,7 @@ describe('createInstallMaestroBuildFunction', () => {
        ['--version'],
        expect.objectContaining({
          env: expect.objectContaining({
-            PATH: expect.stringMatching(/^\/home\/expo\/\.maestro-runner\/bin:/),
+            PATH: expect.stringMatching(/:\/home\/expo\/\.maestro-runner\/bin$/),
          }),
        })
      );
@@ -214,217 +189,6 @@ describe('createInstallMaestroBuildFunction', () => {
    }
  });

-  it('installs maestro-runner 1.1.15 on Xcode versions below 26', async () => {
-    let versionChecks = 0;
-    mockedSpawn.mockImplementation((async (command: string) => {
-      switch (command) {
-        case 'xcodebuild':
-          return { stdout: 'Xcode 16.4\nBuild version 16F6\n' };
-        case 'maestro-runner':
-          return {
-            stdout: versionChecks++ === 0 ? 'maestro-runner 1.1.23\n' : 'maestro-runner 1.1.15\n',
-          };
-        default:
-          return { stdout: '' };
-      }
-    }) as any);
-    const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
-      text: async () => '#!/bin/sh\n',
-    } as Response);
-    const originalPath = process.env.PATH;
-
-    try {
-      const installMaestro = createInstallMaestroBuildFunction();
-      const globalCtx = createGlobalContextMock({
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-      });
-      globalCtx.updateEnv({
-        EAS_BUILD_RUNNER: 'eas-build',
-        HOME: '/home/expo',
-        PATH: '/usr/bin',
-      });
-      const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-        callInputs: { backend: 'maestro-runner' },
-      });
-
-      await step.executeAsync();
-
-      expect(mockedSpawn).toHaveBeenCalledWith(
-        expect.stringMatching(/install_maestro_runner.*\/install_maestro_runner\.sh$/),
-        ['--version', '1.1.15'],
-        expect.objectContaining({ env: expect.objectContaining({ HOME: '/home/expo' }) })
-      );
-      expect(step.getOutputValueByName('maestro_version')).toBe('1.1.15');
-    } finally {
-      fetchSpy.mockRestore();
-      process.env.PATH = originalPath;
-    }
-  });
-
-  it('does not check Xcode when a compatible maestro-runner version is installed', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => {
-      if (command === 'xcodebuild') {
-        throw new Error('xcodebuild should not be called');
-      }
-      return { stdout: command === 'maestro-runner' ? 'maestro-runner 1.1.15\n' : '' };
-    }) as any);
-
-    const installMaestro = createInstallMaestroBuildFunction();
-    const globalCtx = createGlobalContextMock({
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-    });
-    globalCtx.updateEnv({
-      EAS_BUILD_RUNNER: 'eas-build',
-      HOME: '/home/expo',
-      PATH: '/usr/bin',
-    });
-    const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { backend: 'maestro-runner' },
-    });
-
-    await step.executeAsync();
-
-    expect(mockedSpawn).not.toHaveBeenCalledWith(
-      'xcodebuild',
-      expect.anything(),
-      expect.anything()
-    );
-    expect(step.getOutputValueByName('maestro_version')).toBe('1.1.15');
-  });
-
-  it('checks Xcode for latest when a compatible maestro-runner version is installed', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => {
-      switch (command) {
-        case 'xcodebuild':
-          return { stdout: 'Xcode 16.4\nBuild version 16F6\n' };
-        case 'maestro-runner':
-          return { stdout: 'maestro-runner 1.1.15\n' };
-        default:
-          return { stdout: '' };
-      }
-    }) as any);
-
-    const installMaestro = createInstallMaestroBuildFunction();
-    const globalCtx = createGlobalContextMock({
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-    });
-    globalCtx.updateEnv({
-      EAS_BUILD_RUNNER: 'eas-build',
-      HOME: '/home/expo',
-      PATH: '/usr/bin',
-    });
-    const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { backend: 'maestro-runner', maestro_version: 'latest' },
-    });
-
-    await step.executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'xcodebuild',
-      ['-version'],
-      expect.objectContaining({ env: expect.anything() })
-    );
-    expect(step.getOutputValueByName('maestro_version')).toBe('1.1.15');
-  });
-
-  it('installs the latest maestro-runner version on Xcode 26', async () => {
-    let versionChecks = 0;
-    mockedSpawn.mockImplementation((async (command: string) => {
-      if (command === 'xcodebuild') {
-        return { stdout: 'Xcode 26.0\nBuild version 17A324\n' };
-      }
-      if (command === 'maestro-runner' && versionChecks++ === 0) {
-        throw Object.assign(new Error('not found'), { code: 'ENOENT' });
-      }
-      return { stdout: command === 'maestro-runner' ? 'maestro-runner 1.1.23\n' : '' };
-    }) as any);
-    const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValue({
-      text: async () => '#!/bin/sh\n',
-    } as Response);
-    const originalPath = process.env.PATH;
-
-    try {
-      const installMaestro = createInstallMaestroBuildFunction();
-      const globalCtx = createGlobalContextMock({
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-      });
-      globalCtx.updateEnv({
-        EAS_BUILD_RUNNER: 'eas-build',
-        HOME: '/home/expo',
-        PATH: '/usr/bin',
-      });
-      const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-        callInputs: { backend: 'maestro-runner' },
-      });
-
-      await step.executeAsync();
-
-      expect(mockedSpawn).toHaveBeenCalledWith(
-        expect.stringMatching(/install_maestro_runner.*\/install_maestro_runner\.sh$/),
-        [],
-        expect.objectContaining({ env: expect.objectContaining({ HOME: '/home/expo' }) })
-      );
-      expect(step.getOutputValueByName('maestro_version')).toBe('1.1.23');
-    } finally {
-      fetchSpy.mockRestore();
-      process.env.PATH = originalPath;
-    }
-  });
-
-  it('throws a system error when the Xcode version cannot be determined', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => {
-      if (command === 'xcodebuild') {
-        return { stdout: 'unexpected output' };
-      }
-      throw Object.assign(new Error('not found'), { code: 'ENOENT' });
-    }) as any);
-
-    const installMaestro = createInstallMaestroBuildFunction();
-    const globalCtx = createGlobalContextMock({
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-    });
-    globalCtx.updateEnv({
-      EAS_BUILD_RUNNER: 'eas-build',
-      HOME: '/home/expo',
-      PATH: '/usr/bin',
-    });
-    const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { backend: 'maestro-runner' },
-    });
-
-    await expect(step.executeAsync()).rejects.toThrow(SystemError);
-  });
-
-  it('rejects a requested maestro-runner version that is incompatible with Xcode', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => {
-      if (command === 'xcodebuild') {
-        return { stdout: 'Xcode 16.4\nBuild version 16F6\n' };
-      }
-      throw Object.assign(new Error('not found'), { code: 'ENOENT' });
-    }) as any);
-
-    const installMaestro = createInstallMaestroBuildFunction();
-    const globalCtx = createGlobalContextMock({
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-    });
-    globalCtx.updateEnv({
-      EAS_BUILD_RUNNER: 'eas-build',
-      HOME: '/home/expo',
-      PATH: '/usr/bin',
-    });
-    const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { backend: 'maestro-runner', maestro_version: '1.1.23' },
-    });
-
-    const executePromise = step.executeAsync();
-    await expect(executePromise).rejects.toThrow(UserError);
-    await expect(executePromise).rejects.toMatchObject({
-      errorCode: 'ERR_MAESTRO_INVALID_INPUT',
-      message:
-        'maestro-runner 1.1.23 is not compatible with Xcode 16.4.0. Use maestro-runner 1.1.15 or an Xcode 26+ image.',
-    });
-  });
-
  it('installs the requested maestro-runner version', async () => {
    let versionChecks = 0;
    mockedSpawn.mockImplementation((async (command: string) => {
@@ -462,184 +226,4 @@ describe('createInstallMaestroBuildFunction', () => {
      process.env.PATH = originalPath;
    }
  });
-
-  it('installs the prebuilt WDA cache for each available iOS runtime', async () => {
-    const homeDirectory = await fs.promises.mkdtemp(
-      path.join(os.tmpdir(), 'install-maestro-test-')
-    );
-    mockedSpawn.mockImplementation((async (command: string, args: string[]) => {
-      if (command === 'maestro-runner') {
-        return { stdout: 'maestro-runner 1.2.3\n' };
-      }
-      if (command === 'xcrun') {
-        return {
-          stdout: JSON.stringify({
-            runtimes: [
-              {
-                identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-18-3',
-                isAvailable: true,
-                version: '18.3.1',
-              },
-              {
-                identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-26-0',
-                isAvailable: true,
-                version: '26.0',
-              },
-              {
-                identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-17-5',
-                isAvailable: false,
-                version: '17.5',
-              },
-            ],
-          }),
-        };
-      }
-      if (command === 'xcodebuild') {
-        return { stdout: 'Xcode 26.0\nBuild version 17A324\n' };
-      }
-      if (command === 'tar') {
-        const maestroRunnerHome = args[args.indexOf('-C') + 1];
-        const productsDirectory = path.join(
-          maestroRunnerHome,
-          'cache',
-          'wda-builds',
-          'generic',
-          'DerivedData',
-          'Build',
-          'Products'
-        );
-        await fs.promises.mkdir(productsDirectory, { recursive: true });
-        await fs.promises.writeFile(
-          path.join(productsDirectory, 'WebDriverAgentRunner.xctestrun'),
-          'cached'
-        );
-      }
-      return { stdout: '' };
-    }) as any);
-
-    try {
-      await writeInstalledWdaVersion(homeDirectory, '11.1.3');
-      const installMaestro = createInstallMaestroBuildFunction();
-      const globalCtx = createGlobalContextMock({
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-      });
-      globalCtx.updateEnv({
-        EAS_BUILD_RUNNER: 'eas-build',
-        EAS_BUILD_COCOAPODS_CACHE_URL: 'https://cache.example.com',
-        HOME: homeDirectory,
-      });
-      const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-        callInputs: { backend: 'maestro-runner' },
-      });
-
-      await step.executeAsync();
-
-      expect(mockedDownloadFile).toHaveBeenCalledWith(
-        'https://cache.example.com/storage.googleapis.com/turtle-v2/maestro-runner-wda-cache/xcode-26.0-wda-11.1.3.tar.gz',
-        expect.stringMatching(/install_maestro_runner_wda_cache.*\/wda-cache\.tar\.gz$/),
-        { retry: 3, timeout: 20_000 }
-      );
-      for (const runtimeVersion of ['18.3', '26.0']) {
-        await expect(
-          fs.promises.readFile(
-            path.join(
-              homeDirectory,
-              '.maestro-runner',
-              'cache',
-              'wda-builds',
-              `sim-ios${runtimeVersion}-iphone`,
-              'DerivedData',
-              'Build',
-              'Products',
-              'WebDriverAgentRunner.xctestrun'
-            ),
-            'utf8'
-          )
-        ).resolves.toBe('cached');
-      }
-      await expect(
-        fs.promises.access(
-          path.join(homeDirectory, '.maestro-runner', 'cache', 'wda-builds', 'sim-ios17.5-iphone')
-        )
-      ).rejects.toThrow();
-    } finally {
-      await fs.promises.rm(homeDirectory, { force: true, recursive: true });
-    }
-  });
-
-  it('does not download the WDA cache when the installed WDA version is unknown', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => ({
-      stdout:
-        command === 'xcodebuild' ? 'Xcode 26.5\nBuild version 17F90\n' : 'maestro-runner 1.2.3\n',
-    })) as any);
-    const installMaestro = createInstallMaestroBuildFunction();
-    const globalCtx = createGlobalContextMock({
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-    });
-    globalCtx.updateEnv({ EAS_BUILD_RUNNER: 'eas-build', HOME: '/home/expo' });
-    const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-      callInputs: { backend: 'maestro-runner' },
-    });
-
-    await step.executeAsync();
-
-    // The installed WDA version is unknown (no package.json under $HOME), so the
-    // cache download is skipped before resolving the Xcode/runtime versions.
-    expect(mockedDownloadFile).not.toHaveBeenCalled();
-    expect(mockedSpawn.mock.calls.map(([command]) => command)).not.toContain('xcrun');
-  });
-
-  it('continues when the prebuilt WDA cache is not available', async () => {
-    mockedSpawn.mockImplementation((async (command: string) => {
-      switch (command) {
-        case 'maestro-runner':
-          return { stdout: 'maestro-runner 1.2.3\n' };
-        case 'xcodebuild':
-          return { stdout: 'Xcode 26.5\nBuild version 17F90\n' };
-        case 'xcrun':
-          return {
-            stdout: JSON.stringify({
-              runtimes: [
-                {
-                  identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-26-5',
-                  isAvailable: true,
-                  version: '26.5',
-                },
-              ],
-            }),
-          };
-        default:
-          return { stdout: '' };
-      }
-    }) as any);
-    mockedDownloadFile.mockRejectedValue(new Error('HTTP 404'));
-    const homeDirectory = await fs.promises.mkdtemp(
-      path.join(os.tmpdir(), 'install-maestro-test-')
-    );
-
-    try {
-      await writeInstalledWdaVersion(homeDirectory, '11.1.3');
-      const installMaestro = createInstallMaestroBuildFunction();
-      const globalCtx = createGlobalContextMock({
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-      });
-      globalCtx.updateEnv({
-        EAS_BUILD_RUNNER: 'eas-build',
-        EAS_BUILD_COCOAPODS_CACHE_URL: 'https://cache.example.com',
-        HOME: homeDirectory,
-      });
-      const step = installMaestro.createBuildStepFromFunctionCall(globalCtx, {
-        callInputs: { backend: 'maestro-runner' },
-      });
-
-      await expect(step.executeAsync()).resolves.toBeUndefined();
-      expect(step.getOutputValueByName('maestro_version')).toBe('1.2.3');
-      expect(mockedDownloadFile.mock.calls.map(([url]) => url)).toEqual([
-        'https://cache.example.com/storage.googleapis.com/turtle-v2/maestro-runner-wda-cache/xcode-26.5-wda-11.1.3.tar.gz',
-        'https://storage.googleapis.com/turtle-v2/maestro-runner-wda-cache/xcode-26.5-wda-11.1.3.tar.gz',
-      ]);
-    } finally {
-      await fs.promises.rm(homeDirectory, { force: true, recursive: true });
-    }
-  });
 });
@@ -1,320 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-
-import { createGlobalContextMock } from '../../../__tests__/utils/context';
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { createLaunchApplicationFunction, launchApplicationAsync } from '../launchApplication';
-
-jest.mock('@expo/turtle-spawn', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-const mockedSpawn = jest.mocked(spawn);
-
-describe(launchApplicationAsync, () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
-  });
-
-  it('launches an iOS Simulator application by bundle identifier', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'com.example.app',
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'xcrun',
-      ['simctl', 'launch', 'booted', 'com.example.app'],
-      { env: {}, logger }
-    );
-  });
-
-  it('passes launch arguments and opens a URL on iOS', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'host.exp.Exponent',
-      launchArgs: ['--uitesting', 'true'],
-      openUrl: 'exp://example.test',
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      1,
-      'xcrun',
-      ['simctl', 'launch', 'booted', 'host.exp.Exponent', '--uitesting', 'true'],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      2,
-      'xcrun',
-      [
-        'simctl',
-        'spawn',
-        'booted',
-        'defaults',
-        'write',
-        'com.apple.launchservices.schemeapproval',
-        'com.apple.CoreSimulator.CoreSimulatorBridge-->exp',
-        '-string',
-        'host.exp.Exponent',
-      ],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      3,
-      'xcrun',
-      ['simctl', 'openurl', 'booted', 'exp://example.test'],
-      { env: {}, logger }
-    );
-  });
-
-  it('opens a web URL on iOS without preapproving its scheme', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'com.example.app',
-      openUrl: 'https://example.test',
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      1,
-      'xcrun',
-      ['simctl', 'launch', 'booted', 'com.example.app'],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      2,
-      'xcrun',
-      ['simctl', 'openurl', 'booted', 'https://example.test'],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenCalledTimes(2);
-  });
-
-  it('opens a custom URL on iOS when scheme preapproval fails', async () => {
-    const logger = createMockLogger();
-    const approvalError = new Error('Scheme approval is unavailable.');
-    mockedSpawn
-      .mockResolvedValueOnce({ stdout: '', stderr: '' } as any)
-      .mockRejectedValueOnce(approvalError);
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'host.exp.Exponent',
-      openUrl: 'exp://example.test',
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      3,
-      'xcrun',
-      ['simctl', 'openurl', 'booted', 'exp://example.test'],
-      { env: {}, logger }
-    );
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: approvalError },
-      'Could not preapprove the exp URL scheme for host.exp.Exponent. Opening the URL anyway; the Simulator might require manual confirmation.'
-    );
-  });
-
-  it('launches an Android Emulator application by package and activity', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'com.example.app',
-      activityName: 'com.example.app.MainActivity',
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'adb',
-      ['shell', 'am', 'start', '-n', 'com.example.app/com.example.app.MainActivity'],
-      { env: {}, logger }
-    );
-  });
-
-  it('passes launch arguments and opens a URL on Android', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'host.exp.exponent',
-      activityName: 'host.exp.exponent.MainActivity',
-      launchArgs: ['--ez', 'isTest', 'true'],
-      openUrl: 'exp://example.test',
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      1,
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '--ez',
-        'isTest',
-        'true',
-        '-n',
-        'host.exp.exponent/host.exp.exponent.MainActivity',
-      ],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      2,
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '-a',
-        'android.intent.action.VIEW',
-        '-d',
-        'exp://example.test',
-        '-n',
-        'host.exp.exponent/host.exp.exponent.MainActivity',
-      ],
-      { env: {}, logger }
-    );
-    expect(logger.info).toHaveBeenNthCalledWith(
-      1,
-      'Launching host.exp.exponent with arguments ["--ez","isTest","true"].'
-    );
-  });
-
-  it('requires an activity when launching an Android application', async () => {
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_MISSING_ACTIVITY' });
-
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('launches using application metadata passed to the build step', async () => {
-    const launchApplication = createLaunchApplicationFunction();
-    const buildStep = launchApplication.createBuildStepFromFunctionCall(
-      createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX }),
-      {
-        callInputs: {
-          application_identifier: 'com.example.app',
-          activity_name: 'com.example.app.MainActivity',
-          launch_args: ['--ez', 'isTest', 'true'],
-          open_url: 'exp://example.test',
-        },
-      }
-    );
-    await buildStep.executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '--ez',
-        'isTest',
-        'true',
-        '-n',
-        'com.example.app/com.example.app.MainActivity',
-      ],
-      expect.any(Object)
-    );
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '-a',
-        'android.intent.action.VIEW',
-        '-d',
-        'exp://example.test',
-        '-n',
-        'com.example.app/com.example.app.MainActivity',
-      ],
-      expect.any(Object)
-    );
-  });
-
-  it.each([{}, ['valid', 42]])('rejects invalid launch arguments (%j)', async launchArgs => {
-    const launchApplication = createLaunchApplicationFunction();
-    const buildStep = launchApplication.createBuildStepFromFunctionCall(
-      createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.DARWIN }),
-      {
-        callInputs: {
-          application_identifier: 'com.example.app',
-          launch_args: launchArgs,
-        },
-      }
-    );
-
-    await expect(buildStep.executeAsync()).rejects.toMatchObject({
-      errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-      message: 'Input "launch_args" must be an array of strings.',
-    });
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('rejects an invalid URL to open', async () => {
-    const launchApplication = createLaunchApplicationFunction();
-    const buildStep = launchApplication.createBuildStepFromFunctionCall(
-      createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.DARWIN }),
-      {
-        callInputs: {
-          application_identifier: 'com.example.app',
-          open_url: 'not a URL',
-        },
-      }
-    );
-
-    await expect(buildStep.executeAsync()).rejects.toMatchObject({
-      errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-      message: 'Input "open_url" must be a valid URL.',
-    });
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it.each(['application_identifier', 'activity_name'])(
-    'reports an empty %s input as a user error',
-    async inputName => {
-      const launchApplication = createLaunchApplicationFunction();
-      const buildStep = launchApplication.createBuildStepFromFunctionCall(
-        createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX }),
-        {
-          callInputs: {
-            application_identifier: 'com.example.app',
-            activity_name: 'com.example.app.MainActivity',
-            [inputName]: '',
-          },
-        }
-      );
-
-      await expect(buildStep.executeAsync()).rejects.toMatchObject({
-        errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-        message: `Input "${inputName}" must be a non-empty string. Pass the "${inputName}" output from eas/install_build.`,
-      });
-      expect(mockedSpawn).not.toHaveBeenCalled();
-    }
-  );
-});
@@ -10,92 +10,11 @@ import {
  parseFailedFlowNamesFromJUnitFile,
  parseFailedFlowsFromFileAttrs,
  parseFailedFlowsFromJUnit,
-  parseFailedFlowsFromMaestroRunnerReport,
  parseJUnitTestCases,
  parseMaestroResults,
  parseMaestroResultsFromFileAttrs,
-  parseMaestroRunnerReport,
 } from '../maestroResultParser';

-describe(parseFailedFlowsFromMaestroRunnerReport, () => {
-  it('returns exact sourceFile paths for failed flows', async () => {
-    vol.fromJSON({
-      '/project/flows/pass.yml': '',
-      '/project/flows/nested/fail.yml': '',
-      '/reports/attempt-0/report.json': JSON.stringify({
-        flows: [
-          { name: 'Passing flow', sourceFile: 'flows/pass.yml', status: 'passed' },
-          {
-            name: 'Failing flow',
-            sourceFile: 'flows/nested/fail.yml',
-            status: 'failed',
-          },
-          { status: 'skipped' },
-        ],
-      }),
-    });
-
-    await expect(
-      parseFailedFlowsFromMaestroRunnerReport({
-        reportDirectory: '/reports/attempt-0',
-        workingDirectory: '/project',
-      })
-    ).resolves.toEqual(['flows/nested/fail.yml']);
-    await expect(parseMaestroRunnerReport('/reports/attempt-0')).resolves.toEqual({
-      flows: [
-        { name: 'Passing flow', sourceFile: 'flows/pass.yml', status: 'passed' },
-        {
-          name: 'Failing flow',
-          sourceFile: 'flows/nested/fail.yml',
-          status: 'failed',
-        },
-      ],
-    });
-  });
-
-  it.each([
-    {
-      name: 'incomplete flow',
-      report: {
-        version: '1.0.0',
-        status: 'failed',
-        summary: { total: 1 },
-        flows: [{ name: 'Failing flow', sourceFile: 'flows/fail.yml', status: 'running' }],
-      },
-    },
-  ])('returns null for an $name', async ({ report }) => {
-    vol.fromJSON({
-      '/project/flows/fail.yml': '',
-      '/reports/attempt-0/report.json': JSON.stringify(report),
-    });
-
-    await expect(
-      parseFailedFlowsFromMaestroRunnerReport({
-        reportDirectory: '/reports/attempt-0',
-        workingDirectory: '/project',
-      })
-    ).resolves.toBeNull();
-  });
-
-  it('returns null when a failed sourceFile does not exist', async () => {
-    vol.fromJSON({
-      '/reports/attempt-0/report.json': JSON.stringify({
-        version: '1.0.0',
-        status: 'failed',
-        summary: { total: 1 },
-        flows: [{ name: 'Failing flow', sourceFile: 'flows/missing.yml', status: 'failed' }],
-      }),
-    });
-
-    await expect(
-      parseFailedFlowsFromMaestroRunnerReport({
-        reportDirectory: '/reports/attempt-0',
-        workingDirectory: '/project',
-      })
-    ).resolves.toBeNull();
-  });
-});
-
 describe(parseFailedFlowNamesFromJUnitFile, () => {
  it('returns the names of failed testcases, keeping slashes', async () => {
    vol.fromJSON({
@@ -534,20 +453,6 @@ describe('junitFileHasFileAttrs', () => {
    expect(await junitFileHasFileAttrs('/junit/report.xml')).toBe(false);
  });

-  it('returns true for a maestro-runner report with a file property', async () => {
-    vol.fromJSON({
-      '/junit/report.xml': [
-        '<?xml version="1.0"?>',
-        '<testsuites><testsuite>',
-        '  <testcase name="a" time="1.0">',
-        '    <properties><property name="file" value="flows/a.yaml"/></properties>',
-        '  </testcase>',
-        '</testsuite></testsuites>',
-      ].join('\n'),
-    });
-    expect(await junitFileHasFileAttrs('/junit/report.xml')).toBe(true);
-  });
-
  it('returns false when the file cannot be read', async () => {
    expect(await junitFileHasFileAttrs('/missing.xml')).toBe(false);
  });
@@ -573,41 +478,6 @@ describe(parseJUnitTestCases, () => {
    expect(results[0].file).toBe('.maestro/login.yaml');
  });

-  it('parses maestro-runner file properties and standard JUnit pass status', async () => {
-    vol.fromJSON({
-      '/junit/report.xml': [
-        '<?xml version="1.0"?>',
-        '<testsuites><testsuite>',
-        '  <testcase name="login" time="1.0">',
-        '    <properties><property name="file" value="flows/login.yaml"/></properties>',
-        '  </testcase>',
-        '</testsuite></testsuites>',
-      ].join('\n'),
-    });
-
-    const results = await parseJUnitTestCases('/junit');
-
-    expect(results[0]).toEqual(
-      expect.objectContaining({ file: 'flows/login.yaml', status: 'passed' })
-    );
-  });
-
-  it('excludes skipped testcases instead of counting them as passed', async () => {
-    vol.fromJSON({
-      '/junit/report.xml': [
-        '<?xml version="1.0"?>',
-        '<testsuites><testsuite>',
-        '  <testcase name="passing" time="1.0"/>',
-        '  <testcase name="skipped-flow" time="0"><skipped/></testcase>',
-        '</testsuite></testsuites>',
-      ].join('\n'),
-    });
-
-    const results = await parseJUnitTestCases('/junit');
-
-    expect(results.map(r => r.name)).toEqual(['passing']);
-  });
-
  it('treats a missing or empty file= attribute as undefined', async () => {
    vol.fromJSON({
      '/junit/report.xml': [
@@ -3,160 +3,14 @@ import os from 'os';
 import path from 'path';

 import { createMockLogger } from '../../../__tests__/utils/logger';
-import { Sentry } from '../../../sentry';
 import {
  type HarvestedScreenshot,
  computePureFailureFlowNames,
  harvestFailureScreenshotsAsync,
-  harvestMaestroRunnerFailureScreenshotsAsync,
  parseFailureScreenshotFilename,
  selectFailureScreenshots,
 } from '../maestroScreenshots';

-describe(harvestMaestroRunnerFailureScreenshotsAsync, () => {
-  const logger = createMockLogger();
-  let reportDirectory: string;
-  let captureSpy: jest.SpiedFunction<typeof Sentry.capture>;
-
-  beforeEach(async () => {
-    reportDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'maestro-runner-harvest-test-'));
-    await fs.mkdir(path.join(reportDirectory, 'flows'));
-    await fs.mkdir(path.join(reportDirectory, 'assets', 'flow-000'), { recursive: true });
-    captureSpy = jest.spyOn(Sentry, 'capture').mockImplementation(() => {});
-  });
-
-  afterEach(async () => {
-    await fs.rm(reportDirectory, { recursive: true, force: true });
-    captureSpy.mockRestore();
-  });
-
-  it('reads the failed command screenshot from a maestro-runner report bundle', async () => {
-    const capturedSinceMs = Date.now() - 1_000;
-    await fs.writeFile(
-      path.join(reportDirectory, 'report.json'),
-      JSON.stringify({
-        flows: [
-          {
-            name: 'authentication/Login',
-            status: 'failed',
-            dataFile: 'flows/flow-000.json',
-          },
-        ],
-      })
-    );
-    await fs.writeFile(
-      path.join(reportDirectory, 'flows', 'flow-000.json'),
-      JSON.stringify({
-        commands: [
-          {
-            status: 'failed',
-            artifacts: { screenshotAfter: 'assets/flow-000/cmd-001-after.png' },
-          },
-        ],
-      })
-    );
-    const screenshotPath = path.join(reportDirectory, 'assets', 'flow-000', 'cmd-001-after.png');
-    await fs.writeFile(screenshotPath, 'png');
-
-    const shots = await harvestMaestroRunnerFailureScreenshotsAsync({
-      reportDirectory,
-      capturedSinceMs,
-      attemptIndex: 1,
-      logger,
-    });
-
-    expect(shots).toEqual([
-      {
-        fileAbsPath: screenshotPath,
-        displayName: 'Failure Screenshot: authentication_Login (attempt 2)',
-        metadata: {
-          kind: 'maestro-test-screenshot',
-          flowName: 'authentication_Login',
-          attemptIndex: 1,
-          capturedAtMs: expect.any(Number),
-        },
-      },
-    ]);
-  });
-
-  it('rejects a screenshot path that resolves to the parent directory (exact "..")', async () => {
-    await fs.writeFile(
-      path.join(reportDirectory, 'report.json'),
-      JSON.stringify({
-        flows: [{ name: 'Login', status: 'failed', dataFile: 'flows/flow-000.json' }],
-      })
-    );
-    await fs.writeFile(
-      path.join(reportDirectory, 'flows', 'flow-000.json'),
-      JSON.stringify({
-        commands: [{ status: 'failed', artifacts: { screenshotAfter: '..' } }],
-      })
-    );
-
-    await expect(
-      harvestMaestroRunnerFailureScreenshotsAsync({
-        reportDirectory,
-        capturedSinceMs: 0,
-        attemptIndex: 0,
-        logger,
-      })
-    ).resolves.toEqual([]);
-  });
-
-  it('ignores passing flows and paths outside the report directory', async () => {
-    await fs.writeFile(
-      path.join(reportDirectory, 'report.json'),
-      JSON.stringify({
-        flows: [
-          { name: 'Passing', status: 'passed', dataFile: 'flows/flow-000.json' },
-          { name: 'Unsafe', status: 'failed', dataFile: '../outside.json' },
-        ],
-      })
-    );
-
-    await expect(
-      harvestMaestroRunnerFailureScreenshotsAsync({
-        reportDirectory,
-        capturedSinceMs: 0,
-        attemptIndex: 0,
-        logger,
-      })
-    ).resolves.toEqual([]);
-  });
-
-  it.each([
-    ['null', 'null'],
-    ['a non-object flows value', JSON.stringify({ flows: 5 })],
-    ['a null flow entry', JSON.stringify({ flows: [null] })],
-  ])('reports to Sentry and returns [] when report.json is %s', async (_label, contents) => {
-    await fs.writeFile(path.join(reportDirectory, 'report.json'), contents);
-
-    await expect(
-      harvestMaestroRunnerFailureScreenshotsAsync({
-        reportDirectory,
-        capturedSinceMs: 0,
-        attemptIndex: 0,
-        logger,
-      })
-    ).resolves.toEqual([]);
-    expect(captureSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns [] without reporting to Sentry when report.json is not valid JSON', async () => {
-    await fs.writeFile(path.join(reportDirectory, 'report.json'), 'not-json');
-
-    await expect(
-      harvestMaestroRunnerFailureScreenshotsAsync({
-        reportDirectory,
-        capturedSinceMs: 0,
-        attemptIndex: 0,
-        logger,
-      })
-    ).resolves.toEqual([]);
-    expect(captureSpy).not.toHaveBeenCalled();
-  });
-});
-
 describe(parseFailureScreenshotFilename, () => {
  it('parses a plain failure screenshot', () => {
    expect(parseFailureScreenshotFilename('screenshot-❌-1781186692250-(Login Flow).png')).toEqual({
@@ -27,14 +27,10 @@ jest.mock('../../../utils/retry', () => ({
 jest.mock('../maestroScreenshots', () => ({
  ...jest.requireActual('../maestroScreenshots'),
  harvestFailureScreenshotsAsync: jest.fn(),
-  harvestMaestroRunnerFailureScreenshotsAsync: jest.fn(),
 }));

 const mockedSpawn = jest.mocked(spawn);
 const mockedHarvest = jest.mocked(maestroScreenshots.harvestFailureScreenshotsAsync);
-const mockedRunnerHarvest = jest.mocked(
-  maestroScreenshots.harvestMaestroRunnerFailureScreenshotsAsync
-);
 const mockUploadArtifact = jest.fn();

 function makeShot(index: number): maestroScreenshots.HarvestedScreenshot {
@@ -93,8 +89,6 @@ describe('createMaestroTestsBuildFunction', () => {
    jest.spyOn(parser, 'mergeJUnitReports').mockResolvedValue();
    mockedHarvest.mockReset();
    mockedHarvest.mockResolvedValue([]);
-    mockedRunnerHarvest.mockReset();
-    mockedRunnerHarvest.mockResolvedValue([]);
    mockUploadArtifact.mockReset();
    mockUploadArtifact.mockResolvedValue({ artifactId: 'artifact-1' });
  });
@@ -143,171 +137,6 @@ describe('createMaestroTestsBuildFunction', () => {
    expect(args!.join(' ')).toMatch(/--output=.*android-maestro-junit-attempt-0\.xml/);
  });

-  it('runs maestro-runner and collects its JUnit report when selected by input', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    const copyFileSpy = jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const junitFailureNamesSpy = jest.spyOn(parser, 'parseFailedFlowNamesFromJUnitFile');
-    const step = createStep({
-      flow_path: ['flows/a.yaml', 'flows/b.yaml'],
-      output_format: 'junit',
-      platform: 'ios',
-      backend: 'maestro-runner',
-    });
-
-    await step.executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledTimes(1);
-    const [command, args] = mockedSpawn.mock.calls[0];
-    expect(command).toBe('maestro-runner');
-    expect(args).toEqual([
-      '--platform=ios',
-      'test',
-      '--output=/home/expo/.maestro/tests/ios-maestro-runner-attempt-0',
-      '--flatten',
-      'flows/a.yaml',
-      'flows/b.yaml',
-    ]);
-    expect(copyFileSpy).toHaveBeenCalledWith(
-      '/home/expo/.maestro/tests/ios-maestro-runner-attempt-0/junit-report.xml',
-      '/home/expo/.maestro/tests/junit-reports/ios-maestro-junit-attempt-0.xml'
-    );
-    expect(mockedHarvest).not.toHaveBeenCalled();
-    expect(junitFailureNamesSpy).not.toHaveBeenCalled();
-    expect(mockedRunnerHarvest).toHaveBeenCalledWith({
-      reportDirectory: '/home/expo/.maestro/tests/ios-maestro-runner-attempt-0',
-      capturedSinceMs: expect.any(Number),
-      attemptIndex: 0,
-      logger: expect.anything(),
-    });
-  });
-
-  it('clears the deterministic maestro-runner output directory before each attempt', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const rmSpy = jest.spyOn(fs, 'rm').mockResolvedValue();
-    const step = createStep({
-      flow_path: ['flows/a.yaml'],
-      output_format: 'junit',
-      platform: 'ios',
-      backend: 'maestro-runner',
-    });
-
-    await step.executeAsync();
-
-    expect(rmSpy).toHaveBeenCalledWith('/home/expo/.maestro/tests/ios-maestro-runner-attempt-0', {
-      recursive: true,
-      force: true,
-    });
-    // Cleared before the run, so a crash before fresh output can't resurrect stale results.
-    expect(rmSpy.mock.invocationCallOrder[0]).toBeLessThan(mockedSpawn.mock.invocationCallOrder[0]);
-  });
-
-  it('selects maestro-runner from EAS_MAESTRO_BACKEND', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const step = createStep(
-      { flow_path: ['flows/a.yaml'], platform: 'android' },
-      { env: { HOME: '/home/expo', EAS_MAESTRO_BACKEND: 'maestro-runner' } }
-    );
-
-    await step.executeAsync();
-
-    expect(mockedSpawn.mock.calls[0][0]).toBe('maestro-runner');
-  });
-
-  it('prefers the backend input over EAS_MAESTRO_BACKEND', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    const step = createStep(
-      { flow_path: ['flows/a.yaml'], platform: 'android', backend: 'maestro' },
-      { env: { HOME: '/home/expo', EAS_MAESTRO_BACKEND: 'maestro-runner' } }
-    );
-
-    await step.executeAsync();
-
-    expect(mockedSpawn.mock.calls[0][0]).toBe('maestro');
-  });
-
-  it('passes tags to maestro-runner', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const step = createStep({
-      flow_path: ['flows/a.yaml'],
-      platform: 'android',
-      backend: 'maestro-runner',
-      include_tags: 'smoke',
-      exclude_tags: 'slow',
-    });
-
-    await step.executeAsync();
-
-    expect(mockedSpawn.mock.calls[0][1]).toEqual(
-      expect.arrayContaining(['--include-tags=smoke', '--exclude-tags=slow'])
-    );
-  });
-
-  it('rejects invalid backend values', async () => {
-    const step = createStep({
-      flow_path: ['flows/a.yaml'],
-      platform: 'android',
-      backend: 'other',
-    });
-
-    await expect(step.executeAsync()).rejects.toThrow(UserError);
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('rejects sharding with maestro-runner', async () => {
-    const step = createStep({
-      flow_path: ['flows/a.yaml'],
-      platform: 'android',
-      backend: 'maestro-runner',
-      shards: 2,
-    });
-
-    await expect(step.executeAsync()).rejects.toThrow(
-      'maestro-runner does not support EAS Maestro test sharding'
-    );
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('rejects a non-junit output_format with maestro-runner', async () => {
-    const step = createStep({
-      flow_path: ['flows/a.yaml'],
-      platform: 'android',
-      backend: 'maestro-runner',
-      output_format: 'html',
-    });
-
-    await expect(step.executeAsync()).rejects.toThrow(
-      'maestro-runner only supports the "junit" output_format'
-    );
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
-  it('logs that maestro-runner does not support direct DADB', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const logger = createMockLogger();
-    jest.mocked(logger.child).mockReturnValue(logger);
-    const step = createStep(
-      {
-        flow_path: ['flows/a.yaml'],
-        platform: 'android',
-        backend: 'maestro-runner',
-        android_connection_mode: 'dadb',
-      },
-      { env: { HOME: '/home/expo', PATH: '/usr/bin' }, logger }
-    );
-
-    await step.executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledTimes(1);
-    expect(mockedSpawn.mock.calls[0][0]).toBe('maestro-runner');
-    expect(logger.info).toHaveBeenCalledWith(
-      'maestro-runner does not support DADB. Using the default ADB connection.'
-    );
-  });
-
  it('uses direct DADB when android_connection_mode is dadb without cleanup', async () => {
    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
    const writeFileSpy = jest.spyOn(fs, 'writeFile');
@@ -624,36 +453,6 @@ describe('createMaestroTestsBuildFunction', () => {
    expect(a1Args).not.toContain('flows/c.yaml');
  });

-  it('uses maestro-runner report.json for junit retries', async () => {
-    mockedSpawn.mockRejectedValueOnce(rejectExit1()).mockResolvedValueOnce(SPAWN_SUCCESS);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    const runnerReportSpy = jest
-      .spyOn(parser, 'parseFailedFlowsFromMaestroRunnerReport')
-      .mockResolvedValue(['flows/b.yaml']);
-    const junitParseSpy = jest.spyOn(parser, 'parseFailedFlowsFromJUnit');
-
-    const step = createStep({
-      flow_path: ['flows/a.yaml', 'flows/b.yaml'],
-      retries: 1,
-      output_format: 'junit',
-      platform: 'ios',
-      backend: 'maestro-runner',
-    });
-    await step.executeAsync();
-
-    expect(runnerReportSpy).toHaveBeenCalledWith({
-      reportDirectory: '/home/expo/.maestro/tests/ios-maestro-runner-attempt-0',
-      workingDirectory: expect.any(String),
-    });
-    expect(junitParseSpy).not.toHaveBeenCalled();
-    expect(mockedSpawn.mock.calls[0][1]).toEqual(
-      expect.arrayContaining(['flows/a.yaml', 'flows/b.yaml'])
-    );
-    const retryArgs = mockedSpawn.mock.calls[1][1]!;
-    expect(retryArgs).toContain('flows/b.yaml');
-    expect(retryArgs).not.toContain('flows/a.yaml');
-  });
-
  it('retries all flows when parseFailedFlowsFromJUnit returns null', async () => {
    const spawnMock = mockedSpawn
      .mockRejectedValueOnce(rejectExit1())
@@ -1215,29 +1014,6 @@ describe('createMaestroTestsBuildFunction', () => {
    );
  });

-  it('discovers maestro-runner flow results from the attempt report directory', async () => {
-    mockedSpawn.mockResolvedValue(SPAWN_SUCCESS);
-    const shot = makeShot(0);
-    jest.spyOn(fs, 'copyFile').mockResolvedValue();
-    mockedRunnerHarvest.mockResolvedValue([shot]);
-    const parseFlowResultsSpy = jest.spyOn(parser, 'parseMaestroRunnerReport').mockResolvedValue({
-      flows: [{ name: 'Login', sourceFile: 'a.yaml', status: 'failed' }],
-    });
-
-    const step = createStep({
-      flow_path: ['a.yaml'],
-      platform: 'ios',
-      output_format: 'junit',
-      backend: 'maestro-runner',
-    });
-    await step.executeAsync();
-
-    expect(parseFlowResultsSpy).toHaveBeenCalledWith(
-      '/home/expo/.maestro/tests/ios-maestro-runner-attempt-0'
-    );
-    expect(mockUploadArtifact).toHaveBeenCalledTimes(1);
-  });
-
  it('uploads screenshots even when all attempts fail, before throwing ERR_MAESTRO_TESTS_FAILED', async () => {
    mockedSpawn.mockRejectedValue(rejectExit1());
    const shot = makeShot(0);
@@ -26,7 +26,6 @@ describe(readIpaInfoAsync, () => {
      bundleIdentifier: 'dev.expo.SmallestAppExample',
      bundleShortVersion: '1.0',
      bundleVersion: '1',
-      dtPlatformName: 'iphoneos',
    });
  });

@@ -1,205 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { BuildRuntimePlatform, type BuildStepContext } from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-import fs from 'node:fs';
-
-import { type CustomBuildContext } from '../../../customBuildContext';
-import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
-import { isProcessDescendantOfAsync } from '../../../utils/processes';
-import { turtleFetch } from '../../../utils/turtleFetch';
-import {
-  monitorLocalEgressAsync,
-  readLocalEgressHandoffAsync,
-  registerLocalEgressResources,
-  stopLocalEgressResourcesAsync,
-} from '../../utils/localEgress';
-import {
-  startDeviceWebPreviewWithTunnelAsync,
-  uploadRemoteSessionConfigAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../../utils/remoteDeviceRunSession';
-import { createStartAgentDeviceRemoteSessionBuildFunction } from '../startAgentDeviceRemoteSession';
-import { createStartAppiumRemoteSessionBuildFunction } from '../startAppiumRemoteSession';
-import { createStartArgentRemoteSessionBuildFunction } from '../startArgentRemoteSession';
-import { createStartWebPreviewRemoteSessionBuildFunction } from '../startWebPreviewRemoteSession';
-
-jest.mock('@expo/turtle-spawn');
-jest.mock('../../../utils/IosSimulatorUtils');
-jest.mock('../../../utils/processes');
-jest.mock('../../../utils/turtleFetch');
-jest.mock('../../utils/agentDeviceArtifacts');
-jest.mock('../../utils/argentArtifacts');
-jest.mock('../../utils/agentDeviceEvents', () => ({
-  startAgentDeviceEventCollectionAsync: async () => ({ stopAsync: jest.fn() }),
-}));
-jest.mock('../../utils/argentEvents', () => ({
-  ARGENT_EVENT_LOG_FILENAME: 'events.jsonl',
-  startArgentEventCollectionAsync: async () => ({ stopAsync: jest.fn() }),
-}));
-jest.mock('../../utils/appiumEvents', () => ({
-  startAppiumEventCollectionAsync: async () => ({ stopAsync: jest.fn() }),
-}));
-jest.mock('../../utils/localEgress', () => ({
-  ...jest.requireActual('../../utils/localEgress'),
-  readLocalEgressHandoffAsync: jest.fn(),
-  monitorLocalEgressAsync: jest.fn(),
-}));
-jest.mock('../../utils/remoteDeviceRunSession', () => ({
-  getDeviceRunSessionIdOrThrow: () => 'session-id',
-  getNgrokTunnelDomainOrThrow: () => 'example.test',
-  getNgrokAuthtokenOrThrow: () => 'ngrok-token',
-  selectXcodeDeveloperDirectoryAsync: jest.fn(),
-  ensureFfmpegInstalledOnceAsync: jest.fn(),
-  spawnDetached: () => ({ pid: 123, getOutput: () => '', stopAsync: jest.fn() }),
-  waitForFileAsync: async () => ({ port: 1234, token: 'controller-token' }),
-  startNgrokTunnelAsync: async () => ({ url: 'https://controller.test', stopAsync: jest.fn() }),
-  startDeviceWebPreviewWithTunnelAsync: jest.fn(),
-  uploadRemoteSessionConfigAsync: jest.fn(),
-  waitForDeviceRunSessionStoppedAsync: jest.fn(),
-}));
-
-const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-const ctx = {} as CustomBuildContext;
-const env = { DEVICE_RUN_SESSION_ID: 'session-id' };
-const handoff = { url: 'https://egress.test', token: 'secret', fingerprint: 'key=', port: 8899 };
-const fields = {
-  egressUrl: handoff.url,
-  egressToken: handoff.token,
-  egressFingerprint: handoff.fingerprint,
-  egressPort: handoff.port,
-};
-const controllers = [
-  ['agent-device', createStartAgentDeviceRemoteSessionBuildFunction, 'agentDeviceRemoteSessionUrl'],
-  ['Appium', createStartAppiumRemoteSessionBuildFunction, 'appiumUrl'],
-  ['Argent', createStartArgentRemoteSessionBuildFunction, 'toolsUrl'],
-  ['web preview', createStartWebPreviewRemoteSessionBuildFunction, 'previewUrl'],
-] as const;
-
-describe.each(controllers)('%s local egress', (_name, createFunction, controllerField) => {
-  const stopPreview = jest.fn();
-  const stopEgress = jest.fn();
-  let lifetime: AbortSignal;
-  async function run(signal?: AbortSignal): Promise<void> {
-    await createFunction(ctx).fn!(
-      { logger, global: { runtimePlatform: BuildRuntimePlatform.DARWIN } } as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-        },
-        outputs: {},
-        env,
-        signal,
-      } as never
-    );
-  }
-  beforeEach(() => {
-    jest.clearAllMocks();
-    lifetime = registerLocalEgressResources(stopEgress);
-    stopEgress.mockResolvedValue(undefined);
-    stopPreview.mockResolvedValue(undefined);
-    jest.spyOn(fs, 'existsSync').mockReturnValue(true);
-    jest.spyOn(fs.promises, 'mkdtemp').mockResolvedValue('/tmp/appium-egress-test');
-    jest.spyOn(fs.promises, 'writeFile').mockResolvedValue(undefined);
-    jest.spyOn(fs.promises, 'rm').mockResolvedValue(undefined);
-    jest.spyOn(fs.promises, 'readdir').mockResolvedValue(['tool-server.json'] as never);
-    jest
-      .spyOn(fs.promises, 'readFile')
-      .mockResolvedValue(JSON.stringify({ port: 1234, pid: 124, token: 'controller-token' }));
-    jest.mocked(spawn).mockResolvedValue({ stdout: '{}' } as never);
-    jest.mocked(isProcessDescendantOfAsync).mockResolvedValue(true);
-    jest
-      .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ udid: 'sim' }] as never);
-    jest.mocked(turtleFetch).mockResolvedValue({ ok: true } as never);
-    jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue(handoff);
-    jest.mocked(monitorLocalEgressAsync).mockResolvedValue(undefined);
-    jest.mocked(startDeviceWebPreviewWithTunnelAsync).mockResolvedValue({
-      previewUrl: 'https://preview.test',
-      previewToken: 'preview-secret',
-      stopAsync: stopPreview,
-    });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async () => {
-      expect(lifetime.aborted).toBe(false);
-      expect(monitorLocalEgressAsync).toHaveBeenCalledTimes(1);
-    });
-  });
-  afterEach(async () => {
-    await stopLocalEgressResourcesAsync(logger);
-    jest.restoreAllMocks();
-  });
-
-  it('reports credentials and starts monitoring before waiting, then releases resources', async () => {
-    await run();
-    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,
-      logger,
-      signal: expect.any(AbortSignal),
-    });
-    expect(lifetime.aborted).toBe(true);
-    expect(stopEgress).toHaveBeenCalledTimes(1);
-  });
-  it('leaves ordinary remote config unchanged and does not monitor', async () => {
-    await stopLocalEgressResourcesAsync(logger);
-    stopEgress.mockClear();
-    jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue(null);
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
-    await run();
-    const { remoteConfig } = jest.mocked(uploadRemoteSessionConfigAsync).mock.calls[0][0];
-    expect(remoteConfig).toHaveProperty(controllerField);
-    expect(Object.keys(remoteConfig).some(key => key.startsWith('egress'))).toBe(false);
-    expect(monitorLocalEgressAsync).not.toHaveBeenCalled();
-    expect(stopEgress).not.toHaveBeenCalled();
-  });
-  it.each(['startup', 'report', 'wait', 'teardown'])(
-    'releases egress after %s fails',
-    async phase => {
-      const error = new Error(`${phase} failed`);
-      if (phase === 'startup') {
-        jest.mocked(startDeviceWebPreviewWithTunnelAsync).mockRejectedValue(error);
-      } else if (phase === 'report') {
-        jest.mocked(uploadRemoteSessionConfigAsync).mockRejectedValue(error);
-      } else if (phase === 'wait') {
-        jest.mocked(waitForDeviceRunSessionStoppedAsync).mockRejectedValue(error);
-      } else {
-        stopPreview.mockRejectedValue(error);
-      }
-      await expect(run()).rejects.toThrow(error);
-      expect(lifetime.aborted).toBe(true);
-      expect(stopEgress).toHaveBeenCalledTimes(1);
-      expect(monitorLocalEgressAsync).toHaveBeenCalledTimes(
-        phase === 'startup' || phase === 'report' ? 0 : 1
-      );
-    }
-  );
-  it('passes cancellation to the monitor and releases the lifetime', async () => {
-    const abort = new AbortController();
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockImplementation(async () => abort.abort());
-    await run(abort.signal);
-    expect(monitorLocalEgressAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ signal: abort.signal })
-    );
-    expect(lifetime.aborted).toBe(true);
-    expect(stopEgress).toHaveBeenCalledTimes(1);
-  });
-  it('does not report or start a monitor after cancellation', async () => {
-    const abort = new AbortController();
-    abort.abort();
-    await expect(run(abort.signal)).rejects.toThrow();
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    expect(monitorLocalEgressAsync).not.toHaveBeenCalled();
-    expect(stopEgress).toHaveBeenCalledTimes(1);
-  });
-});
@@ -1,5 +1,4 @@
 import { type bunyan } from '@expo/logger';
-import assert from 'node:assert';
 import fg from 'fast-glob';
 import { vol } from 'memfs';
 import path from 'node:path';
@@ -194,53 +193,22 @@ describe(resolveIosSigningOptionsAsync, () => {
    const signingOptions = await resolveIosSigningOptionsAsync({
      job,
      logger: mockLogger,
-      tmpDir: '/tmp',
    });

    expect(signingOptions).not.toBeNull();
-    expect(signingOptions).toMatchObject({
-      keychainPath: '/tmp/ios_keychain',
-      signingIdentity: 'Test App Certificate',
-      provisioningProfile: {
-        'com.example.testapp': '/tmp/ios_provisioning_profile',
-      },
+    expect(signingOptions?.keychainPath).toEqual('/tmp/ios_keychain');
+    expect(signingOptions?.signingIdentity).toEqual('Test App Certificate');
+    expect(signingOptions?.provisioningProfile).toEqual({
+      'com.example.testapp': '/tmp/ios_provisioning_profile',
    });
  });

-  it('should resolve zsign signing options without touching the keychain', async () => {
-    const job = createTestIosJob();
-    const tmpDir = '/tmp';
-    vol.mkdirSync(tmpDir, { recursive: true });
-    const credentialsManagerSpy = jest.spyOn(IosCredentialsManager.prototype, 'prepare');
-
-    const signingOptions = await resolveIosSigningOptionsAsync({
-      job,
-      logger: mockLogger,
-      backend: 'zsign',
-      tmpDir,
-    });
-
-    expect(credentialsManagerSpy).not.toHaveBeenCalled();
-    expect(signingOptions).toMatchObject({
-      backend: 'zsign',
-      keyPassword: job.secrets?.buildCredentials?.['testapp'].distributionCertificate.password,
-    });
-    assert(signingOptions?.backend === 'zsign');
-    expect(signingOptions.certificatePath).toMatch(/\/tmp\/dist-cert-.*\.p12/);
-    expect(vol.existsSync(signingOptions.certificatePath)).toBe(true);
-    assert(typeof signingOptions.provisioningProfile === 'object');
-    const profilePath = signingOptions.provisioningProfile['testapp'];
-    expect(profilePath).toMatch(/\/tmp\/profile-testapp-.*\.mobileprovision/);
-    expect(vol.existsSync(profilePath)).toBe(true);
-  });
-
  it('should return undefined if no build credentials are provided', async () => {
    // @ts-expect-error: createTestIosJob does not support buildCredentials as null
    const job = createTestIosJob({ buildCredentials: null });
    const signingOptions = await resolveIosSigningOptionsAsync({
      job,
      logger: mockLogger,
-      tmpDir: '/tmp',
    });
    expect(signingOptions).toBeUndefined();
  });
@@ -251,7 +219,6 @@ describe(resolveIosSigningOptionsAsync, () => {
    const signingOptions = await resolveIosSigningOptionsAsync({
      job,
      logger: mockLogger,
-      tmpDir: '/tmp',
    });
    expect(signingOptions).toBeUndefined();
  });
@@ -1,157 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { Platform } from '@expo/eas-build-job';
-import fs from 'fs';
-import fetch from 'node-fetch';
-import os from 'os';
-import path from 'path';
-
-import { compressCacheAsync, uploadCacheAsync } from '../saveCache';
-import { decompressCacheAsync } from '../restoreCache';
-
-jest.mock('node-fetch');
-
-const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
-
-function createLoggerMock(): bunyan {
-  return { info: jest.fn(), warn: jest.fn(), error: jest.fn() } as unknown as bunyan;
-}
-
-describe('cache compress/decompress round trip', () => {
-  it('preserves multiple sibling directories archived together', async () => {
-    const logger = createLoggerMock();
-
-    const cachesDir = path.join(os.tmpdir(), 'gradle-caches');
-    const buildCacheDir = path.join(cachesDir, 'build-cache-1');
-    const journalDir = path.join(cachesDir, 'journal-1');
-    await fs.promises.mkdir(buildCacheDir, { recursive: true });
-    await fs.promises.mkdir(journalDir, { recursive: true });
-    await fs.promises.writeFile(path.join(buildCacheDir, 'entry'), 'cache entry');
-    await fs.promises.writeFile(path.join(journalDir, 'file-access.properties'), 'inception=1');
-
-    const { archivePath } = await compressCacheAsync({
-      paths: [buildCacheDir, journalDir],
-      workingDirectory: cachesDir,
-      verbose: false,
-      logger,
-    });
-
-    const restoreDir = path.join(os.tmpdir(), 'gradle-caches-restored');
-    await fs.promises.mkdir(restoreDir, { recursive: true });
-    await decompressCacheAsync({
-      archivePath,
-      workingDirectory: restoreDir,
-      verbose: false,
-      logger,
-    });
-
-    expect(
-      await fs.promises.readFile(path.join(restoreDir, 'build-cache-1', 'entry'), 'utf8')
-    ).toBe('cache entry');
-    expect(
-      await fs.promises.readFile(
-        path.join(restoreDir, 'journal-1', 'file-access.properties'),
-        'utf8'
-      )
-    ).toBe('inception=1');
-  });
-
-  it('preserves file modification times so journal-fallback entries can still age out', async () => {
-    const logger = createLoggerMock();
-
-    const sourceDir = path.join(os.tmpdir(), 'mtime-source');
-    await fs.promises.mkdir(sourceDir, { recursive: true });
-    const filePath = path.join(sourceDir, 'entry');
-    await fs.promises.writeFile(filePath, 'cache entry');
-
-    // A whole-second value in the past — tar stores mtimes at one-second resolution.
-    const mtime = new Date('2026-08-01T00:00:00.000Z');
-    await fs.promises.utimes(filePath, mtime, mtime);
-
-    const { archivePath } = await compressCacheAsync({
-      paths: [sourceDir],
-      workingDirectory: sourceDir,
-      verbose: false,
-      logger,
-    });
-
-    const restoreDir = path.join(os.tmpdir(), 'mtime-restored');
-    await fs.promises.mkdir(restoreDir, { recursive: true });
-    await decompressCacheAsync({
-      archivePath,
-      workingDirectory: restoreDir,
-      verbose: false,
-      logger,
-    });
-
-    const restoredStat = await fs.promises.stat(path.join(restoreDir, 'entry'));
-    expect(Math.floor(restoredStat.mtimeMs / 1000)).toBe(Math.floor(mtime.getTime() / 1000));
-  });
-});
-
-describe(uploadCacheAsync, () => {
-  afterEach(() => {
-    jest.mocked(fetch).mockReset();
-  });
-
-  it.each([
-    ['normal upload', undefined, false],
-    ['forced upload', true, true],
-  ] as const)('sends force for %s', async (_name, force, expectedForce) => {
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'upload-cache-test-'));
-    const archivePath = path.join(tempDir, 'cache.tar.gz');
-    await fs.promises.writeFile(archivePath, 'cache archive');
-
-    jest
-      .mocked(fetch)
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            data: {
-              headers: {},
-              url: 'https://storage.expo.test/cache',
-            },
-          }),
-          { status: 200 }
-        )
-      )
-      .mockImplementationOnce(async (_url, request) => {
-        const body = request!.body as NodeJS.ReadableStream & AsyncIterable<Buffer>;
-        for await (const _chunk of body) {
-          // Consume the archive stream as a real upload would.
-        }
-        return new Response(undefined, { status: 200 });
-      });
-
-    try {
-      await uploadCacheAsync({
-        logger: createLoggerMock(),
-        jobId: 'build-id',
-        expoApiServerURL: 'https://api.expo.test',
-        robotAccessToken: 'robot-token',
-        paths: ['/cache/path'],
-        key: 'cache-key',
-        archivePath,
-        size: 13,
-        platform: Platform.ANDROID,
-        force,
-      });
-
-      expect(fetch).toHaveBeenCalledTimes(2);
-      const [uploadSessionUrl, uploadSessionRequest] = jest.mocked(fetch).mock.calls[0];
-      expect(uploadSessionUrl.toString()).toBe(
-        'https://api.expo.test/v2/turtle-builds/caches/upload-sessions'
-      );
-      expect(JSON.parse(uploadSessionRequest!.body as string)).toMatchObject({
-        buildId: 'build-id',
-        force: expectedForce,
-        key: 'cache-key',
-        size: 13,
-      });
-      expect(jest.mocked(fetch).mock.calls[1][0].toString()).toBe(
-        'https://storage.expo.test/cache'
-      );
-    } finally {
-      await fs.promises.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-});
@@ -83,31 +83,6 @@ describe(createStartAndroidEmulatorBuildFunction, () => {
    mockedMkdtemp.mockRestore();
  });

-  it('passes profile and LCD inputs to emulator creation', async () => {
-    const systemImagePackage = 'system-images;android-35;default;x86_64';
-    await createStep({
-      device_identifier: 'medium_phone',
-      system_image_package: systemImagePackage,
-      lcd_width: 720,
-      lcd_height: 1600,
-      lcd_density: 262,
-    }).executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith('sdkmanager', [systemImagePackage], expect.anything());
-    expect(mockedAndroidUtils.createAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        deviceIdentifier: 'medium_phone',
-        systemImagePackage,
-        lcdWidth: 720,
-        lcdHeight: 1600,
-        lcdDensity: 262,
-      })
-    );
-    expect(mockedAndroidUtils.createAsync.mock.invocationCallOrder[0]).toBeLessThan(
-      mockedAndroidUtils.startAsync.mock.invocationCallOrder[0]
-    );
-  });
-
  it('retries base emulator startup with increasing readiness timeouts', async () => {
    mockedAndroidUtils.startAsync
      .mockResolvedValueOnce(createStartResult('emulator-1111'))
@@ -1,86 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-
-import { AndroidEmulatorUtils } from '../../../utils/AndroidEmulatorUtils';
-import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
-import { selectXcodeDeveloperDirectoryAsync } from '../../utils/remoteDeviceRunSession';
-
-import { resolveAppium3VersionSpec, resolveAppiumDeviceAsync } from '../startAppiumRemoteSession';
-
-jest.mock('../../../utils/AndroidEmulatorUtils', () => ({
-  AndroidEmulatorUtils: { getAttachedDevicesAsync: jest.fn() },
-}));
-jest.mock('../../../utils/IosSimulatorUtils', () => ({
-  IosSimulatorUtils: { getAvailableDevicesAsync: jest.fn() },
-}));
-jest.mock('../../utils/remoteDeviceRunSession', () => ({
-  selectXcodeDeveloperDirectoryAsync: jest.fn(),
-}));
-
-const logger = { info: jest.fn(), warn: jest.fn() } as never;
-
-describe(resolveAppium3VersionSpec, () => {
-  it('uses the worker-supported Appium 3 version by default', () => {
-    expect(resolveAppium3VersionSpec(undefined)).toBe('^3');
-  });
-
-  it.each(['3', '^3', '3.x', '3.5.0', '>=3 <4'])('accepts Appium 3 version %s', version => {
-    expect(resolveAppium3VersionSpec(version)).toBe(version);
-  });
-
-  it.each(['2', '2.19.0', 'latest', '4.0.0', '>=3'])('rejects version %s', version => {
-    expect(() => resolveAppium3VersionSpec(version)).toThrow(
-      `Appium 3 is required for EAS Simulator sessions. Received package version "${version}".`
-    );
-  });
-});
-
-describe(resolveAppiumDeviceAsync, () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('returns XCUITest capabilities for the booted iOS simulator', async () => {
-    jest
-      .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ udid: 'ios-simulator-id' } as never]);
-
-    await expect(
-      resolveAppiumDeviceAsync({
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-        env: {},
-        logger,
-      })
-    ).resolves.toEqual({
-      platformName: 'iOS',
-      automationName: 'XCUITest',
-      driverName: 'xcuitest',
-      udid: 'ios-simulator-id',
-    });
-    expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledWith({ env: {}, logger });
-    expect(IosSimulatorUtils.getAvailableDevicesAsync).toHaveBeenCalledWith({
-      env: {},
-      filter: 'booted',
-    });
-  });
-
-  it('returns UiAutomator2 capabilities for the booted Android emulator', async () => {
-    jest
-      .mocked(AndroidEmulatorUtils.getAttachedDevicesAsync)
-      .mockResolvedValue([{ serialId: 'emulator-5554', state: 'device' } as never]);
-
-    await expect(
-      resolveAppiumDeviceAsync({
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger,
-      })
-    ).resolves.toEqual({
-      platformName: 'Android',
-      automationName: 'UiAutomator2',
-      driverName: 'uiautomator2',
-      udid: 'emulator-5554',
-    });
-    expect(AndroidEmulatorUtils.getAttachedDevicesAsync).toHaveBeenCalledWith({ env: {} });
-    expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
-  });
-});
@@ -9,13 +9,11 @@ import { isProcessDescendantOfAsync } from '../../../utils/processes';
 import { pollArgentArtifactsForUploadAsync } from '../../utils/argentArtifacts';
 import { startArgentEventCollectionAsync } from '../../utils/argentEvents';
 import {
-  ensureFfmpegInstalledOnceAsync,
  getDeviceRunSessionIdOrThrow,
  getNgrokAuthtokenOrThrow,
  getNgrokTunnelDomainOrThrow,
  selectXcodeDeveloperDirectoryAsync,
  spawnDetached,
-  startDeviceWebPreviewWithTunnelAsync,
  startNgrokTunnelAsync,
  uploadRemoteSessionConfigAsync,
  waitForDeviceRunSessionStoppedAsync,
@@ -42,14 +40,14 @@ jest.mock('../../utils/argentEvents', () => ({
  startArgentEventCollectionAsync: jest.fn(),
 }));
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
-  ensureFfmpegInstalledOnceAsync: jest.fn(),
+  ensureFfmpegInstalledAsync: jest.fn(),
  getDeviceRunSessionIdOrThrow: jest.fn(),
  getNgrokAuthtokenOrThrow: jest.fn(),
  getNgrokTunnelDomainOrThrow: jest.fn(),
  selectXcodeDeveloperDirectoryAsync: jest.fn(),
  spawnDetached: jest.fn(),
-  startDeviceWebPreviewWithTunnelAsync: jest.fn(),
  startNgrokTunnelAsync: jest.fn(),
+  startServeSimWithTunnelAsync: jest.fn(),
  uploadRemoteSessionConfigAsync: jest.fn(),
  waitForDeviceRunSessionStoppedAsync: jest.fn(),
 }));
@@ -60,7 +58,6 @@ const EXPECTED_EVENT_LOG_PATH = path.join(ARGENT_STATE_DIR, 'tool-server-events.

 const mockStopAsync = jest.fn();
 const mockTunnelStopAsync = jest.fn();
-const mockPreviewStopAsync = jest.fn();

 describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
  beforeEach(async () => {
@@ -71,7 +68,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
    jest.mocked(pollArgentArtifactsForUploadAsync).mockResolvedValue(undefined);
    mockStopAsync.mockResolvedValue(undefined);
    mockTunnelStopAsync.mockResolvedValue(undefined);
-    mockPreviewStopAsync.mockResolvedValue(undefined);
    jest.mocked(startArgentEventCollectionAsync).mockResolvedValue({
      stopAsync: mockStopAsync,
      getLastEventObservedAt: () => undefined,
@@ -90,10 +86,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
      url: 'https://argent-abc.tunnel.example.com',
      stopAsync: mockTunnelStopAsync,
    });
-    jest.mocked(startDeviceWebPreviewWithTunnelAsync).mockResolvedValue({
-      previewUrl: 'https://web-preview.tunnel.example.com',
-      stopAsync: mockPreviewStopAsync,
-    });
    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);

@@ -128,31 +120,18 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
      } as never
    );

-    // (1) FFmpeg setup starts in the background before Argent setup.
-    expect(ensureFfmpegInstalledOnceAsync).toHaveBeenCalledWith({
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: { EXISTING: 'value' },
-      logger: expect.anything(),
-    });
-    expect(jest.mocked(ensureFfmpegInstalledOnceAsync).mock.invocationCallOrder[0]).toBeLessThan(
-      jest.mocked(spawn).mock.invocationCallOrder[0]
-    );
-
-    // (2) The event log flag is enabled, before the tool-server is launched.
+    // (1) The event log flag is enabled, before the tool-server is launched.
    const spawnCalls = jest.mocked(spawn).mock.calls;
    const enableEventLogIndex = spawnCalls.findIndex(
      ([command, args]) =>
-        command === 'bun' &&
-        Array.isArray(args) &&
-        args[0] === 'x' &&
-        args.includes('tool-server-event-log')
+        command === 'bunx' && Array.isArray(args) && args.includes('tool-server-event-log')
    );
    expect(enableEventLogIndex).toBeGreaterThanOrEqual(0);
    expect(jest.mocked(spawn).mock.invocationCallOrder[enableEventLogIndex]).toBeLessThan(
      jest.mocked(spawnDetached).mock.invocationCallOrder[0]
    );

-    // (3) The tool-server and the collector are pinned to the exact same event log path.
+    // (2) The tool-server and the collector are pinned to the exact same event log path.
    const serverEnv = jest.mocked(spawnDetached).mock.calls[0][0].env;
    expect(serverEnv.ARGENT_EVENT_LOG).toBe(EXPECTED_EVENT_LOG_PATH);
    expect(serverEnv.EXISTING).toBe('value');
@@ -161,7 +140,7 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
      eventLogPath: EXPECTED_EVENT_LOG_PATH,
    });

-    // (4) Collection starts (before we wait for the session to stop) and (5) is torn down
+    // (3) Collection starts (before we wait for the session to stop) and (4) is torn down
    // afterwards, exactly once.
    expect(startArgentEventCollectionAsync).toHaveBeenCalledTimes(1);
    expect(mockStopAsync).toHaveBeenCalledTimes(1);
@@ -172,17 +151,5 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
      jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.invocationCallOrder[0]
    );
    expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
-    expect(startDeviceWebPreviewWithTunnelAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX })
-    );
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        remoteConfig: expect.objectContaining({
-          webPreviewUrl: 'https://web-preview.tunnel.example.com',
-        }),
-      })
-    );
-    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
  });
 });
@@ -74,7 +74,7 @@ describe(warnIfArgentPackageVersionCannotBeVerified, () => {
    ).not.toThrow();
    expect(warn).toHaveBeenCalledTimes(2);
    expect(warn).toHaveBeenCalledWith(
-      expect.stringContaining('Continuing and letting bun x resolve it.')
+      expect.stringContaining('Continuing and letting bunx resolve it.')
    );
  });
 });
@@ -1,187 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { type BuildStepContext } from '@expo/steps';
-import fs from 'node:fs';
-
-import {
-  LOCAL_EGRESS_HANDOFF_PATH,
-  configureSystemProxyAsync,
-  downloadChiselAsync,
-  startChiselServerAsync,
-  stopLocalEgressResourcesAsync,
-  writeLocalEgressHandoffAsync,
-} from '../../utils/localEgress';
-import { findAvailablePortAsync, startNgrokTunnelAsync } from '../../utils/remoteDeviceRunSession';
-import { createStartLocalEgressBuildFunction } from '../startLocalEgress';
-
-jest.mock('../../utils/localEgress', () => ({
-  ...jest.requireActual('../../utils/localEgress'),
-  configureSystemProxyAsync: jest.fn(),
-  downloadChiselAsync: jest.fn(),
-  startChiselServerAsync: jest.fn(),
-  writeLocalEgressHandoffAsync: jest.fn(),
-}));
-jest.mock('../../utils/remoteDeviceRunSession', () => ({
-  findAvailablePortAsync: jest.fn(),
-  startNgrokTunnelAsync: jest.fn(),
-  getNgrokAuthtokenOrThrow: () => 'ngrok-token',
-  getNgrokTunnelDomainOrThrow: () => 'example.com',
-}));
-
-const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-const server = { pid: 12345, getOutput: () => '', stopAsync: jest.fn() };
-const tunnel = { url: 'https://egress.example.com', stopAsync: jest.fn() };
-
-async function start(signal?: AbortSignal): Promise<void> {
-  await createStartLocalEgressBuildFunction().fn!({ logger } as BuildStepContext, {
-    env: {},
-    inputs: {},
-    outputs: {},
-    signal,
-  });
-}
-
-describe('local egress acquisition', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(fs.promises, 'mkdtemp').mockResolvedValue('/tmp/egress-acquisition-test');
-    jest.spyOn(fs.promises, 'writeFile').mockResolvedValue(undefined);
-    jest.spyOn(fs.promises, 'rm').mockResolvedValue(undefined);
-    server.stopAsync.mockResolvedValue(undefined);
-    tunnel.stopAsync.mockResolvedValue(undefined);
-    jest.mocked(findAvailablePortAsync).mockResolvedValue(52001);
-    jest.mocked(downloadChiselAsync).mockResolvedValue('/tmp/egress-acquisition-test/chisel');
-    jest.mocked(startChiselServerAsync).mockResolvedValue({ process: server, fingerprint: 'key=' });
-    jest.mocked(startNgrokTunnelAsync).mockResolvedValue(tunnel);
-    jest.mocked(configureSystemProxyAsync).mockResolvedValue({ service: 'Ethernet' });
-    jest.mocked(writeLocalEgressHandoffAsync).mockResolvedValue(undefined);
-  });
-
-  afterEach(async () => {
-    await stopLocalEgressResourcesAsync(logger);
-    jest.restoreAllMocks();
-  });
-
-  it('stops the detached server and removes credentials when ngrok acquisition fails', async () => {
-    jest.mocked(startNgrokTunnelAsync).mockRejectedValue(new Error('listener quota'));
-    await expect(start()).rejects.toThrow('listener quota');
-    expect(server.stopAsync).toHaveBeenCalledTimes(1);
-    expect(configureSystemProxyAsync).not.toHaveBeenCalled();
-    expect(fs.promises.rm).toHaveBeenCalledWith('/tmp/egress-acquisition-test', {
-      recursive: true,
-      force: true,
-    });
-  });
-
-  it('attempts every release even when one resource cannot stop', async () => {
-    await start();
-    tunnel.stopAsync.mockRejectedValue(new Error('ngrok close failed'));
-    await stopLocalEgressResourcesAsync(logger);
-    expect(server.stopAsync).toHaveBeenCalledTimes(1);
-    expect(fs.promises.rm).toHaveBeenCalledWith(LOCAL_EGRESS_HANDOFF_PATH, { force: true });
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.objectContaining({ err: expect.any(Error) }),
-      'Could not stop a local egress resource.'
-    );
-  });
-
-  it.each([false, true])(
-    'disposes late listeners without delaying cleanup (close fails: %s)',
-    async closeFails => {
-      let finishTunnel!: (value: typeof tunnel) => void;
-      jest.mocked(startNgrokTunnelAsync).mockImplementation(
-        () =>
-          new Promise(resolve => {
-            finishTunnel = resolve;
-          })
-      );
-      const started = start();
-      const rejected = expect(started).rejects.toThrow();
-      await new Promise(resolve => setImmediate(resolve));
-      expect(startNgrokTunnelAsync).toHaveBeenCalledTimes(1);
-      const stopped = stopLocalEgressResourcesAsync(logger);
-      await Promise.all([stopped, rejected]);
-      expect(server.stopAsync).toHaveBeenCalledTimes(1);
-      expect(tunnel.stopAsync).not.toHaveBeenCalled();
-      if (closeFails) {
-        tunnel.stopAsync.mockRejectedValue(new Error('late close failed'));
-      }
-      finishTunnel(tunnel);
-      await new Promise(resolve => setImmediate(resolve));
-      if (closeFails) {
-        expect(logger.warn).toHaveBeenCalledWith(
-          expect.objectContaining({ err: expect.any(Error) }),
-          'Could not release a cancelled local egress acquisition.'
-        );
-      }
-      expect(tunnel.stopAsync).toHaveBeenCalledTimes(1);
-      expect(configureSystemProxyAsync).not.toHaveBeenCalled();
-      expect(writeLocalEgressHandoffAsync).not.toHaveBeenCalled();
-    }
-  );
-
-  it.each(['job', 'step'])('finishes %s cancellation when ngrok never settles', async source => {
-    jest.mocked(startNgrokTunnelAsync).mockReturnValue(new Promise(() => {}));
-    const controller = new AbortController();
-    const started = start(controller.signal);
-    const rejected = expect(started).rejects.toThrow();
-    await new Promise(resolve => setImmediate(resolve));
-    expect(startNgrokTunnelAsync).toHaveBeenCalledTimes(1);
-    if (source === 'step') {
-      controller.abort(new Error('cancelled'));
-    }
-    const stopped = source === 'job' ? stopLocalEgressResourcesAsync(logger) : Promise.resolve();
-    const outcome = await Promise.race([
-      Promise.all([stopped, rejected]).then(() => 'stopped'),
-      new Promise(resolve => setImmediate(() => resolve('still waiting'))),
-    ]);
-    expect(outcome).toBe('stopped');
-    expect(server.stopAsync).toHaveBeenCalledTimes(1);
-    expect(configureSystemProxyAsync).not.toHaveBeenCalled();
-    expect(writeLocalEgressHandoffAsync).not.toHaveBeenCalled();
-  });
-
-  it('handles ngrok rejection after finalization without an unhandled rejection', async () => {
-    let rejectTunnel!: (error: Error) => void;
-    jest.mocked(startNgrokTunnelAsync).mockReturnValue(
-      new Promise((_resolve, reject) => {
-        rejectTunnel = reject;
-      })
-    );
-    const started = start();
-    const rejected = expect(started).rejects.toThrow();
-    await new Promise(resolve => setImmediate(resolve));
-    await Promise.all([stopLocalEgressResourcesAsync(logger), rejected]);
-    rejectTunnel(new Error('late connection failure'));
-    await new Promise(resolve => setImmediate(resolve));
-    expect(server.stopAsync).toHaveBeenCalledTimes(1);
-    expect(configureSystemProxyAsync).not.toHaveBeenCalled();
-  });
-
-  it('does not launch a server after a download finishes following cancellation', async () => {
-    let finishDownload!: (value: string) => void;
-    jest.mocked(downloadChiselAsync).mockImplementation(
-      () =>
-        new Promise(resolve => {
-          finishDownload = resolve;
-        })
-    );
-    const controller = new AbortController();
-    const started = start(controller.signal);
-    const rejected = expect(started).rejects.toThrow('cancelled');
-    await new Promise(resolve => setImmediate(resolve));
-    controller.abort(new Error('cancelled'));
-    await rejected;
-    finishDownload('/tmp/chisel');
-    await new Promise(resolve => setImmediate(resolve));
-    expect(startChiselServerAsync).not.toHaveBeenCalled();
-    expect(
-      jest
-        .mocked(fs.promises.rm)
-        .mock.calls.filter(([target]) => target === '/tmp/egress-acquisition-test')
-    ).toHaveLength(2);
-    expect(fs.promises.rm).toHaveBeenCalledWith('/tmp/egress-acquisition-test', {
-      recursive: true,
-      force: true,
-    });
-  });
-});
@@ -1,104 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { BuildRuntimePlatform, type BuildStepContext, type BuildStepEnv } from '@expo/steps';
-
-import { type CustomBuildContext } from '../../../customBuildContext';
-import {
-  getDeviceRunSessionIdOrThrow,
-  getNgrokTunnelDomainOrThrow,
-  selectXcodeDeveloperDirectoryAsync,
-  startDeviceWebPreviewWithTunnelAsync,
-  uploadRemoteSessionConfigAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../../utils/remoteDeviceRunSession';
-import { createStartWebPreviewRemoteSessionBuildFunction } from '../startWebPreviewRemoteSession';
-
-jest.mock('../../utils/remoteDeviceRunSession');
-
-const ctx = {} as CustomBuildContext;
-const env = {} as BuildStepEnv;
-const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-const stopAsync = jest.fn();
-
-async function runAsync(runtimePlatform: BuildRuntimePlatform): Promise<void> {
-  const buildFunction = createStartWebPreviewRemoteSessionBuildFunction(ctx);
-  await buildFunction.fn!(
-    {
-      logger,
-      global: { runtimePlatform },
-    } as unknown as BuildStepContext,
-    {
-      inputs: {
-        package_version: { value: '1.2.3' },
-        max_duration_seconds: { value: 120 },
-      },
-      outputs: {},
-      env,
-    } as never
-  );
-}
-
-describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.mocked(getDeviceRunSessionIdOrThrow).mockReturnValue('device-run-session-id');
-    jest.mocked(getNgrokTunnelDomainOrThrow).mockReturnValue('tunnel.example.com');
-    jest.mocked(selectXcodeDeveloperDirectoryAsync).mockResolvedValue(undefined);
-    jest.mocked(startDeviceWebPreviewWithTunnelAsync).mockResolvedValue({
-      previewUrl: 'https://web-preview.example.test',
-      stopAsync,
-    });
-    jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
-    jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
-    stopAsync.mockResolvedValue(undefined);
-  });
-
-  it('reports the session token when serve-sim minted one', async () => {
-    jest.mocked(startDeviceWebPreviewWithTunnelAsync).mockResolvedValue({
-      previewUrl: 'https://web-preview.example.test',
-      previewToken: 'tok-1',
-      stopAsync,
-    });
-
-    await runAsync(BuildRuntimePlatform.DARWIN);
-
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        remoteConfig: {
-          previewUrl: 'https://web-preview.example.test',
-          previewToken: 'tok-1',
-        },
-      })
-    );
-  });
-
-  it.each([
-    [BuildRuntimePlatform.DARWIN, true],
-    [BuildRuntimePlatform.LINUX, false],
-  ])('starts the web preview for %s', async (runtimePlatform, selectsXcode) => {
-    await runAsync(runtimePlatform);
-
-    expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledTimes(selectsXcode ? 1 : 0);
-    expect(startDeviceWebPreviewWithTunnelAsync).toHaveBeenCalledWith(ctx, {
-      runtimePlatform,
-      baseDomain: 'tunnel.example.com',
-      env,
-      logger,
-      timeoutMs: 60_000,
-      packageVersion: '1.2.3',
-    });
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith({
-      ctx,
-      deviceRunSessionId: 'device-run-session-id',
-      remoteConfig: { previewUrl: 'https://web-preview.example.test' },
-      logger,
-    });
-    expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledWith({
-      ctx,
-      deviceRunSessionId: 'device-run-session-id',
-      logger,
-      maxDurationSeconds: 120,
-      signal: undefined,
-    });
-    expect(stopAsync).toHaveBeenCalledTimes(1);
-  });
-});
@@ -0,0 +1,110 @@
+import { Platform } from '@expo/eas-build-job';
+import { vol } from 'memfs';
+
+import { createMockLogger } from '../../../__tests__/utils/logger';
+import {
+  XCODE_COMPILATION_CACHE_ENV,
+  XCODE_COMPILATION_CACHE_RELATIVE_PATH,
+  compressXcodeCompilationCacheAsync,
+  decompressXcodeCompilationCacheAsync,
+  generateXcodeCompilationCacheKeyAsync,
+} from '../../../ios/compilationCache';
+import { downloadCacheAsync } from '../restoreCache';
+import { restoreXcodeCompilationCacheAsync } from '../restoreBuildCache';
+import { uploadCacheAsync } from '../saveCache';
+import { saveXcodeCompilationCacheAsync } from '../saveBuildCache';
+
+jest.mock('../restoreCache', () => ({
+  downloadCacheAsync: jest.fn(),
+}));
+
+jest.mock('../saveCache', () => ({
+  uploadCacheAsync: jest.fn(),
+}));
+
+jest.mock('../../../ios/compilationCache', () => ({
+  XCODE_COMPILATION_CACHE_ENV: 'EAS_BUILD_XCODE_COMPILATION_CACHE',
+  XCODE_COMPILATION_CACHE_RELATIVE_PATH: 'ios/build/CompilationCache.noindex',
+  compressXcodeCompilationCacheAsync: jest.fn(),
+  decompressXcodeCompilationCacheAsync: jest.fn(),
+  generateXcodeCompilationCacheKeyAsync: jest.fn(),
+}));
+
+const WORKING_DIRECTORY = '/working-directory';
+const ENV = {
+  [XCODE_COMPILATION_CACHE_ENV]: '1',
+  EAS_USE_CACHE: '1',
+  EAS_BUILD_ID: 'build-id',
+  __API_SERVER_URL: 'https://api.expo.test',
+};
+const SECRETS = { robotAccessToken: 'robot-access-token' };
+
+describe('Xcode compilation build cache', () => {
+  beforeEach(() => {
+    jest.mocked(generateXcodeCompilationCacheKeyAsync).mockResolvedValue({
+      key: 'ios-xcode-compilation-cache-version-dependencies',
+      keyPrefix: 'ios-xcode-compilation-cache-version-',
+      xcodeVersion: 'Xcode 26.0 Build version 17A000',
+    });
+  });
+
+  test('restores through the active build cache service', async () => {
+    jest.mocked(downloadCacheAsync).mockResolvedValue({
+      archivePath: '/tmp/cache.tar.gz',
+      matchedKey: 'ios-xcode-compilation-cache-version-dependencies',
+    });
+
+    await restoreXcodeCompilationCacheAsync({
+      logger: createMockLogger(),
+      workingDirectory: WORKING_DIRECTORY,
+      env: ENV,
+      secrets: SECRETS,
+    });
+
+    expect(downloadCacheAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        jobId: 'build-id',
+        key: 'ios-xcode-compilation-cache-version-dependencies',
+        keyPrefixes: ['ios-xcode-compilation-cache-version-'],
+        paths: [XCODE_COMPILATION_CACHE_RELATIVE_PATH],
+        platform: Platform.IOS,
+      })
+    );
+    expect(decompressXcodeCompilationCacheAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        archivePath: '/tmp/cache.tar.gz',
+        workingDirectory: WORKING_DIRECTORY,
+      })
+    );
+  });
+
+  test('saves through the active build cache service', async () => {
+    vol.fromJSON({ '/tmp/xcode-cache.tar.gz': 'cache' });
+    jest.mocked(compressXcodeCompilationCacheAsync).mockResolvedValue({
+      archivePath: '/tmp/xcode-cache.tar.gz',
+    });
+
+    await saveXcodeCompilationCacheAsync({
+      logger: createMockLogger(),
+      workingDirectory: WORKING_DIRECTORY,
+      env: ENV,
+      secrets: SECRETS,
+    });
+
+    expect(compressXcodeCompilationCacheAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workingDirectory: WORKING_DIRECTORY,
+      })
+    );
+
+    expect(uploadCacheAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        jobId: 'build-id',
+        key: 'ios-xcode-compilation-cache-version-dependencies',
+        paths: [XCODE_COMPILATION_CACHE_RELATIVE_PATH],
+        platform: Platform.IOS,
+        size: 5,
+      })
+    );
+  });
+});
@@ -8,19 +8,15 @@ import {
  BuildStepOutput,
 } from '@expo/steps';
 import { Client } from '@urql/core';
-import contentDisposition from 'content-disposition';
 import { glob } from 'fast-glob';
 import { graphql } from 'gql.tada';
 import fetch from 'node-fetch';
-import assert from 'node:assert';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import stream from 'stream';
 import { promisify } from 'util';
 import { z } from 'zod';
-import bplistParser from 'bplist-parser';
-import plist from 'plist';

 import { CustomBuildContext } from '../../customBuildContext';
 import { formatBytes } from '../../utils/artifacts';
@@ -30,10 +26,6 @@ import { pluralize } from '../../utils/strings';

 const streamPipeline = promisify(stream.pipeline);

-type DownloadBuildSource =
-  | { buildId: string; applicationArchiveUrl?: never }
-  | { buildId?: never; applicationArchiveUrl: string };
-
 const BUILD_BY_ID_QUERY = graphql(`
  query DownloadBuildByIdQuery($buildId: ID!) {
    builds {
@@ -57,12 +49,7 @@ export function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunct
    inputProviders: [
      BuildStepInput.createProvider({
        id: 'build_id',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'application_archive_url',
-        required: false,
+        required: true,
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
      }),
      BuildStepInput.createProvider({
@@ -83,39 +70,12 @@ export function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunct

      const extensions = z.array(z.string()).parse(inputs.extensions.value);
      logger.info(`Expected extensions: [${extensions.join(', ')}]`);
-      const buildId = inputs.build_id.value
-        ? z.string().uuid().parse(inputs.build_id.value)
-        : undefined;
-      const applicationArchiveUrl = inputs.application_archive_url.value
-        ? parseHttpApplicationArchiveUrl(inputs.application_archive_url.value)
-        : undefined;
-
-      let source: DownloadBuildSource;
-      if (buildId) {
-        if (applicationArchiveUrl) {
-          throw new UserError(
-            'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-            'Pass only one of build_id or application_archive_url.'
-          );
-        }
-        source = { buildId };
-      } else {
-        if (!applicationArchiveUrl) {
-          throw new UserError(
-            'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-            'Pass build_id or application_archive_url.'
-          );
-        }
-        source = { applicationArchiveUrl };
-      }
-
-      logger.info(
-        buildId ? `Downloading build ${buildId}...` : `Downloading application archive...`
-      );
+      const buildId = z.string().uuid().parse(inputs.build_id.value);
+      logger.info(`Downloading build ${buildId}...`);

      const { artifactPath } = await downloadBuildAsync({
        logger,
-        ...source,
+        buildId,
        graphqlClient: ctx.graphqlClient,
        robotAccessToken: stepsCtx.global.staticContext.job.secrets?.robotAccessToken ?? null,
        extensions,
@@ -155,50 +115,39 @@ async function fetchApplicationArchiveUrlAsync({
  return applicationArchiveUrl;
 }

-export async function downloadBuildAsync(
-  params: DownloadBuildSource & {
-    logger: bunyan;
-    graphqlClient: Client;
-    robotAccessToken: string | null;
-    extensions: string[];
-  }
-): Promise<{ artifactPath: string }> {
-  const { logger, graphqlClient, robotAccessToken, extensions } = params;
-
-  let downloadUrl: string;
-  let headers: { Authorization: string } | undefined;
-  if (params.applicationArchiveUrl) {
-    if (params.buildId) {
-      throw new UserError(
-        'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-        'Pass only one of buildId or applicationArchiveUrl.'
-      );
-    }
-    downloadUrl = parseHttpApplicationArchiveUrl(params.applicationArchiveUrl);
-    headers = undefined;
-  } else if (params.buildId) {
-    const buildId = z.string().uuid().parse(params.buildId);
-    downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
-    headers = robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined;
-  } else {
-    throw new UserError(
-      'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
-      'Pass buildId or applicationArchiveUrl.'
-    );
-  }
-
+export async function downloadBuildAsync({
+  logger,
+  buildId,
+  graphqlClient,
+  robotAccessToken,
+  extensions,
+}: {
+  logger: bunyan;
+  buildId: string;
+  graphqlClient: Client;
+  robotAccessToken: string | null;
+  extensions: string[];
+}): Promise<{ artifactPath: string }> {
  const downloadDestinationDirectory = await fs.promises.mkdtemp(
    path.join(os.tmpdir(), 'download_build-downloaded-')
  );

-  const response = await retryOnDNSFailure(fetch)(downloadUrl, { headers });
+  const downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
+
+  const response = await retryOnDNSFailure(fetch)(downloadUrl, {
+    headers: robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined,
+  });

  if (!response.ok) {
    const textResult = await asyncResult(response.text());
    throw new Error(`Unexpected response from server (${response.status}): ${textResult.value}`);
  }

-  const archiveFilename = resolveArchiveFilename({ response, extensions });
+  // URL may contain percent-encoded characters, e.g. my%20file.apk
+  // this replaces all non-alphanumeric characters (excluding dot) with underscore
+  const archiveFilename = path
+    .basename(new URL(response.url).pathname)
+    .replace(/([^a-z0-9.-]+)/gi, '_');
  const archivePath = path.join(downloadDestinationDirectory, archiveFilename);

  await streamPipeline(response.body, fs.createWriteStream(archivePath));
@@ -228,18 +177,6 @@ export async function downloadBuildAsync(
    onlyFiles: false,
    onlyDirectories: false,
  });
-  let matchingFilesRoot = extractionDirectory;
-
-  if (
-    matchingFiles.length === 0 &&
-    extensions.includes('app') &&
-    (await isIosAppBundleAsync(extractionDirectory))
-  ) {
-    const appBundlePath = `${extractionDirectory}.app`;
-    await fs.promises.rename(extractionDirectory, appBundlePath);
-    matchingFiles.push(appBundlePath);
-    matchingFilesRoot = path.dirname(appBundlePath);
-  }

  if (matchingFiles.length === 0) {
    throw new UserError(
@@ -252,68 +189,8 @@ export async function downloadBuildAsync(
    `Found ${matchingFiles.length} matching ${pluralize(
      matchingFiles.length,
      'entry'
-    )}:\n${matchingFiles.map(f => `- ${path.relative(matchingFilesRoot, f)}`).join('\n')}`
+    )}:\n${matchingFiles.map(f => `- ${path.relative(extractionDirectory, f)}`).join('\n')}`
  );

  return { artifactPath: matchingFiles[0] };
 }
-
-async function isIosAppBundleAsync(directory: string): Promise<boolean> {
-  try {
-    const infoPlist = await fs.promises.readFile(path.join(directory, 'Info.plist'));
-    const isBinaryPlist = infoPlist.subarray(0, 8).toString('ascii') === 'bplist00';
-    const parsedInfoPlist = (
-      isBinaryPlist
-        ? bplistParser.parseBuffer(infoPlist)[0]
-        : plist.parse(infoPlist.toString('utf8'))
-    ) as Record<string, unknown> | undefined;
-
-    return parsedInfoPlist?.CFBundlePackageType === 'APPL';
-  } catch {
-    return false;
-  }
-}
-
-function parseHttpApplicationArchiveUrl(value: unknown): string {
-  try {
-    const applicationArchiveUrl = z.string().parse(value);
-    const parsedUrl = new URL(applicationArchiveUrl);
-    assert(parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:');
-    return applicationArchiveUrl;
-  } catch {
-    throw new UserError(
-      'EAS_DOWNLOAD_BUILD_INVALID_APPLICATION_ARCHIVE_URL',
-      'application_archive_url must be a valid HTTP or HTTPS URL.'
-    );
-  }
-}
-
-function resolveArchiveFilename({
-  response,
-  extensions,
-}: {
-  response: Awaited<ReturnType<typeof fetch>>;
-  extensions: string[];
-}): string {
-  const contentDispositionHeader = response.headers.get('content-disposition');
-  let headerFilename: string | undefined;
-  if (contentDispositionHeader) {
-    try {
-      headerFilename = contentDisposition.parse(contentDispositionHeader).parameters.filename;
-    } catch {
-      // Ignore malformed Content-Disposition headers and fall back to the response URL.
-    }
-  }
-
-  const urlFilename = path.basename(new URL(response.url).pathname);
-  let archiveFilename = path.basename(headerFilename ?? urlFilename ?? '');
-  if (!archiveFilename || archiveFilename === '.' || archiveFilename === '..') {
-    archiveFilename = 'application';
-  }
-  if (!path.extname(archiveFilename) && extensions.length === 1) {
-    archiveFilename = `${archiveFilename}.${extensions[0]}`;
-  }
-
-  // URL and header filenames may contain percent-encoded or unsafe filesystem characters.
-  return archiveFilename.replace(/([^a-z0-9.-]+)/gi, '_');
-}
@@ -1,124 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import { bunyan } from '@expo/logger';
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  BuildStepEnv,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-  BuildStepOutput,
-} from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-import fs from 'node:fs';
-import path from 'node:path';
-import { z } from 'zod';
-
-export function createInstallBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'install_build',
-    name: 'Install build',
-    __metricsId: 'eas/install_build',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'artifact_path',
-        required: true,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-    ],
-    outputProviders: [
-      BuildStepOutput.createProvider({
-        id: 'application_identifier',
-        required: true,
-      }),
-      BuildStepOutput.createProvider({
-        id: 'activity_name',
-        required: false,
-      }),
-    ],
-    fn: async ({ global, logger }, { inputs, outputs, env }) => {
-      const artifactPath = z.string().min(1).parse(inputs.artifact_path.value);
-      const { applicationIdentifier, activityName } = await installBuildAsync({
-        artifactPath,
-        runtimePlatform: global.runtimePlatform,
-        env,
-        logger,
-      });
-      outputs.application_identifier.set(applicationIdentifier);
-      if (activityName) {
-        outputs.activity_name.set(activityName);
-      }
-    },
-  });
-}
-
-export async function installBuildAsync({
-  artifactPath,
-  runtimePlatform,
-  env,
-  logger,
-}: {
-  artifactPath: string;
-  runtimePlatform: BuildRuntimePlatform;
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<{ applicationIdentifier: string; activityName?: string }> {
-  const artifactStat = await fs.promises.stat(artifactPath).catch(err => {
-    throw new UserError(
-      'EAS_INSTALL_BUILD_INVALID_ARTIFACT',
-      `Build artifact does not exist at ${artifactPath}.`,
-      { cause: err }
-    );
-  });
-
-  if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-    if (path.extname(artifactPath) !== '.app' || !artifactStat.isDirectory()) {
-      throw new UserError(
-        'EAS_INSTALL_BUILD_INVALID_ARTIFACT',
-        'iOS Simulator sessions require a .app build artifact.'
-      );
-    }
-
-    const infoPlistPath = path.join(artifactPath, 'Info.plist');
-    const { stdout } = await spawn(
-      'plutil',
-      ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', infoPlistPath],
-      { stdio: 'pipe', env }
-    );
-    const applicationIdentifier = stdout.trim();
-    if (!applicationIdentifier) {
-      throw new UserError(
-        'EAS_INSTALL_BUILD_MISSING_IDENTIFIER',
-        `Could not read CFBundleIdentifier from ${infoPlistPath}.`
-      );
-    }
-
-    logger.info(`Installing ${artifactPath} on the iOS Simulator.`);
-    await spawn('xcrun', ['simctl', 'install', 'booted', artifactPath], { env, logger });
-    return { applicationIdentifier };
-  }
-
-  if (path.extname(artifactPath) !== '.apk' || !artifactStat.isFile()) {
-    throw new UserError(
-      'EAS_INSTALL_BUILD_INVALID_ARTIFACT',
-      'Android Emulator sessions require an .apk build artifact.'
-    );
-  }
-
-  const { stdout } = await spawn('aapt2', ['dump', 'badging', artifactPath], {
-    stdio: 'pipe',
-    env,
-  });
-  const applicationIdentifier = stdout.match(/package: name='([^']+)'/)?.[1];
-  const activityName = stdout.match(/launchable-activity: name='([^']+)'/)?.[1];
-  if (!applicationIdentifier) {
-    throw new UserError(
-      'EAS_INSTALL_BUILD_MISSING_IDENTIFIER',
-      `Could not read an Android application identifier from ${artifactPath}.`
-    );
-  }
-
-  logger.info(`Installing ${artifactPath} on the Android Emulator.`);
-  await spawn('adb', ['install', '-r', artifactPath], { env, logger });
-  return { applicationIdentifier, activityName };
-}
@@ -1,5 +1,3 @@
-import downloadFile from '@expo/downloader';
-import { SystemError, UserError } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { asyncResult } from '@expo/results';
 import {
@@ -16,15 +14,9 @@ import assert from 'assert';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import semver from 'semver';

 import { MaestroBackend, resolveMaestroBackend } from './maestroBackend';
 import { Datadog } from '../../datadog';
-import { getXcodeVersionAsync } from '../../ios/xcode';
-import { IosSimulatorUtils } from '../../utils/IosSimulatorUtils';
-import { getProxiedDownloadUrl } from '../../utils/download';
-
-const MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS = 20_000;

 export function createInstallMaestroBuildFunction(): BuildFunction {
  return new BuildFunction({
@@ -128,66 +120,19 @@ export function createInstallMaestroBuildFunction(): BuildFunction {
        await installIdbFromBrew({ logger, env });
      }

-      switch (backend) {
-        case 'maestro':
-          // Skip installing if the input sets a specific Maestro version to install
-          // and it is already installed, either on a build image or a local computer.
-          if (
-            !currentMaestroVersion ||
-            (requestedVersion && requestedVersion !== currentMaestroVersion)
-          ) {
+      // Skip installing if the input sets a specific Maestro version to install
+      // and it is already installed which happens when developing on a local computer.
+      if (
+        !currentMaestroVersion ||
+        (requestedVersion && requestedVersion !== currentMaestroVersion)
+      ) {
+        switch (backend) {
+          case 'maestro':
            await installMaestro({ version: requestedVersion, global, logger, env });
-          }
-          break;
-        case 'maestro-runner': {
-          let maestroRunnerVersionToInstall = requestedVersion;
-          const currentMaestroRunnerVersion = semver.coerce(currentMaestroVersion)?.version;
-          const requestedMaestroRunnerVersion =
-            requestedVersion && requestedVersion !== 'latest'
-              ? semver.valid(requestedVersion)
-              : null;
-          if (
-            global.runtimePlatform === BuildRuntimePlatform.DARWIN &&
-            ((requestedMaestroRunnerVersion &&
-              semver.gte(requestedMaestroRunnerVersion, '1.1.16')) ||
-              requestedVersion === 'latest' ||
-              (requestedVersion === undefined &&
-                (!currentMaestroRunnerVersion || semver.gt(currentMaestroRunnerVersion, '1.1.15'))))
-          ) {
-            // `getXcodeVersionAsync` returns the raw version (e.g. "16.4"), which
-            // `semver.coerce` normalizes (e.g. "16.4.0") for comparison and display.
-            const xcodeVersion = semver.coerce(await getXcodeVersionAsync({ env }));
-
-            // maestro-runner 1.1.16 added `arch` to its xcodebuild destination. Xcode versions
-            // below 26 reject that option, so use the last compatible maestro-runner version.
-            if (xcodeVersion && semver.lt(xcodeVersion, '26.0.0')) {
-              if (requestedMaestroRunnerVersion) {
-                throw new UserError(
-                  'ERR_MAESTRO_INVALID_INPUT',
-                  `maestro-runner ${requestedVersion} is not compatible with Xcode ${xcodeVersion}. Use maestro-runner 1.1.15 or an Xcode 26+ image.`
-                );
-              }
-              maestroRunnerVersionToInstall = '1.1.15';
-              logger.info(
-                `Xcode ${xcodeVersion} requires maestro-runner ${maestroRunnerVersionToInstall}.`
-              );
-            }
-          }
-
-          if (
-            !currentMaestroVersion ||
-            (maestroRunnerVersionToInstall &&
-              maestroRunnerVersionToInstall !== currentMaestroVersion)
-          ) {
-            await installMaestroRunner({
-              version: maestroRunnerVersionToInstall,
-              global,
-              logger,
-              env,
-            });
-          }
-
-          break;
+            break;
+          case 'maestro-runner':
+            await installMaestroRunner({ version: requestedVersion, global, logger, env });
+            break;
        }
      }

@@ -198,13 +143,6 @@ export function createInstallMaestroBuildFunction(): BuildFunction {
        throw new Error(`Failed to ensure ${backend} is installed.`);
      }

-      if (backend === 'maestro-runner' && global.runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        await installMaestroRunnerWdaCache({
-          logger,
-          env,
-        });
-      }
-
      logger.info(`${backend} ${maestroVersionResult.value} is ready.`);
      outputs.maestro_version.set(maestroVersionResult.value);

@@ -216,142 +154,6 @@ export function createInstallMaestroBuildFunction(): BuildFunction {
  });
 }

-async function installMaestroRunnerWdaCache({
-  logger,
-  env,
-}: {
-  logger: bunyan;
-  env: BuildStepEnv;
-}): Promise<void> {
-  if (!env.HOME) {
-    logger.warn(
-      'Skipping the prebuilt WebDriverAgent cache because the $HOME environment variable is empty.'
-    );
-    return;
-  }
-  const maestroRunnerHome = path.join(env.HOME, '.maestro-runner');
-
-  try {
-    const wdaVersion = await getMaestroRunnerWdaVersion({ maestroRunnerHome });
-    if (!wdaVersion) {
-      logger.info(
-        'Skipping the prebuilt WebDriverAgent cache because the installed WDA version is unknown.'
-      );
-      return;
-    }
-    const xcodeVersion = await getXcodeVersionAsync({ env });
-    const iosRuntimes = await IosSimulatorUtils.getAvailableRuntimesAsync({ env });
-    const iosRuntimeIdentifierPrefix = 'com.apple.CoreSimulator.SimRuntime.iOS-';
-    // maestro-runner derives its WDA cache key from the runtime identifier, not from the runtime
-    // version. These values can differ for patched runtimes, for example the iOS-26-3 identifier
-    // can report version 26.3.1.
-    const iosRuntimeVersions = [
-      ...new Set(
-        iosRuntimes.map(runtime =>
-          runtime.identifier.slice(iosRuntimeIdentifierPrefix.length).replaceAll('-', '.')
-        )
-      ),
-    ];
-    if (iosRuntimeVersions.length === 0) {
-      logger.info(
-        'Skipping the prebuilt WebDriverAgent cache because no iOS runtime is available.'
-      );
-      return;
-    }
-
-    const tempDirectory = await fs.promises.mkdtemp(
-      path.join(os.tmpdir(), 'install_maestro_runner_wda_cache')
-    );
-    try {
-      const archivePath = path.join(tempDirectory, 'wda-cache.tar.gz');
-      const directArchiveUrl =
-        `https://storage.googleapis.com/turtle-v2/maestro-runner-wda-cache/` +
-        `xcode-${encodeURIComponent(xcodeVersion)}-wda-${encodeURIComponent(wdaVersion)}.tar.gz`;
-      const proxiedArchiveUrl = getProxiedDownloadUrl({
-        directUrl: directArchiveUrl,
-        proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
-      });
-
-      logger.info(`Downloading the prebuilt WebDriverAgent cache for Xcode ${xcodeVersion}`);
-      if (proxiedArchiveUrl) {
-        try {
-          await downloadFile(proxiedArchiveUrl, archivePath, {
-            retry: 3,
-            timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
-          });
-        } catch (err) {
-          logger.debug(
-            { err },
-            'Failed to download the prebuilt WebDriverAgent cache via the proxy; falling back to the direct URL.'
-          );
-          await downloadFile(directArchiveUrl, archivePath, {
-            retry: 3,
-            timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
-          });
-        }
-      } else {
-        await downloadFile(directArchiveUrl, archivePath, {
-          retry: 3,
-          timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
-        });
-      }
-      await fs.promises.mkdir(maestroRunnerHome, { recursive: true });
-      await spawn('tar', ['-xzf', archivePath, '-C', maestroRunnerHome], { logger, env });
-
-      const genericProductsDirectory = path.join(
-        maestroRunnerHome,
-        'cache',
-        'wda-builds',
-        'generic',
-        'DerivedData',
-        'Build',
-        'Products'
-      );
-      for (const runtimeVersion of iosRuntimeVersions) {
-        const productsDirectory = path.join(
-          maestroRunnerHome,
-          'cache',
-          'wda-builds',
-          `sim-ios${runtimeVersion}-iphone`,
-          'DerivedData',
-          'Build',
-          'Products'
-        );
-        await fs.promises.cp(genericProductsDirectory, productsDirectory, { recursive: true });
-      }
-
-      logger.info(
-        `Installed the prebuilt WebDriverAgent cache for iOS ${iosRuntimeVersions.join(', ')}.`
-      );
-    } finally {
-      await fs.promises.rm(tempDirectory, { force: true, recursive: true });
-    }
-  } catch (err: any) {
-    logger.warn(
-      { err },
-      'Failed to install the prebuilt WebDriverAgent cache. maestro-runner will build WebDriverAgent when it is needed.'
-    );
-  }
-}
-
-async function getMaestroRunnerWdaVersion({
-  maestroRunnerHome,
-}: {
-  maestroRunnerHome: string;
-}): Promise<string | null> {
-  try {
-    const packageJson = JSON.parse(
-      await fs.promises.readFile(
-        path.join(maestroRunnerHome, 'drivers', 'ios', 'WebDriverAgent', 'package.json'),
-        'utf8'
-      )
-    );
-    return typeof packageJson.version === 'string' ? packageJson.version : null;
-  } catch {
-    return null;
-  }
-}
-
 async function getMaestroVersion({
  env,
  backend,
@@ -409,10 +211,10 @@ async function installMaestroRunner({
    const binDir = path.join(env.HOME, '.maestro-runner', 'bin');
    global.updateEnv({
      ...global.env,
-      PATH: `${binDir}:${global.env.PATH}`,
+      PATH: `${global.env.PATH}:${binDir}`,
    });
-    env.PATH = `${binDir}:${env.PATH}`;
-    process.env.PATH = `${binDir}:${process.env.PATH}`;
+    env.PATH = `${env.PATH}:${binDir}`;
+    process.env.PATH = `${process.env.PATH}:${binDir}`;
  } finally {
    await fs.promises.rm(tempDirectory, { force: true, recursive: true });
  }
@@ -459,10 +261,10 @@ async function installMaestro({
    const maestroBinDir = path.join(maestroDir, 'bin');
    global.updateEnv({
      ...global.env,
-      PATH: `${maestroBinDir}:${global.env.PATH}`,
+      PATH: `${global.env.PATH}:${maestroBinDir}`,
    });
-    env.PATH = `${maestroBinDir}:${env.PATH}`;
-    process.env.PATH = `${maestroBinDir}:${process.env.PATH}`;
+    env.PATH = `${env.PATH}:${maestroBinDir}`;
+    process.env.PATH = `${process.env.PATH}:${maestroBinDir}`;
  } finally {
    await fs.promises.rm(tempDirectory, { force: true, recursive: true });
  }
@@ -470,64 +272,37 @@ async function installMaestro({

 async function isIdbInstalled({ env }: { env: BuildStepEnv }): Promise<boolean> {
  try {
-    await spawn('idb_companion', ['--version'], { ignoreStdio: true, env });
+    await spawn('idb', ['-h'], { ignoreStdio: true, env });
    return true;
  } catch {
    return false;
  }
 }

-export async function installIdbFromBrew({
+async function installIdbFromBrew({
  logger,
  env,
 }: {
  logger: bunyan;
  env: BuildStepEnv;
 }): Promise<void> {
-  try {
-    // Unfortunately our Mac images sometimes have two Homebrew
-    // installations. We should use the ARM64 one, located in /opt/homebrew.
-    const brewPath = '/opt/homebrew/bin/brew';
-    const localEnv = {
-      ...env,
-      HOMEBREW_NO_AUTO_UPDATE: '1',
-      HOMEBREW_NO_INSTALL_CLEANUP: '1',
-    };
+  // Unfortunately our Mac images sometimes have two Homebrew
+  // installations. We should use the ARM64 one, located in /opt/homebrew.
+  const brewPath = '/opt/homebrew/bin/brew';
+  const localEnv = {
+    ...env,
+    HOMEBREW_NO_AUTO_UPDATE: '1',
+    HOMEBREW_NO_INSTALL_CLEANUP: '1',
+  };

-    logger.info('Tapping facebook/fb...');
-    await spawn(brewPath, ['tap', 'facebook/fb'], {
-      env: localEnv,
-      logger,
-    });
-
-    const brewRepo = await spawn(brewPath, ['--repo', 'facebook/fb'], {
-      env: localEnv,
-    });
-    const tapPath = brewRepo.stdout.trim();
-
-    // c0386793f59da10c619787f2aa18d938ef1d69c9 is hash for 1.1.8 release,
-    // last known compatible version + post_install fix.
-    const gitSha = 'c0386793f59da10c619787f2aa18d938ef1d69c9';
-    logger.info('Checking out facebook/fb at [email protected]...');
-    await spawn('git', ['fetch', 'origin', gitSha], {
-      cwd: tapPath,
-      logger,
-    });
-    await spawn('git', ['checkout', gitSha], {
-      cwd: tapPath,
-      logger,
-    });
-
-    logger.info('Installing idb_companion v1.1.8...');
-    await spawn(brewPath, ['install', 'facebook/fb/idb-companion'], {
-      env: localEnv,
-      logger,
-    });
-  } catch (err) {
-    throw new SystemError('Failed to install idb-companion required for Maestro to run.', {
-      cause: err,
-    });
-  }
+  await spawn(brewPath, ['tap', 'facebook/fb'], {
+    env: localEnv,
+    logger,
+  });
+  await spawn(brewPath, ['install', 'idb-companion'], {
+    env: localEnv,
+    logger,
+  });
 }

 async function isJavaInstalled({ env }: { env: BuildStepEnv }): Promise<boolean> {
@@ -1,219 +0,0 @@
-import { UserError } from '@expo/eas-build-job';
-import { bunyan } from '@expo/logger';
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  BuildStepEnv,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-
-const IOS_URL_SCHEME_APPROVAL_DOMAIN = 'com.apple.launchservices.schemeapproval';
-const IOS_URL_SCHEME_APPROVAL_KEY_PREFIX = 'com.apple.CoreSimulator.CoreSimulatorBridge-->';
-
-export function createLaunchApplicationFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'launch_application',
-    name: 'Launch application',
-    __metricsId: 'eas/launch_application',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'application_identifier',
-        required: true,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'activity_name',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'launch_args',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-      }),
-      BuildStepInput.createProvider({
-        id: 'open_url',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-    ],
-    fn: async ({ global, logger }, { inputs, env }) => {
-      const applicationIdentifier = parseNonEmptyStringInput(
-        inputs.application_identifier.value,
-        'application_identifier'
-      );
-      const activityName =
-        inputs.activity_name.value === undefined
-          ? undefined
-          : parseNonEmptyStringInput(inputs.activity_name.value, 'activity_name');
-      const launchArgs = parseLaunchArgsInput(inputs.launch_args.value);
-      const openUrl =
-        inputs.open_url.value === undefined ? undefined : parseOpenUrlInput(inputs.open_url.value);
-      await launchApplicationAsync({
-        applicationIdentifier,
-        activityName,
-        launchArgs,
-        openUrl,
-        runtimePlatform: global.runtimePlatform,
-        env,
-        logger,
-      });
-    },
-  });
-}
-
-export async function launchApplicationAsync({
-  applicationIdentifier,
-  activityName,
-  launchArgs = [],
-  openUrl,
-  runtimePlatform,
-  env,
-  logger,
-}: {
-  applicationIdentifier: string;
-  activityName?: string;
-  launchArgs?: string[];
-  openUrl?: string;
-  runtimePlatform: BuildRuntimePlatform;
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<void> {
-  if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-    logApplicationLaunch(logger, applicationIdentifier, launchArgs);
-    await spawn('xcrun', ['simctl', 'launch', 'booted', applicationIdentifier, ...launchArgs], {
-      env,
-      logger,
-    });
-    if (openUrl) {
-      await preapproveIosUrlSchemeAsync({ applicationIdentifier, openUrl, env, logger });
-      logger.info(`Opening ${openUrl} in ${applicationIdentifier}.`);
-      await spawn('xcrun', ['simctl', 'openurl', 'booted', openUrl], { env, logger });
-    }
-    return;
-  }
-
-  if (!activityName) {
-    throw new UserError(
-      'EAS_LAUNCH_APPLICATION_MISSING_ACTIVITY',
-      'Launching an Android application requires activity_name.'
-    );
-  }
-
-  logApplicationLaunch(logger, applicationIdentifier, launchArgs);
-  // Android does not support process arguments like iOS. Pass raw `am start` Intent
-  // arguments instead, such as `--es key value` or `--ez key true`.
-  await spawn(
-    'adb',
-    ['shell', 'am', 'start', ...launchArgs, '-n', `${applicationIdentifier}/${activityName}`],
-    {
-      env,
-      logger,
-    }
-  );
-  if (openUrl) {
-    logger.info(`Opening ${openUrl} in ${applicationIdentifier}.`);
-    await spawn(
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '-a',
-        'android.intent.action.VIEW',
-        '-d',
-        openUrl,
-        '-n',
-        `${applicationIdentifier}/${activityName}`,
-      ],
-      { env, logger }
-    );
-  }
-}
-
-async function preapproveIosUrlSchemeAsync({
-  applicationIdentifier,
-  openUrl,
-  env,
-  logger,
-}: {
-  applicationIdentifier: string;
-  openUrl: string;
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<void> {
-  const urlScheme = new URL(openUrl).protocol.slice(0, -1);
-  if (urlScheme === 'http' || urlScheme === 'https') {
-    return;
-  }
-
-  try {
-    await spawn(
-      'xcrun',
-      [
-        'simctl',
-        'spawn',
-        'booted',
-        'defaults',
-        'write',
-        IOS_URL_SCHEME_APPROVAL_DOMAIN,
-        `${IOS_URL_SCHEME_APPROVAL_KEY_PREFIX}${urlScheme}`,
-        '-string',
-        applicationIdentifier,
-      ],
-      { env, logger }
-    );
-  } catch (error) {
-    logger.warn(
-      { err: error },
-      `Could not preapprove the ${urlScheme} URL scheme for ${applicationIdentifier}. Opening the URL anyway; the Simulator might require manual confirmation.`
-    );
-  }
-}
-
-function logApplicationLaunch(
-  logger: bunyan,
-  applicationIdentifier: string,
-  launchArgs: string[]
-): void {
-  const argumentsDescription =
-    launchArgs.length > 0 ? ` with arguments ${JSON.stringify(launchArgs)}` : '';
-  logger.info(`Launching ${applicationIdentifier}${argumentsDescription}.`);
-}
-
-function parseNonEmptyStringInput(value: unknown, inputName: string): string {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new UserError(
-      'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-      `Input "${inputName}" must be a non-empty string. Pass the "${inputName}" output from eas/install_build.`
-    );
-  }
-  return value;
-}
-
-function parseLaunchArgsInput(value: unknown): string[] {
-  if (value === undefined) {
-    return [];
-  }
-  if (!Array.isArray(value) || !value.every(argument => typeof argument === 'string')) {
-    throw new UserError(
-      'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-      'Input "launch_args" must be an array of strings.'
-    );
-  }
-  return value;
-}
-
-function parseOpenUrlInput(value: unknown): string {
-  const openUrl = parseNonEmptyStringInput(value, 'open_url');
-  if (!URL.canParse(openUrl)) {
-    throw new UserError(
-      'EAS_LAUNCH_APPLICATION_INVALID_INPUT',
-      'Input "open_url" must be a valid URL.'
-    );
-  }
-  return openUrl;
-}
@@ -2,7 +2,6 @@ import { asyncResult } from '@expo/results';
 import { XMLBuilder, XMLParser, XMLValidator } from 'fast-xml-parser';
 import fs from 'fs/promises';
 import path from 'path';
-import { z } from 'zod';

 export interface MaestroFlowResult {
  name: string;
@@ -35,16 +34,10 @@ const xmlParser = new XMLParser({
  isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });

-// Official Maestro writes the flow path as a `file=` testcase attribute. maestro-runner writes
-// the same value as a `<property name="file" value="..."/>` child.
+// A `file=` attribute counts as present only when it is a non-empty string.
 function fileAttrOf(tc: any): string | undefined {
  const f = tc?.['@_file'];
-  if (typeof f === 'string' && f.length > 0) {
-    return f;
-  }
-  const properties: { '@_name'?: unknown; '@_value'?: unknown }[] = tc?.properties?.property ?? [];
-  const fileProperty = properties.find(property => property['@_name'] === 'file')?.['@_value'];
-  return typeof fileProperty === 'string' && fileProperty.length > 0 ? fileProperty : undefined;
+  return typeof f === 'string' && f.length > 0 ? f : undefined;
 }

 function parseJUnitContent(content: string): JUnitTestCaseResult[] {
@@ -69,46 +62,26 @@ function parseJUnitContent(content: string): JUnitTestCaseResult[] {
          continue;
        }

-        // Standard JUnit marks skipped tests with a <skipped/> child (no failure/error). Exclude
-        // them so they aren't miscounted as passed, matching the report.json path which drops
-        // skipped flows.
-        if (tc.skipped != null) {
-          continue;
-        }
-
        const file = fileAttrOf(tc);

        const timeStr = tc['@_time'];
        const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
        const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;

-        // maestro-runner puts the real error in the `message` attribute and the command
-        // label (e.g. `tapOn`) in the body; official Maestro only writes the body. Prefer
-        // `@_message` and fall back to `#text` so both stay correct.
+        const status: 'passed' | 'failed' = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
        const failureText =
          tc.failure != null
            ? typeof tc.failure === 'string'
              ? tc.failure
-              : (tc.failure?.['@_message'] ?? tc.failure?.['#text'] ?? null)
+              : (tc.failure?.['#text'] ?? null)
            : null;
        const errorText =
          tc.error != null
            ? typeof tc.error === 'string'
              ? tc.error
-              : (tc.error?.['@_message'] ?? tc.error?.['#text'] ?? null)
+              : (tc.error?.['#text'] ?? null)
            : null;
        const errorMessage: string | null = failureText ?? errorText ?? null;
-        // Official Maestro uses status="SUCCESS". maestro-runner uses standard JUnit semantics:
-        // a testcase passes when it has no failure or error child.
-        const statusAttribute = tc['@_status'];
-        const status: 'passed' | 'failed' =
-          typeof statusAttribute === 'string'
-            ? statusAttribute === 'SUCCESS'
-              ? 'passed'
-              : 'failed'
-            : tc.failure == null && tc.error == null
-              ? 'passed'
-              : 'failed';

        const rawProperties: { '@_name': string; '@_value': string }[] =
          tc.properties?.property ?? [];
@@ -203,69 +176,6 @@ async function fileExists(absPath: string): Promise<boolean> {
  return (await asyncResult(fs.stat(absPath))).ok;
 }

-// maestro-runner writes report.json as the source of truth for a run. Use it for runner control
-// flow because sourceFile preserves the exact flow path, while older runner JUnit reports flatten
-// it to a basename. Keep only passed and failed flows so the result matches Maestro JUnit reports,
-// which do not include skipped flows.
-const MaestroRunnerRecordedFlowSchema = z.object({
-  name: z.string().min(1),
-  sourceFile: z.string().min(1),
-  status: z.enum(['passed', 'failed']),
-});
-const MaestroRunnerReportSchema = z.object({
-  flows: z
-    .array(
-      z.discriminatedUnion('status', [
-        MaestroRunnerRecordedFlowSchema,
-        z.object({ status: z.literal('skipped') }),
-      ])
-    )
-    .transform(flows =>
-      flows.filter(
-        (flow): flow is z.infer<typeof MaestroRunnerRecordedFlowSchema> => flow.status !== 'skipped'
-      )
-    ),
-});
-
-type MaestroRunnerReport = z.infer<typeof MaestroRunnerReportSchema>;
-
-export async function parseFailedFlowsFromMaestroRunnerReport(args: {
-  reportDirectory: string;
-  workingDirectory: string;
-}): Promise<string[] | null> {
-  const report = await parseMaestroRunnerReport(args.reportDirectory);
-  if (report === null) {
-    return null;
-  }
-
-  const failedPaths = [
-    ...new Set(report.flows.filter(flow => flow.status === 'failed').map(flow => flow.sourceFile)),
-  ];
-  if (failedPaths.length === 0) {
-    return null;
-  }
-
-  for (const flowPath of failedPaths) {
-    if (!(await fileExists(path.resolve(args.workingDirectory, flowPath)))) {
-      return null;
-    }
-  }
-  return failedPaths;
-}
-
-export async function parseMaestroRunnerReport(
-  reportDirectory: string
-): Promise<MaestroRunnerReport | null> {
-  let report: unknown;
-  try {
-    report = JSON.parse(await fs.readFile(path.join(reportDirectory, 'report.json'), 'utf8'));
-  } catch {
-    return null;
-  }
-  const result = MaestroRunnerReportSchema.safeParse(report);
-  return result.success ? result.data : null;
-}
-
 // Group by `file=` so two same-named flows in different files stay separate.
 export async function parseMaestroResultsFromFileAttrs(
  junitDirectory: string
@@ -2,9 +2,6 @@ import { bunyan } from '@expo/logger';
 import { type Dirent } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
-import { z } from 'zod';
-
-import { Sentry } from '../../sentry';

 export interface ParsedFailureScreenshot {
  flowName: string;
@@ -136,156 +133,6 @@ export async function harvestFailureScreenshotsAsync(args: {
  return [...legacyShots, ...dedupeBundleShotsByFlowName(bundleShots)];
 }

-const MaestroRunnerCommandSchema = z.object({
-  status: z.string().optional(),
-  artifacts: z
-    .object({
-      screenshotBefore: z.string().optional(),
-      screenshotAfter: z.string().optional(),
-    })
-    .optional(),
-  get subCommands() {
-    return z.array(MaestroRunnerCommandSchema).optional();
-  },
-});
-type MaestroRunnerCommand = z.infer<typeof MaestroRunnerCommandSchema>;
-
-const MaestroRunnerFlowDetailSchema = z.object({
-  commands: z.array(MaestroRunnerCommandSchema).optional(),
-});
-
-const MaestroRunnerScreenshotReportSchema = z.object({
-  flows: z
-    .array(
-      z.object({
-        name: z.string().optional(),
-        status: z.string().optional(),
-        dataFile: z.string().optional(),
-      })
-    )
-    .optional(),
-});
-
-// maestro-runner records failure screenshot paths in its report JSON instead of using the
-// official Maestro debug-directory layout. Never throws, so screenshots cannot change the test
-// result.
-export async function harvestMaestroRunnerFailureScreenshotsAsync(args: {
-  reportDirectory: string;
-  capturedSinceMs: number;
-  attemptIndex: number;
-  logger: bunyan;
-}): Promise<HarvestedScreenshot[]> {
-  let report: unknown;
-  try {
-    report = JSON.parse(await fs.readFile(path.join(args.reportDirectory, 'report.json'), 'utf8'));
-  } catch (err: any) {
-    args.logger.info(
-      { err },
-      `Skipping maestro-runner screenshot harvest: cannot read ${args.reportDirectory}.`
-    );
-    return [];
-  }
-
-  const parsedReport = MaestroRunnerScreenshotReportSchema.safeParse(report);
-  if (!parsedReport.success) {
-    args.logger.warn(
-      { err: parsedReport.error },
-      `Skipping maestro-runner screenshot harvest: unexpected report.json shape in ${args.reportDirectory}.`
-    );
-    Sentry.capture('maestro-runner report.json failed schema validation', parsedReport.error);
-    return [];
-  }
-  const flows = parsedReport.data.flows ?? [];
-
-  const shots: HarvestedScreenshot[] = [];
-  for (const { name, status, dataFile } of flows) {
-    if (status !== 'failed' || !name || !dataFile) {
-      continue;
-    }
-    const flowDataPath = resolvePathInsideDirectory(args.reportDirectory, dataFile);
-    if (!flowDataPath) {
-      args.logger.info(`Skipping maestro-runner flow data outside the report directory.`);
-      continue;
-    }
-
-    let screenshotPath: string | undefined;
-    try {
-      const detail = MaestroRunnerFlowDetailSchema.safeParse(
-        JSON.parse(await fs.readFile(flowDataPath, 'utf8'))
-      );
-      if (!detail.success) {
-        args.logger.warn(
-          { err: detail.error },
-          `Skipping malformed maestro-runner flow data ${flowDataPath}.`
-        );
-        Sentry.capture('maestro-runner flow data failed schema validation', detail.error);
-        continue;
-      }
-      screenshotPath = findFailedMaestroRunnerScreenshot(detail.data.commands ?? []);
-    } catch (err: any) {
-      args.logger.info({ err }, `Skipping unreadable maestro-runner flow data ${flowDataPath}.`);
-      continue;
-    }
-    if (!screenshotPath) {
-      continue;
-    }
-
-    const fileAbsPath = resolvePathInsideDirectory(args.reportDirectory, screenshotPath);
-    if (!fileAbsPath) {
-      args.logger.info(`Skipping maestro-runner screenshot outside the report directory.`);
-      continue;
-    }
-    let capturedAtMs: number;
-    try {
-      capturedAtMs = Math.round((await fs.stat(fileAbsPath)).mtimeMs);
-    } catch (err: any) {
-      args.logger.info({ err }, `Skipping unreadable screenshot ${fileAbsPath}.`);
-      continue;
-    }
-    if (capturedAtMs < args.capturedSinceMs) {
-      continue;
-    }
-
-    const flowName = normalizeFlowName(name);
-    shots.push({
-      fileAbsPath,
-      displayName: `Failure Screenshot: ${flowName} (attempt ${args.attemptIndex + 1})`,
-      metadata: {
-        kind: 'maestro-test-screenshot',
-        flowName,
-        attemptIndex: args.attemptIndex,
-        capturedAtMs,
-      },
-    });
-  }
-  return shots;
-}
-
-function findFailedMaestroRunnerScreenshot(
-  commands: readonly MaestroRunnerCommand[]
-): string | undefined {
-  for (const command of commands) {
-    if (command.status !== 'failed') {
-      continue;
-    }
-    const nested = findFailedMaestroRunnerScreenshot(command.subCommands ?? []);
-    const screenshot =
-      nested ?? command.artifacts?.screenshotAfter ?? command.artifacts?.screenshotBefore;
-    if (screenshot) {
-      return screenshot;
-    }
-  }
-  return undefined;
-}
-
-function resolvePathInsideDirectory(directory: string, relativePath: string): string | null {
-  const candidate = path.resolve(directory, relativePath);
-  const relative = path.relative(directory, candidate);
-  return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)
-    ? candidate
-    : null;
-}
-
 // Maestro >= 2.7.0: resolve a bundle dir to its owning failed flow and return that flow's failure
 // screenshot — the highest-numbered step in `screenshots/`. A required failure halts the flow, so
 // the failed step is normally the last (highest-numbered) captured step; earlier warned steps have
@@ -13,7 +13,6 @@ import os from 'os';
 import path from 'path';
 import { z } from 'zod';

-import { MaestroBackend, resolveMaestroBackend } from './maestroBackend';
 import { buildFlowNameToPathMap } from './maestroFlowDiscovery';
 import {
  copyLatestAttemptXml,
@@ -22,15 +21,12 @@ import {
  parseFailedFlowNamesFromJUnitFile,
  parseFailedFlowsFromFileAttrs,
  parseFailedFlowsFromJUnit,
-  parseFailedFlowsFromMaestroRunnerReport,
  parseJUnitTestCases,
-  parseMaestroRunnerReport,
 } from './maestroResultParser';
 import {
  type HarvestedScreenshot,
  computePureFailureFlowNames,
  harvestFailureScreenshotsAsync,
-  harvestMaestroRunnerFailureScreenshotsAsync,
  selectFailureScreenshots,
 } from './maestroScreenshots';
 import { CustomBuildContext } from '../../customBuildContext';
@@ -66,58 +62,35 @@ function isFilesystemError(err: any): boolean {
  );
 }

-function buildMaestroArgs({
-  backend,
-  platform,
-  flowPaths,
-  output,
-  outputFormat,
-  shards,
-  includeTags,
-  excludeTags,
-}: {
-  backend: MaestroBackend;
-  platform: 'ios' | 'android';
-  flowPaths: string[];
-  output: string | null;
-  outputFormat: string | undefined;
+// `outputPath: null` means "let maestro pick" (no --output flag). Junit and
+// other declared formats pass an explicit path so downstream upload steps
+// know where to find the result.
+function buildMaestroArgs(args: {
+  flow_path: string[];
+  outputPath: string | null;
+  output_format: string | undefined;
  shards: number | undefined;
-  includeTags: string | undefined;
-  excludeTags: string | undefined;
-}): { executable: MaestroBackend; args: string[] } {
-  switch (backend) {
-    case 'maestro': {
-      const args = ['test'];
-      if (outputFormat) {
-        args.push(`--format=${outputFormat.toUpperCase()}`);
-      }
-      if (output) {
-        args.push(`--output=${output}`);
-      }
-      if (shards !== undefined) {
-        args.push(`--shard-split=${shards}`);
-      }
-      if (includeTags) {
-        args.push(`--include-tags=${includeTags}`);
-      }
-      if (excludeTags) {
-        args.push(`--exclude-tags=${excludeTags}`);
-      }
-      args.push(...flowPaths);
-      return { executable: 'maestro', args };
-    }
-    case 'maestro-runner': {
-      const args = [`--platform=${platform}`, 'test', `--output=${output}`, '--flatten'];
-      if (includeTags) {
-        args.push(`--include-tags=${includeTags}`);
-      }
-      if (excludeTags) {
-        args.push(`--exclude-tags=${excludeTags}`);
-      }
-      args.push(...flowPaths);
-      return { executable: 'maestro-runner', args };
-    }
+  include_tags: string | undefined;
+  exclude_tags: string | undefined;
+}): string[] {
+  const out: string[] = ['test'];
+  if (args.output_format) {
+    out.push(`--format=${args.output_format.toUpperCase()}`);
  }
+  if (args.outputPath) {
+    out.push(`--output=${args.outputPath}`);
+  }
+  if (args.shards !== undefined) {
+    out.push(`--shard-split=${args.shards}`);
+  }
+  if (args.include_tags) {
+    out.push(`--include-tags=${args.include_tags}`);
+  }
+  if (args.exclude_tags) {
+    out.push(`--exclude-tags=${args.exclude_tags}`);
+  }
+  out.push(...args.flow_path);
+  return out;
 }

 export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildFunction {
@@ -176,11 +149,6 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
        required: false,
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
      }),
-      BuildStepInput.createProvider({
-        id: 'backend',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
    ],
    outputProviders: [
      BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
@@ -229,14 +197,6 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
        outputs.final_report_path.set(finalReportPath);
      }

-      // Resolved after the output assignments above: an invalid backend input or
-      // EAS_MAESTRO_BACKEND throws, and downstream `if: always()` upload steps still
-      // need the outputs interpolated.
-      const backend = resolveMaestroBackend({
-        input: inputs.backend.value,
-        env,
-      });
-
      const flowPaths = parseInput(
        FlowPathSchema,
        inputs.flow_path.value,
@@ -259,18 +219,6 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
          undefined,
        'android_connection_mode and EAS_MAESTRO_ANDROID_CONNECTION_MODE must be either "adb" or "dadb".'
      );
-      if (backend === 'maestro-runner' && shards !== undefined && shards > 1) {
-        throw new UserError(
-          'ERR_MAESTRO_INVALID_INPUT',
-          'maestro-runner does not support EAS Maestro test sharding. Remove shards or set it to 1.'
-        );
-      }
-      if (backend === 'maestro-runner' && outputFormat !== undefined && outputFormat !== 'junit') {
-        throw new UserError(
-          'ERR_MAESTRO_INVALID_INPUT',
-          `maestro-runner only supports the "junit" output_format, but received "${outputFormat}".`
-        );
-      }
      const retryFailedOnly = inputs.retry_failed_only.value as boolean;

      try {
@@ -279,7 +227,7 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
        throw new SystemError('Failed to create JUnit report directory', { cause: err });
      }

-      // Official Maestro legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
+      // Legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
      // flow scan is built lazily in the retry branch below and memoized so
      // retries share one scan. Never runs when the report has `file=`.
      let nameToPathPromise: Promise<Map<string, string> | null> | undefined;
@@ -289,23 +237,15 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
      //   numeric err.status → maestro exited non-zero → retry.
      //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
      //     downgraded to "tests failed".
-      // Retry-failed-only: after a failed attempt, subset to the failing flows. The
-      // failed-flow parsers return null when a report cannot be trusted; we then fall
-      // through to dumb retry (re-run everything).
+      // Retry-failed-only (junit mode): after a failed attempt, subset to the failing
+      // flows. The failed-flow parsers return null when the JUnit cannot be
+      // trusted; we then fall through to dumb retry (re-run everything).
      let flowsToRun: string[] = flowPaths;
      let lastAttemptExitCode: number | null = null;
      const harvested: HarvestedScreenshot[] = [];
-      const reportDirectories = backend === 'maestro' ? [junitReportDirectory] : [];

      const totalAttempts = retries + 1;
-      if (
-        backend === 'maestro-runner' &&
-        platform === 'android' &&
-        androidConnectionMode === 'dadb'
-      ) {
-        logger.info('maestro-runner does not support DADB. Using the default ADB connection.');
-      }
-      if (backend === 'maestro' && platform === 'android' && androidConnectionMode === 'dadb') {
+      if (platform === 'android' && androidConnectionMode === 'dadb') {
        try {
          const adbOverrideDirectoryPath = await fs.mkdtemp(
            path.join(os.tmpdir(), 'maestro-tests-adb-override-')
@@ -340,45 +280,29 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
      }

      for (let attempt = 0; attempt <= retries; attempt++) {
-        // maestro-runner writes its JUnit report and screenshot metadata to this directory.
-        const runnerOutputDirectory = path.join(
-          testsDirectory,
-          `${platform}-maestro-runner-attempt-${attempt}`
-        );
        const outputPath =
          outputFormat === 'junit'
            ? path.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)
-            : backend === 'maestro' && outputFormat
+            : outputFormat
              ? path.join(testsDirectory, `${platform}-maestro-${outputFormat}.${outputFormat}`)
              : null;
-        const { executable, args: maestroArgs } = buildMaestroArgs({
-          backend,
-          platform,
-          flowPaths: flowsToRun,
-          output: backend === 'maestro-runner' ? runnerOutputDirectory : outputPath,
-          outputFormat,
+
+        const maestroArgs = buildMaestroArgs({
+          flow_path: flowsToRun,
+          outputPath,
+          output_format: outputFormat,
          shards,
-          includeTags,
-          excludeTags,
+          include_tags: includeTags,
+          exclude_tags: excludeTags,
        });
        logger.info(
-          `Running ${executable} (attempt ${attempt + 1}/${totalAttempts}): ${executable} ${maestroArgs.join(' ')}`
+          `Running maestro (attempt ${attempt + 1}/${totalAttempts}): maestro ${maestroArgs.join(' ')}`
        );

-        // The runner output directory is deterministic and can survive a prior run; clear it
-        // best-effort so a crash before it writes fresh output can't resurrect stale results.
-        if (backend === 'maestro-runner') {
-          try {
-            await fs.rm(runnerOutputDirectory, { recursive: true, force: true });
-          } catch (err) {
-            logger.warn({ err }, `Failed to clear ${runnerOutputDirectory} before the attempt.`);
-          }
-        }
-
        const attemptStartedAtMs = Date.now();

        try {
-          await spawn(executable, maestroArgs, {
+          await spawn('maestro', maestroArgs, {
            cwd: stepCtx.workingDirectory,
            env: spawnEnv,
            logger,
@@ -387,108 +311,56 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
          lastAttemptExitCode = 0;
        } catch (err: any) {
          if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) {
-            throw new SystemError(`Failed to invoke ${executable}`, { cause: err });
+            throw new SystemError('Failed to invoke maestro', { cause: err });
          }
          if (err && typeof err.status === 'number') {
            lastAttemptExitCode = err.status;
          } else {
-            throw new SystemError(`Unexpected spawn failure invoking ${executable}`, {
-              cause: err,
-            });
+            throw new SystemError('Unexpected spawn failure invoking maestro', { cause: err });
          }
        }

-        // maestro-runner writes a report directory. Copy its JUnit file into the existing
-        // per-attempt directory so retry parsing and final report merging remain shared.
-        if (backend === 'maestro-runner' && outputPath) {
-          try {
-            await fs.copyFile(path.join(runnerOutputDirectory, 'junit-report.xml'), outputPath);
-          } catch (err: any) {
-            logger.warn(
-              { err },
-              `Failed to collect the maestro-runner JUnit report for attempt ${attempt + 1}.`
-            );
-          }
-        }
-
-        if (backend === 'maestro-runner') {
-          reportDirectories.push(runnerOutputDirectory);
-        }
-
        // Harvest this attempt's failure screenshots before any retry subsetting. Gated on
        // junit: test-case-result rows (and therefore the summary icons) only exist for junit
        // runs, so harvesting other formats would just create orphan artifacts the website hides.
        if (outputFormat === 'junit') {
-          let screenshots: HarvestedScreenshot[];
-          switch (backend) {
-            case 'maestro': {
-              const failedFlowNames = outputPath
-                ? await parseFailedFlowNamesFromJUnitFile(outputPath)
-                : new Set<string>();
-              screenshots = await harvestFailureScreenshotsAsync({
-                testsDirectory,
-                capturedSinceMs: attemptStartedAtMs,
-                attemptIndex: attempt,
-                failedFlowNames,
-                logger,
-              });
-              break;
-            }
-            case 'maestro-runner':
-              screenshots = await harvestMaestroRunnerFailureScreenshotsAsync({
-                reportDirectory: runnerOutputDirectory,
-                capturedSinceMs: attemptStartedAtMs,
-                attemptIndex: attempt,
-                logger,
-              });
-              break;
-          }
-          harvested.push(...screenshots);
+          const failedFlowNames = outputPath
+            ? await parseFailedFlowNamesFromJUnitFile(outputPath)
+            : new Set<string>();
+          harvested.push(
+            ...(await harvestFailureScreenshotsAsync({
+              testsDirectory,
+              capturedSinceMs: attemptStartedAtMs,
+              attemptIndex: attempt,
+              failedFlowNames,
+              logger,
+            }))
+          );
        }

        if (lastAttemptExitCode === 0 || attempt === retries) {
          break;
        }

-        if (
-          retryFailedOnly &&
-          (backend === 'maestro-runner' || (outputFormat === 'junit' && outputPath))
-        ) {
+        if (retryFailedOnly && outputFormat === 'junit' && outputPath) {
          let failed: string[] | null;
-          switch (backend) {
-            case 'maestro-runner':
-              failed = await parseFailedFlowsFromMaestroRunnerReport({
-                reportDirectory: runnerOutputDirectory,
-                workingDirectory: stepCtx.workingDirectory,
-              });
-              break;
-            case 'maestro':
-              if (!outputPath) {
-                failed = null;
-                break;
-              }
-              if (await junitFileHasFileAttrs(outputPath)) {
-                failed = await parseFailedFlowsFromFileAttrs({
-                  junitFile: outputPath,
-                  workingDirectory: stepCtx.workingDirectory,
-                });
-                break;
-              }
-              // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
-              // paths via the flow-file scan. DELETE this arm once the fleet is
-              // on >= 2.6.0.
-              const nameToPath = await (nameToPathPromise ??= buildFlowNameToPathMap({
-                inputFlowPaths: flowPaths,
-                projectRoot: stepCtx.workingDirectory,
-                logger,
-              }));
-              failed = nameToPath
-                ? await parseFailedFlowsFromJUnit({
-                    junitFile: outputPath,
-                    nameToPath,
-                  })
-                : null;
-              break;
+          if (await junitFileHasFileAttrs(outputPath)) {
+            failed = await parseFailedFlowsFromFileAttrs({
+              junitFile: outputPath,
+              workingDirectory: stepCtx.workingDirectory,
+            });
+          } else {
+            // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
+            // paths via the flow-file scan. DELETE this arm once the fleet is
+            // on >= 2.6.0.
+            const nameToPath = await (nameToPathPromise ??= buildFlowNameToPathMap({
+              inputFlowPaths: flowPaths,
+              projectRoot: stepCtx.workingDirectory,
+              logger,
+            }));
+            failed = nameToPath
+              ? await parseFailedFlowsFromJUnit({ junitFile: outputPath, nameToPath })
+              : null;
          }
          if (failed !== null && failed.length > 0) {
            flowsToRun = failed;
@@ -541,13 +413,7 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
      // Upload before the ERR_MAESTRO_TESTS_FAILED throw below so fully-failed runs (which need
      // screenshots most) still upload. Harvest only ran for junit, so guard the same way.
      if (outputFormat === 'junit') {
-        await uploadFailureScreenshotsAsync({
-          harvested,
-          backend,
-          reportDirectories,
-          ctx,
-          logger,
-        });
+        await uploadFailureScreenshotsAsync({ harvested, junitReportDirectory, ctx, logger });
      }

      // The retry loop exits via success (0), numeric status (retryable),
@@ -568,14 +434,12 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
 // the maestro test result. Caller guards on junit (harvest only runs for junit).
 async function uploadFailureScreenshotsAsync({
  harvested,
-  backend,
-  reportDirectories,
+  junitReportDirectory,
  ctx,
  logger,
 }: {
  harvested: HarvestedScreenshot[];
-  backend: MaestroBackend;
-  reportDirectories: string[];
+  junitReportDirectory: string;
  ctx: CustomBuildContext;
  logger: bunyan;
 }): Promise<void> {
@@ -585,25 +449,9 @@ async function uploadFailureScreenshotsAsync({
  // test verdict (the whole step is verdict-neutral for screenshots).
  let selected: HarvestedScreenshot[];
  try {
-    let flowResults: { name: string; status: 'passed' | 'failed' }[];
-    switch (backend) {
-      case 'maestro':
-        flowResults = (
-          await Promise.all(reportDirectories.map(directory => parseJUnitTestCases(directory)))
-        ).flat();
-        break;
-      case 'maestro-runner': {
-        const results = await Promise.all(
-          reportDirectories.map(directory => parseMaestroRunnerReport(directory))
-        );
-        // Use whichever reports parsed. An unreadable report (e.g. a final retry that crashed
-        // before writing report.json) contributes no flows rather than discarding screenshots
-        // harvested from the attempts that did report — mirroring the maestro path above.
-        flowResults = results.flatMap(result => result?.flows ?? []);
-        break;
-      }
-    }
-    const pureFailureFlowNames = computePureFailureFlowNames(flowResults);
+    const pureFailureFlowNames = computePureFailureFlowNames(
+      await parseJUnitTestCases(junitReportDirectory)
+    );
    selected = selectFailureScreenshots(harvested, pureFailureFlowNames);
  } catch (err: any) {
    logger.warn({ err }, 'Failed to classify failure screenshots; skipping screenshot upload.');
@@ -16,10 +16,6 @@ export type IpaInfo = {
  bundleIdentifier: string;
  bundleShortVersion: string;
  bundleVersion: string;
-  // `DTPlatformName` from the bundle's Info.plist (e.g. `iphoneos`, `appletvos`,
-  // `macosx`, `xros`), or null when absent. Used to pick the App Store Connect
-  // platform for the upload. See `AscApiUtils.ascPlatformFromDtPlatformName`.
-  dtPlatformName: string | null;
 };

 const INFO_PLIST_PATH_REGEXP = /^Payload\/[^/]+\.app\/Info\.plist$/;
@@ -95,14 +91,10 @@ export async function readIpaInfoAsync(ipaPath: string): Promise<IpaInfo> {
      );
    }

-    const dtPlatformName =
-      typeof infoPlist.DTPlatformName === 'string' ? infoPlist.DTPlatformName : null;
-
    return {
      bundleIdentifier,
      bundleShortVersion,
      bundleVersion,
-      dtPlatformName,
    };
  } catch (error) {
    if (error instanceof UserError) {
@@ -62,12 +62,6 @@ export function createRepackBuildFunction(): BuildFunction {
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
        required: false,
      }),
-      BuildStepInput.createProvider({
-        id: 'ios_signing_backend',
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-        required: false,
-        allowedValues: ['fastlane', 'zsign'],
-      }),
      BuildStepInput.createProvider({
        id: 'repack_version',
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
@@ -150,14 +144,12 @@ export function createRepackBuildFunction(): BuildFunction {
            iosSigningOptions: await resolveIosSigningOptionsAsync({
              job: stepsCtx.global.staticContext.job,
              logger: stepsCtx.logger,
-              backend: inputs.ios_signing_backend.value as 'fastlane' | 'zsign' | undefined,
              useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value as
                | boolean
                | undefined,
              entitlementsPath: inputs.ios_signing_app_entitlements_path.value as
                | string
                | undefined,
-              tmpDir,
            }),
            logger: stepsCtx.logger,
            spawnAsync: repackSpawnAsync,
@@ -305,51 +297,24 @@ export async function resolveAndroidSigningOptionsAsync({
 }

 /**
- * Resolves iOS signing options from the job secrets, dispatching on the
- * requested signing backend.
+ * Resolves iOS signing options from the job secrets.
 */
 export async function resolveIosSigningOptionsAsync({
  job,
  logger,
-  backend,
  useAppEntitlements,
  entitlementsPath,
-  tmpDir,
 }: {
  job: Job;
  logger: bunyan;
-  backend?: 'fastlane' | 'zsign';
  useAppEntitlements?: boolean;
  entitlementsPath?: string;
-  tmpDir: string;
 }): Promise<IosSigningOptions | undefined> {
  const iosJob = job as Ios.Job;
  const buildCredentials = iosJob.secrets?.buildCredentials;
  if (iosJob.simulator || buildCredentials == null) {
    return undefined;
  }
-  const commonOptions = { buildCredentials, logger, useAppEntitlements, entitlementsPath };
-  return backend === 'zsign'
-    ? await createIosZsignOptionsAsync({ ...commonOptions, tmpDir })
-    : await createIosFastlaneOptionsAsync(commonOptions);
-}
-
-/**
- * Creates signing options for the fastlane backend: certificates are imported
- * into a temporary keychain and provisioning profiles are parsed with the
- * macOS `security` tool.
- */
-async function createIosFastlaneOptionsAsync({
-  buildCredentials,
-  logger,
-  useAppEntitlements,
-  entitlementsPath,
-}: {
-  buildCredentials: Ios.BuildCredentials;
-  logger: bunyan;
-  useAppEntitlements?: boolean;
-  entitlementsPath?: string;
-}): Promise<IosSigningOptions> {
  const credentialsManager = new IosCredentialsManager(buildCredentials);
  const credentials = await credentialsManager.prepare(logger);

@@ -365,53 +330,3 @@ async function createIosFastlaneOptionsAsync({
    entitlementsPath,
  };
 }
-
-/**
- * Creates signing options for the zsign backend. The distribution certificate
- * secret is already a PKCS#12 file, so it goes to disk as-is together with the
- * provisioning profiles.
- */
-async function createIosZsignOptionsAsync({
-  buildCredentials,
-  logger,
-  useAppEntitlements,
-  entitlementsPath,
-  tmpDir,
-}: {
-  buildCredentials: Ios.BuildCredentials;
-  logger: bunyan;
-  useAppEntitlements?: boolean;
-  entitlementsPath?: string;
-  tmpDir: string;
-}): Promise<IosSigningOptions> {
-  const targets = Object.entries(buildCredentials);
-  const [targetName, targetCredentials] = targets[0];
-  logger.info(`Using the distribution certificate from target '${targetName}' for zsign`);
-
-  const certificatePath = path.join(tmpDir, `dist-cert-${randomUUID()}.p12`);
-  await fs.promises.writeFile(
-    certificatePath,
-    new Uint8Array(Buffer.from(targetCredentials.distributionCertificate.dataBase64, 'base64'))
-  );
-
-  // zsign matches profiles to bundles by the app-id suffix itself, so the
-  // record keys are informational only.
-  const provisioningProfile: Record<string, string> = {};
-  for (const [target, credentials] of targets) {
-    const profilePath = path.join(tmpDir, `profile-${target}-${randomUUID()}.mobileprovision`);
-    await fs.promises.writeFile(
-      profilePath,
-      new Uint8Array(Buffer.from(credentials.provisioningProfileBase64, 'base64'))
-    );
-    provisioningProfile[target] = profilePath;
-  }
-
-  return {
-    backend: 'zsign',
-    certificatePath,
-    keyPassword: targetCredentials.distributionCertificate.password,
-    provisioningProfile,
-    useAppEntitlements,
-    entitlementsPath,
-  };
-}
@@ -15,17 +15,17 @@ import path from 'path';
 import { sendCcacheStatsAsync } from './ccacheStats';
 import { decompressCacheAsync, downloadCacheAsync, downloadPublicCacheAsync } from './restoreCache';
 import {
-  CcacheBuildTarget,
+  CACHE_KEY_PREFIX_BY_PLATFORM,
  generateDefaultBuildCacheKeyAsync,
-  getCcacheKeyPrefix,
  getCcachePath,
 } from '../../utils/cacheKey';
-import {
-  getCocoapodsCachePaths,
-  resolveCocoapodsCacheKeyAsync,
-  restoreCocoapodsCacheArchiveAsync,
-} from '../../utils/cocoapodsCache';
 import { Datadog } from '../../datadog';
+import {
+  XCODE_COMPILATION_CACHE_ENV,
+  XCODE_COMPILATION_CACHE_RELATIVE_PATH,
+  decompressXcodeCompilationCacheAsync,
+  generateXcodeCompilationCacheKeyAsync,
+} from '../../ios/compilationCache';
 import { GRADLE_CACHE_KEY_PREFIX, generateGradleCacheKeyAsync } from '../../utils/gradleCacheKey';
 import { TurtleFetchError, turtleFetch } from '../../utils/turtleFetch';

@@ -41,11 +41,6 @@ export function createRestoreBuildCacheFunction(): BuildFunction {
        required: false,
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
      }),
-      BuildStepInput.createProvider({
-        id: 'simulator',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-      }),
    ],
    fn: async (stepCtx, { env, inputs }) => {
      const { logger } = stepCtx;
@@ -59,43 +54,91 @@ export function createRestoreBuildCacheFunction(): BuildFunction {
        );
      }

-      const target: CcacheBuildTarget =
+      await Promise.all([
+        restoreCcacheAsync({
+          logger,
+          workingDirectory,
+          platform,
+          env,
+          secrets: stepCtx.global.staticContext.job.secrets,
+        }),
        platform === Platform.IOS
-          ? {
-              platform,
-              simulator:
-                (inputs.simulator.value as boolean | undefined) ??
-                (stepCtx.global.staticContext.job.platform === Platform.IOS &&
-                  stepCtx.global.staticContext.job.simulator === true),
-            }
-          : { platform };
-      await restoreCcacheAsync({
-        logger,
-        workingDirectory,
-        target,
-        env,
-        secrets: stepCtx.global.staticContext.job.secrets,
-      });
-
-      if (platform === Platform.ANDROID) {
-        await restoreGradleCacheAsync({
-          logger,
-          workingDirectory,
-          env,
-          secrets: stepCtx.global.staticContext.job.secrets,
-        });
-      } else {
-        await restoreCocoapodsCacheAsync({
-          logger,
-          workingDirectory,
-          env,
-          secrets: stepCtx.global.staticContext.job.secrets,
-        });
-      }
+          ? restoreXcodeCompilationCacheAsync({
+              logger,
+              workingDirectory,
+              env,
+              secrets: stepCtx.global.staticContext.job.secrets,
+            })
+          : restoreGradleCacheAsync({
+              logger,
+              workingDirectory,
+              env,
+              secrets: stepCtx.global.staticContext.job.secrets,
+            }),
+      ]);
    },
  });
 }

+export async function restoreXcodeCompilationCacheAsync({
+  logger,
+  workingDirectory,
+  env,
+  secrets,
+}: {
+  logger: bunyan;
+  workingDirectory: string;
+  env: Record<string, string | undefined>;
+  secrets?: { robotAccessToken?: string };
+}): Promise<void> {
+  const buildCacheEnabled =
+    env.EAS_RESTORE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_RESTORE_CACHE !== '0');
+  if (!buildCacheEnabled || env[XCODE_COMPILATION_CACHE_ENV] !== '1') {
+    return;
+  }
+
+  try {
+    const robotAccessToken = nullthrows(
+      secrets?.robotAccessToken,
+      'Robot access token is required for cache operations'
+    );
+    const expoApiServerURL = nullthrows(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+    const jobId = nullthrows(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
+    const { key, keyPrefix, xcodeVersion } = await generateXcodeCompilationCacheKeyAsync({
+      workingDirectory,
+      env,
+      logger,
+    });
+    logger.info(`Restoring Xcode compilation cache for ${xcodeVersion} with key: ${key}`);
+
+    const { archivePath, matchedKey } = await downloadCacheAsync({
+      logger,
+      jobId,
+      expoApiServerURL,
+      robotAccessToken,
+      paths: [XCODE_COMPILATION_CACHE_RELATIVE_PATH],
+      key,
+      keyPrefixes: [keyPrefix],
+      platform: Platform.IOS,
+    });
+    await decompressXcodeCompilationCacheAsync({
+      archivePath,
+      workingDirectory,
+      env,
+      logger,
+    });
+    logger.info(
+      `Xcode compilation cache restored ${matchedKey === key ? '(direct hit)' : '(prefix match)'}`
+    );
+  } catch (err: unknown) {
+    if (err instanceof TurtleFetchError && err.response?.status === 404) {
+      logger.info('No Xcode compilation cache found for this key');
+    } else {
+      logger.warn({ err }, 'Failed to restore Xcode compilation cache');
+    }
+  }
+}
+
 export function createCacheStatsBuildFunction(): BuildFunction {
  return new BuildFunction({
    namespace: 'eas',
@@ -120,13 +163,13 @@ export function createCacheStatsBuildFunction(): BuildFunction {
 export async function restoreCcacheAsync({
  logger,
  workingDirectory,
-  target,
+  platform,
  env,
  secrets,
 }: {
  logger: bunyan;
  workingDirectory: string;
-  target: CcacheBuildTarget;
+  platform: Platform;
  env: Record<string, string | undefined>;
  secrets?: { robotAccessToken?: string };
 }): Promise<void> {
@@ -164,7 +207,7 @@ export async function restoreCcacheAsync({
      })
    );

-    const cacheKey = await generateDefaultBuildCacheKeyAsync(workingDirectory, target);
+    const cacheKey = await generateDefaultBuildCacheKeyAsync(workingDirectory, platform);
    logger.info(`Restoring cache key: ${cacheKey}`);

    const jobId = nullthrows(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
@@ -175,8 +218,8 @@ export async function restoreCcacheAsync({
      robotAccessToken,
      paths: [cachePath],
      key: cacheKey,
-      keyPrefixes: [getCcacheKeyPrefix(target)],
-      platform: target.platform,
+      keyPrefixes: [CACHE_KEY_PREFIX_BY_PLATFORM[platform]],
+      platform,
    });

    await decompressCacheAsync({
@@ -203,7 +246,7 @@ export async function restoreCcacheAsync({
          expoApiServerURL,
          robotAccessToken,
          paths: [cachePath],
-          platform: target.platform,
+          platform,
        });
        await decompressCacheAsync({
          archivePath,
@@ -218,67 +261,6 @@ export async function restoreCcacheAsync({
  }
 }

-export async function restoreCocoapodsCacheAsync({
-  logger,
-  workingDirectory,
-  env,
-  secrets,
-}: {
-  logger: bunyan;
-  workingDirectory: string;
-  env: Record<string, string | undefined>;
-  secrets?: { robotAccessToken?: string };
-}): Promise<void> {
-  if (env.EAS_PODS_CACHE !== '1') {
-    return;
-  }
-
-  try {
-    const { stdout } = await spawnAsync('pod', ['--version'], {
-      env,
-      stdio: 'pipe',
-    });
-    const { key, keyPrefix } = await resolveCocoapodsCacheKeyAsync(workingDirectory, stdout);
-    logger.info(`Restoring CocoaPods cache key: ${key}`);
-
-    const jobId = nullthrows(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
-    const robotAccessToken = nullthrows(
-      secrets?.robotAccessToken,
-      'Robot access token is required for cache operations'
-    );
-    const expoApiServerURL = nullthrows(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
-    const { podsDirectory } = getCocoapodsCachePaths(workingDirectory);
-
-    const { archivePath, matchedKey } = await downloadCacheAsync({
-      logger,
-      jobId,
-      expoApiServerURL,
-      robotAccessToken,
-      paths: [podsDirectory],
-      key,
-      keyPrefixes: [keyPrefix],
-      platform: Platform.IOS,
-    });
-
-    await restoreCocoapodsCacheArchiveAsync({ archivePath, workingDirectory });
-
-    const hitType = matchedKey === key ? 'direct_hit' : 'prefix_match';
-    logger.info(
-      `CocoaPods cache restored to ${podsDirectory} (${hitType === 'direct_hit' ? 'direct hit' : 'prefix match'})`
-    );
-    Datadog.log(`CocoaPods cache restored (${hitType})`, {
-      event: 'cocoapods_cache_restored',
-      cache_hit_type: hitType,
-    });
-  } catch (err: unknown) {
-    if (err instanceof TurtleFetchError && err.response?.status === 404) {
-      logger.info('No CocoaPods cache found for this key');
-    } else {
-      logger.warn('Failed to restore CocoaPods cache: ', err);
-    }
-  }
-}
-
 export async function restoreGradleCacheAsync({
  logger,
  workingDirectory,
@@ -347,14 +329,13 @@ export async function restoreGradleCacheAsync({
    const gradleCachesPath = path.join(os.homedir(), '.gradle', 'caches');

    const buildCachePath = path.join(gradleCachesPath, 'build-cache-1');
-    const journalPath = path.join(gradleCachesPath, 'journal-1');

    const { archivePath, matchedKey } = await downloadCacheAsync({
      logger,
      jobId,
      expoApiServerURL,
      robotAccessToken,
-      paths: [buildCachePath, journalPath],
+      paths: [buildCachePath],
      key: cacheKey,
      keyPrefixes: [GRADLE_CACHE_KEY_PREFIX],
      platform: Platform.ANDROID,
@@ -14,17 +14,14 @@ import os from 'os';
 import path from 'path';

 import { compressCacheAsync, uploadCacheAsync } from './saveCache';
+import {
+  XCODE_COMPILATION_CACHE_ENV,
+  XCODE_COMPILATION_CACHE_RELATIVE_PATH,
+  compressXcodeCompilationCacheAsync,
+  generateXcodeCompilationCacheKeyAsync,
+} from '../../ios/compilationCache';
 import { formatBytes } from '../../utils/artifacts';
-import {
-  CcacheBuildTarget,
-  generateDefaultBuildCacheKeyAsync,
-  getCcachePath,
-} from '../../utils/cacheKey';
-import {
-  compressCocoapodsCacheAsync,
-  getCocoapodsCachePaths,
-  resolveCocoapodsCacheKeyAsync,
-} from '../../utils/cocoapodsCache';
+import { generateDefaultBuildCacheKeyAsync, getCcachePath } from '../../utils/cacheKey';
 import { generateGradleCacheKeyAsync } from '../../utils/gradleCacheKey';

 export function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFunction {
@@ -39,11 +36,6 @@ export function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFuncti
        required: false,
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
      }),
-      BuildStepInput.createProvider({
-        id: 'simulator',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.BOOLEAN,
-      }),
    ],
    fn: async (stepCtx, { env, inputs }) => {
      const { logger } = stepCtx;
@@ -57,45 +49,34 @@ export function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFuncti
        );
      }

-      const target: CcacheBuildTarget =
+      await Promise.all([
+        saveCcacheAsync({
+          logger,
+          workingDirectory,
+          platform,
+          evictUsedBefore,
+          env,
+          secrets: stepCtx.global.staticContext.job.secrets,
+        }),
        platform === Platform.IOS
-          ? {
-              platform,
-              simulator:
-                (inputs.simulator.value as boolean | undefined) ??
-                (stepCtx.global.staticContext.job.platform === Platform.IOS &&
-                  stepCtx.global.staticContext.job.simulator === true),
-            }
-          : { platform };
-      await saveCcacheAsync({
-        logger,
-        workingDirectory,
-        target,
-        evictUsedBefore,
-        env,
-        secrets: stepCtx.global.staticContext.job.secrets,
-      });
-
-      if (platform === Platform.ANDROID) {
-        await saveGradleCacheAsync({
-          logger,
-          workingDirectory,
-          env,
-          secrets: stepCtx.global.staticContext.job.secrets,
-        });
-      } else {
-        await saveCocoapodsCacheAsync({
-          logger,
-          workingDirectory,
-          env,
-          secrets: stepCtx.global.staticContext.job.secrets,
-        });
-      }
+          ? saveXcodeCompilationCacheAsync({
+              logger,
+              workingDirectory,
+              env,
+              secrets: stepCtx.global.staticContext.job.secrets,
+            })
+          : saveGradleCacheAsync({
+              logger,
+              workingDirectory,
+              env,
+              secrets: stepCtx.global.staticContext.job.secrets,
+            }),
+      ]);
    },
  });
 }

-export async function saveCocoapodsCacheAsync({
+export async function saveXcodeCompilationCacheAsync({
  logger,
  workingDirectory,
  env,
@@ -106,37 +87,32 @@ export async function saveCocoapodsCacheAsync({
  env: Record<string, string | undefined>;
  secrets?: { robotAccessToken?: string };
 }): Promise<void> {
-  if (env.EAS_PODS_CACHE !== '1') {
-    return;
-  }
-
-  const { podsDirectory, podfileLockPath } = getCocoapodsCachePaths(workingDirectory);
-  try {
-    await Promise.all([fs.promises.access(podsDirectory), fs.promises.access(podfileLockPath)]);
-  } catch {
-    logger.warn('No CocoaPods installation found, skipping cache save');
+  const buildCacheEnabled =
+    env.EAS_SAVE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_SAVE_CACHE !== '0');
+  if (!buildCacheEnabled || env[XCODE_COMPILATION_CACHE_ENV] !== '1') {
    return;
  }

  try {
-    const { stdout } = await spawnAsync('pod', ['--version'], {
+    const { key, xcodeVersion } = await generateXcodeCompilationCacheKeyAsync({
+      workingDirectory,
      env,
-      stdio: 'pipe',
+      logger,
    });
-    const { key } = await resolveCocoapodsCacheKeyAsync(workingDirectory, stdout);
-    logger.info(`Saving CocoaPods cache key: ${key}`);
-
+    logger.info(`Saving Xcode compilation cache for ${xcodeVersion} with key: ${key}`);
    const jobId = nullthrows(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
    const robotAccessToken = nullthrows(
      secrets?.robotAccessToken,
      'Robot access token is required for cache operations'
    );
    const expoApiServerURL = nullthrows(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
-
-    logger.info('Compressing CocoaPods cache...');
-    const { archivePath } = await compressCocoapodsCacheAsync({ workingDirectory });
+    const { archivePath } = await compressXcodeCompilationCacheAsync({
+      workingDirectory,
+      env,
+      logger,
+    });
    const { size } = await fs.promises.stat(archivePath);
-    logger.info(`CocoaPods cache archive size: ${formatBytes(size)}`);
+    logger.info(`Xcode compilation cache archive size: ${formatBytes(size)}`);

    await uploadCacheAsync({
      logger,
@@ -145,26 +121,26 @@ export async function saveCocoapodsCacheAsync({
      robotAccessToken,
      archivePath,
      key,
-      paths: [podsDirectory],
+      paths: [XCODE_COMPILATION_CACHE_RELATIVE_PATH],
      size,
      platform: Platform.IOS,
    });
  } catch (err) {
-    logger.error({ err }, 'Failed to save CocoaPods cache');
+    logger.error({ err }, 'Failed to save Xcode compilation cache');
  }
 }

 export async function saveCcacheAsync({
  logger,
  workingDirectory,
-  target,
+  platform,
  evictUsedBefore,
  env,
  secrets,
 }: {
  logger: bunyan;
  workingDirectory: string;
-  target: CcacheBuildTarget;
+  platform: Platform;
  evictUsedBefore: Date;
  env: Record<string, string | undefined>;
  secrets?: { robotAccessToken?: string };
@@ -189,7 +165,7 @@ export async function saveCcacheAsync({
  }

  try {
-    const cacheKey = await generateDefaultBuildCacheKeyAsync(workingDirectory, target);
+    const cacheKey = await generateDefaultBuildCacheKeyAsync(workingDirectory, platform);
    logger.info(`Saving cache key: ${cacheKey}`);

    const jobId = nullthrows(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
@@ -233,7 +209,7 @@ export async function saveCcacheAsync({
      key: cacheKey,
      paths: [cachePath],
      size,
-      platform: target.platform,
+      platform,
    });
  } catch (err) {
    logger.error({ err }, 'Failed to save cache');
@@ -257,7 +233,6 @@ export async function saveGradleCacheAsync({

  const gradleCachesPath = path.join(os.homedir(), '.gradle', 'caches');
  const buildCachePath = path.join(gradleCachesPath, 'build-cache-1');
-  const journalPath = path.join(gradleCachesPath, 'journal-1');

  try {
    await fs.promises.access(buildCachePath);
@@ -277,11 +252,9 @@ export async function saveGradleCacheAsync({
    );
    const expoApiServerURL = nullthrows(env.__API_SERVER_URL, '__API_SERVER_URL is not set');

-    await fs.promises.mkdir(journalPath, { recursive: true });
-
    logger.info('Compressing Gradle build cache...');
    const { archivePath } = await compressCacheAsync({
-      paths: [buildCachePath, journalPath],
+      paths: [buildCachePath],
      workingDirectory: gradleCachesPath,
      verbose: env.EXPO_DEBUG === '1',
      logger,
@@ -297,7 +270,7 @@ export async function saveGradleCacheAsync({
      robotAccessToken,
      archivePath,
      key: cacheKey,
-      paths: [buildCachePath, journalPath],
+      paths: [buildCachePath],
      size,
      platform: Platform.ANDROID,
    });
@@ -103,7 +103,6 @@ export async function uploadCacheAsync({
  archivePath,
  size,
  platform,
-  force = false,
 }: {
  logger: bunyan;
  jobId: string;
@@ -114,7 +113,6 @@ export async function uploadCacheAsync({
  archivePath: string;
  size: number;
  platform: Platform | undefined;
-  force?: boolean;
 }): Promise<void> {
  const routerURL = platform
    ? 'v2/turtle-builds/caches/upload-sessions'
@@ -129,14 +127,12 @@ export async function uploadCacheAsync({
          key,
          version: getCacheVersion(paths),
          size,
-          force,
        })
      : JSON.stringify({
          jobRunId: jobId,
          key,
          version: getCacheVersion(paths),
          size,
-          force,
        }),
    headers: {
      Authorization: `Bearer ${robotAccessToken}`,
@@ -352,10 +348,7 @@ export async function compressCacheAsync({
    for (const { absolutePath, archivePath: targetRelativePath } of allFiles) {
      const targetPath = path.join(tempDir, targetRelativePath);
      await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
-      // We want to keep source timestamps since Gradle may check them when pruning cache.
-      const { atime, mtime } = await fs.promises.stat(absolutePath);
      await fs.promises.copyFile(absolutePath, targetPath);
-      await fs.promises.utimes(targetPath, atime, mtime);

      if (verbose) {
        logger.info(`- ${targetRelativePath}`);
@@ -13,10 +13,6 @@ import os from 'node:os';
 import path from 'node:path';

 import { type CustomBuildContext } from '../../customBuildContext';
-import {
-  uploadRemoteSessionConfigWithLocalEgressAsync,
-  withLocalEgressSession,
-} from '../utils/localEgressSession';
 import { Sentry } from '../../sentry';
 import { pollAgentDeviceArtifactsForUploadAsync } from '../utils/agentDeviceArtifacts';
 import { startAgentDeviceEventCollectionAsync } from '../utils/agentDeviceEvents';
@@ -27,8 +23,9 @@ import {
  getNgrokTunnelDomainOrThrow,
  selectXcodeDeveloperDirectoryAsync,
  spawnDetached,
-  startDeviceWebPreviewWithTunnelAsync,
  startNgrokTunnelAsync,
+  startServeSimWithTunnelAsync,
+  uploadRemoteSessionConfigAsync,
  waitForDeviceRunSessionStoppedAsync,
  waitForFileAsync,
 } from '../utils/remoteDeviceRunSession';
@@ -63,13 +60,8 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
        required: false,
        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
      }),
-      BuildStepInput.createProvider({
-        id: 'max_duration_seconds',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
    ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
+    fn: async ({ logger, global }, { inputs, env, signal }) => {
      // Fail fast before any expensive setup if the injected env
      // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
      // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
@@ -81,7 +73,6 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
      const packageVersion = inputs.package_version.value as string | undefined;
      // 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;
      const { runtimePlatform } = global;
      logger.info(
        `Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`
@@ -110,30 +101,30 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
      const agentDeviceRemoteSessionUrl = agentDeviceTunnel.url;
      logger.info(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);

-      let webPreview: Awaited<ReturnType<typeof startDeviceWebPreviewWithTunnelAsync>> | undefined;
+      let serveSim: Awaited<ReturnType<typeof startServeSimWithTunnelAsync>> | undefined;
      let eventCollection:
        | Awaited<ReturnType<typeof startAgentDeviceEventCollectionAsync>>
        | undefined;
      try {
-        webPreview = await startDeviceWebPreviewWithTunnelAsync(ctx, {
-          runtimePlatform,
-          baseDomain: ngrokTunnelDomain,
-          env,
-          logger,
-          timeoutMs: STARTUP_TIMEOUT_MS,
-        });
-        logger.info(`Web preview URL: ${webPreview.previewUrl}`);
+        // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
+        // on Darwin. Android sessions go without a preview URL.
+        if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
+          serveSim = await startServeSimWithTunnelAsync(ctx, {
+            baseDomain: ngrokTunnelDomain,
+            env,
+            logger,
+            timeoutMs: STARTUP_TIMEOUT_MS,
+          });
+          logger.info(`Web preview URL: ${serveSim.previewUrl}`);
+        }

-        await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
-          signal,
+        await uploadRemoteSessionConfigAsync({
          ctx,
          deviceRunSessionId,
          remoteConfig: {
            agentDeviceRemoteSessionUrl,
            agentDeviceRemoteSessionToken: daemonToken,
-            webPreviewUrl: webPreview.previewUrl,
-            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+            ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
          },
          logger,
        });
@@ -155,7 +146,6 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
          ctx,
          deviceRunSessionId,
          logger,
-          maxDurationSeconds,
          signal,
          idleTimeout:
            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
@@ -166,8 +156,8 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
              : undefined,
        });
      } finally {
-        if (webPreview) {
-          await webPreview.stopAsync();
+        if (serveSim) {
+          await serveSim.stopAsync();
        }
        await agentDeviceTunnel.stopAsync();
        if (eventCollection) {
@@ -179,7 +169,7 @@ export function createStartAgentDeviceRemoteSessionBuildFunction(
        }
        await daemonProcess.stopAsync();
      }
-    }),
+    },
  });
 }

@@ -46,21 +46,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
        defaultValue: AndroidEmulatorUtils.defaultSystemImagePackage,
        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
      }),
-      BuildStepInput.createProvider({
-        id: 'lcd_width',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
-      BuildStepInput.createProvider({
-        id: 'lcd_height',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
-      BuildStepInput.createProvider({
-        id: 'lcd_density',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
      BuildStepInput.createProvider({
        id: 'count',
        required: false,
@@ -101,9 +86,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
      const systemImagePackage = `${inputs.system_image_package.value}`;
      // We can cast because allowedValueTypeName validated this is a string.
      const deviceIdentifier = inputs.device_identifier.value as AndroidDeviceName | undefined;
-      const lcdWidth = inputs.lcd_width.value as number | undefined;
-      const lcdHeight = inputs.lcd_height.value as number | undefined;
-      const lcdDensity = inputs.lcd_density.value as number | undefined;
      const shouldAdjustAnimationScale =
        env.ANDROID_EMULATOR_ADJUST_ANIMATION_SCALE !== 'false' &&
        env.ANDROID_EMULATOR_ADJUST_ANIMATION_SCALE !== '0';
@@ -147,9 +129,6 @@ export function createStartAndroidEmulatorBuildFunction(): BuildFunction {
              deviceName,
              systemImagePackage,
              deviceIdentifier: deviceIdentifier ?? null,
-              lcdWidth: lcdWidth ?? null,
-              lcdHeight: lcdHeight ?? null,
-              lcdDensity: lcdDensity ?? null,
              env,
              logger,
            });
@@ -1,314 +0,0 @@
-import { SystemError } from '@expo/eas-build-job';
-import { type bunyan } from '@expo/logger';
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  type BuildStepEnv,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import semver from 'semver';
-import { z } from 'zod';
-
-import { type CustomBuildContext } from '../../customBuildContext';
-import {
-  uploadRemoteSessionConfigWithLocalEgressAsync,
-  withLocalEgressSession,
-} from '../utils/localEgressSession';
-import { AndroidEmulatorUtils } from '../../utils/AndroidEmulatorUtils';
-import { IosSimulatorUtils } from '../../utils/IosSimulatorUtils';
-import { sleepAsync } from '../../utils/retry';
-import { turtleFetch } from '../../utils/turtleFetch';
-import { startAppiumEventCollectionAsync } from '../utils/appiumEvents';
-import {
-  getDeviceRunSessionIdOrThrow,
-  getNgrokAuthtokenOrThrow,
-  getNgrokTunnelDomainOrThrow,
-  selectXcodeDeveloperDirectoryAsync,
-  spawnDetached,
-  startDeviceWebPreviewWithTunnelAsync,
-  startNgrokTunnelAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../utils/remoteDeviceRunSession';
-
-const APPIUM_HOST = '127.0.0.1';
-const APPIUM_PORT = 4723;
-const APPIUM_STARTUP_TIMEOUT_MS = 120_000;
-const DEFAULT_APPIUM_VERSION = '^3';
-
-const AppiumInstalledDriversSchema = z.record(
-  z.string(),
-  z.object({ installed: z.boolean().optional() }).passthrough()
-);
-
-export function createStartAppiumRemoteSessionBuildFunction(
-  ctx: CustomBuildContext
-): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'start_appium_remote_session',
-    name: 'Start Appium remote session',
-    __metricsId: 'eas/start_appium_remote_session',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'package_version',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'max_idle_time_minutes',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
-    ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
-      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(env);
-      const packageVersion = inputs.package_version.value as string | undefined;
-      const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value as number | undefined;
-      const { runtimePlatform } = global;
-      const versionSpec = resolveAppium3VersionSpec(packageVersion);
-
-      logger.info(
-        `Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
-      );
-      const device = await resolveAppiumDeviceAsync({ runtimePlatform, env, logger });
-      const { appiumHome, appiumBinPath, appiumEnv } = await installAppiumAsync({
-        versionSpec,
-        driverName: device.driverName,
-        env,
-        logger,
-      });
-
-      const 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 }),
-        ],
-        env: appiumEnv,
-      });
-      try {
-        await waitForAppiumReadyAsync({ appiumProcess, logger });
-      } catch (error) {
-        await appiumProcess.stopAsync();
-        await fs.promises.rm(appiumHome, { recursive: true, force: true });
-        throw error;
-      }
-
-      const eventCollection = await startAppiumEventCollectionAsync({
-        ctx,
-        deviceRunSessionId,
-        appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
-        logger,
-      });
-      let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
-      let webPreview: Awaited<ReturnType<typeof startDeviceWebPreviewWithTunnelAsync>> | undefined;
-      try {
-        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.
-        webPreview = await startDeviceWebPreviewWithTunnelAsync(ctx, {
-          runtimePlatform,
-          baseDomain: ngrokTunnelDomain,
-          env,
-          logger,
-          timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
-        });
-
-        await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
-          signal,
-          ctx,
-          deviceRunSessionId,
-          remoteConfig: {
-            appiumUrl: appiumTunnel.url,
-            capabilities: {
-              platformName: device.platformName,
-              'appium:automationName': device.automationName,
-              'appium:udid': device.udid,
-            },
-            webPreviewUrl: webPreview.previewUrl,
-            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
-          },
-          logger,
-        });
-
-        await waitForDeviceRunSessionStoppedAsync({
-          ctx,
-          deviceRunSessionId,
-          logger,
-          signal,
-          idleTimeout:
-            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
-              ? {
-                  maxIdleTimeMinutes,
-                  getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                }
-              : undefined,
-        });
-      } finally {
-        if (webPreview) {
-          await webPreview.stopAsync();
-        }
-        if (appiumTunnel) {
-          await appiumTunnel.stopAsync();
-        }
-        await eventCollection.stopAsync();
-        await appiumProcess.stopAsync();
-        await fs.promises.rm(appiumHome, { recursive: true, force: true });
-      }
-    }),
-  });
-}
-
-export function resolveAppium3VersionSpec(packageVersion: string | undefined): string {
-  const versionSpec = packageVersion ?? DEFAULT_APPIUM_VERSION;
-  const range = semver.validRange(versionSpec);
-  if (!range || !semver.subset(range, '>=3.0.0 <4.0.0-0')) {
-    throw new SystemError(
-      `Appium 3 is required for EAS Simulator sessions. Received package version "${versionSpec}".`
-    );
-  }
-  return versionSpec;
-}
-
-type AppiumDevice = {
-  platformName: 'iOS' | 'Android';
-  automationName: 'XCUITest' | 'UiAutomator2';
-  driverName: 'xcuitest' | 'uiautomator2';
-  udid: string;
-};
-
-export async function resolveAppiumDeviceAsync({
-  runtimePlatform,
-  env,
-  logger,
-}: {
-  runtimePlatform: BuildRuntimePlatform;
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<AppiumDevice> {
-  switch (runtimePlatform) {
-    case BuildRuntimePlatform.DARWIN: {
-      await selectXcodeDeveloperDirectoryAsync({ env, logger });
-      const [bootedDevice] = await IosSimulatorUtils.getAvailableDevicesAsync({
-        env,
-        filter: 'booted',
-      });
-      if (!bootedDevice) {
-        throw new SystemError('Could not find a booted iOS simulator for the Appium session.');
-      }
-      return {
-        platformName: 'iOS',
-        automationName: 'XCUITest',
-        driverName: 'xcuitest',
-        udid: bootedDevice.udid,
-      };
-    }
-    case BuildRuntimePlatform.LINUX: {
-      const attachedDevices = await AndroidEmulatorUtils.getAttachedDevicesAsync({ env });
-      const bootedDevice = attachedDevices.find(device => device.state === 'device');
-      if (!bootedDevice) {
-        throw new SystemError('Could not find a booted Android emulator for the Appium session.');
-      }
-      return {
-        platformName: 'Android',
-        automationName: 'UiAutomator2',
-        driverName: 'uiautomator2',
-        udid: bootedDevice.serialId,
-      };
-    }
-  }
-}
-
-async function installAppiumAsync({
-  versionSpec,
-  driverName,
-  env,
-  logger,
-}: {
-  versionSpec: string;
-  driverName: AppiumDevice['driverName'];
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<{ appiumHome: string; appiumBinPath: string; appiumEnv: BuildStepEnv }> {
-  const appiumHome = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'eas-appium-home-'));
-  await fs.promises.writeFile(
-    path.join(appiumHome, 'package.json'),
-    `${JSON.stringify({ name: 'eas-appium-home', private: true })}\n`
-  );
-  const appiumEnv: BuildStepEnv = { ...env, APPIUM_HOME: appiumHome };
-  const appiumBinPath = path.join(appiumHome, 'node_modules', '.bin', 'appium');
-
-  logger.info(`Installing appium@${versionSpec}.`);
-  await spawn('npm', ['install', '--prefix', appiumHome, `appium@${versionSpec}`], {
-    env: appiumEnv,
-    logger,
-  });
-  const { stdout } = await spawn(appiumBinPath, ['driver', 'list', '--installed', '--json'], {
-    env: appiumEnv,
-    stdio: 'pipe',
-  });
-  const installedDrivers = AppiumInstalledDriversSchema.parse(JSON.parse(stdout));
-  if (installedDrivers[driverName]?.installed) {
-    logger.info(`Updating the installed Appium ${driverName} driver.`);
-    await spawn(appiumBinPath, ['driver', 'update', driverName], { env: appiumEnv, logger });
-  } else {
-    logger.info(`Installing the Appium ${driverName} driver.`);
-    await spawn(appiumBinPath, ['driver', 'install', driverName], { env: appiumEnv, logger });
-  }
-  return { appiumHome, appiumBinPath, appiumEnv };
-}
-
-async function waitForAppiumReadyAsync({
-  appiumProcess,
-  logger,
-}: {
-  appiumProcess: { getOutput: () => string };
-  logger: bunyan;
-}): Promise<void> {
-  const deadline = Date.now() + APPIUM_STARTUP_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    try {
-      const response = await turtleFetch(`http://${APPIUM_HOST}:${APPIUM_PORT}/status`, 'GET', {
-        timeout: 2_000,
-        retries: 0,
-        logger,
-      });
-      if (response.ok) {
-        return;
-      }
-    } catch {}
-    await sleepAsync(1_000);
-  }
-  const output = appiumProcess.getOutput();
-  throw new SystemError(
-    `Timed out waiting for Appium to become ready.${output ? `\nAppium output:\n${output}` : ''}`
-  );
-}
@@ -14,24 +14,21 @@ import semver from 'semver';
 import { z } from 'zod';

 import { CustomBuildContext } from '../../customBuildContext';
-import {
-  uploadRemoteSessionConfigWithLocalEgressAsync,
-  withLocalEgressSession,
-} from '../utils/localEgressSession';
 import { Sentry } from '../../sentry';
 import { isProcessDescendantOfAsync } from '../../utils/processes';
 import { sleepAsync } from '../../utils/retry';
 import { pollArgentArtifactsForUploadAsync } from '../utils/argentArtifacts';
 import { ARGENT_EVENT_LOG_FILENAME, startArgentEventCollectionAsync } from '../utils/argentEvents';
 import {
-  ensureFfmpegInstalledOnceAsync,
+  ensureFfmpegInstalledAsync,
  getDeviceRunSessionIdOrThrow,
  getNgrokAuthtokenOrThrow,
  getNgrokTunnelDomainOrThrow,
  selectXcodeDeveloperDirectoryAsync,
  spawnDetached,
-  startDeviceWebPreviewWithTunnelAsync,
  startNgrokTunnelAsync,
+  startServeSimWithTunnelAsync,
+  uploadRemoteSessionConfigAsync,
  waitForDeviceRunSessionStoppedAsync,
 } from '../utils/remoteDeviceRunSession';

@@ -76,13 +73,8 @@ export function createStartArgentRemoteSessionBuildFunction(
        required: false,
        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
      }),
-      BuildStepInput.createProvider({
-        id: 'max_duration_seconds',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
    ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
+    fn: async ({ logger, global }, { inputs, env, signal }) => {
      // Fail fast before any expensive setup if the injected env
      // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
      // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
@@ -94,7 +86,6 @@ export function createStartArgentRemoteSessionBuildFunction(
      const packageVersion = inputs.package_version.value as string | undefined;
      // A missing or non-positive value disables the idle timeout (opt-in feature).
      const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value as number | undefined;
-      const maxDurationSeconds = inputs.max_duration_seconds?.value as number | undefined;
      warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
      const versionSpec = packageVersion ?? 'latest';
      const { runtimePlatform } = global;
@@ -106,39 +97,32 @@ export function createStartArgentRemoteSessionBuildFunction(
        await selectXcodeDeveloperDirectoryAsync({ env, logger });
      }

-      // Start the potentially slow installation while Argent is being prepared.
-      // On Linux expo-device-hub calls this again and awaits the same in-flight
-      // setup before launching. On macOS this remains non-blocking, so only a
-      // recording started in the first moments may miss ffmpeg.
-      // Never rejects, so `void` is safe.
-      void ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger });
+      // Argent shells out to ffmpeg to record the screen. Installing it pulls a
+      // large Homebrew dependency tree, so do not block session readiness on it:
+      // the session comes up at its usual speed and only a recording started in
+      // the first moments misses ffmpeg. Never rejects, so `void` is safe.
+      void ensureFfmpegInstalledAsync({ runtimePlatform, env, logger });

      logger.info('Enabling the Argent artifacts list endpoint flag.');
      await spawn(
-        'bun',
-        [
-          'x',
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'enable',
-          ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG,
-        ],
+        'bunx',
+        [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG],
        { env, logger }
      );

      logger.info('Enabling the Argent tool-server event log flag.');
      await spawn(
-        'bun',
-        ['x', `${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_EVENT_LOG_FLAG],
+        'bunx',
+        [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_EVENT_LOG_FLAG],
        { env, logger }
      );

-      logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bun x.`);
-      // Keep Argent itself in foreground mode under the detached bun process. This preserves
-      // the bun -> Argent CLI -> tool-server ancestry used to identify the matching state file.
+      logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
+      // Keep Argent itself in foreground mode under the detached bunx process. This preserves
+      // the bunx -> Argent CLI -> tool-server ancestry used to identify the matching state file.
      const argentServer = spawnDetached({
-        command: 'bun',
+        command: 'bunx',
        args: [
-          'x',
          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
          'server',
          'start',
@@ -196,7 +180,7 @@ export function createStartArgentRemoteSessionBuildFunction(
      });

      let toolsTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
-      let webPreview: Awaited<ReturnType<typeof startDeviceWebPreviewWithTunnelAsync>> | undefined;
+      let serveSim: Awaited<ReturnType<typeof startServeSimWithTunnelAsync>> | undefined;
      try {
        toolsTunnel = await startNgrokTunnelAsync({
          port: toolServerPort,
@@ -209,25 +193,26 @@ export function createStartArgentRemoteSessionBuildFunction(
        const publicToolsUrl = toolsTunnel.url;
        logger.info(`Tunnel is ready at ${publicToolsUrl}.`);

-        webPreview = await startDeviceWebPreviewWithTunnelAsync(ctx, {
-          runtimePlatform,
-          baseDomain: ngrokTunnelDomain,
-          env,
-          logger,
-          timeoutMs: STARTUP_TIMEOUT_MS,
-        });
-        logger.info(`Web preview URL: ${webPreview.previewUrl}`);
+        // serve-sim is iOS-only — Android sessions go without a preview URL.
+        let webPreviewUrl: string | undefined;
+        if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
+          serveSim = await startServeSimWithTunnelAsync(ctx, {
+            baseDomain: ngrokTunnelDomain,
+            env,
+            logger,
+            timeoutMs: STARTUP_TIMEOUT_MS,
+          });
+          webPreviewUrl = serveSim.previewUrl;
+          logger.info(`Web preview URL: ${webPreviewUrl}`);
+        }

-        await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
-          signal,
+        await uploadRemoteSessionConfigAsync({
          ctx,
          deviceRunSessionId,
          remoteConfig: {
            toolsUrl: publicToolsUrl,
            ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
-            webPreviewUrl: webPreview.previewUrl,
-            ...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
+            ...(webPreviewUrl ? { webPreviewUrl } : {}),
          },
          logger,
        });
@@ -236,7 +221,6 @@ export function createStartArgentRemoteSessionBuildFunction(
          ctx,
          deviceRunSessionId,
          logger,
-          maxDurationSeconds,
          signal,
          idleTimeout:
            maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
@@ -247,8 +231,8 @@ export function createStartArgentRemoteSessionBuildFunction(
              : undefined,
        });
      } finally {
-        if (webPreview) {
-          await webPreview.stopAsync();
+        if (serveSim) {
+          await serveSim.stopAsync();
        }
        if (toolsTunnel) {
          await toolsTunnel.stopAsync();
@@ -264,7 +248,7 @@ export function createStartArgentRemoteSessionBuildFunction(
        }
        await argentServer.stopAsync();
      }
-    }),
+    },
  });
 }

@@ -306,7 +290,7 @@ export function warnIfArgentPackageVersionCannotBeVerified({
    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 bun x resolve it.`
+        `Continuing and letting bunx resolve it.`
    );
    return;
  }
@@ -1,199 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import {
-  CHISEL_VERSION,
-  LOCAL_EGRESS_HANDOFF_PATH,
-  LOCAL_EGRESS_PROXY_PORT,
-  configureSystemProxyAsync,
-  createChiselAuthfileContents,
-  downloadChiselAsync,
-  generateEgressCredentials,
-  registerLocalEgressResources,
-  startChiselServerAsync,
-  stopLocalEgressResourcesAsync,
-  writeLocalEgressHandoffAsync,
-} from '../utils/localEgress';
-import {
-  type DetachedProcessHandle,
-  type NgrokTunnelHandle,
-  findAvailablePortAsync,
-  getNgrokAuthtokenOrThrow,
-  getNgrokTunnelDomainOrThrow,
-  startNgrokTunnelAsync,
-} from '../utils/remoteDeviceRunSession';
-
-/**
- * The downloader and ngrok SDK do not accept an AbortSignal. Stop awaiting them
- * on cancellation, while retaining handlers that dispose any eventual result.
- */
-function awaitLocalEgressAcquisitionAsync<T>(
-  pending: Promise<T>,
-  signal: AbortSignal,
-  disposeAbandonedAsync: (result?: T) => Promise<void>,
-  logger: bunyan
-): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let abandoned = false;
-    const abort = (): void => {
-      signal.removeEventListener('abort', abort);
-      abandoned = true;
-      reject(signal.reason);
-    };
-    signal.addEventListener('abort', abort, { once: true });
-    if (signal.aborted) {
-      abort();
-    }
-    void pending
-      .then(
-        async result => {
-          signal.removeEventListener('abort', abort);
-          if (abandoned) {
-            await disposeAbandonedAsync(result);
-          } else {
-            resolve(result);
-          }
-        },
-        async error => {
-          signal.removeEventListener('abort', abort);
-          if (abandoned) {
-            await disposeAbandonedAsync();
-          } else {
-            reject(error);
-          }
-        }
-      )
-      .catch(err =>
-        logger.warn({ err }, 'Could not release a cancelled local egress acquisition.')
-      );
-  });
-}
-
-/**
- * Points the device host's system HTTP(S) proxy at the EAS CLI's egress client.
- * Must run before `eas/start_ios_simulator`: the simulator reads the system proxy
- * at boot. Nothing else on the host changes, so requests from libraries that
- * bypass the system proxy are not covered; the shared session monitor reports
- * them. The shared session cleanup releases the resources started here when
- * the session ends, with a job finalizer as a fallback.
- */
-export function createStartLocalEgressBuildFunction(): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'start_local_egress',
-    name: 'Start local egress',
-    __metricsId: 'eas/start_local_egress',
-    supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
-    fn: async ({ logger }, { env, signal }) => {
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(env);
-      let workDir: string | undefined;
-      let server: DetachedProcessHandle | undefined;
-      let tunnel: NgrokTunnelHandle | undefined;
-      let finishSetup!: () => void;
-      const setupFinished = new Promise<void>(resolve => {
-        finishSetup = resolve;
-      });
-      // Register before acquisition. Cancellation ends setup promptly; pending
-      // SDK calls retain their own late-result disposal handlers.
-      const lifetimeSignal = registerLocalEgressResources(async () => {
-        await setupFinished;
-        const results = await Promise.allSettled([
-          Promise.resolve().then(() => tunnel?.stopAsync()),
-          Promise.resolve().then(() => server?.stopAsync()),
-        ]);
-        for (const result of results) {
-          if (result.status === 'rejected') {
-            logger.warn({ err: result.reason }, 'Could not stop a local egress resource.');
-          }
-        }
-        await Promise.all([
-          fs.promises.rm(LOCAL_EGRESS_HANDOFF_PATH, { force: true }),
-          workDir ? fs.promises.rm(workDir, { recursive: true, force: true }) : undefined,
-        ]);
-      });
-      const startupSignal = signal ? AbortSignal.any([signal, lifetimeSignal]) : lifetimeSignal;
-
-      try {
-        startupSignal.throwIfAborted();
-        workDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'eas-local-egress-'));
-        startupSignal.throwIfAborted();
-        logger.info(`Downloading the reverse tunnel server (chisel ${CHISEL_VERSION}).`);
-        const downloadDir = workDir;
-        const chiselPath = await awaitLocalEgressAcquisitionAsync(
-          downloadChiselAsync({ destinationDir: downloadDir, logger }),
-          startupSignal,
-          async () => await fs.promises.rm(downloadDir, { recursive: true, force: true }),
-          logger
-        );
-        startupSignal.throwIfAborted();
-
-        const credentials = generateEgressCredentials();
-        const authfilePath = path.join(workDir, 'authfile.json');
-        await fs.promises.writeFile(
-          authfilePath,
-          createChiselAuthfileContents({ ...credentials, port: LOCAL_EGRESS_PROXY_PORT }),
-          { encoding: 'utf8', mode: 0o600 }
-        );
-        startupSignal.throwIfAborted();
-
-        const controlPort = await findAvailablePortAsync();
-        startupSignal.throwIfAborted();
-        logger.info(`Starting the reverse tunnel server on 127.0.0.1:${controlPort}.`);
-        const started = await startChiselServerAsync({
-          chiselPath,
-          controlPort,
-          authfilePath,
-          env,
-          signal: startupSignal,
-        });
-        server = started.process;
-        startupSignal.throwIfAborted();
-        tunnel = await awaitLocalEgressAcquisitionAsync(
-          startNgrokTunnelAsync({
-            port: controlPort,
-            subdomainPrefix: 'egress',
-            baseDomain: ngrokTunnelDomain,
-            authtoken: ngrokAuthtoken,
-            logger,
-          }),
-          startupSignal,
-          async listener => await listener?.stopAsync(),
-          logger
-        );
-        startupSignal.throwIfAborted();
-
-        const { service } = await configureSystemProxyAsync({
-          env,
-          logger,
-          port: LOCAL_EGRESS_PROXY_PORT,
-          signal: startupSignal,
-        });
-        startupSignal.throwIfAborted();
-        await writeLocalEgressHandoffAsync({
-          url: tunnel.url,
-          token: credentials.password,
-          fingerprint: started.fingerprint,
-          port: LOCAL_EGRESS_PROXY_PORT,
-        });
-        startupSignal.throwIfAborted();
-        logger.info(
-          `Local egress is configured on network service "${service}". HTTP(S) and WebSocket ` +
-            'requests that honor the system proxy (WebKit, URLSession and other CFNetwork clients) ' +
-            'fail until the EAS CLI egress client connects, then exit from that machine. Requests ' +
-            'from libraries that bypass the system proxy are not covered and exit from this worker. ' +
-            'Connection sampling may report these bypasses, but can miss short connections and unconnected UDP traffic.'
-        );
-      } catch (error) {
-        finishSetup();
-        await stopLocalEgressResourcesAsync(logger);
-        throw error;
-      } finally {
-        finishSetup();
-      }
-    },
-  });
-}
@@ -0,0 +1,59 @@
+import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
+
+import { CustomBuildContext } from '../../customBuildContext';
+import {
+  getDeviceRunSessionIdOrThrow,
+  getNgrokTunnelDomainOrThrow,
+  selectXcodeDeveloperDirectoryAsync,
+  startServeSimWithTunnelAsync,
+  uploadRemoteSessionConfigAsync,
+  waitForDeviceRunSessionStoppedAsync,
+} from '../utils/remoteDeviceRunSession';
+
+const STARTUP_TIMEOUT_MS = 60_000;
+
+export function createStartServeSimRemoteSessionBuildFunction(
+  ctx: CustomBuildContext
+): BuildFunction {
+  return new BuildFunction({
+    namespace: 'eas',
+    id: 'start_serve_sim_remote_session',
+    name: 'Start serve-sim remote session',
+    __metricsId: 'eas/start_serve_sim_remote_session',
+    supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
+    fn: async ({ logger }, { env, signal }) => {
+      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
+
+      logger.info('Starting serve-sim remote session.');
+
+      await selectXcodeDeveloperDirectoryAsync({ env, logger });
+
+      const serveSim = await startServeSimWithTunnelAsync(ctx, {
+        baseDomain: ngrokTunnelDomain,
+        env,
+        logger,
+        timeoutMs: STARTUP_TIMEOUT_MS,
+      });
+      logger.info(`Preview URL: ${serveSim.previewUrl}`);
+
+      try {
+        await uploadRemoteSessionConfigAsync({
+          ctx,
+          deviceRunSessionId,
+          remoteConfig: { previewUrl: serveSim.previewUrl },
+          logger,
+        });
+
+        await waitForDeviceRunSessionStoppedAsync({
+          ctx,
+          deviceRunSessionId,
+          logger,
+          signal,
+        });
+      } finally {
+        await serveSim.stopAsync();
+      }
+    },
+  });
+}
@@ -1,91 +0,0 @@
-import {
-  BuildFunction,
-  BuildRuntimePlatform,
-  BuildStepInput,
-  BuildStepInputValueTypeName,
-} from '@expo/steps';
-
-import { CustomBuildContext } from '../../customBuildContext';
-import {
-  uploadRemoteSessionConfigWithLocalEgressAsync,
-  withLocalEgressSession,
-} from '../utils/localEgressSession';
-import {
-  getDeviceRunSessionIdOrThrow,
-  getNgrokTunnelDomainOrThrow,
-  selectXcodeDeveloperDirectoryAsync,
-  startDeviceWebPreviewWithTunnelAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../utils/remoteDeviceRunSession';
-
-const STARTUP_TIMEOUT_MS = 60_000;
-
-export function createStartWebPreviewRemoteSessionBuildFunction(
-  ctx: CustomBuildContext
-): BuildFunction {
-  return new BuildFunction({
-    namespace: 'eas',
-    id: 'start_serve_sim_remote_session',
-    name: 'Start web preview remote session',
-    __metricsId: 'eas/start_serve_sim_remote_session',
-    inputProviders: [
-      BuildStepInput.createProvider({
-        id: 'package_version',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.STRING,
-      }),
-      BuildStepInput.createProvider({
-        id: 'max_duration_seconds',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
-    ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
-      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
-      const maxDurationSeconds = inputs.max_duration_seconds?.value as number | undefined;
-      const packageVersion = inputs.package_version?.value as string | undefined;
-      const { runtimePlatform } = global;
-
-      logger.info(`Starting web preview remote session (runtime: ${runtimePlatform}).`);
-
-      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        await selectXcodeDeveloperDirectoryAsync({ env, logger });
-      }
-
-      const webPreview = await startDeviceWebPreviewWithTunnelAsync(ctx, {
-        runtimePlatform,
-        baseDomain: ngrokTunnelDomain,
-        env,
-        logger,
-        timeoutMs: STARTUP_TIMEOUT_MS,
-        packageVersion,
-      });
-      logger.info(`Preview URL: ${webPreview.previewUrl}`);
-
-      try {
-        await uploadRemoteSessionConfigWithLocalEgressAsync({
-          env,
-          signal,
-          ctx,
-          deviceRunSessionId,
-          remoteConfig: {
-            previewUrl: webPreview.previewUrl,
-            ...(webPreview.previewToken ? { previewToken: webPreview.previewToken } : {}),
-          },
-          logger,
-        });
-
-        await waitForDeviceRunSessionStoppedAsync({
-          ctx,
-          deviceRunSessionId,
-          logger,
-          maxDurationSeconds,
-          signal,
-        });
-      } finally {
-        await webPreview.stopAsync();
-      }
-    }),
-  });
-}
@@ -90,24 +90,19 @@ export function createUploadToAscBuildFunction(): BuildFunction {
      const ascApiKeyJson = await fs.readJson(ascApiKeyPath);
      const ascApiKey = z
        .object({
-          issuer_id: z.string().nullish(),
+          issuer_id: z.string(),
          key_id: z.string(),
          key: z.string(),
        })
        .parse(ascApiKeyJson);

      const privateKey = await jose.importPKCS8(ascApiKey.key, 'ES256');
-      const jwt = new jose.SignJWT({})
+      const token = await new jose.SignJWT({})
        .setProtectedHeader({ alg: 'ES256', kid: ascApiKey.key_id })
+        .setIssuer(ascApiKey.issuer_id)
        .setAudience('appstoreconnect-v1')
-        .setExpirationTime('20m');
-      if (ascApiKey.issuer_id) {
-        jwt.setIssuer(ascApiKey.issuer_id);
-      } else {
-        // Nullish issuer_id means an individual API key
-        jwt.setSubject('user');
-      }
-      const token = await jwt.sign(privateKey);
+        .setExpirationTime('20m')
+        .sign(privateKey);

      const client = new AscApiClient({ token, logger: stepsCtx.logger });

@@ -120,27 +115,16 @@ export function createUploadToAscBuildFunction(): BuildFunction {
        `Uploading Build to "${appResponse.data.attributes.name}" (${ascAppBundleIdentifier})...`
      );

-      // Derive the App Store Connect platform from the IPA itself so tvOS (and
-      // other) binaries are uploaded to the correct version train instead of the
-      // iOS one. Falls back to `IOS` if the platform cannot be read.
-      const ipaInfoResult = await asyncResult(readIpaInfoAsync(ipaPath));
-      const platform = ipaInfoResult.ok
-        ? AscApiUtils.ascPlatformFromDtPlatformName(ipaInfoResult.value.dtPlatformName)
-        : 'IOS';
-      stepsCtx.logger.info(`Detected App Store Connect platform: ${platform}`);
-
      stepsCtx.logger.info('Creating Build Upload...');
      const buildUploadResponse = await AscApiUtils.createBuildUploadAsync({
        client,
        appleAppIdentifier,
        bundleShortVersion,
        bundleVersion,
-        platform,
      });

      const buildUploadId = buildUploadResponse.data.id;
-      const platformPathSegment = AscApiUtils.testFlightPlatformPathSegment(platform);
-      const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/${platformPathSegment}/${buildUploadId}`;
+      const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/ios/${buildUploadId}`;
      outputs.build_upload_id.set(buildUploadId);
      outputs.build_upload_url.set(buildUploadUrl);

@@ -1,38 +0,0 @@
-import { APPIUM_COMMAND_SUMMARIES, humanizeAppiumCommand } from '../appiumCommandSummary';
-
-// Coverage of the generated Appium and driver command sets is enforced at compile time by the
-// `Record<AppiumCommand, string>` type in appiumCommandSummary.ts, so it is not
-// re-checked here.
-
-describe('APPIUM_COMMAND_SUMMARIES', () => {
-  it('has a non-empty summary that differs from the command name for every entry', () => {
-    for (const [command, summary] of Object.entries(APPIUM_COMMAND_SUMMARIES)) {
-      expect(summary).toBeTruthy();
-      expect(summary).not.toBe(command);
-    }
-  });
-});
-
-describe(humanizeAppiumCommand, () => {
-  it.each([
-    ['getWindowRect', 'Read the screen size'],
-    ['getScreenshot', 'Took a screenshot'],
-    ['getPageSource', 'Read the screen contents'],
-    ['click', 'Tapped an element'],
-    ['setValue', 'Typed into an element'],
-    ['createSession', 'Started the session'],
-    ['deleteSession', 'Ended the session'],
-    ['postAcceptAlert', 'Accepted an alert'],
-    ['mobileScroll', 'Scrolled the screen'],
-    ['openNotifications', 'Opened notifications'],
-  ])('maps the known command %s to a curated summary', (command, expected) => {
-    expect(humanizeAppiumCommand(command)).toBe(expected);
-  });
-
-  it.each(['proxyReqRes', 'mobile: scroll', 'getDeviceInfo', 'toString', 'constructor', ''])(
-    'returns the raw command %p when it has no curated summary',
-    command => {
-      expect(humanizeAppiumCommand(command)).toBe(command);
-    }
-  );
-});
@@ -1,98 +0,0 @@
-import fs from 'node:fs';
-
-import { turtleFetch } from '../../../utils/turtleFetch';
-import { startAppiumEventCollectionAsync } from '../appiumEvents';
-import { startDeviceRunSessionEventCollectionAsync } from '../deviceRunSessionEvents';
-
-jest.mock('../../../utils/turtleFetch');
-jest.mock('../deviceRunSessionEvents', () => ({
-  startDeviceRunSessionEventCollectionAsync: jest.fn(async () => ({
-    getLastEventObservedAt: () => undefined,
-    stopAsync: async () => undefined,
-  })),
-}));
-
-describe(startAppiumEventCollectionAsync, () => {
-  it('writes new Appium Event Timings commands to a normal event file', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(response({ value: [{ id: 'appium-session-id' }] }))
-      .mockResolvedValueOnce(
-        response({
-          value: {
-            commands: [
-              { cmd: 'getOrientation', startTime: 1_786_693_000_000, endTime: 1_786_693_000_025 },
-              { cmd: 'getLogEvents', startTime: 1_786_693_000_026, endTime: 1_786_693_000_027 },
-            ],
-          },
-        })
-      )
-      .mockResolvedValueOnce(response({ value: [] }));
-
-    const collection = await startAppiumEventCollectionAsync({
-      ctx: {} as never,
-      deviceRunSessionId: 'device-session-id',
-      appiumUrl: 'http://127.0.0.1:4723/',
-      logger: { warn: jest.fn() } as never,
-      pollIntervalMs: 60_000,
-    });
-    const source = jest.mocked(startDeviceRunSessionEventCollectionAsync).mock.calls[0][0].source;
-    const [eventFile] = await source.findEventFilesAsync();
-    let contents = '';
-    await waitForAsync(async () => {
-      contents = await fs.promises.readFile(eventFile, 'utf8');
-      expect(contents).toContain('getOrientation');
-    });
-    const lines = contents.trim().split('\n');
-    expect(lines).toHaveLength(1);
-    const [line] = lines;
-    expect(
-      source.parseLine({
-        line,
-        sourceKey: source.sourceKeyForFile(eventFile),
-        sequenceNumber: 1,
-        deviceRunSessionId: 'device-session-id',
-      })
-    ).toMatchObject({
-      event: {
-        producer: 'appium',
-        type: 'operation.completed',
-        durationMs: 25,
-        summary: 'Read the screen orientation',
-        data: {
-          command: 'getOrientation',
-        },
-      },
-    });
-
-    // Appium 3 removed GET /sessions; session discovery must use /appium/sessions.
-    expect(turtleFetch).toHaveBeenCalledWith(
-      'http://127.0.0.1:4723/appium/sessions',
-      'GET',
-      expect.anything()
-    );
-    expect(turtleFetch).toHaveBeenCalledWith(
-      'http://127.0.0.1:4723/session/appium-session-id/appium/events',
-      'POST',
-      expect.anything()
-    );
-
-    await collection.stopAsync();
-  });
-});
-
-async function waitForAsync(assertion: () => Promise<void>): Promise<void> {
-  for (let attempt = 0; attempt < 20; attempt += 1) {
-    try {
-      await assertion();
-      return;
-    } catch {
-      await new Promise(resolve => setTimeout(resolve, 10));
-    }
-  }
-  await assertion();
-}
-
-function response(value: unknown): Awaited<ReturnType<typeof turtleFetch>> {
-  return { json: async () => value } as never;
-}
@@ -67,17 +67,10 @@ describe(listArgentArtifactsAsync, () => {
          artifacts: [
            {
              id: 'artifact-id',
-              kind: 'native-profile-report',
              filename: 'report.json',
              mimeType: 'application/json',
              isDirectory: false,
            },
-            {
-              id: 'legacy-artifact-id',
-              filename: 'screen.png',
-              mimeType: 'image/png',
-              isDirectory: false,
-            },
          ],
        })
      )
@@ -91,17 +84,10 @@ describe(listArgentArtifactsAsync, () => {
    expect(artifacts).toEqual([
      {
        id: 'artifact-id',
-        kind: 'native-profile-report',
        filename: 'report.json',
        mimeType: 'application/json',
        isDirectory: false,
      },
-      {
-        id: 'legacy-artifact-id',
-        filename: 'screen.png',
-        mimeType: 'image/png',
-        isDirectory: false,
-      },
    ]);
    expect(jest.mocked(fetch)).toHaveBeenCalledWith('http://127.0.0.1:1234/artifacts', {
      headers: { Authorization: 'Bearer tools-token' },
@@ -157,7 +143,6 @@ describe(uploadArgentArtifactAsync, () => {

  async function uploadAsync(artifact: {
    id: string;
-    kind?: string;
    filename: string;
    mimeType: string;
    isDirectory?: boolean;
@@ -200,42 +185,7 @@ describe(uploadArgentArtifactAsync, () => {
    );
  });

-  it('uses the semantic kind reported by Argent', async () => {
-    const ctx = await uploadAsync({
-      id: 'artifact-id',
-      kind: 'native-profile-report',
-      filename: 'native-profile-report.md',
-      mimeType: 'text/markdown',
-    });
-
-    expect(jest.mocked(uploadDeviceRunSessionArtifactAsync)).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({
-        filename: 'native-profile-report.md',
-        kind: 'native-profile-report',
-      })
-    );
-  });
-
-  it('keeps the semantic kind when a directory is uploaded as a tarball', async () => {
-    const ctx = await uploadAsync({
-      id: 'artifact-id',
-      kind: 'native-profile-trace',
-      filename: 'native-profile.trace',
-      mimeType: 'application/octet-stream',
-      isDirectory: true,
-    });
-
-    expect(jest.mocked(uploadDeviceRunSessionArtifactAsync)).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({
-        filename: 'native-profile.trace.tar.gz',
-        kind: 'native-profile-trace',
-      })
-    );
-  });
-
-  it('leaves an older unclassified directory artifact without a kind', async () => {
+  it('leaves directory artifacts unclassified because they are uploaded as a tarball', async () => {
    const ctx = await uploadAsync({
      id: 'artifact-id',
      filename: 'screenshots',
@@ -1,425 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { spawnDetached } from '../remoteDeviceRunSession';
-
-import {
-  CHISEL_VERSION,
-  LOCAL_EGRESS_PROXY_PORT,
-  buildEgressRemoteConfigFields,
-  buildNetworksetupProxyArgs,
-  collectSimulatorProcessIds,
-  createChiselAuthfileContents,
-  getChiselAssetName,
-  getChiselDownloadUrl,
-  parseChiselFingerprint,
-  parseDefaultRouteInterface,
-  parseDirectSimulatorConnections,
-  parseExitIpResponse,
-  parseNetworkServiceNameForDevice,
-  readLocalEgressHandoffAsync,
-  registerLocalEgressResources,
-  startChiselServerAsync,
-  stopLocalEgressResourcesAsync,
-  writeLocalEgressHandoffAsync,
-} from '../localEgress';
-
-jest.mock('@ngrok/ngrok');
-jest.mock('@expo/turtle-spawn');
-jest.mock('../remoteDeviceRunSession', () => ({ spawnDetached: jest.fn() }));
-
-describe(getChiselAssetName, () => {
-  it.each([
-    ['darwin', 'arm64', `chisel_${CHISEL_VERSION}_darwin_arm64.gz`],
-    ['darwin', 'x64', `chisel_${CHISEL_VERSION}_darwin_amd64.gz`],
-    ['linux', 'x64', `chisel_${CHISEL_VERSION}_linux_amd64.gz`],
-    ['linux', 'arm64', `chisel_${CHISEL_VERSION}_linux_arm64.gz`],
-  ] as const)('maps %s/%s to %s', (platform, arch, expected) => {
-    expect(getChiselAssetName({ platform, arch })).toBe(expected);
-  });
-
-  it('rejects platforms without a pinned binary', () => {
-    expect(() => getChiselAssetName({ platform: 'win32', arch: 'x64' })).toThrow(
-      'Local egress is not supported on win32/x64'
-    );
-    expect(() => getChiselAssetName({ platform: 'linux', arch: 'ia32' })).toThrow(
-      'Local egress is not supported on linux/ia32'
-    );
-  });
-
-  it('downloads from the pinned GitHub release', () => {
-    expect(getChiselDownloadUrl(`chisel_${CHISEL_VERSION}_darwin_arm64.gz`)).toBe(
-      `https://github.com/jpillora/chisel/releases/download/v${CHISEL_VERSION}/chisel_${CHISEL_VERSION}_darwin_arm64.gz`
-    );
-  });
-});
-
-describe(createChiselAuthfileContents, () => {
-  it('allows reverse remotes on the loopback proxy port and unprivileged loopback ports only', () => {
-    const contents = createChiselAuthfileContents({ user: 'eas', password: 'pw', port: 8899 });
-    const parsed = JSON.parse(contents) as Record<string, string[]>;
-    expect(parsed['eas:pw']).toHaveLength(2);
-    expect(parsed['eas:pw'][0]).toBe('^R:127\\.0\\.0\\.1:8899$');
-
-    const patterns = parsed['eas:pw'].map(source => new RegExp(source));
-    const allowed = (remote: string): boolean => patterns.some(pattern => pattern.test(remote));
-    expect(allowed('R:127.0.0.1:8899')).toBe(true);
-    expect(allowed('R:127.0.0.1:1024')).toBe(true);
-    expect(allowed('R:127.0.0.1:3000')).toBe(true);
-    expect(allowed('R:127.0.0.1:8081')).toBe(true);
-    expect(allowed('R:127.0.0.1:65535')).toBe(true);
-    // Privileged and out-of-range ports, other interfaces, and forward remotes stay denied.
-    expect(allowed('R:127.0.0.1:1023')).toBe(false);
-    expect(allowed('R:127.0.0.1:80')).toBe(false);
-    expect(allowed('R:127.0.0.1:0')).toBe(false);
-    expect(allowed('R:127.0.0.1:65536')).toBe(false);
-    expect(allowed('R:127.0.0.1:88990')).toBe(false);
-    expect(allowed('R:0.0.0.0:8899')).toBe(false);
-    expect(allowed('R:0.0.0.0:3000')).toBe(false);
-    expect(allowed('R:[::1]:3000')).toBe(false);
-    expect(allowed('R:127x0x0x1:8899')).toBe(false);
-    expect(allowed('R:socks')).toBe(false);
-    expect(allowed('example.com:443')).toBe(false);
-    expect(allowed('127.0.0.1:3000')).toBe(false);
-  });
-});
-
-describe(parseChiselFingerprint, () => {
-  it('extracts the fingerprint chisel prints at startup', () => {
-    const output =
-      '2026/09/07 22:00:00 server: Fingerprint eZm5d2ZQ+Zb2aS0lJm7A5GkWm9G9ZqnPz2W0i2Y6Q1c=\n' +
-      '2026/09/07 22:00:00 server: Reverse tunnelling enabled\n' +
-      '2026/09/07 22:00:00 server: Listening on http://127.0.0.1:52001\n';
-    expect(parseChiselFingerprint(output)).toBe('eZm5d2ZQ+Zb2aS0lJm7A5GkWm9G9ZqnPz2W0i2Y6Q1c=');
-  });
-
-  it('returns null before the fingerprint line appears', () => {
-    expect(parseChiselFingerprint('')).toBeNull();
-    expect(parseChiselFingerprint('2026/09/07 22:00:00 server: starting')).toBeNull();
-  });
-});
-
-describe(parseDefaultRouteInterface, () => {
-  it('reads the interface from `route -n get default`', () => {
-    const output =
-      '   route to: default\n' +
-      'destination: default\n' +
-      '       mask: default\n' +
-      '    gateway: 172.20.10.1\n' +
-      '  interface: en0\n' +
-      '      flags: <UP,GATEWAY,DONE,STATIC,PRCLONING,GLOBAL>\n';
-    expect(parseDefaultRouteInterface(output)).toBe('en0');
-  });
-
-  it('returns null when there is no default route', () => {
-    expect(
-      parseDefaultRouteInterface('route: writing to routing socket: not in table\n')
-    ).toBeNull();
-  });
-});
-
-describe(parseNetworkServiceNameForDevice, () => {
-  const listOutput =
-    'An asterisk (*) denotes that a network service is disabled.\n' +
-    '(1) Thunderbolt Ethernet Slot 0\n' +
-    '(Hardware Port: Thunderbolt Ethernet Slot 0, Device: en8)\n' +
-    '\n' +
-    '(2) Thunderbolt Bridge\n' +
-    '(Hardware Port: Thunderbolt Bridge, Device: bridge0)\n' +
-    '\n' +
-    '(3) Wi-Fi\n' +
-    '(Hardware Port: Wi-Fi, Device: en0)\n' +
-    '\n' +
-    '(4) iPhone USB\n' +
-    '(Hardware Port: iPhone USB, Device: en9)\n';
-
-  it('returns the service whose device matches', () => {
-    expect(parseNetworkServiceNameForDevice(listOutput, 'en0')).toBe('Wi-Fi');
-    expect(parseNetworkServiceNameForDevice(listOutput, 'en8')).toBe('Thunderbolt Ethernet Slot 0');
-  });
-
-  it('returns null for an unknown device', () => {
-    expect(parseNetworkServiceNameForDevice(listOutput, 'utun3')).toBeNull();
-  });
-});
-
-describe(buildNetworksetupProxyArgs, () => {
-  it('sets both the HTTP and HTTPS proxy to the loopback egress port', () => {
-    expect(
-      buildNetworksetupProxyArgs({ service: 'Ethernet', host: '127.0.0.1', port: 8899 })
-    ).toEqual([
-      ['-setwebproxy', 'Ethernet', '127.0.0.1', '8899'],
-      ['-setsecurewebproxy', 'Ethernet', '127.0.0.1', '8899'],
-    ]);
-  });
-});
-
-describe(collectSimulatorProcessIds, () => {
-  const runtimeRoot =
-    '/Library/Developer/CoreSimulator/Volumes/iOS_23F77/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS 26.5.simruntime/Contents/Resources/RuntimeRoot';
-  const psOutput =
-    '    1     0 /sbin/launchd\n' +
-    '  501     1 /usr/local/bin/node\n' +
-    `  600     1 ${runtimeRoot}/sbin/launchd_sim\n` +
-    '  610   600 /Users/expo/Library/Developer/CoreSimulator/Devices/ABC/data/Containers/Bundle/Application/DEF/App.app/App\n' +
-    `  611   600 ${runtimeRoot}/System/Library/ExtensionKit/Extensions/NetworkingExtension.appex/com.apple.WebKit.Networking\n` +
-    '  620   610 /usr/bin/helper\n' +
-    '  700     1 /usr/sbin/lsof\n';
-
-  it('returns every descendant of launchd_sim and nothing else', () => {
-    expect(collectSimulatorProcessIds(psOutput).sort((a, b) => a - b)).toEqual([610, 611, 620]);
-  });
-
-  it('returns nothing when no simulator is running', () => {
-    expect(
-      collectSimulatorProcessIds('    1     0 /sbin/launchd\n  501     1 /usr/local/bin/node\n')
-    ).toEqual([]);
-  });
-});
-
-describe(parseDirectSimulatorConnections, () => {
-  const lsofOutput = [
-    'p610',
-    'cApp',
-    'f10',
-    'PTCP',
-    'n127.0.0.1:52344->127.0.0.1:8899',
-    'TST=ESTABLISHED',
-    'f11',
-    'PTCP',
-    'n192.168.64.2:52345->93.184.216.34:443',
-    'TST=ESTABLISHED',
-    'f12',
-    'PTCP',
-    'n192.168.64.2:52346->104.16.0.1:443',
-    'TST=SYN_SENT',
-    'f13',
-    'PTCP',
-    'n*:8080',
-    'TST=LISTEN',
-    'f14',
-    'PUDP',
-    'n*:5353',
-    'f15',
-    'PUDP',
-    'n192.168.64.2:60000->1.1.1.1:443',
-    'f16',
-    'PTCP',
-    'n[::1]:52347->[::1]:8899',
-    'TST=ESTABLISHED',
-    'f17',
-    'PTCP',
-    'n[fd00::2]:52348->[2606:4700:4700::1111]:443',
-    'TST=ESTABLISHED',
-    'p700',
-    'cnode',
-    'f20',
-    'PTCP',
-    'n192.168.64.2:52349->93.184.216.34:443',
-    'TST=ESTABLISHED',
-    '',
-  ].join('\n');
-
-  it('reports simulator connections to non-loopback peers only', () => {
-    expect(parseDirectSimulatorConnections(lsofOutput, new Set([610]))).toEqual([
-      { pid: 610, command: 'App', protocol: 'TCP', remote: '93.184.216.34:443' },
-      { pid: 610, command: 'App', protocol: 'TCP', remote: '104.16.0.1:443' },
-      { pid: 610, command: 'App', protocol: 'UDP', remote: '1.1.1.1:443' },
-      { pid: 610, command: 'App', protocol: 'TCP', remote: '[2606:4700:4700::1111]:443' },
-    ]);
-  });
-
-  it('ignores processes outside the simulator', () => {
-    expect(parseDirectSimulatorConnections(lsofOutput, new Set([700]))).toEqual([
-      { pid: 700, command: 'node', protocol: 'TCP', remote: '93.184.216.34:443' },
-    ]);
-    expect(parseDirectSimulatorConnections(lsofOutput, new Set([999]))).toEqual([]);
-  });
-
-  it('returns nothing for an empty listing', () => {
-    expect(parseDirectSimulatorConnections('', new Set([610]))).toEqual([]);
-  });
-});
-
-describe(buildEgressRemoteConfigFields, () => {
-  it('returns nothing without a handoff', () => {
-    expect(buildEgressRemoteConfigFields(null)).toEqual({});
-  });
-
-  it('maps the handoff to the remoteConfig field names', () => {
-    expect(
-      buildEgressRemoteConfigFields({
-        url: 'https://egress-abc.eas-simulator.ngrok.dev',
-        token: 'pw',
-        fingerprint: 'fp=',
-        port: LOCAL_EGRESS_PROXY_PORT,
-      })
-    ).toEqual({
-      egressUrl: 'https://egress-abc.eas-simulator.ngrok.dev',
-      egressToken: 'pw',
-      egressFingerprint: 'fp=',
-      egressPort: LOCAL_EGRESS_PROXY_PORT,
-    });
-  });
-});
-
-describe(parseExitIpResponse, () => {
-  it('reads the ip field', () => {
-    expect(parseExitIpResponse('{"ip":"64.114.211.44"}')).toBe('64.114.211.44');
-  });
-
-  it('rejects responses without an ip', () => {
-    expect(() => parseExitIpResponse('{"error":"rate limited"}')).toThrow(
-      'Unexpected exit IP response'
-    );
-  });
-});
-
-describe('local egress handoff', () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'local-egress-test-'));
-  });
-
-  afterEach(async () => {
-    await fs.promises.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it('round-trips through the handoff file', async () => {
-    const handoffPath = path.join(tempDir, 'handoff.json');
-    const handoff = {
-      url: 'https://egress-abc.eas-simulator.ngrok.dev',
-      token: 'pw',
-      fingerprint: 'fp=',
-      port: 8899,
-    };
-    await writeLocalEgressHandoffAsync(handoff, handoffPath);
-    await expect(readLocalEgressHandoffAsync(handoffPath)).resolves.toEqual(handoff);
-  });
-
-  it('returns null when no egress step ran', async () => {
-    await expect(
-      readLocalEgressHandoffAsync(path.join(tempDir, 'missing.json'))
-    ).resolves.toBeNull();
-  });
-
-  it('rejects a malformed handoff', async () => {
-    const handoffPath = path.join(tempDir, 'handoff.json');
-    await fs.promises.writeFile(handoffPath, JSON.stringify({ url: 'x' }), 'utf8');
-    await expect(readLocalEgressHandoffAsync(handoffPath)).rejects.toThrow('malformed');
-  });
-});
-
-describe(startChiselServerAsync, () => {
-  const options = {
-    chiselPath: '/tmp/chisel',
-    controlPort: 52001,
-    authfilePath: '/tmp/authfile.json',
-    env: { PATH: '/bin', AUTH: 'unexpected:password' },
-  };
-  let output: string;
-  let stopAsync: jest.Mock;
-
-  beforeEach(() => {
-    jest.useFakeTimers();
-    output = 'server: Fingerprint pinned-key=\n';
-    stopAsync = jest.fn().mockResolvedValue(undefined);
-    jest.spyOn(process, 'kill').mockReturnValue(true);
-    jest.mocked(spawnDetached).mockReturnValue({
-      pid: 12345,
-      getOutput: () => output,
-      stopAsync,
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-    jest.useRealTimers();
-  });
-
-  it('waits for the child to bind its exact port and clears inherited AUTH', async () => {
-    let resolved = false;
-    const started = startChiselServerAsync(options).then(result => {
-      resolved = true;
-      return result;
-    });
-    output += 'server: Listening on http://127.0.0.1:520010\n';
-    await jest.advanceTimersByTimeAsync(250);
-    expect(resolved).toBe(false);
-    output += 'server: Listening on http://127.0.0.1:52001\n';
-    await jest.advanceTimersByTimeAsync(250);
-    await expect(started).resolves.toMatchObject({ fingerprint: 'pinned-key=' });
-    expect(spawnDetached).toHaveBeenCalledWith(
-      expect.objectContaining({ env: { PATH: '/bin', AUTH: '' } })
-    );
-    expect(options.env.AUTH).toBe('unexpected:password');
-    expect(stopAsync).not.toHaveBeenCalled();
-  });
-
-  it('rejects and stops a child that prints its fingerprint then fails to bind', async () => {
-    const started = startChiselServerAsync(options);
-    const rejected = expect(started).rejects.toThrow('address already in use');
-    output += 'listen tcp 127.0.0.1:52001: bind: address already in use\n';
-    jest.mocked(process.kill).mockImplementation(() => {
-      throw new Error('ESRCH');
-    });
-    await jest.advanceTimersByTimeAsync(250);
-    await rejected;
-    expect(stopAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('stops the child when startup is cancelled', async () => {
-    const controller = new AbortController();
-    const started = startChiselServerAsync({ ...options, signal: controller.signal });
-    const rejected = expect(started).rejects.toThrow('cancelled');
-    controller.abort(new Error('cancelled'));
-    await jest.advanceTimersByTimeAsync(250);
-    await rejected;
-    expect(stopAsync).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('local egress resource lifetime', () => {
-  const logger = { warn: jest.fn() } as unknown as bunyan;
-
-  it('aborts the lifetime and awaits the same cleanup for concurrent callers', async () => {
-    let finish!: () => void;
-    const cleanup = jest.fn(
-      () =>
-        new Promise<void>(resolve => {
-          finish = resolve;
-        })
-    );
-    const signal = registerLocalEgressResources(cleanup);
-    const first = stopLocalEgressResourcesAsync(logger);
-    const second = stopLocalEgressResourcesAsync(logger);
-    expect(signal.aborted).toBe(true);
-    await Promise.resolve();
-    expect(cleanup).toHaveBeenCalledTimes(1);
-    let complete = false;
-    void second.then(() => {
-      complete = true;
-    });
-    await Promise.resolve();
-    expect(complete).toBe(false);
-    finish();
-    await Promise.all([first, second]);
-    await stopLocalEgressResourcesAsync(logger);
-    expect(cleanup).toHaveBeenCalledTimes(1);
-  });
-
-  it('reports cleanup failure without masking the job result', async () => {
-    const error = new Error('cleanup failed');
-    registerLocalEgressResources(async () => {
-      throw error;
-    });
-    await expect(stopLocalEgressResourcesAsync(logger)).resolves.toBeUndefined();
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: error },
-      'Could not stop a local egress resource.'
-    );
-  });
-});
@@ -2,43 +2,29 @@ import { bunyan } from '@expo/logger';
 import { BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import * as ngrok from '@ngrok/ngrok';
-import {
-  clearTimeout as clearTimeoutCallback,
-  setTimeout as setTimeoutCallback,
-} from 'node:timers';
 import { setTimeout as setTimeoutAsync } from 'node:timers/promises';

 import { CustomBuildContext } from '../../../customBuildContext';
 import { Sentry } from '../../../sentry';
 import { turtleFetch } from '../../../utils/turtleFetch';
-import { readServeSimServersAsync } from '../serveSimMetricsRecorder';
 import { sleepAsync } from '../../../utils/retry';
 import {
-  createExpoDeviceHubArgs,
  createServeSimArgs,
-  ensureFfmpegInstalledOnceAsync,
-  fetchWebPreviewTurnArgsAsync,
+  ensureFfmpegInstalledAsync,
+  fetchServeSimTurnArgsAsync,
  metricsCorsOriginToServeSimArgs,
-  startDeviceWebPreviewWithTunnelAsync,
-  startExpoDeviceHubWithTunnelAsync,
  startNgrokTunnelAsync,
-  turnIceServersToWebPreviewArgs,
+  turnIceServersToServeSimArgs,
  waitForDeviceRunSessionStoppedAsync,
-  waitForWebPreviewReadyAsync,
+  waitForServeSimReadyAsync,
 } from '../remoteDeviceRunSession';

 jest.mock('@ngrok/ngrok');
-jest.mock('node:timers');
 jest.mock('node:timers/promises');
 jest.mock('../../../utils/turtleFetch');
 jest.mock('../../../utils/retry', () => ({ sleepAsync: jest.fn() }));
 jest.mock('../../../sentry');
 jest.mock('@expo/turtle-spawn');
-// Spyable so a test can stand in for the serve-sim state directory, which a local serve-sim owns.
-jest.mock('../serveSimMetricsRecorder', () => {
-  const actual = jest.requireActual('../serveSimMetricsRecorder');
-  return { ...actual, readServeSimServersAsync: jest.fn(actual.readServeSimServersAsync) };
-});

 function createLoggerMock(): bunyan {
  return {
@@ -136,17 +122,16 @@ describe(createServeSimArgs, () => {
      '4321',
      '--host',
      '127.0.0.1',
-      '--require-token',
      '--transport',
      'webrtc',
      '--webrtc-codec',
      'vp8',
      '--max-dimension',
-      '960',
+      '1280',
      '--mjpeg-quality',
      '0.55',
      '--video-bitrate',
-      '6000000',
+      '3000000',
      '--video-fps',
      '60',
      '--turn-url',
@@ -167,63 +152,6 @@ describe(createServeSimArgs, () => {
      'https://expo.dev',
    ]);
  });
-
-  it('pins the requested package version', () => {
-    expect(createServeSimArgs({ port: 4321, packageVersion: '0.1.38' }).slice(0, 2)).toEqual([
-      '--yes',
-      '@expo/[email protected]',
-    ]);
-  });
-
-  it('pins a dist-tag', () => {
-    expect(createServeSimArgs({ port: 4321, packageVersion: 'next' }).slice(0, 2)).toEqual([
-      '--yes',
-      '@expo/serve-sim@next',
-    ]);
-  });
-});
-
-describe(createExpoDeviceHubArgs, () => {
-  it('uses the latest Expo package and applies the EAS Android streaming policy', () => {
-    expect(
-      createExpoDeviceHubArgs({
-        port: 4321,
-        turnArgs: ['--turn-url', 'turns:turn.example.test:443'],
-      })
-    ).toEqual([
-      '--yes',
-      'expo-device-hub@latest',
-      '--port',
-      '4321',
-      '--host',
-      '127.0.0.1',
-      '--platform',
-      'android',
-      '--transport',
-      'webrtc',
-      '--webrtc-codec',
-      'h264',
-      '--webrtc-ice-policy',
-      'all',
-      '--max-dimension',
-      '960',
-      '--video-bitrate',
-      '6000000',
-      '--video-fps',
-      '60',
-      '--hide-sidebar',
-      '--hide-boot-device',
-      '--turn-url',
-      'turns:turn.example.test:443',
-    ]);
-  });
-
-  it('pins the requested package version', () => {
-    expect(createExpoDeviceHubArgs({ port: 4321, packageVersion: '0.7.0' }).slice(0, 2)).toEqual([
-      '--yes',
-      '[email protected]',
-    ]);
-  });
 });

 describe(metricsCorsOriginToServeSimArgs, () => {
@@ -253,7 +181,7 @@ describe(metricsCorsOriginToServeSimArgs, () => {
  });
 });

-describe(waitForWebPreviewReadyAsync, () => {
+describe(waitForServeSimReadyAsync, () => {
  beforeEach(() => {
    jest.mocked(turtleFetch).mockReset();
    jest.mocked(sleepAsync).mockReset();
@@ -268,9 +196,8 @@ describe(waitForWebPreviewReadyAsync, () => {
        json: async () => ({ status: 'ready', device: 'DEVICE-A' }),
      } as unknown as Awaited<ReturnType<typeof turtleFetch>>);

-    await waitForWebPreviewReadyAsync({
-      previewServer: { pid: undefined, getOutput: () => '' },
-      serverName: 'expo-device-hub',
+    await waitForServeSimReadyAsync({
+      serveSim: { pid: undefined, getOutput: () => '' },
      port: 4321,
      timeoutMs: 10_000,
    });
@@ -289,14 +216,14 @@ describe(startNgrokTunnelAsync, () => {
  it('uses a 128-bit capability hostname and exposes explicit cleanup', async () => {
    const close = jest.fn().mockResolvedValue(undefined);
    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://web-preview.example.test',
+      url: () => 'https://serve-sim.example.test',
      close,
    } as never);

    const tunnel = await startNgrokTunnelAsync({
      port: 4321,
-      subdomainPrefix: 'web-preview',
-      baseDomain: 'eas-simulator.ngrok.dev',
+      subdomainPrefix: 'serve-sim',
+      baseDomain: 'tunnel.example.test',
      authtoken: 'token',
      logger: createLoggerMock(),
    });
@@ -305,249 +232,24 @@ describe(startNgrokTunnelAsync, () => {
      expect.objectContaining({
        addr: 4321,
        authtoken: 'token',
-        domain: expect.stringMatching(/^web-preview-[a-f0-9]{32}\.eas-simulator\.ngrok\.dev$/),
+        domain: expect.stringMatching(/^serve-sim-[a-f0-9]{32}\.tunnel\.example\.test$/),
      })
    );
-    expect(tunnel.url).toBe('https://web-preview.example.test');
+    expect(tunnel.url).toBe('https://serve-sim.example.test');
    await tunnel.stopAsync();
    await tunnel.stopAsync();
    expect(close).toHaveBeenCalledTimes(1);
  });
 });

-describe(startDeviceWebPreviewWithTunnelAsync, () => {
-  const baseDomain = 'eas-simulator.ngrok.dev';
-  const turnArgs = [
-    '--turn-url',
-    'turns:turn.example.test:443',
-    '--turn-username',
-    'turn-user',
-    '--turn-credential',
-    'turn-credential',
-  ];
-  const metricsCorsArgs = ['--metrics-cors-origin', 'https://metrics.expo.test'];
-  const env = {
-    DEVICE_RUN_SESSION_ID: 'drs-id',
-    EAS_SIMULATOR_METRICS_CORS_ORIGIN: 'https://metrics.expo.test',
-    NGROK_AUTHTOKEN: 'ngrok-token',
-  } as unknown as BuildStepEnv;
-
-  beforeEach(() => {
-    jest.mocked(spawn).mockReset();
-    jest.mocked(ngrok.forward).mockReset();
-    jest.mocked(turtleFetch).mockReset();
-    jest
-      .mocked(readServeSimServersAsync)
-      .mockResolvedValue([{ udid: 'device-id', url: 'http://127.0.0.1:1', token: 'tok-1' }]);
-
-    const spawnPromise = Object.assign(Promise.resolve(undefined), {
-      child: {
-        pid: undefined,
-        unref: jest.fn(),
-      },
-    });
-    jest.mocked(spawn).mockReturnValue(spawnPromise as never);
-
-    jest.mocked(turtleFetch).mockImplementation(async url => {
-      if (url.endsWith('/turn-ice-servers')) {
-        return {
-          json: async () => ({
-            data: {
-              iceServers: [
-                {
-                  urls: ['turns:turn.example.test:443'],
-                  username: 'turn-user',
-                  credential: 'turn-credential',
-                },
-              ],
-            },
-          }),
-        } as unknown as Awaited<ReturnType<typeof turtleFetch>>;
-      }
-      return {
-        json: async () => ({ status: 'ready', device: 'device-id' }),
-      } as unknown as Awaited<ReturnType<typeof turtleFetch>>;
-    });
-  });
-
-  it('installs ffmpeg before starting expo-device-hub for Linux', async () => {
-    const packageVersion = '1.2.3';
-    const close = jest.fn().mockResolvedValue(undefined);
-    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://android-preview.example.test',
-      close,
-    } as never);
-    jest
-      .mocked(spawn)
-      .mockReturnValueOnce(
-        Promise.reject(new Error('ffmpeg is missing')) as ReturnType<typeof spawn>
-      )
-      .mockReturnValueOnce(Promise.resolve({}) as unknown as ReturnType<typeof spawn>)
-      .mockReturnValueOnce(Promise.resolve({}) as unknown as ReturnType<typeof spawn>);
-
-    const preview = await startDeviceWebPreviewWithTunnelAsync(createCtxMock(), {
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      baseDomain,
-      env,
-      logger: createLoggerMock(),
-      timeoutMs: 10_000,
-      packageVersion,
-    });
-
-    const spawnCalls = jest.mocked(spawn).mock.calls;
-    expect(spawnCalls[0]).toEqual(['ffmpeg', ['-version'], { env }]);
-    expect(spawnCalls[1]).toEqual([
-      'sudo',
-      ['apt-get', 'update'],
-      expect.objectContaining({
-        env: expect.objectContaining({ DEBIAN_FRONTEND: 'noninteractive' }),
-      }),
-    ]);
-    expect(spawnCalls[2]).toEqual([
-      'sudo',
-      ['apt-get', 'install', '-y', 'ffmpeg'],
-      expect.objectContaining({
-        env: expect.objectContaining({ DEBIAN_FRONTEND: 'noninteractive' }),
-      }),
-    ]);
-    const expoDeviceHubCallIndex = spawnCalls.findIndex(([command]) => command === 'npx');
-    expect(expoDeviceHubCallIndex).toBeGreaterThan(2);
-    expect(jest.mocked(spawn).mock.invocationCallOrder[2]).toBeLessThan(
-      jest.mocked(spawn).mock.invocationCallOrder[expoDeviceHubCallIndex]
-    );
-    const [command, args] = spawnCalls[expoDeviceHubCallIndex];
-    const port = Number(args[args.indexOf('--port') + 1]);
-    expect(port).toBeGreaterThan(0);
-    expect(command).toBe('npx');
-    expect(args).toEqual(createExpoDeviceHubArgs({ port, turnArgs, packageVersion }));
-    expect(ngrok.forward).toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
-    expect(preview.previewUrl).toBe('https://android-preview.example.test');
-
-    await preview.stopAsync();
-    expect(close).toHaveBeenCalledTimes(1);
-  });
-
-  it('carries the serve-sim session token for Darwin', async () => {
-    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://preview.example.test',
-      close: jest.fn().mockResolvedValue(undefined),
-    } as never);
-
-    const preview = await startDeviceWebPreviewWithTunnelAsync(createCtxMock(), {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      baseDomain,
-      env,
-      logger: createLoggerMock(),
-      timeoutMs: 10_000,
-    });
-
-    expect(preview.previewToken).toBe('tok-1');
-    expect(preview.previewUrl).toBe('https://preview.example.test');
-  });
-
-  // serve-sim is always launched with --require-token, so a missing token means it is running
-  // ungated on a public tunnel. Failing beats handing out a preview that is dead or unprotected.
-  it('fails for Darwin when serve-sim reports no token', async () => {
-    jest
-      .mocked(readServeSimServersAsync)
-      .mockResolvedValue([{ udid: 'device-id', url: 'http://127.0.0.1:1' }]);
-
-    await expect(
-      startDeviceWebPreviewWithTunnelAsync(createCtxMock(), {
-        runtimePlatform: BuildRuntimePlatform.DARWIN,
-        baseDomain,
-        env,
-        logger: createLoggerMock(),
-        timeoutMs: 10_000,
-      })
-    ).rejects.toThrow(/wrote no session token/);
-  });
-
-  // expo-device-hub mints no token, so the Android preview must not require one.
-  it('starts for Linux without a token, and does not gate expo-device-hub', async () => {
-    jest.mocked(readServeSimServersAsync).mockResolvedValue([]);
-    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://android-preview.example.test',
-      close: jest.fn().mockResolvedValue(undefined),
-    } as never);
-
-    const preview = await startDeviceWebPreviewWithTunnelAsync(createCtxMock(), {
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      baseDomain,
-      env,
-      logger: createLoggerMock(),
-      timeoutMs: 10_000,
-    });
-
-    expect(preview.previewToken).toBeUndefined();
-    const [, args] = jest.mocked(spawn).mock.calls[0];
-    expect(args).not.toContain('--require-token');
-  });
-
-  it('starts serve-sim for Darwin with its metrics policy and cleans up the preview resources', async () => {
-    const packageVersion = '4.5.6';
-    const close = jest.fn().mockResolvedValue(undefined);
-    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://ios-preview.example.test',
-      close,
-    } as never);
-
-    const preview = await startDeviceWebPreviewWithTunnelAsync(createCtxMock(), {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      baseDomain,
-      env,
-      logger: createLoggerMock(),
-      timeoutMs: 10_000,
-      packageVersion,
-    });
-
-    const [command, args] = jest.mocked(spawn).mock.calls[0];
-    const port = Number(args[args.indexOf('--port') + 1]);
-    expect(port).toBeGreaterThan(0);
-    expect(command).toBe('npx');
-    expect(args).toEqual(createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion }));
-    expect(ngrok.forward).toHaveBeenCalledWith(expect.objectContaining({ addr: port }));
-    expect(preview.previewUrl).toBe('https://ios-preview.example.test');
-
-    await preview.stopAsync();
-    expect(close).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not install ffmpeg before starting expo-device-hub outside Linux', async () => {
-    const close = jest.fn().mockResolvedValue(undefined);
-    jest.mocked(ngrok.forward).mockResolvedValue({
-      url: () => 'https://android-preview.example.test',
-      close,
-    } as never);
-
-    const preview = await startExpoDeviceHubWithTunnelAsync(createCtxMock(), {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      baseDomain,
-      env,
-      logger: createLoggerMock(),
-      timeoutMs: 10_000,
-    });
-
-    expect(jest.mocked(spawn).mock.calls[0][0]).toBe('npx');
-    expect(jest.mocked(spawn)).not.toHaveBeenCalledWith(
-      'ffmpeg',
-      expect.anything(),
-      expect.anything()
-    );
-
-    await preview.stopAsync();
-    expect(close).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe(turnIceServersToWebPreviewArgs, () => {
+describe(turnIceServersToServeSimArgs, () => {
  it('returns no args for an empty ICE server list', () => {
-    expect(turnIceServersToWebPreviewArgs([])).toEqual([]);
+    expect(turnIceServersToServeSimArgs([])).toEqual([]);
  });

  it('builds --stun-url and --turn-url flags from Cloudflare ICE servers', () => {
    expect(
-      turnIceServersToWebPreviewArgs([
+      turnIceServersToServeSimArgs([
        { urls: ['stun:stun.cloudflare.com:3478', 'stun:stun.cloudflare.com:53'] },
        {
          urls: [
@@ -572,7 +274,7 @@ describe(turnIceServersToWebPreviewArgs, () => {

  it('emits only --turn-url flags when no credential-less (STUN) entry is present', () => {
    expect(
-      turnIceServersToWebPreviewArgs([
+      turnIceServersToServeSimArgs([
        {
          urls: ['turns:turn.cloudflare.com:443?transport=tcp'],
          username: 'u',
@@ -590,19 +292,19 @@ describe(turnIceServersToWebPreviewArgs, () => {
  });

  it('emits only --stun-url when there is no credentialed TURN entry', () => {
-    expect(turnIceServersToWebPreviewArgs([{ urls: ['stun:stun.cloudflare.com:3478'] }])).toEqual([
+    expect(turnIceServersToServeSimArgs([{ urls: ['stun:stun.cloudflare.com:3478'] }])).toEqual([
      '--stun-url',
      'stun:stun.cloudflare.com:3478',
    ]);
  });
 });

-describe(fetchWebPreviewTurnArgsAsync, () => {
+describe(fetchServeSimTurnArgsAsync, () => {
  beforeEach(() => {
    jest.mocked(turtleFetch).mockReset();
  });

-  it('requests TURN ICE servers from the device run session endpoint and returns web preview args', async () => {
+  it('requests TURN ICE servers from the device run session endpoint and returns serve-sim args', async () => {
    jest.mocked(turtleFetch).mockResolvedValue({
      json: async () => ({
        data: {
@@ -618,7 +320,7 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
      }),
    } as unknown as Awaited<ReturnType<typeof turtleFetch>>);

-    const args = await fetchWebPreviewTurnArgsAsync(createCtxMock(), {
+    const args = await fetchServeSimTurnArgsAsync(createCtxMock(), {
      env: createEnvMock(),
      logger: createLoggerMock(),
    });
@@ -642,11 +344,11 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
    );
  });

-  it('returns [] and warns when the request fails so the web preview falls back to P2P/STUN', async () => {
+  it('returns [] and warns when the request fails so serve-sim falls back to P2P/STUN', async () => {
    jest.mocked(turtleFetch).mockRejectedValue(new Error('boom'));
    const logger = createLoggerMock();

-    const args = await fetchWebPreviewTurnArgsAsync(createCtxMock(), {
+    const args = await fetchServeSimTurnArgsAsync(createCtxMock(), {
      env: createEnvMock(),
      logger,
    });
@@ -658,13 +360,8 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
 });

 describe(waitForDeviceRunSessionStoppedAsync, () => {
-  const durationTimeout = {} as NodeJS.Timeout;
-
  beforeEach(() => {
    jest.mocked(Sentry).capture.mockReset();
-    jest.mocked(setTimeoutCallback).mockReset();
-    jest.mocked(setTimeoutCallback).mockReturnValue(durationTimeout);
-    jest.mocked(clearTimeoutCallback).mockReset();
    jest.mocked(setTimeoutAsync).mockReset();
    jest.mocked(setTimeoutAsync).mockResolvedValue(undefined);
  });
@@ -681,57 +378,6 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {

    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(2);
    expect(logger.info).toHaveBeenCalledWith('Device run session drs-id was stopped.');
-    expect(setTimeoutCallback).not.toHaveBeenCalled();
-  });
-
-  it('returns normally when the maximum duration elapses', async () => {
-    const ctx = createStatusCtxMock([{ status: 'IN_PROGRESS' }]);
-    const logger = createLoggerMock();
-    const waitPromise = waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger,
-      maxDurationSeconds: 1,
-    });
-
-    expect(setTimeoutCallback).toHaveBeenCalledWith(expect.any(Function), 1_000);
-    const durationTimeoutCallback = jest.mocked(setTimeoutCallback).mock.calls[0][0];
-    durationTimeoutCallback();
-    await waitPromise;
-
-    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith(
-      'Device run session drs-id reached its maximum duration.'
-    );
-    expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
-  });
-
-  it('clears the duration timeout when the session stops first', async () => {
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx: createStatusCtxMock([{ status: 'STOPPED' }]),
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-      maxDurationSeconds: 30,
-    });
-
-    expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
-  });
-
-  it('does not poll when the build step is already aborted', async () => {
-    const ctx = createStatusCtxMock([]);
-    const abortController = new AbortController();
-    abortController.abort();
-
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-      maxDurationSeconds: 30,
-      signal: abortController.signal,
-    });
-
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
-    expect(setTimeoutCallback).not.toHaveBeenCalled();
  });

  it('throws when the device run session errors', async () => {
@@ -742,28 +388,8 @@ describe(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();
-    const waitPromise = waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-      maxDurationSeconds: 30,
-      signal: abortController.signal,
-    });
-
-    abortController.abort();
-    await waitPromise;
-
-    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(1);
-    expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
  });

  it('logs and retries transient polling errors', async () => {
@@ -907,7 +533,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
  });
 });

-describe(ensureFfmpegInstalledOnceAsync, () => {
+describe(ensureFfmpegInstalledAsync, () => {
  const spawnMock = jest.mocked(spawn);

  function spawnResolved(): ReturnType<typeof spawn> {
@@ -926,7 +552,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
  it('does not install when ffmpeg is on PATH', async () => {
    spawnMock.mockReturnValueOnce(spawnResolved());

-    await ensureFfmpegInstalledOnceAsync({
+    await ensureFfmpegInstalledAsync({
      runtimePlatform: BuildRuntimePlatform.DARWIN,
      env: createEnvMock(),
      logger: createLoggerMock(),
@@ -939,7 +565,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
  it('installs ffmpeg with Homebrew on darwin when it is missing', async () => {
    spawnMock.mockReturnValueOnce(spawnRejected()).mockReturnValueOnce(spawnResolved());

-    await ensureFfmpegInstalledOnceAsync({
+    await ensureFfmpegInstalledAsync({
      runtimePlatform: BuildRuntimePlatform.DARWIN,
      env: createEnvMock(),
      logger: createLoggerMock(),
@@ -960,7 +586,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
      .mockReturnValueOnce(spawnResolved()) // apt-get update
      .mockReturnValueOnce(spawnResolved()); // apt-get install

-    await ensureFfmpegInstalledOnceAsync({
+    await ensureFfmpegInstalledAsync({
      runtimePlatform: BuildRuntimePlatform.LINUX,
      env: createEnvMock(),
      logger: createLoggerMock(),
@@ -982,33 +608,6 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
    );
  });

-  it('shares an in-flight ffmpeg setup between callers', async () => {
-    let finishInstall: (() => void) | undefined;
-    const pendingInstall = new Promise<void>(resolve => {
-      finishInstall = resolve;
-    });
-    spawnMock
-      .mockReturnValueOnce(spawnRejected()) // ffmpeg -version
-      .mockReturnValueOnce(spawnResolved()) // apt-get update
-      .mockReturnValueOnce(pendingInstall as unknown as ReturnType<typeof spawn>); // apt-get install
-    const options = {
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: createEnvMock(),
-      logger: createLoggerMock(),
-    };
-
-    const firstSetup = ensureFfmpegInstalledOnceAsync(options);
-    await new Promise<void>(resolve => setImmediate(resolve));
-    expect(spawnMock).toHaveBeenCalledTimes(3);
-
-    const secondSetup = ensureFfmpegInstalledOnceAsync(options);
-    expect(spawnMock).toHaveBeenCalledTimes(3);
-
-    finishInstall?.();
-    await Promise.all([firstSetup, secondSetup]);
-    expect(spawnMock).toHaveBeenCalledTimes(3);
-  });
-
  it('still installs on linux when the apt index refresh fails', async () => {
    spawnMock
      .mockReturnValueOnce(spawnRejected()) // ffmpeg -version
@@ -1016,7 +615,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
      .mockReturnValueOnce(spawnResolved()); // apt-get install
    const logger = createLoggerMock();

-    await ensureFfmpegInstalledOnceAsync({
+    await ensureFfmpegInstalledAsync({
      runtimePlatform: BuildRuntimePlatform.LINUX,
      env: createEnvMock(),
      logger,
@@ -1035,7 +634,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
    const logger = createLoggerMock();

    await expect(
-      ensureFfmpegInstalledOnceAsync({
+      ensureFfmpegInstalledAsync({
        runtimePlatform: BuildRuntimePlatform.DARWIN,
        env: createEnvMock(),
        logger,
@@ -1056,7 +655,7 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
    const logger = createLoggerMock();

    await expect(
-      ensureFfmpegInstalledOnceAsync({
+      ensureFfmpegInstalledAsync({
        runtimePlatform: BuildRuntimePlatform.DARWIN,
        env: createEnvMock(),
        logger,
@@ -101,14 +101,6 @@ describe(readServeSimServersAsync, () => {
    ]);
  });

-  it('includes the session token when the state file carries one', async () => {
-    await writeServerStateAsync('E', { device: 'E', url: 'http://127.0.0.1:5', token: 'tok-abc' });
-
-    expect(await readServeSimServersAsync(stateDir)).toEqual([
-      { udid: 'E', url: 'http://127.0.0.1:5', token: 'tok-abc' },
-    ]);
-  });
-
  it('returns [] when the state dir does not exist', async () => {
    expect(await readServeSimServersAsync(path.join(workDir, 'nope'))).toEqual([]);
  });
@@ -128,20 +120,6 @@ describe(streamServeSimMetricsToFileAsync, () => {
    expect(String(jest.mocked(fetch).mock.calls[0][0])).toBe('https://sim.example/metrics');
  });

-  it('sends the session token as a bearer header when given one', async () => {
-    jest.mocked(fetch).mockResolvedValue(sseResponse());
-    await streamServeSimMetricsToFileAsync({
-      serveSimUrl: 'https://sim.example',
-      serveSimToken: 'tok-abc',
-      filePath: path.join(workDir, 'auth.ndjson'),
-      signal: new AbortController().signal,
-      logger: createLoggerMock(),
-    });
-    expect(jest.mocked(fetch).mock.calls[0][1]?.headers).toMatchObject({
-      Authorization: 'Bearer tok-abc',
-    });
-  });
-
  it('writes nothing on a non-ok response', async () => {
    jest.mocked(fetch).mockResolvedValue(new Response('nope', { status: 502 }));
    const filePath = path.join(workDir, 'empty.ndjson');
@@ -1,421 +0,0 @@
-import { type AppiumCommand } from './appiumCommands.generated';
-
-export const APPIUM_COMMAND_SUMMARIES: Record<AppiumCommand, string> = {
-  // Session lifecycle
-  createSession: 'Started the session',
-  deleteSession: 'Ended the session',
-  getSession: 'Read the session details',
-  getStatus: 'Checked the server status',
-  getAppiumSessions: 'Listed Appium sessions',
-  getAppiumSessionCapabilities: 'Read the session capabilities',
-  getTimeouts: 'Read timeouts',
-  timeouts: 'Set timeouts',
-  getSettings: 'Read Appium settings',
-  updateSettings: 'Updated Appium settings',
-  listCommands: 'Listed available commands',
-  listExtensions: 'Listed available extensions',
-  receiveAsyncResponse: 'Received an async response',
-
-  // Screen and media
-  getScreenshot: 'Took a screenshot',
-  getElementScreenshot: 'Took a screenshot of an element',
-  getPageSource: 'Read the screen contents',
-  printPage: 'Printed the page',
-
-  // Window and orientation
-  getWindowRect: 'Read the screen size',
-  setWindowRect: 'Resized the window',
-  maximizeWindow: 'Maximized the window',
-  minimizeWindow: 'Minimized the window',
-  fullScreenWindow: 'Made the window full screen',
-  getWindowHandle: 'Read the current window',
-  getWindowHandles: 'Listed open windows',
-  setWindow: 'Switched window',
-  closeWindow: 'Closed the window',
-  createNewWindow: 'Opened a new window',
-  setFrame: 'Switched to a frame',
-  switchToParentFrame: 'Switched to the parent frame',
-  getOrientation: 'Read the screen orientation',
-  setOrientation: 'Changed the screen orientation',
-  getRotation: 'Read the device rotation',
-  setRotation: 'Rotated the device',
-
-  // Device
-  getDeviceTime: 'Read the device time',
-  getGeoLocation: 'Read the device location',
-  setGeoLocation: 'Set the device location',
-  getNetworkConnection: 'Read the network connection',
-  setNetworkConnection: 'Changed the network connection',
-  setDevicePosture: 'Set the device posture',
-  clearDevicePosture: 'Cleared the device posture',
-  setPermissions: 'Set app permissions',
-
-  // Element discovery
-  findElement: 'Found an element',
-  findElements: 'Found elements',
-  findElementFromElement: 'Found a nested element',
-  findElementsFromElement: 'Found nested elements',
-  findElementFromShadowRoot: 'Found an element in a shadow root',
-  findElementsFromShadowRoot: 'Found elements in a shadow root',
-  elementShadowRoot: 'Read an element shadow root',
-  active: 'Read the focused element',
-
-  // Element interaction
-  click: 'Tapped an element',
-  clear: 'Cleared an element',
-  setValue: 'Typed into an element',
-  getText: 'Read element text',
-  getName: 'Read an element tag',
-  getAttribute: 'Read an element attribute',
-  getProperty: 'Read an element property',
-  getCssProperty: 'Read an element style',
-  getComputedLabel: 'Read an element label',
-  getComputedRole: 'Read an element role',
-  getElementRect: 'Read an element position and size',
-  elementDisplayed: 'Checked if an element was visible',
-  elementEnabled: 'Checked if an element was enabled',
-  elementSelected: 'Checked if an element was selected',
-
-  // Gestures
-  performActions: 'Performed a gesture',
-  releaseActions: 'Finished a gesture',
-
-  // App management
-  installApp: 'Installed an app',
-  removeApp: 'Removed an app',
-  isAppInstalled: 'Checked if an app was installed',
-  activateApp: 'Activated an app',
-  terminateApp: 'Terminated an app',
-  queryAppState: 'Read the app state',
-  background: 'Sent the app to the background',
-
-  // Contexts
-  getContexts: 'Listed available contexts',
-  getCurrentContext: 'Read the current context',
-  setContext: 'Switched context',
-
-  // Web navigation
-  setUrl: 'Opened a URL',
-  getUrl: 'Read the current URL',
-  back: 'Navigated back',
-  forward: 'Navigated forward',
-  refresh: 'Refreshed the page',
-  title: 'Read the page title',
-
-  // Cookies
-  getCookie: 'Read a cookie',
-  getCookies: 'Read all cookies',
-  setCookie: 'Set a cookie',
-  deleteCookie: 'Deleted a cookie',
-  deleteCookies: 'Deleted all cookies',
-
-  // Alerts
-  getAlertText: 'Read an alert',
-  setAlertText: 'Typed into an alert',
-  postAcceptAlert: 'Accepted an alert',
-  postDismissAlert: 'Dismissed an alert',
-
-  // Keyboard and input methods
-  hideKeyboard: 'Hid the keyboard',
-  isKeyboardShown: 'Checked if the keyboard was shown',
-  activateIMEEngine: 'Activated an input method',
-  deactivateIMEEngine: 'Deactivated the input method',
-  getActiveIMEEngine: 'Read the active input method',
-  availableIMEEngines: 'Listed input methods',
-  isIMEActivated: 'Checked if an input method was active',
-
-  // Clipboard (driver-level, not declared by base-driver)
-  getClipboard: 'Read the clipboard',
-  setClipboard: 'Wrote to the clipboard',
-
-  // Files
-  pushFile: 'Pushed a file to the device',
-  pullFile: 'Pulled a file from the device',
-  pullFolder: 'Pulled a folder from the device',
-
-  // Logs
-  getLog: 'Read device logs',
-  getLogTypes: 'Listed log types',
-  getLogEvents: 'Read logged events',
-  logCustomEvent: 'Logged a custom event',
-  generateTestReport: 'Generated a test report',
-
-  // Scripts
-  execute: 'Ran a script command',
-  executeAsync: 'Ran an async script command',
-  executeCdp: 'Ran a Chrome DevTools command',
-
-  // Web authentication (virtual authenticators)
-  addVirtualAuthenticator: 'Added a virtual authenticator',
-  removeVirtualAuthenticator: 'Removed a virtual authenticator',
-  addAuthCredential: 'Added an auth credential',
-  getAuthCredential: 'Read auth credentials',
-  removeAuthCredential: 'Removed an auth credential',
-  removeAllAuthCredentials: 'Removed all auth credentials',
-  setUserAuthVerified: 'Set the user verification state',
-
-  // Federated sign-in (FedCM)
-  fedCMGetAccounts: 'Listed federated sign-in accounts',
-  fedCMSelectAccount: 'Selected a federated sign-in account',
-  fedCMGetDialogType: 'Read the federated sign-in dialog type',
-  fedCMGetTitle: 'Read the federated sign-in dialog title',
-  fedCMClickDialogButton: 'Clicked a federated sign-in dialog button',
-  fedCMCancelDialog: 'Canceled the federated sign-in dialog',
-  fedCMResetCooldown: 'Reset the federated sign-in cooldown',
-  fedCMSetDelayEnabled: 'Toggled the federated sign-in delay',
-
-  // Virtual sensors and pressure sources
-  createVirtualSensor: 'Created a virtual sensor',
-  updateVirtualSensorReading: 'Updated a virtual sensor reading',
-  getVirtualSensorInfo: 'Read virtual sensor info',
-  deleteVirtualSensor: 'Removed a virtual sensor',
-  createVirtualPressureSource: 'Created a virtual pressure source',
-  updateVirtualPressureSource: 'Updated a virtual pressure source',
-  deleteVirtualPressureSource: 'Removed a virtual pressure source',
-
-  // Privacy / experimental web platform
-  getGlobalPrivacyControl: 'Read the Global Privacy Control setting',
-  setGlobalPrivacyControl: 'Set the Global Privacy Control setting',
-  setStorageAccess: 'Set storage access',
-  setRPHRegistrationMode: 'Set the protocol handler registration mode',
-  setSPCTransactionMode: 'Set the payment transaction mode',
-
-  // Driver routes and compatibility commands
-  asyncScriptTimeout: 'Set the async script timeout',
-  closeApp: 'Closed the app',
-  disableConditionInducer: 'Disabled the condition inducer',
-  enableConditionInducer: 'Enabled the condition inducer',
-  fingerprint: 'Simulated a fingerprint',
-  getCurrentActivity: 'Read the current activity',
-  getCurrentPackage: 'Read the current package',
-  getDisplayDensity: 'Read the display density',
-  getLocation: 'Read an element location',
-  getLocationInView: 'Read an element location in view',
-  getPerformanceData: 'Read performance data',
-  getPerformanceDataTypes: 'Listed performance data types',
-  getScreenInfo: 'Read screen information',
-  getSize: 'Read an element size',
-  getStrings: 'Read app strings',
-  getSystemBars: 'Read system bar information',
-  getViewportRect: 'Read the viewport size',
-  getViewportScreenshot: 'Took a viewport screenshot',
-  getWindowSize: 'Read the window size',
-  gsmCall: 'Simulated a phone call',
-  gsmSignal: 'Changed the cellular signal',
-  gsmVoice: 'Changed the cellular voice state',
-  implicitWait: 'Set the element lookup timeout',
-  isLocationServicesEnabled: 'Checked if location services were enabled',
-  isLocked: 'Checked if the device was locked',
-  keyevent: 'Sent a key event',
-  keys: 'Sent keyboard input',
-  launchApp: 'Launched the app',
-  listConditionInducers: 'Listed condition inducers',
-  lock: 'Locked the device',
-  longPressKeyCode: 'Long-pressed a key',
-  networkSpeed: 'Changed the network speed',
-  openNotifications: 'Opened notifications',
-  powerAC: 'Changed the charging state',
-  powerCapacity: 'Changed the battery level',
-  pressKeyCode: 'Pressed a key',
-  replaceValue: 'Replaced an element value',
-  reset: 'Reset the app',
-  sendSMS: 'Simulated a text message',
-  sensorSet: 'Changed a sensor value',
-  setStylusHandwriting: 'Changed stylus handwriting mode',
-  setValueImmediate: 'Typed into an element immediately',
-  startActivity: 'Started an activity',
-  startAudioRecording: 'Started audio recording',
-  startRecordingScreen: 'Started screen recording',
-  stopAudioRecording: 'Stopped audio recording',
-  stopRecordingScreen: 'Stopped screen recording',
-  submit: 'Submitted an element',
-  toggleData: 'Toggled mobile data',
-  toggleEnrollTouchId: 'Changed Touch ID enrollment',
-  toggleFlightMode: 'Toggled airplane mode',
-  toggleLocationServices: 'Toggled location services',
-  toggleWiFi: 'Toggled Wi-Fi',
-  touchId: 'Simulated Touch ID',
-  unlock: 'Unlocked the device',
-
-  // Driver mobile commands
-  mobileAcceptAlert: 'Accepted an alert',
-  mobileActivateApp: 'Activated an app',
-  mobileBackgroundApp: 'Sent the app to the background',
-  mobileBluetooth: 'Changed Bluetooth state',
-  mobileBroadcast: 'Sent an Android broadcast',
-  mobileCalibrateWebToRealCoordinatesTranslation: 'Calibrated web coordinates',
-  mobileChangePermissions: 'Changed app permissions',
-  mobileClearApp: 'Cleared app data',
-  mobileClearKeychains: 'Cleared keychains',
-  mobileClickGesture: 'Performed a click gesture',
-  mobileConfigureLocalization: 'Changed device localization',
-  mobileDeepLink: 'Opened a deep link',
-  mobileDeleteFile: 'Deleted a device file',
-  mobileDeleteFolder: 'Deleted a device folder',
-  mobileDeviceidle: 'Changed device idle state',
-  mobileDisableVoiceOver: 'Disabled VoiceOver',
-  mobileDismissAlert: 'Dismissed an alert',
-  mobileDoubleClickGesture: 'Performed a double-click gesture',
-  mobileDoubleTap: 'Double-tapped the screen',
-  mobileDragFromToForDuration: 'Dragged between screen points',
-  mobileDragFromToWithVelocity: 'Dragged with a set velocity',
-  mobileDragGesture: 'Performed a drag gesture',
-  mobileEnableVoiceOver: 'Enabled VoiceOver',
-  mobileEnrollBiometric: 'Changed biometric enrollment',
-  mobileExecEmuConsoleCommand: 'Ran an emulator console command',
-  mobileExpectNotification: 'Waited for a notification',
-  mobileFingerprint: 'Simulated a fingerprint',
-  mobileFlingGesture: 'Performed a fling gesture',
-  mobileForcePress: 'Force-pressed the screen',
-  mobileGetActionHistory: 'Read scheduled action history',
-  mobileGetActiveAppInfo: 'Read active app information',
-  mobileGetAppearance: 'Read the device appearance',
-  mobileGetBatteryInfo: 'Read battery information',
-  mobileGetChromeCapabilities: 'Read Chrome capabilities',
-  mobileGetConnectivity: 'Read device connectivity',
-  mobileGetContentSize: 'Read scrollable content size',
-  mobileGetContexts: 'Listed available contexts',
-  mobileGetDeviceInfo: 'Read device information',
-  mobileGetDeviceTime: 'Read the device time',
-  mobileGetDeclaredOrientation: 'Read the declared device orientation',
-  mobileGetGeolocation: 'Read the device location',
-  mobileGetIncreaseContrast: 'Read the Increase Contrast setting',
-  mobileGetNotifications: 'Read notifications',
-  mobileGetPasteboard: 'Read the pasteboard',
-  mobileGetPerformanceData: 'Read app performance data',
-  mobileGetPermission: 'Read an app permission',
-  mobileGetPermissions: 'Read app permissions',
-  mobileGetSimulatedLocation: 'Read the simulated location',
-  mobileGetSource: 'Read the screen contents',
-  mobileGetUiMode: 'Read the Android UI mode',
-  mobileGetXctestScreenRecordingInfo: 'Read XCTest screen recording information',
-  mobileGsmCall: 'Simulated a phone call',
-  mobileGsmSignal: 'Changed the cellular signal',
-  mobileGsmVoice: 'Changed the cellular voice state',
-  mobileHandleAlert: 'Handled an alert',
-  mobileHideKeyboard: 'Hid the keyboard',
-  mobileInjectEmulatorCameraImage: 'Injected an emulator camera image',
-  mobileInstallApp: 'Installed an app',
-  mobileInstallCertificate: 'Installed a certificate',
-  mobileInstallMultipleApks: 'Installed multiple APKs',
-  mobileInstallXCTestBundle: 'Installed an XCTest bundle',
-  mobileIsAppInstalled: 'Checked if an app was installed',
-  mobileIsBiometricEnrolled: 'Checked biometric enrollment',
-  mobileIsMediaProjectionRecordingRunning: 'Checked media projection recording',
-  mobileIsVoiceOverEnabled: 'Checked if VoiceOver was enabled',
-  mobileKeys: 'Sent keyboard input',
-  mobileKillApp: 'Stopped an app',
-  mobileLaunchApp: 'Launched an app',
-  mobileListApps: 'Listed installed apps',
-  mobileListCertificates: 'Listed certificates',
-  mobileListDisplays: 'Listed displays',
-  mobileListSms: 'Listed text messages',
-  mobileListWindows: 'Listed app windows',
-  mobileListXCTestBundles: 'Listed XCTest bundles',
-  mobileLongClickGesture: 'Performed a long-click gesture',
-  mobileNetworkSpeed: 'Changed the network speed',
-  mobileNfc: 'Changed NFC state',
-  mobilePerformAccessibilityAudit: 'Ran an accessibility audit',
-  mobilePerformEditorAction: 'Performed a keyboard editor action',
-  mobilePerformHandGesture: 'Performed a hand gesture',
-  mobilePerformIndigoHidEvent: 'Performed an Indigo HID event',
-  mobilePerformIoHidEvent: 'Performed an IOHID event',
-  mobilePerformStatusBarCommand: 'Performed a status bar command',
-  mobilePinch: 'Pinched the screen',
-  mobilePinchCloseGesture: 'Performed a pinch-close gesture',
-  mobilePinchOpenGesture: 'Performed a pinch-open gesture',
-  mobilePowerAc: 'Changed the charging state',
-  mobilePowerCapacity: 'Changed the battery level',
-  mobilePressButton: 'Pressed a device button',
-  mobilePressKey: 'Pressed a key',
-  mobilePullFile: 'Pulled a file from the device',
-  mobilePullFolder: 'Pulled a folder from the device',
-  mobilePushFile: 'Pushed a file to the device',
-  mobilePushNotification: 'Sent a push notification',
-  mobileQueryAppState: 'Read the app state',
-  mobileRefreshGpsCache: 'Refreshed the GPS cache',
-  mobileRemoveApp: 'Removed an app',
-  mobileRemoveCertificate: 'Removed a certificate',
-  mobileReplaceElementValue: 'Replaced an element value',
-  mobileResetAccessibilityCache: 'Reset the accessibility cache',
-  mobileResetGeolocation: 'Reset the device location',
-  mobileResetLocationService: 'Reset location services',
-  mobileResetPermission: 'Reset an app permission',
-  mobileResetSimulatedLocation: 'Reset the simulated location',
-  mobileRotateDigitalCrown: 'Rotated the Digital Crown',
-  mobileRotateElement: 'Rotated an element',
-  mobileRunXCTest: 'Ran an XCTest bundle',
-  mobileScheduleAction: 'Scheduled a device action',
-  mobileScreenshots: 'Took display screenshots',
-  mobileScroll: 'Scrolled the screen',
-  mobileScrollBackTo: 'Scrolled back to an element',
-  mobileScrollGesture: 'Performed a scroll gesture',
-  mobileScrollToElement: 'Scrolled to an element',
-  mobileSelectPickerWheelValue: 'Changed a picker wheel value',
-  mobileSendBiometricMatch: 'Simulated biometric authentication',
-  mobileSendMemoryWarning: 'Sent a memory warning',
-  mobileSendSms: 'Simulated a text message',
-  mobileSendTrimMemory: 'Sent an Android memory trim event',
-  mobileSetAppearance: 'Changed the device appearance',
-  mobileSetConnectivity: 'Changed device connectivity',
-  mobileSetContentSize: 'Changed the content size',
-  mobileSetGeolocation: 'Set the device location',
-  mobileSetIncreaseContrast: 'Changed the Increase Contrast setting',
-  mobileSetPasteboard: 'Wrote to the pasteboard',
-  mobileSetPermissions: 'Set app permissions',
-  mobileSetSimulatedLocation: 'Set a simulated location',
-  mobileSetUiMode: 'Changed the Android UI mode',
-  mobileShake: 'Shook the device',
-  mobileShell: 'Ran an Android shell command',
-  mobileSimctl: 'Ran a simctl command',
-  mobileSiriCommand: 'Sent a Siri command',
-  mobileStartActivity: 'Started an activity',
-  mobileStartAutomationSession: 'Started an automation session',
-  mobileStartLogsBroadcast: 'Started log streaming',
-  mobileStartMediaProjectionRecording: 'Started media projection recording',
-  mobileStartNetworkMonitor: 'Started network monitoring',
-  mobileStartPerfRecord: 'Started performance recording',
-  mobileStartScreenRecording: 'Started screen recording',
-  mobileStartScreenStreaming: 'Started screen streaming',
-  mobileStartService: 'Started a service',
-  mobileStartSystemMonitor: 'Started system monitoring',
-  mobileStartXctestScreenRecording: 'Started XCTest screen recording',
-  mobileStopAutomationSession: 'Stopped an automation session',
-  mobileStopLogsBroadcast: 'Stopped log streaming',
-  mobileStopMediaProjectionRecording: 'Stopped media projection recording',
-  mobileStopNetworkMonitor: 'Stopped network monitoring',
-  mobileStopPerfRecord: 'Stopped performance recording',
-  mobileStopScreenRecording: 'Stopped screen recording',
-  mobileStopScreenStreaming: 'Stopped screen streaming',
-  mobileStopService: 'Stopped a service',
-  mobileStopSystemMonitor: 'Stopped system monitoring',
-  mobileStopXctestScreenRecording: 'Stopped XCTest screen recording',
-  mobileSwipe: 'Swiped the screen',
-  mobileSwipeGesture: 'Performed a swipe gesture',
-  mobileTap: 'Tapped the screen',
-  mobileTapWithNumberOfTaps: 'Tapped the screen multiple times',
-  mobileTerminateApp: 'Terminated an app',
-  mobileTouchAndHold: 'Touched and held the screen',
-  mobileTwoFingerTap: 'Tapped with two fingers',
-  mobileType: 'Typed text',
-  mobileUnlock: 'Unlocked the device',
-  mobileUnscheduleAction: 'Canceled a scheduled action',
-  mobileUpdateSafariPreferences: 'Updated Safari preferences',
-  mobileViewPortRect: 'Read the viewport size',
-  mobileViewportElementRect: 'Read an element position and size in the viewport',
-  mobileViewportScreenshot: 'Took a viewport screenshot',
-  mobileVoiceOverCurrentSpeech: 'Read current VoiceOver speech',
-  mobileVoiceOverMove: 'Moved the VoiceOver cursor',
-};
-
-/**
- * Translate a raw Appium command name into a short, human-readable summary.
- *
- * If a command has no curated summary, the raw command name is returned
- * unchanged — we intentionally do not guess a phrasing.
- */
-export function humanizeAppiumCommand(command: string): string {
-  return Object.hasOwn(APPIUM_COMMAND_SUMMARIES, command)
-    ? (APPIUM_COMMAND_SUMMARIES as Record<string, string>)[command]
-    : command;
-}
@@ -1,404 +0,0 @@
-// AUTO-GENERATED. Do not edit by hand.
-// Run `yarn workspace @expo/build-tools generate-appium-commands` to refresh this
-// list from Appium, XCUITest, and UiAutomator2 (installed on demand by the generator).
-export type BaseDriverAppiumCommand =
-  | 'activateApp'
-  | 'activateIMEEngine'
-  | 'active'
-  | 'addAuthCredential'
-  | 'addVirtualAuthenticator'
-  | 'availableIMEEngines'
-  | 'back'
-  | 'clear'
-  | 'clearDevicePosture'
-  | 'click'
-  | 'closeWindow'
-  | 'createNewWindow'
-  | 'createSession'
-  | 'createVirtualPressureSource'
-  | 'createVirtualSensor'
-  | 'deactivateIMEEngine'
-  | 'deleteCookie'
-  | 'deleteCookies'
-  | 'deleteSession'
-  | 'deleteVirtualPressureSource'
-  | 'deleteVirtualSensor'
-  | 'elementDisplayed'
-  | 'elementEnabled'
-  | 'elementSelected'
-  | 'elementShadowRoot'
-  | 'execute'
-  | 'executeAsync'
-  | 'executeCdp'
-  | 'fedCMCancelDialog'
-  | 'fedCMClickDialogButton'
-  | 'fedCMGetAccounts'
-  | 'fedCMGetDialogType'
-  | 'fedCMGetTitle'
-  | 'fedCMResetCooldown'
-  | 'fedCMSelectAccount'
-  | 'fedCMSetDelayEnabled'
-  | 'findElement'
-  | 'findElementFromElement'
-  | 'findElementFromShadowRoot'
-  | 'findElements'
-  | 'findElementsFromElement'
-  | 'findElementsFromShadowRoot'
-  | 'forward'
-  | 'fullScreenWindow'
-  | 'generateTestReport'
-  | 'getActiveIMEEngine'
-  | 'getAlertText'
-  | 'getAppiumSessionCapabilities'
-  | 'getAppiumSessions'
-  | 'getAttribute'
-  | 'getAuthCredential'
-  | 'getComputedLabel'
-  | 'getComputedRole'
-  | 'getContexts'
-  | 'getCookie'
-  | 'getCookies'
-  | 'getCssProperty'
-  | 'getCurrentContext'
-  | 'getDeviceTime'
-  | 'getElementRect'
-  | 'getElementScreenshot'
-  | 'getGeoLocation'
-  | 'getGlobalPrivacyControl'
-  | 'getLog'
-  | 'getLogEvents'
-  | 'getLogTypes'
-  | 'getName'
-  | 'getNetworkConnection'
-  | 'getOrientation'
-  | 'getPageSource'
-  | 'getProperty'
-  | 'getRotation'
-  | 'getScreenshot'
-  | 'getSession'
-  | 'getSettings'
-  | 'getStatus'
-  | 'getText'
-  | 'getTimeouts'
-  | 'getUrl'
-  | 'getVirtualSensorInfo'
-  | 'getWindowHandle'
-  | 'getWindowHandles'
-  | 'getWindowRect'
-  | 'hideKeyboard'
-  | 'installApp'
-  | 'isAppInstalled'
-  | 'isIMEActivated'
-  | 'isKeyboardShown'
-  | 'listCommands'
-  | 'listExtensions'
-  | 'logCustomEvent'
-  | 'maximizeWindow'
-  | 'minimizeWindow'
-  | 'performActions'
-  | 'postAcceptAlert'
-  | 'postDismissAlert'
-  | 'printPage'
-  | 'pullFile'
-  | 'pullFolder'
-  | 'pushFile'
-  | 'queryAppState'
-  | 'receiveAsyncResponse'
-  | 'refresh'
-  | 'releaseActions'
-  | 'removeAllAuthCredentials'
-  | 'removeApp'
-  | 'removeAuthCredential'
-  | 'removeVirtualAuthenticator'
-  | 'setAlertText'
-  | 'setContext'
-  | 'setCookie'
-  | 'setDevicePosture'
-  | 'setFrame'
-  | 'setGeoLocation'
-  | 'setGlobalPrivacyControl'
-  | 'setNetworkConnection'
-  | 'setOrientation'
-  | 'setPermissions'
-  | 'setRPHRegistrationMode'
-  | 'setRotation'
-  | 'setSPCTransactionMode'
-  | 'setStorageAccess'
-  | 'setUrl'
-  | 'setUserAuthVerified'
-  | 'setValue'
-  | 'setWindow'
-  | 'setWindowRect'
-  | 'switchToParentFrame'
-  | 'terminateApp'
-  | 'timeouts'
-  | 'title'
-  | 'updateSettings'
-  | 'updateVirtualPressureSource'
-  | 'updateVirtualSensorReading';
-
-export type XCUITestAppiumCommand =
-  | 'asyncScriptTimeout'
-  | 'background'
-  | 'closeApp'
-  | 'disableConditionInducer'
-  | 'enableConditionInducer'
-  | 'getClipboard'
-  | 'getLocation'
-  | 'getLocationInView'
-  | 'getScreenInfo'
-  | 'getSize'
-  | 'getStrings'
-  | 'getViewportRect'
-  | 'getViewportScreenshot'
-  | 'getWindowSize'
-  | 'implicitWait'
-  | 'isLocked'
-  | 'keys'
-  | 'launchApp'
-  | 'listConditionInducers'
-  | 'lock'
-  | 'mobileActivateApp'
-  | 'mobileCalibrateWebToRealCoordinatesTranslation'
-  | 'mobileClearApp'
-  | 'mobileClearKeychains'
-  | 'mobileConfigureLocalization'
-  | 'mobileDeepLink'
-  | 'mobileDeleteFile'
-  | 'mobileDeleteFolder'
-  | 'mobileDisableVoiceOver'
-  | 'mobileDoubleTap'
-  | 'mobileDragFromToForDuration'
-  | 'mobileDragFromToWithVelocity'
-  | 'mobileEnableVoiceOver'
-  | 'mobileEnrollBiometric'
-  | 'mobileExpectNotification'
-  | 'mobileForcePress'
-  | 'mobileGetActiveAppInfo'
-  | 'mobileGetAppearance'
-  | 'mobileGetBatteryInfo'
-  | 'mobileGetContentSize'
-  | 'mobileGetContexts'
-  | 'mobileGetDeviceInfo'
-  | 'mobileGetDeviceTime'
-  | 'mobileGetIncreaseContrast'
-  | 'mobileGetPasteboard'
-  | 'mobileGetPermission'
-  | 'mobileGetSimulatedLocation'
-  | 'mobileGetSource'
-  | 'mobileGetXctestScreenRecordingInfo'
-  | 'mobileHandleAlert'
-  | 'mobileHideKeyboard'
-  | 'mobileInstallApp'
-  | 'mobileInstallCertificate'
-  | 'mobileInstallXCTestBundle'
-  | 'mobileIsAppInstalled'
-  | 'mobileIsBiometricEnrolled'
-  | 'mobileIsVoiceOverEnabled'
-  | 'mobileKeys'
-  | 'mobileKillApp'
-  | 'mobileLaunchApp'
-  | 'mobileListApps'
-  | 'mobileListCertificates'
-  | 'mobileListXCTestBundles'
-  | 'mobilePerformAccessibilityAudit'
-  | 'mobilePerformHandGesture'
-  | 'mobilePerformIndigoHidEvent'
-  | 'mobilePerformIoHidEvent'
-  | 'mobilePinch'
-  | 'mobilePressButton'
-  | 'mobilePullFile'
-  | 'mobilePullFolder'
-  | 'mobilePushFile'
-  | 'mobilePushNotification'
-  | 'mobileQueryAppState'
-  | 'mobileRemoveApp'
-  | 'mobileRemoveCertificate'
-  | 'mobileResetLocationService'
-  | 'mobileResetPermission'
-  | 'mobileResetSimulatedLocation'
-  | 'mobileRotateDigitalCrown'
-  | 'mobileRotateElement'
-  | 'mobileRunXCTest'
-  | 'mobileScroll'
-  | 'mobileScrollToElement'
-  | 'mobileSelectPickerWheelValue'
-  | 'mobileSendBiometricMatch'
-  | 'mobileSendMemoryWarning'
-  | 'mobileSetAppearance'
-  | 'mobileSetContentSize'
-  | 'mobileSetIncreaseContrast'
-  | 'mobileSetPasteboard'
-  | 'mobileSetPermissions'
-  | 'mobileSetSimulatedLocation'
-  | 'mobileShake'
-  | 'mobileSimctl'
-  | 'mobileSiriCommand'
-  | 'mobileStartAutomationSession'
-  | 'mobileStartLogsBroadcast'
-  | 'mobileStartNetworkMonitor'
-  | 'mobileStartPerfRecord'
-  | 'mobileStartScreenRecording'
-  | 'mobileStartSystemMonitor'
-  | 'mobileStartXctestScreenRecording'
-  | 'mobileStopAutomationSession'
-  | 'mobileStopLogsBroadcast'
-  | 'mobileStopNetworkMonitor'
-  | 'mobileStopPerfRecord'
-  | 'mobileStopScreenRecording'
-  | 'mobileStopSystemMonitor'
-  | 'mobileStopXctestScreenRecording'
-  | 'mobileSwipe'
-  | 'mobileTap'
-  | 'mobileTapWithNumberOfTaps'
-  | 'mobileTerminateApp'
-  | 'mobileTouchAndHold'
-  | 'mobileTwoFingerTap'
-  | 'mobileUpdateSafariPreferences'
-  | 'mobileVoiceOverCurrentSpeech'
-  | 'mobileVoiceOverMove'
-  | 'reset'
-  | 'setClipboard'
-  | 'setValueImmediate'
-  | 'startAudioRecording'
-  | 'startRecordingScreen'
-  | 'stopAudioRecording'
-  | 'stopRecordingScreen'
-  | 'submit'
-  | 'toggleEnrollTouchId'
-  | 'touchId'
-  | 'unlock';
-
-export type UiAutomator2AppiumCommand =
-  | 'background'
-  | 'fingerprint'
-  | 'getClipboard'
-  | 'getCurrentActivity'
-  | 'getCurrentPackage'
-  | 'getDisplayDensity'
-  | 'getLocation'
-  | 'getLocationInView'
-  | 'getPerformanceData'
-  | 'getPerformanceDataTypes'
-  | 'getSize'
-  | 'getStrings'
-  | 'getSystemBars'
-  | 'getWindowSize'
-  | 'gsmCall'
-  | 'gsmSignal'
-  | 'gsmVoice'
-  | 'implicitWait'
-  | 'isLocationServicesEnabled'
-  | 'isLocked'
-  | 'keyevent'
-  | 'keys'
-  | 'lock'
-  | 'longPressKeyCode'
-  | 'mobileAcceptAlert'
-  | 'mobileBackgroundApp'
-  | 'mobileBluetooth'
-  | 'mobileBroadcast'
-  | 'mobileChangePermissions'
-  | 'mobileClearApp'
-  | 'mobileClickGesture'
-  | 'mobileDeepLink'
-  | 'mobileDeleteFile'
-  | 'mobileDeviceidle'
-  | 'mobileDismissAlert'
-  | 'mobileDoubleClickGesture'
-  | 'mobileDragGesture'
-  | 'mobileExecEmuConsoleCommand'
-  | 'mobileFingerprint'
-  | 'mobileFlingGesture'
-  | 'mobileGetActionHistory'
-  | 'mobileGetBatteryInfo'
-  | 'mobileGetChromeCapabilities'
-  | 'mobileGetConnectivity'
-  | 'mobileGetContexts'
-  | 'mobileGetDeclaredOrientation'
-  | 'mobileGetDeviceInfo'
-  | 'mobileGetDeviceTime'
-  | 'mobileGetGeolocation'
-  | 'mobileGetNotifications'
-  | 'mobileGetPerformanceData'
-  | 'mobileGetPermissions'
-  | 'mobileGetUiMode'
-  | 'mobileGsmCall'
-  | 'mobileGsmSignal'
-  | 'mobileGsmVoice'
-  | 'mobileInjectEmulatorCameraImage'
-  | 'mobileInstallApp'
-  | 'mobileInstallMultipleApks'
-  | 'mobileIsAppInstalled'
-  | 'mobileIsMediaProjectionRecordingRunning'
-  | 'mobileListApps'
-  | 'mobileListDisplays'
-  | 'mobileListSms'
-  | 'mobileListWindows'
-  | 'mobileLongClickGesture'
-  | 'mobileNetworkSpeed'
-  | 'mobileNfc'
-  | 'mobilePerformEditorAction'
-  | 'mobilePerformStatusBarCommand'
-  | 'mobilePinchCloseGesture'
-  | 'mobilePinchOpenGesture'
-  | 'mobilePowerAc'
-  | 'mobilePowerCapacity'
-  | 'mobilePressKey'
-  | 'mobileRefreshGpsCache'
-  | 'mobileRemoveApp'
-  | 'mobileReplaceElementValue'
-  | 'mobileResetAccessibilityCache'
-  | 'mobileResetGeolocation'
-  | 'mobileScheduleAction'
-  | 'mobileScreenshots'
-  | 'mobileScroll'
-  | 'mobileScrollBackTo'
-  | 'mobileScrollGesture'
-  | 'mobileSendSms'
-  | 'mobileSendTrimMemory'
-  | 'mobileSetConnectivity'
-  | 'mobileSetGeolocation'
-  | 'mobileSetUiMode'
-  | 'mobileShell'
-  | 'mobileStartActivity'
-  | 'mobileStartLogsBroadcast'
-  | 'mobileStartMediaProjectionRecording'
-  | 'mobileStartScreenStreaming'
-  | 'mobileStartService'
-  | 'mobileStopLogsBroadcast'
-  | 'mobileStopMediaProjectionRecording'
-  | 'mobileStopScreenStreaming'
-  | 'mobileStopService'
-  | 'mobileSwipeGesture'
-  | 'mobileTerminateApp'
-  | 'mobileType'
-  | 'mobileUnlock'
-  | 'mobileUnscheduleAction'
-  | 'mobileViewPortRect'
-  | 'mobileViewportElementRect'
-  | 'mobileViewportScreenshot'
-  | 'networkSpeed'
-  | 'openNotifications'
-  | 'powerAC'
-  | 'powerCapacity'
-  | 'pressKeyCode'
-  | 'replaceValue'
-  | 'sendSMS'
-  | 'sensorSet'
-  | 'setClipboard'
-  | 'setStylusHandwriting'
-  | 'setValueImmediate'
-  | 'startActivity'
-  | 'startRecordingScreen'
-  | 'stopRecordingScreen'
-  | 'toggleData'
-  | 'toggleFlightMode'
-  | 'toggleLocationServices'
-  | 'toggleWiFi'
-  | 'unlock';
-
-export type AppiumCommand =
-  | BaseDriverAppiumCommand
-  | XCUITestAppiumCommand
-  | UiAutomator2AppiumCommand;
@@ -1,217 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { setTimeout as setTimeoutAsync } from 'node:timers/promises';
-import { z } from 'zod';
-
-import { type CustomBuildContext } from '../../customBuildContext';
-import { turtleFetch } from '../../utils/turtleFetch';
-import { humanizeAppiumCommand } from './appiumCommandSummary';
-import {
-  type DeviceRunSessionEventCollection,
-  type DeviceRunSessionEventSource,
-  startDeviceRunSessionEventCollectionAsync,
-} from './deviceRunSessionEvents';
-
-const APPIUM_REQUEST_TIMEOUT_MS = 10_000;
-const POLL_INTERVAL_MS = 1_000;
-const GET_LOG_EVENTS_COMMAND = 'getLogEvents';
-
-const AppiumSessionsResponseSchema = z.object({
-  value: z.array(z.object({ id: z.string() }).passthrough()),
-});
-
-const AppiumCommandSchema = z.object({
-  appiumSessionId: z.string(),
-  cmd: z.string(),
-  startTime: z.number(),
-  endTime: z.number(),
-});
-
-const AppiumEventsResponseSchema = z.object({
-  value: z.object({
-    commands: z.array(AppiumCommandSchema.omit({ appiumSessionId: true })),
-  }),
-});
-
-type AppiumCommand = z.infer<typeof AppiumCommandSchema>;
-
-export async function startAppiumEventCollectionAsync({
-  ctx,
-  deviceRunSessionId,
-  appiumUrl,
-  logger,
-  pollIntervalMs = POLL_INTERVAL_MS,
-}: {
-  ctx: CustomBuildContext;
-  deviceRunSessionId: string;
-  appiumUrl: string;
-  logger: bunyan;
-  pollIntervalMs?: number;
-}): Promise<DeviceRunSessionEventCollection> {
-  const eventDirectory = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'eas-appium-events-'));
-  const eventFile = path.join(eventDirectory, 'commands.ndjson');
-  await fs.promises.writeFile(eventFile, '');
-
-  let eventCollection: DeviceRunSessionEventCollection;
-  try {
-    eventCollection = await startDeviceRunSessionEventCollectionAsync({
-      ctx,
-      deviceRunSessionId,
-      logger,
-      pollIntervalMs,
-      source: createAppiumEventSource(eventFile),
-    });
-  } catch (error) {
-    await fs.promises.rm(eventDirectory, { recursive: true, force: true });
-    throw error;
-  }
-
-  const observedCommandKeys = new Set<string>();
-  const controller = new AbortController();
-  let didReportCollectionFailure = false;
-  const collectSafelyAsync = async (): Promise<void> => {
-    try {
-      await collectAppiumCommandsAsync({
-        appiumUrl,
-        eventFile,
-        observedCommandKeys,
-        logger,
-      });
-      didReportCollectionFailure = false;
-    } catch (error) {
-      if (!didReportCollectionFailure) {
-        didReportCollectionFailure = true;
-        logger.warn({ err: error }, 'Could not collect Appium events.');
-      }
-    }
-  };
-  const pollingPromise = (async () => {
-    while (!controller.signal.aborted) {
-      await collectSafelyAsync();
-      try {
-        await setTimeoutAsync(pollIntervalMs, undefined, { signal: controller.signal });
-      } catch (error) {
-        if (!controller.signal.aborted) {
-          throw error;
-        }
-      }
-    }
-  })().catch(error => {
-    logger.warn({ err: error }, 'Appium event collection poller failed.');
-  });
-
-  return {
-    getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-    stopAsync: async () => {
-      controller.abort();
-      await pollingPromise;
-      await collectSafelyAsync();
-      try {
-        await eventCollection.stopAsync();
-      } finally {
-        await fs.promises.rm(eventDirectory, { recursive: true, force: true });
-      }
-    },
-  };
-}
-
-function createAppiumEventSource(eventFile: string): DeviceRunSessionEventSource {
-  return {
-    producer: 'appium',
-    findEventFilesAsync: async () => [eventFile],
-    sourceKeyForFile: file => path.basename(file, path.extname(file)),
-    parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
-      if (!line.trim()) {
-        return {};
-      }
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        return { failure: 'invalid-json' };
-      }
-      const result = AppiumCommandSchema.safeParse(parsed);
-      if (!result.success) {
-        return { failure: 'invalid-event' };
-      }
-      const command = result.data;
-      const operationId = `${sourceKey}:${sequenceNumber}`;
-      return {
-        event: {
-          v: 1,
-          eventId: `appium:${deviceRunSessionId}:${operationId}`,
-          ts: new Date(command.endTime).toISOString(),
-          producer: 'appium',
-          type: 'operation.completed',
-          operationId,
-          durationMs: Math.max(0, command.endTime - command.startTime),
-          summary: humanizeAppiumCommand(command.cmd),
-          data: {
-            command: command.cmd,
-            appiumSessionId: command.appiumSessionId,
-          },
-        },
-      };
-    },
-  };
-}
-
-async function collectAppiumCommandsAsync({
-  appiumUrl,
-  eventFile,
-  observedCommandKeys,
-  logger,
-}: {
-  appiumUrl: string;
-  eventFile: string;
-  observedCommandKeys: Set<string>;
-  logger: bunyan;
-}): Promise<void> {
-  const response = await turtleFetch(new URL('appium/sessions', appiumUrl).toString(), 'GET', {
-    timeout: APPIUM_REQUEST_TIMEOUT_MS,
-    retries: 0,
-    logger,
-  });
-  const sessions = AppiumSessionsResponseSchema.parse(await response.json()).value;
-  const newCommands: { key: string; command: AppiumCommand }[] = [];
-  const pendingCommandKeys = new Set<string>();
-
-  for (const { id: appiumSessionId } of sessions) {
-    const eventsResponse = await turtleFetch(
-      new URL(`session/${encodeURIComponent(appiumSessionId)}/appium/events`, appiumUrl).toString(),
-      'POST',
-      {
-        json: {},
-        timeout: APPIUM_REQUEST_TIMEOUT_MS,
-        retries: 0,
-        logger,
-      }
-    );
-    const commands = AppiumEventsResponseSchema.parse(await eventsResponse.json()).value.commands;
-    for (const command of commands) {
-      const key = [appiumSessionId, command.cmd, command.startTime, command.endTime].join(':');
-      if (
-        command.cmd === GET_LOG_EVENTS_COMMAND ||
-        observedCommandKeys.has(key) ||
-        pendingCommandKeys.has(key)
-      ) {
-        continue;
-      }
-      pendingCommandKeys.add(key);
-      newCommands.push({ key, command: { appiumSessionId, ...command } });
-    }
-  }
-
-  if (newCommands.length === 0) {
-    return;
-  }
-  await fs.promises.appendFile(
-    eventFile,
-    `${newCommands.map(({ command }) => JSON.stringify(command)).join('\n')}\n`
-  );
-  for (const { key } of newCommands) {
-    observedCommandKeys.add(key);
-  }
-}
@@ -18,11 +18,11 @@ const ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
 const ARGENT_ARTIFACT_UPLOAD_CLEANUP_TIMEOUT_MS = 30_000;
 const ARGENT_ARTIFACT_FETCH_TIMEOUT_MS = 10_000;

-// Fallback kinds for Argent versions that do not include a semantic artifact kind. Only media types
-// the EAS dashboard renders specially can be inferred safely. Note that these kinds only affect
-// grouping and labelling. The dashboard gates its inline video player on the
-// `__eas_screen_recording` metadata flag, which Argent artifacts deliberately do not set, so a
-// `screen-recording` kind here does not add a player to the session page.
+// Kinds the EAS dashboard groups device run session artifacts by. Only media types the dashboard
+// renders specially are mapped; anything else stays unclassified and lands in its "Other" group.
+// Note that these kinds only affect grouping and labelling. The dashboard gates its inline video
+// player on the `__eas_screen_recording` metadata flag, which Argent artifacts deliberately do not
+// set, so a `screen-recording` kind here does not add a player to the session page.
 const ARGENT_ARTIFACT_KIND_BY_MIME_TYPE = new Map<string, string>([
  ['image/png', 'screenshot'],
  ['image/jpeg', 'screenshot'],
@@ -32,9 +32,6 @@ const ARGENT_ARTIFACT_KIND_BY_MIME_TYPE = new Map<string, string>([

 const ArgentArtifactSchema = z.object({
  id: z.string(),
-  // Optional for compatibility with older Argent tool servers. Keep this open to new kinds so a
-  // newer Argent version can add a category without requiring an EAS worker release first.
-  kind: z.string().optional(),
  filename: z.string(),
  mimeType: z.string(),
  isDirectory: z.boolean().optional(),
@@ -46,12 +43,8 @@ const ArgentArtifactsListResponseSchema = z.object({
 type ArgentArtifact = z.infer<typeof ArgentArtifactSchema>;

 function getArgentArtifactKind(artifact: ArgentArtifact): string | undefined {
-  if (artifact.kind) {
-    return artifact.kind;
-  }
  // Directories are repackaged as a tarball before upload, so the reported media type describes the
-  // contents rather than the file we actually store. A semantic kind above remains valid because it
-  // describes what the artifact represents, not its transport format.
+  // contents rather than the file we actually store.
  if (artifact.isDirectory) {
    return undefined;
  }
@@ -272,10 +272,6 @@ export type AscApiClientPostApi = {
  };
 };

-// https://developer.apple.com/documentation/appstoreconnectapi/platform
-export type AscPlatform =
-  AscApiClientPostApi['/v1/buildUploads']['request']['data']['attributes']['platform'];
-
 export type AscApiClientPatchApi = {
  [Path in keyof typeof PatchApi]: {
    request: z.input<(typeof PatchApi)[Path]['request']>;
@@ -5,44 +5,9 @@ import {
  AscApiClientGetApi,
  AscApiClientPostApi,
  AscApiRequestError,
-  AscPlatform,
 } from './AscApiClient';

 export namespace AscApiUtils {
-  /**
-   * Maps a bundle's `DTPlatformName` (from its Info.plist) to the App Store
-   * Connect platform used for a build upload. Unknown or missing values fall
-   * back to `IOS` to preserve the previous default.
-   */
-  export function ascPlatformFromDtPlatformName(dtPlatformName: string | null): AscPlatform {
-    switch (dtPlatformName) {
-      case 'appletvos':
-        return 'TV_OS';
-      case 'macosx':
-        return 'MAC_OS';
-      case 'xros':
-        return 'VISION_OS';
-      case 'iphoneos':
-      default:
-        return 'IOS';
-    }
-  }
-
-  /** The App Store Connect TestFlight URL path segment for a platform. */
-  export function testFlightPlatformPathSegment(platform: AscPlatform): string {
-    switch (platform) {
-      case 'TV_OS':
-        return 'tvos';
-      case 'MAC_OS':
-        return 'macos';
-      case 'VISION_OS':
-        return 'visionos';
-      case 'IOS':
-      default:
-        return 'ios';
-    }
-  }
-
  export async function getAppInfoAsync({
    client,
    appleAppIdentifier,
@@ -96,20 +61,18 @@ export namespace AscApiUtils {
    appleAppIdentifier,
    bundleShortVersion,
    bundleVersion,
-    platform,
  }: {
    client: Pick<AscApiClient, 'postAsync'>;
    appleAppIdentifier: string;
    bundleShortVersion: string;
    bundleVersion: string;
-    platform: AscPlatform;
  }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']> {
    try {
      return await client.postAsync('/v1/buildUploads', {
        data: {
          type: 'buildUploads',
          attributes: {
-            platform,
+            platform: 'IOS',
            cfBundleShortVersionString: bundleShortVersion,
            cfBundleVersion: bundleVersion,
          },
@@ -148,7 +148,6 @@ describe('AscApiUtils', () => {
          appleAppIdentifier: '1491144534',
          bundleShortVersion: '1.2.3',
          bundleVersion: '42',
-          platform: 'IOS',
        })
      ).rejects.toEqual(
        expect.objectContaining({
@@ -177,40 +176,10 @@ describe('AscApiUtils', () => {
          appleAppIdentifier: '1491144534',
          bundleShortVersion: '1.2.3',
          bundleVersion: '42',
-          platform: 'IOS',
        })
      ).resolves.toEqual(response);
    });

-    it('sends the requested platform in the build upload attributes', async () => {
-      const response = {
-        data: {
-          type: 'buildUploads',
-          id: 'fdf9c476-aaa4-4ead-b91c-6e3cc3a47805',
-        },
-      } as const;
-      const client = {
-        postAsync: jest.fn().mockResolvedValue(response),
-      };
-
-      await AscApiUtils.createBuildUploadAsync({
-        client,
-        appleAppIdentifier: '1491144534',
-        bundleShortVersion: '1.2.3',
-        bundleVersion: '42',
-        platform: 'TV_OS',
-      });
-
-      expect(client.postAsync).toHaveBeenCalledWith(
-        '/v1/buildUploads',
-        expect.objectContaining({
-          data: expect.objectContaining({
-            attributes: expect.objectContaining({ platform: 'TV_OS' }),
-          }),
-        })
-      );
-    });
-
    it('rethrows when error payload includes mixed error codes', async () => {
      const payload = {
        errors: [
@@ -239,32 +208,8 @@ describe('AscApiUtils', () => {
          appleAppIdentifier: '1491144534',
          bundleShortVersion: '1.2.3',
          bundleVersion: '42',
-          platform: 'IOS',
        })
      ).rejects.toBe(mixedError);
    });
  });
-
-  describe('ascPlatformFromDtPlatformName', () => {
-    it('maps known DTPlatformName values to App Store Connect platforms', () => {
-      expect(AscApiUtils.ascPlatformFromDtPlatformName('iphoneos')).toBe('IOS');
-      expect(AscApiUtils.ascPlatformFromDtPlatformName('appletvos')).toBe('TV_OS');
-      expect(AscApiUtils.ascPlatformFromDtPlatformName('macosx')).toBe('MAC_OS');
-      expect(AscApiUtils.ascPlatformFromDtPlatformName('xros')).toBe('VISION_OS');
-    });
-
-    it('falls back to IOS for unknown or missing values', () => {
-      expect(AscApiUtils.ascPlatformFromDtPlatformName(null)).toBe('IOS');
-      expect(AscApiUtils.ascPlatformFromDtPlatformName('watchos')).toBe('IOS');
-    });
-  });
-
-  describe('testFlightPlatformPathSegment', () => {
-    it('returns the TestFlight URL segment for each platform', () => {
-      expect(AscApiUtils.testFlightPlatformPathSegment('IOS')).toBe('ios');
-      expect(AscApiUtils.testFlightPlatformPathSegment('TV_OS')).toBe('tvos');
-      expect(AscApiUtils.testFlightPlatformPathSegment('MAC_OS')).toBe('macos');
-      expect(AscApiUtils.testFlightPlatformPathSegment('VISION_OS')).toBe('visionos');
-    });
-  });
 });
@@ -5,6 +5,7 @@ import path from 'path';

 import { COMMON_FASTLANE_ENV } from '../../../common/fastlane';
 import { XcodeBuildLogger } from '../../../common/xcpretty';
+import * as CompilationCache from '../../../ios/compilationCache';

 export async function runFastlaneGym({
  workingDir,
@@ -19,14 +20,23 @@ export async function runFastlaneGym({
  env: BuildStepEnv;
  extraEnv?: BuildStepEnv;
 }): Promise<void> {
+  const workspacePath = path.join(workingDir, 'ios');
+  const derivedDataPath = path.join(workspacePath, 'build');
+  // When caching is enabled, this also sets GYM_DERIVED_DATA_PATH so Fastlane
+  // and the cache restore/save operations use this exact directory.
+  const compilationCacheEnv = await CompilationCache.prepareXcodeCompilationCacheEnvAsync({
+    derivedDataPath,
+    env,
+    logger,
+  });
  const buildLogger = new XcodeBuildLogger(logger, workingDir);
  void buildLogger.watchLogFiles(buildLogsDirectory);
  try {
    await runFastlane(['gym'], {
-      cwd: path.join(workingDir, 'ios'),
+      cwd: workspacePath,
      logger,
      env,
-      extraEnv,
+      extraEnv: { ...extraEnv, ...compilationCacheEnv },
    });
  } finally {
    await buildLogger.flush();
@@ -9,7 +9,6 @@ import path from 'path';
 import { z } from 'zod';

 import { Sentry } from '../../../sentry';
-import { getProxiedDownloadUrl } from '../../../utils/download';

 const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.47';
 const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclogparser';
@@ -295,6 +294,24 @@ function getXclogparserZipName(version: string): string {
  return `XCLogParser-macOS-x86-64-arm64-${version}.zip`;
 }

+function getProxiedDownloadUrl({
+  directUrl,
+  proxyBaseUrl,
+}: {
+  directUrl: string;
+  proxyBaseUrl?: string;
+}): string | null {
+  if (!proxyBaseUrl) {
+    return null;
+  }
+
+  const parsedUrl = new URL(directUrl);
+  return directUrl.replace(
+    `${parsedUrl.protocol}//${parsedUrl.host}`,
+    `${proxyBaseUrl}/${parsedUrl.host}`
+  );
+}
+
 export function isCompileStep(step: Partial<XcactivitylogStep>): boolean {
  const detailStepType = step.detailStepType ?? '';
  const signature = step.signature ?? '';
@@ -1,724 +0,0 @@
-import downloadFile from '@expo/downloader';
-import { SystemError } from '@expo/eas-build-job';
-import { bunyan } from '@expo/logger';
-import { BuildStepEnv } from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-import { createHash, randomBytes } from 'node:crypto';
-import fs from 'node:fs';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import zlib from 'node:zlib';
-
-import { sleepAsync } from '../../utils/retry';
-
-import { type DetachedProcessHandle, spawnDetached } from './remoteDeviceRunSession';
-
-/**
- * Local egress provides an HTTP(S) proxy through the machine running the EAS CLI.
- * Requests that use this proxy exit through that machine's network.
- *
- * Worker side: a chisel server in reverse mode listens on loopback and is exposed
- * through the session's ngrok domain. When the CLI's egress client connects, chisel
- * opens LOCAL_EGRESS_PROXY_PORT on this host and forwards every connection to the
- * HTTP proxy the CLI runs. The macOS system proxy points at that port. Until the
- * client connects, nothing listens on the port and proxied requests fail.
- *
- * Contract: HTTP(S) and WebSocket requests that honor the system proxy (WebKit,
- * URLSession and other CFNetwork clients) exit from the egress client's network
- * and fail while the client is disconnected. Requests from libraries that bypass
- * the system proxy are not covered and exit from this host. Nothing here enforces
- * routing; the session monitor reports such direct connections instead.
- */
-
-export const LOCAL_EGRESS_PROXY_HOST = '127.0.0.1';
-export const LOCAL_EGRESS_PROXY_PORT = 8899;
-export const LOCAL_EGRESS_USERNAME = 'eas';
-export const LOCAL_EGRESS_HANDOFF_PATH = path.join(os.tmpdir(), 'eas-simulator-local-egress.json');
-
-export const CHISEL_VERSION = '1.12.0';
-// sha256 of the release .gz assets, cross-checked against chisel_1.12.0_checksums.txt.
-const CHISEL_SHA256_BY_ASSET: Record<string, string> = {
-  'chisel_1.12.0_darwin_arm64.gz':
-    '707a4b932eea214765146504a0df246cefc415b4297af65a80dd67cf69ba85a9',
-  'chisel_1.12.0_darwin_amd64.gz':
-    '4aeae36c867f11c8e8c3f2b913a0e063ea3c6d29e1c14a52ed2e6eef8cfc4395',
-  'chisel_1.12.0_linux_amd64.gz':
-    'f3f180f1d93aa72cce4e6386f98cc06569a0146fbd65eb4423cf83e6434bcfe6',
-  'chisel_1.12.0_linux_arm64.gz':
-    '2ec6152cd2c74fe0146d4d79e4e7aa174521368c56e433d55e023a92ea404ec3',
-};
-
-const CHISEL_STARTUP_TIMEOUT_MS = 15_000;
-const EGRESS_MONITOR_INTERVAL_MS = 2_000;
-const EGRESS_ESCAPE_SCAN_INTERVAL_MS = 5_000;
-const EGRESS_ESCAPE_LOG_LIMIT = 50;
-
-export type LocalEgressHandoff = {
-  /** Public URL of the reverse tunnel server, reachable through ngrok. */
-  url: string;
-  /** Secret the client presents to the tunnel server, paired with LOCAL_EGRESS_USERNAME. */
-  token: string;
-  /** Fingerprint of the tunnel server key, for the client to pin. */
-  fingerprint: string;
-  /** Loopback port on this host that the client must serve. */
-  port: number;
-};
-
-export function getChiselAssetName({
-  platform,
-  arch,
-}: {
-  platform: NodeJS.Platform;
-  arch: string;
-}): string {
-  const os = platform === 'darwin' ? 'darwin' : platform === 'linux' ? 'linux' : null;
-  const cpu = arch === 'arm64' ? 'arm64' : arch === 'x64' ? 'amd64' : null;
-  if (!os || !cpu) {
-    throw new SystemError(
-      `Local egress is not supported on ${platform}/${arch}. The reverse tunnel binary is available for macOS and Linux on arm64 and x64.`
-    );
-  }
-  return `chisel_${CHISEL_VERSION}_${os}_${cpu}.gz`;
-}
-
-export function getChiselDownloadUrl(assetName: string): string {
-  return `https://github.com/jpillora/chisel/releases/download/v${CHISEL_VERSION}/${assetName}`;
-}
-
-async function sha256FileAsync(filePath: string): Promise<string> {
-  const hash = createHash('sha256');
-  await pipeline(fs.createReadStream(filePath), hash);
-  return hash.digest('hex');
-}
-
-export async function downloadChiselAsync({
-  destinationDir,
-  logger,
-  platform = process.platform,
-  arch = process.arch,
-}: {
-  destinationDir: string;
-  logger: bunyan;
-  platform?: NodeJS.Platform;
-  arch?: string;
-}): Promise<string> {
-  const assetName = getChiselAssetName({ platform, arch });
-  const expectedSha256 = CHISEL_SHA256_BY_ASSET[assetName];
-  if (!expectedSha256) {
-    throw new SystemError(`No pinned checksum for ${assetName}.`);
-  }
-  const url = getChiselDownloadUrl(assetName);
-  const archivePath = path.join(destinationDir, assetName);
-  logger.info(`Downloading ${url}.`);
-  await downloadFile(url, archivePath, { retry: 3, timeout: 60_000 });
-
-  const actualSha256 = await sha256FileAsync(archivePath);
-  if (actualSha256 !== expectedSha256) {
-    throw new SystemError(
-      `Checksum mismatch for ${assetName}: expected ${expectedSha256}, got ${actualSha256}. ` +
-        'The download may be corrupted or tampered with; the session was not started.'
-    );
-  }
-
-  const binaryPath = path.join(destinationDir, 'chisel');
-  await pipeline(
-    fs.createReadStream(archivePath),
-    zlib.createGunzip(),
-    fs.createWriteStream(binaryPath)
-  );
-  await fs.promises.chmod(binaryPath, 0o755);
-  return binaryPath;
-}
-
-export function generateEgressCredentials(): { user: string; password: string } {
-  return { user: LOCAL_EGRESS_USERNAME, password: randomBytes(24).toString('base64url') };
-}
-
-// Matches 1024-65535: every unprivileged TCP port.
-const UNPRIVILEGED_PORT_PATTERN =
-  '(102[4-9]|10[3-9][0-9]|1[1-9][0-9]{2}|[2-9][0-9]{3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])';
-
-/**
- * chisel authfile: one user, allowed to open reverse remotes on loopback only.
- * The proxy port carries proxied requests. Any unprivileged loopback port may be
- * forwarded too: the EAS CLI opens one per `--egress-allow localhost:<port>`
- * entry so `127.0.0.1:<port>` inside the simulator reaches that port on the
- * developer's machine, like `adb reverse`. iOS never sends loopback-literal
- * requests to the system proxy, so the proxy alone cannot serve them.
- * Reverse remotes are matched as `R:<interface>:<port>`.
- */
-export function createChiselAuthfileContents({
-  user,
-  password,
-  port,
-}: {
-  user: string;
-  password: string;
-  port: number;
-}): string {
-  const escapedHost = LOCAL_EGRESS_PROXY_HOST.replace(/\./g, '\\.');
-  return JSON.stringify({
-    [`${user}:${password}`]: [
-      `^R:${escapedHost}:${port}$`,
-      `^R:${escapedHost}:${UNPRIVILEGED_PORT_PATTERN}$`,
-    ],
-  });
-}
-
-export function parseChiselFingerprint(output: string): string | null {
-  const match = /Fingerprint\s+(\S+)/.exec(output);
-  return match?.[1] ?? null;
-}
-
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function startChiselServerAsync({
-  chiselPath,
-  controlPort,
-  authfilePath,
-  env,
-  signal,
-}: {
-  chiselPath: string;
-  controlPort: number;
-  authfilePath: string;
-  env: BuildStepEnv;
-  signal?: AbortSignal;
-}): Promise<{ process: DetachedProcessHandle; fingerprint: string }> {
-  const server = spawnDetached({
-    command: chiselPath,
-    args: [
-      'server',
-      '--host',
-      LOCAL_EGRESS_PROXY_HOST,
-      '--port',
-      String(controlPort),
-      '--reverse',
-      '--authfile',
-      authfilePath,
-    ],
-    // AUTH adds an unrestricted user even when --authfile is supplied.
-    env: { ...env, AUTH: '' },
-  });
-
-  try {
-    const deadline = Date.now() + CHISEL_STARTUP_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      signal?.throwIfAborted();
-      if (server.pid === undefined || !isProcessRunning(server.pid)) {
-        break;
-      }
-      const output = server.getOutput();
-      const fingerprint = parseChiselFingerprint(output);
-      // Chisel prints the fingerprint before binding. This line comes from the
-      // child only after its listener succeeds, unlike a probe of a reused port.
-      const listening = output
-        .split('\n')
-        .some(line =>
-          line
-            .trimEnd()
-            .endsWith(`server: Listening on http://${LOCAL_EGRESS_PROXY_HOST}:${controlPort}`)
-        );
-      if (fingerprint && listening) {
-        return { process: server, fingerprint };
-      }
-      await sleepAsync(250);
-    }
-    throw new SystemError(
-      `The reverse tunnel server did not start within ${CHISEL_STARTUP_TIMEOUT_MS / 1000}s. Output:\n${
-        server.getOutput() || '<empty>'
-      }`
-    );
-  } catch (error) {
-    await server.stopAsync();
-    throw error;
-  }
-}
-
-export function parseDefaultRouteInterface(routeOutput: string): string | null {
-  const match = /^\s*interface:\s*(\S+)/m.exec(routeOutput);
-  return match?.[1] ?? null;
-}
-
-/**
- * `networksetup -listnetworkserviceorder` prints each service as two lines:
- * "(1) Wi-Fi" followed by "(Hardware Port: Wi-Fi, Device: en0)". Return the
- * service name whose device matches.
- */
-export function parseNetworkServiceNameForDevice(
-  listOutput: string,
-  device: string
-): string | null {
-  const lines = listOutput.split('\n').map(line => line.trim());
-  for (let i = 0; i < lines.length; i++) {
-    const hardwarePortMatch = /^\(Hardware Port: (.+), Device: (\S+)\)$/.exec(lines[i]);
-    if (!hardwarePortMatch || hardwarePortMatch[2] !== device) {
-      continue;
-    }
-    const serviceLineMatch = /^\(\d+\) (.+)$/.exec(lines[i - 1] ?? '');
-    return serviceLineMatch?.[1] ?? hardwarePortMatch[1];
-  }
-  return null;
-}
-
-export async function resolveActiveNetworkServiceNameAsync({
-  env,
-}: {
-  env: BuildStepEnv;
-}): Promise<string> {
-  const routeResult = await spawn('route', ['-n', 'get', 'default'], { env, stdio: 'pipe' });
-  const device = parseDefaultRouteInterface(routeResult.stdout);
-  if (!device) {
-    throw new SystemError(
-      'Could not determine the default network interface of the device host, so the system proxy ' +
-        'cannot be configured. Output of `route -n get default`:\n' +
-        (routeResult.stdout || '<empty>')
-    );
-  }
-  const listResult = await spawn('networksetup', ['-listnetworkserviceorder'], {
-    env,
-    stdio: 'pipe',
-  });
-  const service = parseNetworkServiceNameForDevice(listResult.stdout, device);
-  if (!service) {
-    throw new SystemError(
-      `Could not find the network service for interface ${device}, so the system proxy cannot be ` +
-        'configured. Output of `networksetup -listnetworkserviceorder`:\n' +
-        (listResult.stdout || '<empty>')
-    );
-  }
-  return service;
-}
-
-export function buildNetworksetupProxyArgs({
-  service,
-  host,
-  port,
-}: {
-  service: string;
-  host: string;
-  port: number;
-}): string[][] {
-  return [
-    ['-setwebproxy', service, host, String(port)],
-    ['-setsecurewebproxy', service, host, String(port)],
-  ];
-}
-
-/**
- * Point the macOS system HTTP and HTTPS proxy at the loopback egress port. The
- * simulator reads these settings when it boots, so this must run before
- * `start_ios_simulator`. Existing bypass and automatic proxy settings are left
- * unchanged. Requests that bypass this proxy can leave from this host's address.
- */
-export async function configureSystemProxyAsync({
-  env,
-  logger,
-  port,
-  signal,
-}: {
-  env: BuildStepEnv;
-  logger: bunyan;
-  port: number;
-  signal?: AbortSignal;
-}): Promise<{ service: string }> {
-  if (process.env.ENVIRONMENT === 'development') {
-    logger.info('Job running outside of EAS, not changing the system proxy.');
-    return { service: '<development>' };
-  }
-  const service = await resolveActiveNetworkServiceNameAsync({ env });
-  for (const args of buildNetworksetupProxyArgs({ service, host: LOCAL_EGRESS_PROXY_HOST, port })) {
-    signal?.throwIfAborted();
-    await spawn('networksetup', args, { env, logger, signal });
-  }
-  logger.info(`System proxy for "${service}" set to ${LOCAL_EGRESS_PROXY_HOST}:${port}.`);
-  return { service };
-}
-
-export async function writeLocalEgressHandoffAsync(
-  handoff: LocalEgressHandoff,
-  handoffPath: string = LOCAL_EGRESS_HANDOFF_PATH
-): Promise<void> {
-  await fs.promises.writeFile(handoffPath, JSON.stringify(handoff), {
-    encoding: 'utf8',
-    mode: 0o600,
-  });
-}
-
-export async function readLocalEgressHandoffAsync(
-  handoffPath: string = LOCAL_EGRESS_HANDOFF_PATH
-): Promise<LocalEgressHandoff | null> {
-  let raw: string;
-  try {
-    raw = await fs.promises.readFile(handoffPath, 'utf8');
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      return null;
-    }
-    throw err;
-  }
-  const parsed = JSON.parse(raw) as Partial<LocalEgressHandoff>;
-  if (
-    typeof parsed.url !== 'string' ||
-    typeof parsed.token !== 'string' ||
-    typeof parsed.fingerprint !== 'string' ||
-    typeof parsed.port !== 'number'
-  ) {
-    throw new SystemError(`Local egress handoff at ${handoffPath} is malformed.`);
-  }
-  return {
-    url: parsed.url,
-    token: parsed.token,
-    fingerprint: parsed.fingerprint,
-    port: parsed.port,
-  };
-}
-
-/** remoteConfig fields the CLI needs to start the egress client. */
-export function buildEgressRemoteConfigFields(
-  handoff: LocalEgressHandoff | null
-): Record<string, string | number> {
-  if (!handoff) {
-    return {};
-  }
-  return {
-    egressUrl: handoff.url,
-    egressToken: handoff.token,
-    egressFingerprint: handoff.fingerprint,
-    egressPort: handoff.port,
-  };
-}
-
-// The egress step returns before the session ends, so the resources it created
-// are held here and released by the session step or the job's finally block.
-let activeLocalEgressResources:
-  | { stopAsync: () => Promise<void>; controller: AbortController; stopping?: Promise<void> }
-  | undefined;
-
-export function registerLocalEgressResources(stopAsync: () => Promise<void>): AbortSignal {
-  if (activeLocalEgressResources) {
-    throw new SystemError('Local egress resources are already registered for this job.');
-  }
-  const controller = new AbortController();
-  activeLocalEgressResources = { stopAsync, controller };
-  return controller.signal;
-}
-
-export async function stopLocalEgressResourcesAsync(logger: bunyan): Promise<void> {
-  const resources = activeLocalEgressResources;
-  if (!resources) {
-    return;
-  }
-  resources.controller.abort();
-  resources.stopping ??= Promise.resolve()
-    .then(resources.stopAsync)
-    .catch(err => logger.warn({ err }, 'Could not stop a local egress resource.'))
-    .finally(() => {
-      activeLocalEgressResources = undefined;
-    });
-  await resources.stopping;
-}
-
-export async function isPortListeningAsync({
-  host,
-  port,
-  timeoutMs = 1_000,
-}: {
-  host: string;
-  port: number;
-  timeoutMs?: number;
-}): Promise<boolean> {
-  return await new Promise<boolean>(resolve => {
-    const socket = net.connect({ host, port });
-    const finish = (listening: boolean): void => {
-      socket.destroy();
-      resolve(listening);
-    };
-    socket.setTimeout(timeoutMs, () => finish(false));
-    socket.once('connect', () => finish(true));
-    socket.once('error', () => finish(false));
-  });
-}
-
-export function parseExitIpResponse(body: string): string {
-  const parsed = JSON.parse(body) as { ip?: unknown };
-  if (typeof parsed.ip !== 'string' || parsed.ip.length === 0) {
-    throw new SystemError(`Unexpected exit IP response: ${body}`);
-  }
-  return parsed.ip;
-}
-
-export async function fetchExitIpThroughProxyAsync({
-  port,
-  env,
-}: {
-  port: number;
-  env: BuildStepEnv;
-}): Promise<string> {
-  const result = await spawn(
-    'curl',
-    [
-      '-sS',
-      '--max-time',
-      '10',
-      '-x',
-      `http://${LOCAL_EGRESS_PROXY_HOST}:${port}`,
-      'https://api.ipify.org?format=json',
-    ],
-    { env, stdio: 'pipe' }
-  );
-  return parseExitIpResponse(result.stdout);
-}
-
-/**
- * Processes inside the simulator run on the host as descendants of launchd_sim,
- * so `ps -axo pid=,ppid=,comm=` ancestry identifies them. Returns every
- * descendant pid; launchd_sim itself opens no network connections.
- */
-export function collectSimulatorProcessIds(psOutput: string): number[] {
-  const childrenByParent = new Map<number, number[]>();
-  const roots: number[] = [];
-  for (const line of psOutput.split('\n')) {
-    const match = /^\s*(\d+)\s+(\d+)\s+(\S.*)$/.exec(line);
-    if (!match) {
-      continue;
-    }
-    const pid = Number(match[1]);
-    const parentPid = Number(match[2]);
-    const command = match[3].trim();
-    const siblings = childrenByParent.get(parentPid) ?? [];
-    siblings.push(pid);
-    childrenByParent.set(parentPid, siblings);
-    if (path.basename(command) === 'launchd_sim') {
-      roots.push(pid);
-    }
-  }
-
-  const descendants: number[] = [];
-  const seen = new Set<number>(roots);
-  const queue = [...roots];
-  for (let i = 0; i < queue.length; i++) {
-    for (const child of childrenByParent.get(queue[i]) ?? []) {
-      if (seen.has(child)) {
-        continue;
-      }
-      seen.add(child);
-      descendants.push(child);
-      queue.push(child);
-    }
-  }
-  return descendants;
-}
-
-export type DirectSimulatorConnection = {
-  pid: number;
-  command: string;
-  protocol: string;
-  /** Remote peer as lsof prints it, e.g. `93.184.216.34:443` or `[2606::1]:443`. */
-  remote: string;
-};
-
-function remoteHostOf(remote: string): string {
-  if (remote.startsWith('[')) {
-    const end = remote.indexOf(']');
-    return end === -1 ? remote : remote.slice(1, end);
-  }
-  const colon = remote.lastIndexOf(':');
-  return colon === -1 ? remote : remote.slice(0, colon);
-}
-
-function isLoopbackHost(host: string): boolean {
-  return (
-    host === 'localhost' || host.startsWith('127.') || host === '::1' || host === '::ffff:127.0.0.1'
-  );
-}
-
-/**
- * Parse `lsof -nP -i -F pcPnT` output. Returns the TCP and UDP connections that
- * simulator processes hold to peers outside loopback. Those did not go through
- * the proxy on 127.0.0.1, so they exit from this host instead of the egress
- * client. Listening sockets, unconnected UDP sockets and connections to
- * loopback (the proxy itself) are ignored.
- */
-export function parseDirectSimulatorConnections(
-  lsofOutput: string,
-  simulatorPids: ReadonlySet<number>
-): DirectSimulatorConnection[] {
-  const connections: DirectSimulatorConnection[] = [];
-  let pid: number | null = null;
-  let command = '';
-  let protocol: string | null = null;
-  let name: string | null = null;
-  let tcpState: string | null = null;
-
-  const flush = (): void => {
-    if (pid !== null && simulatorPids.has(pid) && protocol && name) {
-      const arrow = name.indexOf('->');
-      const remote = arrow === -1 ? null : name.slice(arrow + 2);
-      const active =
-        protocol !== 'TCP' ||
-        tcpState === null ||
-        tcpState === 'ESTABLISHED' ||
-        tcpState === 'SYN_SENT';
-      if (remote && active && !isLoopbackHost(remoteHostOf(remote))) {
-        connections.push({ pid, command, protocol, remote });
-      }
-    }
-    protocol = null;
-    name = null;
-    tcpState = null;
-  };
-
-  for (const line of lsofOutput.split('\n')) {
-    const field = line[0];
-    const value = line.slice(1);
-    switch (field) {
-      case 'p':
-        flush();
-        pid = Number(value);
-        command = '';
-        break;
-      case 'c':
-        command = value;
-        break;
-      case 'f':
-        flush();
-        break;
-      case 'P':
-        protocol = value;
-        break;
-      case 'n':
-        name = value;
-        break;
-      case 'T':
-        if (value.startsWith('ST=')) {
-          tcpState = value.slice('ST='.length);
-        }
-        break;
-      default:
-        break;
-    }
-  }
-  flush();
-  return connections;
-}
-
-async function findDirectSimulatorConnectionsAsync({
-  env,
-}: {
-  env: BuildStepEnv;
-}): Promise<DirectSimulatorConnection[]> {
-  const ps = await spawn('ps', ['-axo', 'pid=,ppid=,comm='], { env, stdio: 'pipe' });
-  const pids = collectSimulatorProcessIds(ps.stdout);
-  if (pids.length === 0) {
-    return [];
-  }
-  let lsofOutput: string;
-  try {
-    const lsof = await spawn('lsof', ['-nP', '-i', '-F', 'pcPnT', '-a', '-p', pids.join(',')], {
-      env,
-      stdio: 'pipe',
-    });
-    lsofOutput = lsof.stdout;
-  } catch (err) {
-    // lsof exits with 1 when none of the processes holds a matching socket, and
-    // when one of them exited between `ps` and `lsof`. Its stdout is still valid.
-    const result = err as { status?: number | null; stdout?: string };
-    if (result.status !== 1) {
-      throw err;
-    }
-    lsofOutput = result.stdout ?? '';
-  }
-  return parseDirectSimulatorConnections(lsofOutput, new Set(pids));
-}
-
-/**
- * Log proxy listener availability, the exit IP observed by a worker request
- * through it, and simulator connections that bypassed the proxy. Neither check
- * verifies that proxied simulator requests reach the egress client. Never
- * rejects: it runs in the background for the whole session.
- */
-export async function monitorLocalEgressAsync({
-  port,
-  env,
-  logger,
-  signal,
-}: {
-  port: number;
-  env: BuildStepEnv;
-  logger: bunyan;
-  signal: AbortSignal;
-}): Promise<void> {
-  let connected = false;
-  let lastEscapeScanAt = 0;
-  let escapeScanBroken = false;
-  const reportedEscapes = new Set<string>();
-  const lifetimeSignal = activeLocalEgressResources?.controller.signal;
-  try {
-    while (!signal.aborted && !lifetimeSignal?.aborted) {
-      const listening = await isPortListeningAsync({ host: LOCAL_EGRESS_PROXY_HOST, port });
-      if (listening && !connected) {
-        connected = true;
-        logger.info('Local egress proxy listener is available.');
-        try {
-          const exitIp = await fetchExitIpThroughProxyAsync({ port, env });
-          logger.info(
-            `Worker proxy exit-IP check observed ${exitIp}. This does not verify simulator routing.`
-          );
-        } catch (err) {
-          logger.warn(
-            { err },
-            'The local egress proxy listener is available, but the worker exit-IP check through it failed.'
-          );
-        }
-      } else if (!listening && connected) {
-        connected = false;
-        logger.warn(
-          'Local egress proxy listener is unavailable. Proxied HTTP(S) requests fail until it returns.'
-        );
-      }
-
-      if (!escapeScanBroken && Date.now() - lastEscapeScanAt >= EGRESS_ESCAPE_SCAN_INTERVAL_MS) {
-        lastEscapeScanAt = Date.now();
-        try {
-          for (const connection of await findDirectSimulatorConnectionsAsync({ env })) {
-            const key = `${connection.pid}|${connection.protocol}|${connection.remote}`;
-            if (reportedEscapes.has(key)) {
-              continue;
-            }
-            reportedEscapes.add(key);
-            if (reportedEscapes.size > EGRESS_ESCAPE_LOG_LIMIT) {
-              if (reportedEscapes.size === EGRESS_ESCAPE_LOG_LIMIT + 1) {
-                logger.warn(
-                  `Local egress: more than ${EGRESS_ESCAPE_LOG_LIMIT} direct connections were reported; further ones are not logged.`
-                );
-              }
-              continue;
-            }
-            logger.warn(
-              `Local egress: ${connection.command} (pid ${connection.pid}) opened a direct ${connection.protocol} connection to ${connection.remote}, bypassing the system proxy. That traffic exits from this worker, not from the egress client.`
-            );
-          }
-        } catch (err) {
-          escapeScanBroken = true;
-          logger.warn(
-            { err },
-            'Local egress: could not inspect simulator connections. Direct connections that bypass the proxy will not be reported.'
-          );
-        }
-      }
-      await sleepAsync(EGRESS_MONITOR_INTERVAL_MS);
-    }
-  } catch (err) {
-    logger.warn({ err }, 'Local egress monitoring stopped unexpectedly.');
-  }
-}
@@ -1,55 +0,0 @@
-import { type BuildFunction, type BuildStepEnv } from '@expo/steps';
-
-import {
-  buildEgressRemoteConfigFields,
-  monitorLocalEgressAsync,
-  readLocalEgressHandoffAsync,
-  stopLocalEgressResourcesAsync,
-} from './localEgress';
-import { uploadRemoteSessionConfigAsync } from './remoteDeviceRunSession';
-
-/** Release the pre-boot egress resources even if controller startup or teardown fails. */
-export function withLocalEgressSession(
-  fn: NonNullable<BuildFunction['fn']>
-): NonNullable<BuildFunction['fn']> {
-  return async (context, args) => {
-    try {
-      args.signal?.throwIfAborted();
-      await fn(context, args);
-    } finally {
-      await stopLocalEgressResourcesAsync(context.logger);
-    }
-  };
-}
-
-/** All simulator controllers publish the same egress handoff and run the same monitor. */
-export async function uploadRemoteSessionConfigWithLocalEgressAsync({
-  env,
-  signal,
-  ...options
-}: Parameters<typeof uploadRemoteSessionConfigAsync>[0] & {
-  env: BuildStepEnv;
-  signal?: AbortSignal;
-}): Promise<void> {
-  // Written by start_local_egress before simulator boot; absent for ordinary sessions.
-  const localEgress = await readLocalEgressHandoffAsync();
-  signal?.throwIfAborted();
-  await uploadRemoteSessionConfigAsync({
-    ...options,
-    remoteConfig: { ...options.remoteConfig, ...buildEgressRemoteConfigFields(localEgress) },
-  });
-  if (localEgress && !signal?.aborted) {
-    options.logger.info(
-      'Local egress: waiting for the EAS CLI egress client to connect. Proxied HTTP(S) ' +
-        'requests are unavailable until it does.'
-    );
-    // The monitor also observes the registered resources' lifetime signal, which
-    // withLocalEgressSession aborts on success, failure, or cancellation.
-    void monitorLocalEgressAsync({
-      port: localEgress.port,
-      env,
-      logger: options.logger,
-      signal: signal ?? new AbortController().signal,
-    });
-  }
-}
@@ -10,26 +10,20 @@ import { z } from 'zod';
 import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import { createServer } from 'node:net';
-import { clearTimeout, setTimeout } from 'node:timers';
 import { setTimeout as setTimeoutAsync } from 'node:timers/promises';

 import { CustomBuildContext } from '../../customBuildContext';
 import { Sentry } from '../../sentry';
 import { sleepAsync } from '../../utils/retry';
 import { turtleFetch } from '../../utils/turtleFetch';
-import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';

 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
-const WEB_PREVIEW_HOST = '127.0.0.1';
-const SERVE_SIM_PACKAGE_NAME = '@expo/serve-sim';
-const SERVE_SIM_MAX_DIMENSION = '960';
+const SERVE_SIM_PACKAGE_SPEC = '@expo/serve-sim@latest';
+const SERVE_SIM_HOST = '127.0.0.1';
+const SERVE_SIM_MAX_DIMENSION = '1280';
 const SERVE_SIM_MJPEG_QUALITY = '0.55';
-const SERVE_SIM_VIDEO_BITRATE = '6000000';
+const SERVE_SIM_VIDEO_BITRATE = '3000000';
 const SERVE_SIM_VIDEO_FPS = '60';
-const EXPO_DEVICE_HUB_PACKAGE_NAME = 'expo-device-hub';
-const EXPO_DEVICE_HUB_MAX_DIMENSION = '960';
-const EXPO_DEVICE_HUB_VIDEO_BITRATE = '6000000';
-const EXPO_DEVICE_HUB_VIDEO_FPS = '60';

 const START_DEVICE_RUN_SESSION_MUTATION = graphql(`
  mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
@@ -150,107 +144,77 @@ export async function waitForDeviceRunSessionStoppedAsync({
  ctx,
  deviceRunSessionId,
  logger,
-  maxDurationSeconds,
-  signal: cancelSignal,
+  signal,
  idleTimeout,
 }: {
  ctx: CustomBuildContext;
  deviceRunSessionId: string;
  logger: bunyan;
-  maxDurationSeconds?: number;
  signal?: AbortSignal;
  idleTimeout?: DeviceRunSessionIdleTimeout;
 }): Promise<void> {
-  const durationAbortController = new AbortController();
-  const signal = cancelSignal
-    ? AbortSignal.any([cancelSignal, durationAbortController.signal])
-    : durationAbortController.signal;
-  // Nothing to wait for if the step was already aborted before we started;
-  // return before logging so we don't claim to be polling a session we never poll.
-  if (signal.aborted) {
-    return;
-  }
-  const durationTimeout =
-    maxDurationSeconds === undefined
-      ? undefined
-      : setTimeout(() => {
-          logger.info(`Device run session ${deviceRunSessionId} reached its maximum duration.`);
-          durationAbortController.abort();
-        }, maxDurationSeconds * 1_000);
-
-  try {
+  logger.info(
+    `Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`
+  );
+  if (idleTimeout) {
    logger.info(
-      `Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`
+      `The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`
    );
-    if (durationTimeout !== undefined) {
-      logger.info(
-        `The device run session will stop automatically after ${maxDurationSeconds} seconds.`
-      );
-    }
+  }
+  let pollErrorCount = 0;
+  let lastActivityAt = new Date();
+
+  while (!signal?.aborted) {
    if (idleTimeout) {
-      logger.info(
-        `The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`
-      );
-    }
-    let pollErrorCount = 0;
-    let lastActivityAt = new Date();
-
-    while (!signal.aborted) {
-      if (idleTimeout) {
-        const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
-        if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
-          lastActivityAt = lastEventObservedAt;
-        }
-        if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
-          logger.info(
-            `Device run session ${deviceRunSessionId} had no activity for ` +
-              `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`
-          );
-          await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
-          return;
-        }
+      const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
+      if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
+        lastActivityAt = lastEventObservedAt;
      }
-      try {
-        const result = await ctx.graphqlClient
-          .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
-          .toPromise();
-        if (result.error) {
-          throw result.error;
-        }
-
-        const status = result.data?.deviceRunSessions?.byId?.status;
-        if (!status) {
-          throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
-        }
-        pollErrorCount = 0;
-        if (status === 'STOPPED') {
-          logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
-          return;
-        }
-        if (status === 'ERRORED') {
-          throw new SystemError(`Device run session ${deviceRunSessionId} errored.`);
-        }
-      } catch (err) {
-        if (err instanceof SystemError) {
-          throw err;
-        }
-
-        const error = err instanceof Error ? err : new Error(String(err));
-        pollErrorCount += 1;
-        if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
-          Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
-          logger.warn(
-            { err: error, failedStatusPollCount: pollErrorCount },
-            'Could not poll device run session status; will retry.'
-          );
-        }
+      if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
+        logger.info(
+          `Device run session ${deviceRunSessionId} had no activity for ` +
+            `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`
+        );
+        await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
+        return;
      }
-      await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
    }
-  } finally {
-    if (durationTimeout !== undefined) {
-      clearTimeout(durationTimeout);
+    try {
+      const result = await ctx.graphqlClient
+        .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
+        .toPromise();
+      if (result.error) {
+        throw result.error;
+      }
+
+      const status = result.data?.deviceRunSessions?.byId?.status;
+      if (!status) {
+        throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+      }
+      pollErrorCount = 0;
+      if (status === 'STOPPED') {
+        logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
+        return;
+      }
+      if (status === 'ERRORED') {
+        throw new SystemError(`Device run session ${deviceRunSessionId} errored.`);
+      }
+    } catch (err) {
+      if (err instanceof SystemError) {
+        throw err;
+      }
+
+      const error = err instanceof Error ? err : new Error(String(err));
+      pollErrorCount += 1;
+      if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
+        Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
+        logger.warn(
+          { err: error, failedStatusPollCount: pollErrorCount },
+          'Could not poll device run session status; will retry.'
+        );
+      }
    }
+    await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
  }
 }

@@ -298,9 +262,10 @@ async function sleepUntilAbortedAsync(
  }
 }

-// Device-session tools resolve `ffmpeg` from PATH. Spawning it with the step's
-// environment rejects with ENOENT when the binary is absent, and running it also
-// proves that the installed binary works.
+// Argent encodes screen recordings by piping simulator frames into `ffmpeg`,
+// which it resolves from PATH. The tool-server inherits this step's env, so
+// spawning ffmpeg resolves against the same PATH argent will search: it rejects
+// with ENOENT when the binary is absent, and running it also proves it works.
 async function isFfmpegAvailableAsync(env: BuildStepEnv): Promise<boolean> {
  return (await asyncResult(spawn('ffmpeg', ['-version'], { env }))).ok;
 }
@@ -333,15 +298,14 @@ async function installFfmpegWithAptAsync({
  await spawn('sudo', ['apt-get', 'install', '-y', 'ffmpeg'], { env: aptEnv, logger });
 }

-let ffmpegSetupPromise: Promise<void> | undefined;
-
 /**
- * Install ffmpeg when the runtime does not already provide it. Device-session
- * tools use it for video encoding on macOS (iOS simulators) and Linux (Android
- * emulators) alike, but the worker images do not ship it yet.
+ * Install ffmpeg when the runtime does not already provide it, so argent's
+ * `screen-recording-start` tool can encode a video. The worker images do not
+ * ship ffmpeg yet, so without this the tool fails with "`ffmpeg` was not found
+ * on PATH" — on macOS (iOS simulators) and Linux (Android emulators) alike.
 *
- * Best-effort by design: a failure here is logged and the session continues
- * without FFmpeg-dependent features.
+ * Best-effort by design: screen recording is one optional argent tool, so a
+ * failure here is logged and the session continues without it.
 *
 * The whole body is wrapped because the caller runs this in the background with
 * `void`. There is no unhandledRejection handler in the worker, so a rejection
@@ -349,7 +313,7 @@ let ffmpegSetupPromise: Promise<void> | undefined;
 * `spawn` is not an async function and can throw synchronously, which
 * `asyncResult` cannot catch — it only wraps an already-created promise.
 */
-async function ensureFfmpegInstalledAsync({
+export async function ensureFfmpegInstalledAsync({
  runtimePlatform,
  env,
  logger,
@@ -368,7 +332,7 @@ async function ensureFfmpegInstalledAsync({
    logger.info(
      `ffmpeg is not installed, installing it with ${
        isDarwin ? 'Homebrew' : 'apt'
-      } for the device session.`
+      } for argent screen recording.`
    );
    if (isDarwin) {
      await installFfmpegWithHomebrewAsync({ env, logger });
@@ -378,41 +342,16 @@ async function ensureFfmpegInstalledAsync({
    logger.info('Installed ffmpeg.');
  } catch (err) {
    const error = err instanceof Error ? err : new Error(String(err));
-    Sentry.capture('Could not install ffmpeg for the device session', error, {
+    Sentry.capture('Could not install ffmpeg for argent screen recording', error, {
      level: 'warning',
    });
    logger.warn(
      { err: error },
-      'Could not install ffmpeg. FFmpeg-dependent features may not work in this session.'
+      'Could not install ffmpeg. Argent screen recording will not work in this session.'
    );
  }
 }

-export async function ensureFfmpegInstalledOnceAsync({
-  runtimePlatform,
-  env,
-  logger,
-}: {
-  runtimePlatform: BuildRuntimePlatform;
-  env: BuildStepEnv;
-  logger: bunyan;
-}): Promise<void> {
-  if (ffmpegSetupPromise) {
-    await ffmpegSetupPromise;
-    return;
-  }
-
-  const setupPromise = ensureFfmpegInstalledAsync({ runtimePlatform, env, logger });
-  ffmpegSetupPromise = setupPromise;
-  try {
-    await setupPromise;
-  } finally {
-    if (ffmpegSetupPromise === setupPromise) {
-      ffmpegSetupPromise = undefined;
-    }
-  }
-}
-
 const TurnIceServersResponseSchema = z.object({
  data: z.object({
    iceServers: TurnIceServersSchema,
@@ -420,12 +359,11 @@ const TurnIceServersResponseSchema = z.object({
 });

 /**
- * Translate Cloudflare ICE servers into web preview CLI flags: `--stun-url` (the
+ * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
 * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
- * (the entry carrying the short-lived credentials). serve-sim and expo-device-hub
- * intentionally expose the same ICE flag contract.
+ * (the entry carrying the short-lived credentials).
 */
-export function turnIceServersToWebPreviewArgs(iceServers: TurnIceServers): string[] {
+export function turnIceServersToServeSimArgs(iceServers: TurnIceServers): string[] {
  const stunUrls = iceServers
    .filter(server => !server.username && !server.credential)
    .flatMap(server => server.urls);
@@ -451,14 +389,14 @@ export function turnIceServersToWebPreviewArgs(iceServers: TurnIceServers): stri
 /**
 * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
 * (minted on demand, mirroring how the worker fetches project clone URLs) and
- * translate them into web preview CLI flags.
+ * translate them into serve-sim CLI flags.
 *
- * Best-effort: on any failure we log and return [] so the preview server falls
- * back to its built-in P2P/STUN behavior. The credential is passed as a process
- * arg and deliberately not logged (turtle-spawn never logs argv and the worker
- * is single-tenant).
+ * Best-effort: on any failure we log and return [] so serve-sim falls back to
+ * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
+ * process arg and deliberately not logged (turtle-spawn never logs argv and the
+ * worker is single-tenant).
 */
-export async function fetchWebPreviewTurnArgsAsync(
+export async function fetchServeSimTurnArgsAsync(
  ctx: CustomBuildContext,
  { env, logger }: { env: BuildStepEnv; logger: bunyan }
 ): Promise<string[]> {
@@ -487,9 +425,9 @@ export async function fetchWebPreviewTurnArgsAsync(
    );

    const { data } = TurnIceServersResponseSchema.parse(await response.json());
-    const args = turnIceServersToWebPreviewArgs(data.iceServers);
+    const args = turnIceServersToServeSimArgs(data.iceServers);
    if (args.length > 0) {
-      logger.info('Configured the web preview with Cloudflare TURN ICE servers.');
+      logger.info('Configured serve-sim with Cloudflare TURN ICE servers.');
    }
    return args;
  } catch (err) {
@@ -497,7 +435,7 @@ export async function fetchWebPreviewTurnArgsAsync(
    Sentry.capture('Could not fetch Cloudflare TURN ICE servers', error, { level: 'warning' });
    logger.warn(
      { err: error },
-      'Could not fetch Cloudflare TURN ICE servers; the web preview will fall back to P2P/STUN.'
+      'Could not fetch Cloudflare TURN ICE servers; serve-sim will fall back to P2P/STUN.'
    );
    return [];
  }
@@ -627,33 +565,22 @@ export function metricsCorsOriginToServeSimArgs(env: BuildStepEnv): string[] {
  return args;
 }

-function createServeSimPackageSpec(packageVersion: string | undefined): string {
-  return `${SERVE_SIM_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
-}
-
-function createExpoDeviceHubPackageSpec(packageVersion: string | undefined): string {
-  return `${EXPO_DEVICE_HUB_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
-}
-
 export function createServeSimArgs({
  port,
  turnArgs = [],
  metricsCorsArgs = [],
-  packageVersion,
 }: {
  port: number;
  turnArgs?: string[];
  metricsCorsArgs?: string[];
-  packageVersion?: string;
 }): string[] {
  return [
    '--yes',
-    createServeSimPackageSpec(packageVersion),
+    SERVE_SIM_PACKAGE_SPEC,
    '--port',
    String(port),
    '--host',
-    WEB_PREVIEW_HOST,
-    '--require-token',
+    SERVE_SIM_HOST,
    '--transport',
    'webrtc',
    '--webrtc-codec',
@@ -671,84 +598,44 @@ export function createServeSimArgs({
  ];
 }

-export function createExpoDeviceHubArgs({
-  port,
-  turnArgs = [],
-  packageVersion,
-}: {
-  port: number;
-  turnArgs?: string[];
-  packageVersion?: string;
-}): string[] {
-  return [
-    '--yes',
-    createExpoDeviceHubPackageSpec(packageVersion),
-    '--port',
-    String(port),
-    '--host',
-    WEB_PREVIEW_HOST,
-    '--platform',
-    'android',
-    '--transport',
-    'webrtc',
-    '--webrtc-codec',
-    'h264',
-    '--webrtc-ice-policy',
-    'all',
-    '--max-dimension',
-    EXPO_DEVICE_HUB_MAX_DIMENSION,
-    '--video-bitrate',
-    EXPO_DEVICE_HUB_VIDEO_BITRATE,
-    '--video-fps',
-    EXPO_DEVICE_HUB_VIDEO_FPS,
-    '--hide-sidebar',
-    '--hide-boot-device',
-    ...turnArgs,
-  ];
-}
-
-export async function findAvailablePortAsync(): Promise<number> {
+async function findAvailablePortAsync(): Promise<number> {
  const server = createServer();
  server.unref();
  await new Promise<void>((resolve, reject) => {
    server.once('error', reject);
-    server.listen(0, WEB_PREVIEW_HOST, () => resolve());
+    server.listen(0, SERVE_SIM_HOST, () => resolve());
  });
  const address = server.address();
  await new Promise<void>((resolve, reject) => {
    server.close(err => (err ? reject(err) : resolve()));
  });
  if (!address || typeof address === 'string') {
-    throw new SystemError('Could not allocate a local port for the web preview.');
+    throw new SystemError('Could not allocate a local port for serve-sim.');
  }
  return address.port;
 }

-const WebPreviewReadyResponseSchema = z.object({
+const ServeSimReadyResponseSchema = z.object({
  status: z.literal('ready'),
  device: z.string(),
 });

-export async function waitForWebPreviewReadyAsync({
-  previewServer,
-  serverName,
+export async function waitForServeSimReadyAsync({
+  serveSim,
  port,
  timeoutMs,
 }: {
-  previewServer: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
-  serverName: string;
+  serveSim: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
  port: number;
  timeoutMs: number;
-}): Promise<string> {
-  const readyUrl = `http://${WEB_PREVIEW_HOST}:${port}/readyz`;
+}): Promise<void> {
+  const readyUrl = `http://${SERVE_SIM_HOST}:${port}/readyz`;
  const deadline = Date.now() + timeoutMs;
  let lastError: unknown;
  while (Date.now() < deadline) {
-    if (previewServer.pid !== undefined && !isProcessRunning(previewServer.pid)) {
+    if (serveSim.pid !== undefined && !isProcessRunning(serveSim.pid)) {
      throw new SystemError(
-        `${serverName} exited before becoming ready. Last output:\n${
-          previewServer.getOutput() || '<empty>'
-        }`
+        `serve-sim exited before becoming ready. Last output:\n${serveSim.getOutput() || '<empty>'}`
      );
    }
    try {
@@ -756,102 +643,25 @@ export async function waitForWebPreviewReadyAsync({
        retries: 0,
        timeout: 2_000,
      });
-      const ready = WebPreviewReadyResponseSchema.parse(await response.json());
-      return ready.device;
+      ServeSimReadyResponseSchema.parse(await response.json());
+      return;
    } catch (error) {
      lastError = error;
    }
    await sleepAsync(1_000);
  }
  throw new SystemError(
-    `Timed out waiting for ${serverName} readiness at ${readyUrl}${
+    `Timed out waiting for serve-sim readiness at ${readyUrl}${
      lastError instanceof Error ? `: ${lastError.message}` : ''
-    }. Last output:\n${previewServer.getOutput() || '<empty>'}`
+    }. Last output:\n${serveSim.getOutput() || '<empty>'}`
  );
 }

-export type DeviceWebPreviewHandle = {
+export type ServeSimPreviewHandle = {
  previewUrl: string;
-  /** Session token gating the preview. Only serve-sim mints one. */
-  previewToken?: string;
  stopAsync: () => Promise<void>;
 };

-export type ServeSimPreviewHandle = DeviceWebPreviewHandle;
-
-async function startWebPreviewWithTunnelAsync(
-  ctx: CustomBuildContext,
-  {
-    baseDomain,
-    env,
-    logger,
-    timeoutMs,
-    serverName,
-    packageSpec,
-    createArgs,
-    readPreviewTokenAsync,
-  }: {
-    baseDomain: string;
-    env: BuildStepEnv;
-    logger: bunyan;
-    timeoutMs: number;
-    serverName: string;
-    packageSpec: string;
-    createArgs: (port: number, turnArgs: string[]) => string[];
-    readPreviewTokenAsync?: (device: string) => Promise<string>;
-  }
-): Promise<DeviceWebPreviewHandle> {
-  const port = await findAvailablePortAsync();
-  logger.info(`Launching ${packageSpec} on ${WEB_PREVIEW_HOST}:${port}.`);
-  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { env, logger });
-  const previewServer = spawnDetached({
-    command: 'npx',
-    args: createArgs(port, turnArgs),
-    env,
-  });
-
-  try {
-    logger.info(`Waiting for ${serverName} to become ready.`);
-    const device = await waitForWebPreviewReadyAsync({
-      previewServer,
-      serverName,
-      port,
-      timeoutMs,
-    });
-    const previewToken = await readPreviewTokenAsync?.(device);
-    const tunnel = await startNgrokTunnelAsync({
-      port,
-      subdomainPrefix: 'web-preview',
-      baseDomain,
-      authtoken: getNgrokAuthtokenOrThrow(env),
-      logger,
-    });
-    return {
-      previewUrl: tunnel.url,
-      previewToken,
-      stopAsync: async () => {
-        const results = await Promise.allSettled([tunnel.stopAsync(), previewServer.stopAsync()]);
-        for (const result of results) {
-          if (result.status === 'rejected') {
-            logger.warn({ err: result.reason }, `Could not stop a ${serverName} preview resource.`);
-          }
-        }
-      },
-    };
-  } catch (error) {
-    await previewServer.stopAsync();
-    throw error;
-  }
-}
-
-export async function readServeSimPreviewTokenAsync(
-  udid: string,
-  stateDir: string = SERVE_SIM_STATE_DIR
-): Promise<string | undefined> {
-  const servers = await readServeSimServersAsync(stateDir);
-  return servers.find(server => server.udid === udid)?.token;
-}
-
 export async function startServeSimWithTunnelAsync(
  ctx: CustomBuildContext,
  {
@@ -859,93 +669,47 @@ export async function startServeSimWithTunnelAsync(
    env,
    logger,
    timeoutMs,
-    packageVersion,
  }: {
    baseDomain: string;
    env: BuildStepEnv;
    logger: bunyan;
    timeoutMs: number;
-    packageVersion?: string;
  }
 ): Promise<ServeSimPreviewHandle> {
+  const port = await findAvailablePortAsync();
+  logger.info(`Launching ${SERVE_SIM_PACKAGE_SPEC} on ${SERVE_SIM_HOST}:${port}.`);
+  const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
  const metricsCorsArgs = metricsCorsOriginToServeSimArgs(env);
-  return await startWebPreviewWithTunnelAsync(ctx, {
-    baseDomain,
+  const serveSim = spawnDetached({
+    command: 'npx',
+    args: createServeSimArgs({ port, turnArgs, metricsCorsArgs }),
    env,
-    logger,
-    timeoutMs,
-    serverName: 'serve-sim',
-    packageSpec: createServeSimPackageSpec(packageVersion),
-    createArgs: (port, turnArgs) =>
-      createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion }),
-    readPreviewTokenAsync: async device => {
-      const previewToken = await readServeSimPreviewTokenAsync(device);
-      if (!previewToken) {
-        // A serve-sim that does not know --require-token fails earlier, in the readiness check, so
-        // reaching here means it started and left no token in its state file.
-        throw new SystemError(
-          `serve-sim became ready but wrote no session token for device ${device}. The preview is ` +
-            'on a public tunnel and would be reachable without one, so the session cannot continue. ' +
-            'This usually means the state file was not written as expected; retry the session, and ' +
-            'report it if it repeats.'
-        );
-      }
-      return previewToken;
-    },
  });
-}

-export async function startExpoDeviceHubWithTunnelAsync(
-  ctx: CustomBuildContext,
-  {
-    runtimePlatform,
-    baseDomain,
-    env,
-    logger,
-    timeoutMs,
-    packageVersion,
-  }: {
-    runtimePlatform: BuildRuntimePlatform;
-    baseDomain: string;
-    env: BuildStepEnv;
-    logger: bunyan;
-    timeoutMs: number;
-    packageVersion?: string;
-  }
-): Promise<DeviceWebPreviewHandle> {
-  if (runtimePlatform === BuildRuntimePlatform.LINUX) {
-    await ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger });
-  }
-  return await startWebPreviewWithTunnelAsync(ctx, {
-    baseDomain,
-    env,
-    logger,
-    timeoutMs,
-    serverName: 'expo-device-hub',
-    packageSpec: createExpoDeviceHubPackageSpec(packageVersion),
-    createArgs: (port, turnArgs) => createExpoDeviceHubArgs({ port, turnArgs, packageVersion }),
-  });
-}
-
-export async function startDeviceWebPreviewWithTunnelAsync(
-  ctx: CustomBuildContext,
-  {
-    runtimePlatform,
-    ...options
-  }: {
-    runtimePlatform: BuildRuntimePlatform;
-    baseDomain: string;
-    env: BuildStepEnv;
-    logger: bunyan;
-    timeoutMs: number;
-    packageVersion?: string;
-  }
-): Promise<DeviceWebPreviewHandle> {
-  switch (runtimePlatform) {
-    case BuildRuntimePlatform.DARWIN:
-      return await startServeSimWithTunnelAsync(ctx, options);
-    case BuildRuntimePlatform.LINUX:
-      return await startExpoDeviceHubWithTunnelAsync(ctx, { ...options, runtimePlatform });
+  try {
+    logger.info('Waiting for serve-sim to become ready.');
+    await waitForServeSimReadyAsync({ serveSim, port, timeoutMs });
+    const tunnel = await startNgrokTunnelAsync({
+      port,
+      subdomainPrefix: 'serve-sim',
+      baseDomain,
+      authtoken: getNgrokAuthtokenOrThrow(env),
+      logger,
+    });
+    return {
+      previewUrl: tunnel.url,
+      stopAsync: async () => {
+        const results = await Promise.allSettled([tunnel.stopAsync(), serveSim.stopAsync()]);
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            logger.warn({ err: result.reason }, 'Could not stop a serve-sim preview resource.');
+          }
+        }
+      },
+    };
+  } catch (error) {
+    await serveSim.stopAsync();
+    throw error;
  }
 }

@@ -13,9 +13,9 @@ const POLL_INTERVAL_MS = 2_000;
 const MAX_CONSECUTIVE_STREAM_FAILURES_PER_DEVICE = 10;
 const END_STREAM_TIMEOUT_MS = 2_000;
 // serve-sim's own per-device registry while serving: `${tmpdir}/serve-sim/server-<udid>.json`.
-export const SERVE_SIM_STATE_DIR = path.join(os.tmpdir(), 'serve-sim');
+const SERVE_SIM_STATE_DIR = path.join(os.tmpdir(), 'serve-sim');

-type ServeSimServer = { udid: string; url: string; token?: string };
+type ServeSimServer = { udid: string; url: string };

 type ServeSimMetricsSession = {
  logger: bunyan;
@@ -130,7 +130,6 @@ async function pollServeSimMetricsAsync(session: ServeSimMetricsSession): Promis
      logger.info(`Collecting serve-sim metrics for ${server.udid}.`);
      const donePromise = streamServeSimMetricsToFileAsync({
        serveSimUrl: server.url,
-        serveSimToken: server.token,
        filePath,
        signal: streamSignal,
        logger,
@@ -173,14 +172,9 @@ export async function readServeSimServersAsync(stateDir: string): Promise<ServeS
      const state = JSON.parse(await readFile(path.join(stateDir, entry), 'utf-8')) as {
        device?: unknown;
        url?: unknown;
-        token?: unknown;
      };
      if (typeof state.device === 'string' && typeof state.url === 'string') {
-        servers.push({
-          udid: state.device,
-          url: state.url,
-          ...(typeof state.token === 'string' ? { token: state.token } : {}),
-        });
+        servers.push({ udid: state.device, url: state.url });
      }
    } catch {
      continue;
@@ -191,13 +185,11 @@ export async function readServeSimServersAsync(stateDir: string): Promise<ServeS

 export async function streamServeSimMetricsToFileAsync({
  serveSimUrl,
-  serveSimToken,
  filePath,
  signal,
  logger,
 }: {
  serveSimUrl: string;
-  serveSimToken?: string;
  filePath: string;
  signal: AbortSignal;
  logger: bunyan;
@@ -209,10 +201,7 @@ export async function streamServeSimMetricsToFileAsync({
  let receivedData = false;
  let metadata: Record<string, unknown> | undefined;
  try {
-    const response = await fetch(new URL('/metrics', serveSimUrl).toString(), {
-      signal,
-      ...(serveSimToken ? { headers: { Authorization: `Bearer ${serveSimToken}` } } : {}),
-    });
+    const response = await fetch(new URL('/metrics', serveSimUrl).toString(), { signal });
    if (!response.ok || !response.body) {
      logger.warn(`serve-sim /metrics responded ${response.status} for ${serveSimUrl}.`);
      return { receivedData, metadata };
@@ -6,13 +6,11 @@ import assert from 'assert';
 import FastGlob from 'fast-glob';
 import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
-import { Socket } from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import { setTimeout } from 'node:timers/promises';
 import { z } from 'zod';

-import { Sentry } from '../sentry';
 import { retryAsync } from './retry';

 /** Android Virtual Device is the device we run. */
@@ -99,18 +97,12 @@ export namespace AndroidEmulatorUtils {
    deviceName,
    systemImagePackage,
    deviceIdentifier,
-    lcdWidth,
-    lcdHeight,
-    lcdDensity,
    env,
    logger,
  }: {
    deviceName: AndroidVirtualDeviceName;
    systemImagePackage: string;
    deviceIdentifier: AndroidDeviceName | null;
-    lcdWidth: number | null;
-    lcdHeight: number | null;
-    lcdDensity: number | null;
    env: NodeJS.ProcessEnv;
    logger: bunyan;
  }): Promise<void> {
@@ -182,13 +174,6 @@ export namespace AndroidEmulatorUtils {
        }
      }

-      if (lcdWidth !== null && lcdHeight !== null && lcdDensity !== null) {
-        logger.info(
-          `Setting screen resolution to ${lcdWidth}x${lcdHeight} and density to ${lcdDensity} ppi.`
-        );
-        configIniFileContent = `${configIniFileContent}\nhw.lcd.height=${lcdHeight}\nhw.lcd.width=${lcdWidth}\nhw.lcd.density=${lcdDensity}\n`;
-      }
-
      const shouldAdjustHeapSize =
        env.ANDROID_EMULATOR_ADJUST_HEAP_SIZE !== 'false' &&
        env.ANDROID_EMULATOR_ADJUST_HEAP_SIZE !== '0';
@@ -320,23 +305,21 @@ export namespace AndroidEmulatorUtils {
    emulatorPromise: SpawnPromise<SpawnResult>;
    serialId: AndroidDeviceSerialId;
    logcatOutputPath: string;
-    emulatorOutputPath: string;
  }> {
    let logcatOutputPath: string;
-    let emulatorOutputPath: string;
    try {
      await fs.promises.mkdir(logcatDirectory, { recursive: true });
      const safeDeviceName = deviceName.replace(/[^a-zA-Z0-9_.-]/g, '_');
      const timestamp = Math.floor(Date.now() / 1000)
        .toString(16)
        .padStart(8, '0');
-      const outputName = `${safeDeviceName}-${timestamp}-${randomBytes(2).toString('hex')}`;
-      logcatOutputPath = path.join(logcatDirectory, `${outputName}-logcat.log`);
-      emulatorOutputPath = path.join(logcatDirectory, `${outputName}-emulator.log`);
+      logcatOutputPath = path.join(
+        logcatDirectory,
+        `${safeDeviceName}-${timestamp}-${randomBytes(2).toString('hex')}.log`
+      );
      await fs.promises.writeFile(logcatOutputPath, '');
-      await fs.promises.writeFile(emulatorOutputPath, '');
    } catch (err) {
-      throw new SystemError(`Failed to prepare Android emulator output for ${deviceName}.`, {
+      throw new SystemError(`Failed to prepare Android emulator logcat output for ${deviceName}.`, {
        cause: err,
      });
    }
@@ -363,8 +346,7 @@ export namespace AndroidEmulatorUtils {
      ],
      {
        detached: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        ignoreStdio: true,
+        stdio: 'inherit',
        env: {
          ...env,
          // We don't need to wait for emulator to exit gracefully.
@@ -372,43 +354,6 @@ export namespace AndroidEmulatorUtils {
        },
      }
    );
-    const emulatorOutputStream = fs.createWriteStream(emulatorOutputPath, { flags: 'a' });
-    let reportedEmulatorOutputError = false;
-    emulatorOutputStream.on('error', err => {
-      process.stderr.write(
-        `Failed to write Android emulator output to ${emulatorOutputPath}: ${err}\n`
-      );
-      if (!reportedEmulatorOutputError) {
-        reportedEmulatorOutputError = true;
-        Sentry.capture('Failed to write Android emulator process output', err, {
-          level: 'warning',
-          tags: {
-            errorCode: (err as NodeJS.ErrnoException).code ?? 'unknown',
-          },
-          extras: {
-            deviceName,
-            emulatorOutputPath,
-          },
-        });
-      }
-    });
-    // Only into the log file -- this process' stdout/stderr is not watched or uploaded.
-    emulatorPromise.child.stdout?.pipe(emulatorOutputStream, { end: false });
-    emulatorPromise.child.stderr?.pipe(emulatorOutputStream, { end: false });
-    emulatorPromise.child.once('close', () => {
-      emulatorOutputStream.end();
-    });
-    // Piped stdio creates socket handles in this process which, unlike inherited
-    // file descriptors, keep the event loop alive for as long as the emulator runs.
-    // We never stop the emulator explicitly, so without unref-ing these the process
-    // would never exit on its own -- defeating the `detached` + `unref()` below.
-    // Output is still captured for as long as this process lives.
-    if (emulatorPromise.child.stdout instanceof Socket) {
-      emulatorPromise.child.stdout.unref();
-    }
-    if (emulatorPromise.child.stderr instanceof Socket) {
-      emulatorPromise.child.stderr.unref();
-    }
    // If emulator fails to start, throw its error.
    if (!emulatorPromise.child.pid) {
      await emulatorPromise;
@@ -437,7 +382,7 @@ export namespace AndroidEmulatorUtils {

    // We don't want to await the SpawnPromise here.
    // eslint-disable-next-line @typescript-eslint/return-await
-    return { emulatorPromise, serialId, logcatOutputPath, emulatorOutputPath };
+    return { emulatorPromise, serialId, logcatOutputPath };
  }

  export async function waitForReadyAsync({
@@ -44,32 +44,6 @@ export namespace IosSimulatorUtils {
    };
  };

-  export type IosSimulatorRuntime = {
-    identifier: string;
-    isAvailable?: boolean;
-    version?: string;
-  };
-
-  type XcrunSimctlListRuntimesJsonOutput = {
-    runtimes: (Omit<IosSimulatorRuntime, 'identifier'> & { identifier?: string })[];
-  };
-
-  export async function getAvailableRuntimesAsync({
-    env,
-  }: {
-    env: NodeJS.ProcessEnv;
-  }): Promise<IosSimulatorRuntime[]> {
-    const { stdout } = await spawn('xcrun', ['simctl', 'list', 'runtimes', '--json'], { env });
-    const { runtimes } = JSON.parse(stdout) as XcrunSimctlListRuntimesJsonOutput;
-
-    return runtimes.flatMap(runtime =>
-      runtime.isAvailable !== false &&
-      runtime.identifier?.startsWith('com.apple.CoreSimulator.SimRuntime.iOS-')
-        ? [{ ...runtime, identifier: runtime.identifier }]
-        : []
-    );
-  }
-
  export async function getAvailableDevicesAsync({
    env,
    filter,
@@ -71,9 +71,6 @@ describe('AndroidEmulatorUtils', () => {
        deviceName,
        systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
        deviceIdentifier: null,
-        lcdWidth: null,
-        lcdHeight: null,
-        lcdDensity: null,
        env: process.env,
        logger: createMockLogger({ logToConsole: true }),
      });
@@ -98,9 +95,6 @@ describe('AndroidEmulatorUtils', () => {
      deviceName,
      systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
      deviceIdentifier: null,
-      lcdWidth: null,
-      lcdHeight: null,
-      lcdDensity: null,
      env: process.env,
      logger: createMockLogger({ logToConsole: true }),
    });
@@ -164,9 +158,6 @@ describe('AndroidEmulatorUtils', () => {
      deviceName,
      systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
      deviceIdentifier: null,
-      lcdWidth: null,
-      lcdHeight: null,
-      lcdDensity: null,
      env: process.env,
      logger: createMockLogger({ logToConsole: true }),
    });
@@ -218,9 +209,6 @@ describe('AndroidEmulatorUtils', () => {
            deviceName,
            systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
            deviceIdentifier: null,
-            lcdWidth: null,
-            lcdHeight: null,
-            lcdDensity: null,
            env: envForAttempt,
            logger: createMockLogger({ logToConsole: true }),
          });
@@ -285,7 +273,7 @@ describe('AndroidEmulatorUtils', () => {
    expect(attemptCounter).toBe(2);
  }, 360_000);

-  it('captures emulator and native logcat output across an ADB server restart', async () => {
+  it('captures native logcat output across an ADB server restart', async () => {
    const testLogcatDirectory = await fs.promises.mkdtemp(
      path.join(os.tmpdir(), 'android-emulator-logcat-e2e-')
    );
@@ -302,9 +290,6 @@ describe('AndroidEmulatorUtils', () => {
        deviceName,
        systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
        deviceIdentifier: null,
-        lcdWidth: null,
-        lcdHeight: null,
-        lcdDensity: null,
        env: process.env,
        logger,
      });
@@ -317,21 +302,6 @@ describe('AndroidEmulatorUtils', () => {
      emulatorPromise = asyncResult(startResult.emulatorPromise);

      await AndroidEmulatorUtils.waitForReadyAsync({ serialId, env: process.env });
-      await retryAsync(
-        async () => {
-          const contents = await fs.promises.readFile(startResult.emulatorOutputPath, 'utf-8');
-          if (!contents.includes('Android emulator version')) {
-            throw new Error('Did not find the emulator version in emulator process output yet.');
-          }
-        },
-        {
-          logger,
-          retryOptions: {
-            retries: 10,
-            retryIntervalMs: 1_000,
-          },
-        }
-      );
      await spawn('adb', ['kill-server'], { env: process.env });
      await spawn('adb', ['start-server'], { env: process.env });
      await spawn('adb', ['-s', serialId, 'shell', 'log', '-t', 'EAS_CLI_TEST', marker], {
@@ -376,9 +346,6 @@ describe('AndroidEmulatorUtils', () => {
      deviceName,
      systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
      deviceIdentifier: null,
-      lcdWidth: null,
-      lcdHeight: null,
-      lcdDensity: null,
      env: process.env,
      logger: createMockLogger({ logToConsole: true }),
    });
@@ -1,18 +1,11 @@
 import { SystemError } from '@expo/eas-build-job';
 import spawn from '@expo/turtle-spawn';
-import { EventEmitter, once } from 'node:events';
 import fs from 'node:fs';
-import { Socket } from 'node:net';
 import os from 'node:os';
 import path from 'node:path';

 import { createMockLogger } from '../../__tests__/utils/logger';
-import { Sentry } from '../../sentry';
-import {
-  AndroidDeviceName,
-  AndroidEmulatorUtils,
-  AndroidVirtualDeviceName,
-} from '../AndroidEmulatorUtils';
+import { AndroidEmulatorUtils, AndroidVirtualDeviceName } from '../AndroidEmulatorUtils';
 import { retryAsync } from '../retry';

 jest.mock('@expo/turtle-spawn', () => ({
@@ -24,12 +17,6 @@ jest.mock('../retry', () => ({
  retryAsync: jest.fn(async fn => await fn(0)),
 }));

-jest.mock('../../sentry', () => ({
-  Sentry: {
-    capture: jest.fn(),
-  },
-}));
-
 const mockedSpawn = jest.mocked(spawn);
 const mockedRetryAsync = jest.mocked(retryAsync);

@@ -38,13 +25,11 @@ describe('AndroidEmulatorUtils', () => {

  beforeEach(() => {
    temporaryDirectories = [];
-    jest.mocked(Sentry.capture).mockReset();
    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
    mockedRetryAsync.mockImplementation(async fn => await fn(0));
  });

  afterEach(async () => {
-    jest.restoreAllMocks();
    await Promise.all(
      temporaryDirectories.map(async temporaryDirectory => {
        await fs.promises.rm(temporaryDirectory, { force: true, recursive: true });
@@ -52,134 +37,9 @@ describe('AndroidEmulatorUtils', () => {
    );
  });

-  describe(AndroidEmulatorUtils.createAsync, () => {
-    it('applies an explicit LCD configuration after screen scaling', async () => {
-      const deviceName = 'eas-simulator' as AndroidVirtualDeviceName;
-      const avdDirectory = `/home/expo/.android/avd/${deviceName}.avd`;
-      await fs.promises.mkdir(avdDirectory, { recursive: true });
-      await fs.promises.writeFile(
-        `${avdDirectory}/config.ini`,
-        [
-          'hw.ramSize=1536',
-          'hw.lcd.height=2424',
-          'hw.lcd.width=1080',
-          'hw.lcd.density=420',
-          'skin.path=pixel_9',
-          'showDeviceFrame=yes',
-        ].join('\n')
-      );
-      const avdManagerPromise = Promise.resolve({ stdout: '', stderr: '' }) as any;
-      const write = jest.fn();
-      const end = jest.fn();
-      avdManagerPromise.child = { stdin: { write, end } };
-      mockedSpawn.mockReturnValue(avdManagerPromise);
-      const logger = createMockLogger();
-
-      await AndroidEmulatorUtils.createAsync({
-        deviceName,
-        systemImagePackage: 'system-images;android-35;default;x86_64',
-        deviceIdentifier: 'medium_phone' as AndroidDeviceName,
-        lcdWidth: 720,
-        lcdHeight: 1600,
-        lcdDensity: 262,
-        env: {
-          HOME: '/home/expo',
-          ANDROID_EMULATOR_ADJUST_SCREEN: '1',
-          ANDROID_EMULATOR_ADJUST_HEAP_SIZE: '0',
-        },
-        logger,
-      });
-
-      expect(mockedSpawn).toHaveBeenCalledWith(
-        'avdmanager',
-        [
-          'create',
-          'avd',
-          '--name',
-          deviceName,
-          '--package',
-          'system-images;android-35;default;x86_64',
-          '--force',
-          '--device',
-          'medium_phone',
-        ],
-        { env: expect.any(Object), stdio: 'pipe' }
-      );
-      expect(write).toHaveBeenCalledWith('no');
-      expect(end).toHaveBeenCalled();
-      expect(logger.info).toHaveBeenCalledWith(
-        'Setting scaled screen resolution: hw.lcd.height to 1270 and hw.lcd.width to 566.'
-      );
-      expect(logger.info).toHaveBeenCalledWith(
-        'Setting screen resolution to 720x1600 and density to 262 ppi.'
-      );
-      await expect(fs.promises.readFile(`${avdDirectory}/config.ini`, 'utf8')).resolves.toBe(
-        [
-          'hw.ramSize=1536',
-          'hw.lcd.height=2424',
-          'hw.lcd.width=1080',
-          'hw.lcd.density=420',
-          'skin.path=pixel_9',
-          'showDeviceFrame=yes',
-          'hw.ramSize=2048',
-          '',
-          'hw.lcd.density=220',
-          '',
-          'hw.lcd.height=1270',
-          'hw.lcd.width=566',
-          '',
-          'hw.lcd.height=1600',
-          'hw.lcd.width=720',
-          'hw.lcd.density=262',
-          '',
-        ].join('\n')
-      );
-    });
-
-    it('does not apply an LCD configuration when it is omitted', async () => {
-      const deviceName = 'generic-emulator' as AndroidVirtualDeviceName;
-      const avdDirectory = `/home/expo/.android/avd/${deviceName}.avd`;
-      const initialConfig = ['skin.path=pixel_9', 'showDeviceFrame=yes'].join('\n');
-      await fs.promises.mkdir(avdDirectory, { recursive: true });
-      await fs.promises.writeFile(`${avdDirectory}/config.ini`, initialConfig);
-      const avdManagerPromise = Promise.resolve({ stdout: '', stderr: '' }) as any;
-      avdManagerPromise.child = { stdin: { write: jest.fn(), end: jest.fn() } };
-      mockedSpawn.mockReturnValue(avdManagerPromise);
-
-      await AndroidEmulatorUtils.createAsync({
-        deviceName,
-        systemImagePackage: AndroidEmulatorUtils.defaultSystemImagePackage,
-        deviceIdentifier: null,
-        lcdWidth: null,
-        lcdHeight: null,
-        lcdDensity: null,
-        env: {
-          HOME: '/home/expo',
-          ANDROID_EMULATOR_ADJUST_HEAP_SIZE: '0',
-        },
-        logger: createMockLogger(),
-      });
-
-      const config = await fs.promises.readFile(`${avdDirectory}/config.ini`, 'utf8');
-      expect(config).toContain(initialConfig);
-      expect(config).not.toContain('hw.lcd.');
-    });
-  });
-
  describe(AndroidEmulatorUtils.startAsync, () => {
    function mockSuccessfulStart(deviceName: AndroidVirtualDeviceName) {
-      // Under `stdio: 'pipe'` these are net.Sockets, which is what startAsync
-      // narrows on before unref-ing them.
-      const stdout = new Socket();
-      const stderr = new Socket();
-      jest.spyOn(stdout, 'unref').mockReturnValue(stdout);
-      jest.spyOn(stderr, 'unref').mockReturnValue(stderr);
-      const child = Object.assign(new EventEmitter(), {
-        pid: 1234,
-        unref: jest.fn(),
-        stdout,
-        stderr,
-      });
+      const child = { pid: 1234, unref: jest.fn() };
      const spawnPromise = Promise.resolve({ stdout: '', stderr: '' }) as any;
      spawnPromise.child = child;
      mockedSpawn.mockImplementation(((command: string, args: string[]) => {
@@ -197,12 +57,11 @@ describe('AndroidEmulatorUtils', () => {
      return { child };
    }

-    it('captures logcat and emulator process output', async () => {
+    it('captures logcat through the emulator process', async () => {
      const outputDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'logcat-staging-'));
      temporaryDirectories.push(outputDir);
      const deviceName = 'eas-simulator' as AndroidVirtualDeviceName;
      const { child } = mockSuccessfulStart(deviceName);
-      const createWriteStreamSpy = jest.spyOn(fs, 'createWriteStream');

      const result = await AndroidEmulatorUtils.startAsync({
        deviceName,
@@ -211,21 +70,13 @@ describe('AndroidEmulatorUtils', () => {
      });

      expect(result.logcatOutputPath).toMatch(
-        new RegExp(`^${outputDir}/eas-simulator-[a-f0-9]{8}-[a-f0-9]{4}-logcat\\.log$`)
-      );
-      expect(result.emulatorOutputPath).toMatch(
-        new RegExp(`^${outputDir}/eas-simulator-[a-f0-9]{8}-[a-f0-9]{4}-emulator\\.log$`)
+        new RegExp(`^${outputDir}/eas-simulator-[a-f0-9]{8}-[a-f0-9]{4}\\.log$`)
      );
      await expect(fs.promises.access(result.logcatOutputPath)).resolves.toBeUndefined();
-      await expect(fs.promises.access(result.emulatorOutputPath)).resolves.toBeUndefined();
      expect(mockedSpawn).toHaveBeenCalledWith(
        expect.stringMatching(/\/emulator\/emulator$/),
        expect.arrayContaining(['-logcat', '*:v', '-logcat-output', result.logcatOutputPath]),
-        expect.objectContaining({
-          detached: true,
-          stdio: ['ignore', 'pipe', 'pipe'],
-          ignoreStdio: true,
-        })
+        expect.objectContaining({ detached: true, stdio: 'inherit' })
      );
      expect(mockedSpawn).not.toHaveBeenCalledWith(
        'adb',
@@ -233,32 +84,6 @@ describe('AndroidEmulatorUtils', () => {
        expect.anything()
      );
      expect(child.unref).toHaveBeenCalled();
-      // Piped stdio would otherwise keep this process' event loop alive
-      // for as long as the emulator runs.
-      expect(child.stdout.unref).toHaveBeenCalled();
-      expect(child.stderr.unref).toHaveBeenCalled();
-      const emulatorOutputStream = createWriteStreamSpy.mock.results[0].value;
-      const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
-      const writeError = Object.assign(new Error('disk full'), { code: 'ENOSPC' });
-      emulatorOutputStream.emit('error', writeError);
-      emulatorOutputStream.emit('error', writeError);
-      expect(stderrWriteSpy).toHaveBeenCalledTimes(2);
-      expect(Sentry.capture).toHaveBeenCalledTimes(1);
-      expect(Sentry.capture).toHaveBeenCalledWith(
-        'Failed to write Android emulator process output',
-        writeError,
-        {
-          level: 'warning',
-          tags: { errorCode: 'ENOSPC' },
-          extras: {
-            deviceName,
-            emulatorOutputPath: result.emulatorOutputPath,
-          },
-        }
-      );
-      const emulatorOutputStreamClosed = once(emulatorOutputStream, 'close');
-      child.emit('close');
-      await emulatorOutputStreamClosed;
    });

    it('throws a SystemError when the staging directory cannot be prepared', async () => {
@@ -275,7 +100,7 @@ describe('AndroidEmulatorUtils', () => {
            logcatDirectory: outputDir,
          })
        ).rejects.toEqual(
-          new SystemError('Failed to prepare Android emulator output for eas-simulator.', {
+          new SystemError('Failed to prepare Android emulator logcat output for eas-simulator.', {
            cause: mkdirError,
          })
        );
@@ -23,41 +23,6 @@ describe('IosSimulatorUtils', () => {
    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as any);
  });

-  describe(IosSimulatorUtils.getAvailableRuntimesAsync, () => {
-    it('returns available iOS runtimes', async () => {
-      mockedSpawn.mockResolvedValue({
-        stdout: JSON.stringify({
-          runtimes: [
-            {
-              identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-18-3',
-              isAvailable: true,
-              version: '18.3.1',
-            },
-            {
-              identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-17-5',
-              isAvailable: false,
-              version: '17.5',
-            },
-          ],
-        }),
-        stderr: '',
-      } as any);
-
-      await expect(
-        IosSimulatorUtils.getAvailableRuntimesAsync({ env: process.env })
-      ).resolves.toEqual([
-        {
-          identifier: 'com.apple.CoreSimulator.SimRuntime.iOS-18-3',
-          isAvailable: true,
-          version: '18.3.1',
-        },
-      ]);
-      expect(mockedSpawn).toHaveBeenCalledWith('xcrun', ['simctl', 'list', 'runtimes', '--json'], {
-        env: process.env,
-      });
-    });
-  });
-
  describe(IosSimulatorUtils.getAvailableDevicesAsync, () => {
    it('adds a human-readable runtime display name', async () => {
      mockedSpawn.mockResolvedValue({
@@ -1,18 +0,0 @@
-import { Platform } from '@expo/eas-build-job';
-
-import { getCcacheKeyPrefix } from '../cacheKey';
-
-describe(getCcacheKeyPrefix, () => {
-  it('uses separate prefixes for iOS device and simulator builds', () => {
-    expect(getCcacheKeyPrefix({ platform: Platform.IOS, simulator: false })).toBe(
-      'ios-device-ccache-'
-    );
-    expect(getCcacheKeyPrefix({ platform: Platform.IOS, simulator: true })).toBe(
-      'ios-simulator-ccache-'
-    );
-  });
-
-  it('does not change the Android prefix', () => {
-    expect(getCcacheKeyPrefix({ platform: Platform.ANDROID })).toBe('android-ccache-');
-  });
-});
Author	SHA1	Message	Date
Stanisław Chmiela	8a04ae6342	[worker] Revert Xcode build tool prewarming	2026-08-14 20:50:13 +02:00
Stanisław Chmiela	8443581d13	[worker] Prewarm Xcode interface build tools	2026-08-14 20:33:26 +02:00
Stanisław Chmiela	aa6e610000	[build-tools] Add local Xcode compilation cache	2026-08-14 18:14:57 +02:00