obsidian-integration-testing 12.1.2 → 12.3.0

package/dist/lib/esm/transport-factory.mjs

@@ -17,7 +17,8 @@ import { join } from "node:path";
 import process from "node:process";
 import {
   checkIsDeviceListed,
-  listOnlineDeviceIds
+  listOnlineDeviceIds,
+  parseAdbDevices
 } from "./adb-device-list.mjs";
 import { resolveEmulatorBinaryPath } from "./android-sdk.mjs";
 import {
@@ -34,6 +35,7 @@ import {
 } from "./appium-server-marker.mjs";
 import {
   resolveAppiumStartTimeoutInMilliseconds,
+  resolveScriptTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds
 } from "./appium-session-config.mjs";
 import {
@@ -61,16 +63,32 @@ import {
   resolveDeviceIdleTimeoutInMilliseconds,
   resolveNetworkReadyTimeoutInMilliseconds
 } from "./device-readiness.mjs";
-import { buildEmulatorArguments } from "./emulator-arguments.mjs";
 import {
-  parsePosixProcessList,
-  parseWindowsTaskList,
-  selectEmulatorBackendPids
-} from "./emulator-backend.mjs";
+  buildEmulatorArguments,
+  buildEmulatorEnvironment,
+  NETSIM_LOG_FILTER
+} from "./emulator-arguments.mjs";
+import { selectEmulatorBackendPids } from "./emulator-backend.mjs";
 import {
   buildEmulatorLivenessMessage,
   resolveEmulatorLivenessVerdict
 } from "./emulator-liveness.mjs";
+import {
+  checkIsMarkedEmulatorRunning,
+  clearEmulatorMarker,
+  clearEmulatorMarkerIfStopped,
+  readEmulatorMarker,
+  resolveEmulatorMarkerVerdict,
+  selectLiveMarkedPids,
+  writeEmulatorMarker
+} from "./emulator-marker.mjs";
+import { spawnEmulatorReaper } from "./emulator-reaper.mjs";
+import {
+  ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,
+  ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,
+  EmulatorReclaimer,
+  HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
+} from "./emulator-reclaim.mjs";
 import {
   buildAvdSnapshotDirectoryCandidates,
   buildSnapshotAgeMessage
@@ -144,9 +162,7 @@ import {
 } from "./wedged-appium-server.mjs";
 const APP_PACKAGE = "md.obsidian";
 const APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;
-const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5e3;
 const AVD_PROBE_ATTEMPT_COUNT = 2;
-const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8388608;
 const ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS = 3e4;
 const APPIUM_CONNECTION_RETRY_COUNT = 3;
 const APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5e3;
@@ -156,34 +172,37 @@ const APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const APPIUM_STOP_TIMEOUT_IN_MILLISECONDS = 15e3;
 const ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS = 3e4;
 const CHROMEDRIVER_AUTODOWNLOAD_FEATURE = "uiautomator2:chromedriver_autodownload";
-const COMMAND_TIMEOUT_IN_MILLISECONDS = 300;
 const DEFAULT_TRANSPORT_TYPE = "obsidian-cdp";
+const ANDROID_APPIUM_TRANSPORT_TYPE = "obsidian-android-appium";
 const DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
 const DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS = 15e3;
 const DEVICE_LIVENESS_ATTEMPT_COUNT = 2;
 const EMULATOR_BOOT_ATTEMPT_COUNT = 2;
 const EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
 const EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 12e4;
-const EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5e3;
 const EMULATOR_LIST_TIMEOUT_IN_MILLISECONDS = 1e4;
 const EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8e3;
-const EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;
-const EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 2e4;
-const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 3e4;
 const HTTP_MULTIPLE_CHOICES = 300;
 const HTTP_OK = 200;
+const IMPLICIT_WAIT_TIMEOUT_IN_MILLISECONDS = 0;
 const KEYCODE_MENU = 82;
 const KEYCODE_WAKEUP = 224;
 const MILLISECONDS_PER_SECOND = 1e3;
 const NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
+const NEW_COMMAND_TIMEOUT_IN_SECONDS = 300;
+const PAGE_LOAD_TIMEOUT_IN_MILLISECONDS = 3e5;
 const SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 12e4;
 const SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 12e4;
 const SYNC_TEARDOWN_QUERY_TIMEOUT_IN_MILLISECONDS = 5e3;
 let cachedTransport;
 class AppiumTransportFactory {
+  emulators;
   type;
   constructor(type) {
     this.type = type;
+    this.emulators = new EmulatorReclaimer((message) => {
+      this.log(message);
+    });
   }
   /**
    * Creates an Appium transport by establishing a WebDriverIO session.
@@ -201,6 +220,22 @@ class AppiumTransportFactory {
     }
     return this.createNewSession(options);
   }
+  /**
+   * Arms the emulator reaper (`emulator-reaper.ts`) for an emulator this run has
+   * just recorded as its own.
+   *
+   * @param avdName - The AVD whose marker was just written.
+   * @param startedAtInMilliseconds - The emulator's launch time, as the marker records it.
+   */
+  armEmulatorReaper(avdName, startedAtInMilliseconds) {
+    spawnEmulatorReaper({
+      avdName,
+      log: (message) => {
+        this.log(message);
+      },
+      startedAtInMilliseconds
+    });
+  }
   async attachToExistingSession(sessionId, deviceId, options) {
     const url = new URL(options.appiumUrl);
     const port = Number(url.port);
@@ -225,6 +260,9 @@ class AppiumTransportFactory {
       deviceId,
       isSessionOwner: false,
       platform: "android",
+      // The session this reattaches to was created with the same resolution, so the number reported on a
+      // Script timeout is the one that session is actually enforcing.
+      scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),
       shouldSweepLeftovers: willSweepLeftovers(options),
       ...options.appStartTimeoutInMilliseconds !== void 0 && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds },
       ...options.layoutReadyTimeoutInMilliseconds !== void 0 && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds },
@@ -327,33 +365,12 @@ class AppiumTransportFactory {
    */
   async checkIsDeviceListedQuietly(deviceId) {
     try {
-      return checkIsDeviceListed({ deviceId, devicesOutput: await this.getDevicesOutput() });
+      return checkIsDeviceListed({ deviceId, devicesOutput: await this.emulators.getDevicesOutput() });
     } catch (error) {
       this.log(`Could not re-check the device listing: ${error instanceof Error ? error.message : String(error)}`);
       return false;
     }
   }
-  /**
-   * Decides whether the emulator this run started is really gone.
-   *
-   * Two independent proofs, cheapest first: none of the PIDs this run owns is
-   * alive, and the device no longer appears in `adb devices` **in any state** (a
-   * dying emulator answers `offline` while it still holds the AVD).
-   *
-   * @param params - The device and the PIDs this run owns.
-   * @returns `true` when nothing of this run's emulator is left.
-   */
-  async checkIsEmulatorGone(params) {
-    if (params.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid))) {
-      return false;
-    }
-    try {
-      return !checkIsDeviceListed({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });
-    } catch (error) {
-      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);
-      return true;
-    }
-  }
   async connectSession(params) {
     const { remote } = await importWebdriverio();
     return remote({
@@ -362,12 +379,27 @@ class AppiumTransportFactory {
         "appium:appPackage": params.appId,
         "appium:autoGrantPermissions": true,
         "appium:automationName": "UiAutomator2",
-        "appium:newCommandTimeout": COMMAND_TIMEOUT_IN_MILLISECONDS,
+        "appium:newCommandTimeout": NEW_COMMAND_TIMEOUT_IN_SECONDS,
         "appium:noReset": true,
         "appium:udid": params.deviceId,
         "appium:uiautomator2ServerInstallTimeout": SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,
         "appium:uiautomator2ServerLaunchTimeout": SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,
-        "platformName": "Android"
+        "platformName": "Android",
+        /*
+         * `script` is declared so the per-closure cap is a number this harness owns and states, but the
+         * Declaration is NOT what enforces it: UiAutomator2 was measured accepting this, reporting it
+         * Back as 30000 from the WebView context, and never acting on it — over-cap closures ran past a
+         * 60s ceiling without one `script timeout`. `AppiumTransport.evaluate` enforces the same number
+         * Node-side, and this stays because it is free, it is the honest declaration of the intended
+         * Budget, and it would start working on its own if a future driver honoured it. The other two are
+         * Restated at their W3C defaults only because the capability is all-or-nothing — WebDriverIO's
+         * `Timeouts` type has no partial form — so they change nothing.
+         */
+        "timeouts": {
+          implicit: IMPLICIT_WAIT_TIMEOUT_IN_MILLISECONDS,
+          pageLoad: PAGE_LOAD_TIMEOUT_IN_MILLISECONDS,
+          script: params.scriptTimeoutInMilliseconds
+        }
       },
       connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,
       connectionRetryTimeout: params.sessionConnectionRetryTimeoutInMilliseconds,
@@ -423,7 +455,7 @@ class AppiumTransportFactory {
           break;
         }
         const ownedEmulatorProcess = emulatorProcess;
-        const canRetry = attempt < EMULATOR_BOOT_ATTEMPT_COUNT && ownedEmulatorProcess !== void 0 && ownedEmulatorPids.length > 0;
+        const canRetry = attempt < EMULATOR_BOOT_ATTEMPT_COUNT && ownedEmulatorPids.length > 0;
         if (!canRetry) {
           throw new Error(diagnosis);
         }
@@ -435,7 +467,7 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
         emulatorProcess = void 0;
         ownedEmulatorPids = [];
         actualDeviceId = void 0;
-        await this.stopAutoStartedEmulator({
+        await this.emulators.stopEmulator({
           avdName: options.avdName,
           deviceId: doomedDeviceId,
           emulatorProcess: ownedEmulatorProcess,
@@ -453,6 +485,7 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
         isAdoptedServer: result.isAdoptedAppiumServer,
         isAppiumConsoleVisible: options.isAppiumConsoleVisible,
         port,
+        scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),
         sessionConnectionRetryTimeoutInMilliseconds: resolveSessionConnectionRetryTimeoutInMilliseconds(options),
         shouldAutoStartAppium: options.shouldAutoStartAppium,
         url
@@ -468,6 +501,8 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
         browser,
         deviceId: actualDeviceId,
         platform: "android",
+        // The same number the session was created with above, so a script timeout reports the cap that killed it.
+        scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),
         shouldSweepLeftovers: willSweepLeftovers(options),
         ...options.appStartTimeoutInMilliseconds !== void 0 && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds },
         ...options.layoutReadyTimeoutInMilliseconds !== void 0 && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds },
@@ -672,6 +707,7 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
   async ensureDeviceConnected(params) {
     const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible, networkReadyTimeoutInMilliseconds } = params;
     const timeouts = { deviceIdleTimeoutInMilliseconds, networkReadyTimeoutInMilliseconds };
+    await this.emulators.reclaimLeftoverEmulators({ exceptAvdName: avdName, scope: "preflight" });
     const deviceIdsBefore = await this.getConnectedDeviceIds();
     this.log(`Checking existing devices for AVD "${avdName}"... (connected: [${deviceIdsBefore.join(", ")}])`);
     const probeResults = await this.probeDevicesForAvd(avdName, deviceIdsBefore);
@@ -702,12 +738,26 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
     if (shouldReuseSnapshot) {
       this.logSnapshotAge(avdName);
     }
+    const launchedAtInMilliseconds = Date.now();
     const emulator = this.startEmulator(avdName, shouldReuseSnapshot, isEmulatorVisible);
-    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, timeouts);
+    const isRecordedFromLaunch = this.recordEmulatorLaunch({ avdName, emulator, launchedAtInMilliseconds, preLaunchEmulatorPids: emulatorPidsBefore });
+    let actualDeviceId;
+    try {
+      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, timeouts, (deviceId) => {
+        this.recordEmulatorLaunchDevice({ avdName, deviceId, launchedAtInMilliseconds });
+      });
+    } catch (error) {
+      await this.stopEmulatorAfterFailedStart({ avdName, deviceIdsBefore, emulator, emulatorPidsBefore });
+      throw error;
+    }
     const ownedEmulatorPids = await this.listEmulatorBackendPids(emulatorPidsBefore);
     this.log(
       `Emulator "${avdName}" started, device ${actualDeviceId} is connected (owned emulator PIDs: [${ownedEmulatorPids.join(", ")}]).`
     );
+    writeEmulatorMarker({ avdName, deviceId: actualDeviceId, ownedEmulatorPids, startedAtInMilliseconds: launchedAtInMilliseconds });
+    if (!isRecordedFromLaunch) {
+      this.armEmulatorReaper(avdName, launchedAtInMilliseconds);
+    }
     await this.suppressErrorDialogs(actualDeviceId);
     return {
       actualDeviceId,
@@ -796,7 +846,7 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
     }
   }
   async getConnectedDeviceIds() {
-    return listOnlineDeviceIds(await this.getDevicesOutput());
+    return listOnlineDeviceIds(await this.emulators.getDevicesOutput());
   }
   /**
    * Lists the host's connected devices for the wedged-server cross-check, where
@@ -824,49 +874,6 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
       );
     });
   }
-  /**
-   * Runs `adb devices` and returns its raw stdout.
-   *
-   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only
-   * the `device` state, and an emulator on its way out answers `offline` while
-   * still holding the AVD — see `adb-device-list.ts`.
-   *
-   * @returns The raw `adb devices` output.
-   * @throws If adb could not be run at all.
-   */
-  getDevicesOutput() {
-    return new Promise((resolve, reject) => {
-      execFile("adb", ["devices"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));
-          return;
-        }
-        if (stderr) {
-          this.log(`ADB stderr: ${stderr.trim()}`);
-        }
-        resolve(stdout);
-      });
-    });
-  }
-  /**
-   * Asks the emulator to shut itself down over its console.
-   *
-   * Preferred over killing the process outright because it is the path that
-   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does
-   * not answer is reported and the caller falls through to the kill.
-   *
-   * @param deviceId - The emulator's device ID.
-   */
-  killEmulatorConsole(deviceId) {
-    return new Promise((resolve) => {
-      execFile("adb", ["-s", deviceId, "emu", "kill"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {
-        this.log(
-          error ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}` : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`
-        );
-        resolve();
-      });
-    });
-  }
   /**
    * Lists the emulator processes currently running on the host, excluding a set
    * that is already accounted for.
@@ -894,24 +901,10 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
    * @returns The emulator PIDs not in `knownPids`.
    */
   async listEmulatorBackendPids(knownPids) {
-    const query = buildHostProcessQuery();
-    const output = await new Promise((resolve) => {
-      execFile(
-        query.command,
-        query.commandArguments,
-        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },
-        (error, stdout) => {
-          if (error) {
-            this.log(`Warning: could not list host processes (\`${query.command}\`): ${error.message}`);
-          }
-          resolve(error ? "" : stdout);
-        }
-      );
-    });
-    const processes = parseHostProcessList(output);
-    if (processes.length === 0) {
+    const processes = await this.emulators.queryHostProcesses();
+    if (processes === void 0) {
       this.log(
-        `Warning: \`${query.command}\` listed no processes, so this run cannot identify the emulator backend it owns. Teardown will fall back to \`adb devices\` alone and will have no PID to escalate to.`
+        "Warning: the host process listing failed, so this run cannot identify the emulator backend it owns. Teardown will fall back to `adb devices` alone and will have no PID to escalate to."
       );
       return [];
     }
@@ -1109,6 +1102,86 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
     this.log(`WARNING: ${provenance}, and it survived this run's kill too. Adopting it, which may fail mid-session.`);
     return false;
   }
+  /**
+   * Records an emulator as this run's the moment it is launched, before it has
+   * a device — and arms its reaper there.
+   *
+   * The marker used to be written once the device connected, about 45s into a
+   * cold boot, and the reaper with it. A runner killed inside that window left a
+   * running emulator with **no marker at all**, which every later run correctly
+   * refuses to touch (**L46**) and no reaper was watching: the leftover was
+   * nobody's to stop, for ever. A launch-time marker closes that window with the
+   * one thing already known — the launcher's PID, which `emulator-backend.ts`
+   * counts as an emulator process, so the marker convicts as a
+   * `harness-leftover` exactly like a completed one — plus the pre-launch
+   * snapshot, which is what lets a later reclaim identify the backend the
+   * launcher forks without having been there to watch it.
+   *
+   * **It never overwrites a marker whose processes are still running.** A launch
+   * can happen while an older emulator of the same AVD is still up and recorded
+   * — an `offline` leftover the probe cannot see, which is the launch that dies
+   * on `Running multiple emulators with the same AVD`. Clobbering that marker
+   * would erase the only record of a running emulator, the very thing
+   * `clearEmulatorMarkerIfStopped` exists to prevent. In that case the record
+   * waits for the success path, as before.
+   *
+   * @param params - The AVD, its launcher, and when it was launched.
+   * @returns `true` when the launch was recorded and its reaper armed.
+   */
+  recordEmulatorLaunch(params) {
+    const { avdName } = params;
+    const launcherPid = params.emulator.process.pid;
+    if (launcherPid === void 0) {
+      this.log(`The emulator launcher for AVD "${avdName}" reported no PID, so its launch cannot be recorded; it is recorded once its device connects.`);
+      return false;
+    }
+    const existingMarker = readEmulatorMarker(avdName);
+    if (existingMarker && (selectLiveMarkedPids(existingMarker, params.preLaunchEmulatorPids).length > 0 || checkIsMarkedEmulatorRunning(existingMarker))) {
+      this.log(`Not recording the launch of AVD "${avdName}" yet: its existing marker still names a running process, and that record is the only one of an emulator that may still be up.`);
+      return false;
+    }
+    writeEmulatorMarker({
+      avdName,
+      ownedEmulatorPids: [launcherPid],
+      preLaunchEmulatorPids: params.preLaunchEmulatorPids,
+      startedAtInMilliseconds: params.launchedAtInMilliseconds
+    });
+    this.log(`Recorded the emulator launch for AVD "${avdName}" (launcher PID ${String(launcherPid)}) before its device exists, so a kill during the boot still leaves it convictable.`);
+    this.armEmulatorReaper(avdName, params.launchedAtInMilliseconds);
+    return true;
+  }
+  /**
+   * Fills the device into the marker this launch wrote, as soon as one appears.
+   *
+   * Worth its own write because the console shutdown is the only stop that
+   * releases the AVD's `multiinstance.lock` (**L46**), and it needs a device to
+   * talk to. Deliberately **no** host process listing here: that query is
+   * budgeted at {@link HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS} for exactly
+   * this contended window, and spending it inside the boot path would eat the
+   * readiness budgets that follow. The backend PIDs arrive with the success
+   * write, one listing, as before.
+   *
+   * Only ever fills in **this** launch's marker: one carrying another launch
+   * time, or a device already, belongs to an emulator this run did not start.
+   *
+   * @param params - The AVD, the device that appeared, and the launch it belongs to.
+   */
+  recordEmulatorLaunchDevice(params) {
+    const { avdName, deviceId } = params;
+    const marker = readEmulatorMarker(avdName);
+    if (!marker || marker.deviceId !== void 0 || marker.startedAtInMilliseconds !== params.launchedAtInMilliseconds) {
+      return;
+    }
+    writeEmulatorMarker({
+      avdName,
+      deviceId,
+      ownedEmulatorPids: marker.ownedEmulatorPids,
+      // Still provisional: the backend's PID arrives with the success write, and until then the diff is what convicts it.
+      preLaunchEmulatorPids: marker.preLaunchEmulatorPids,
+      startedAtInMilliseconds: marker.startedAtInMilliseconds
+    });
+    this.log(`Recorded device ${deviceId} against the launch marker for AVD "${avdName}", so a stop from here on can shut it down over its console.`);
+  }
   /**
    * Replaces a wedged server this harness started earlier and retries the
    * session once.
@@ -1151,15 +1224,25 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
    * @param avdName - The AVD it is serving.
    * @param deviceId - The device to adopt.
    * @param timeouts - The two post-boot readiness budgets.
-   * @returns The adopted device, owning no emulator PIDs.
+   * @returns The adopted device, owning the emulator's PIDs only when it is a leftover this harness started.
    */
   async reuseConnectedDevice(avdName, deviceId, timeouts) {
-    this.log(`AVD "${avdName}" is already running on device ${deviceId}, reusing.`);
-    await this.suppressErrorDialogs(deviceId);
-    await this.waitForBoot(deviceId, Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS, void 0);
-    await this.waitForDeviceReady(deviceId, timeouts);
-    await this.wakeScreen(deviceId);
-    return { actualDeviceId: deviceId, ownedEmulatorPids: [] };
+    const ownedEmulatorPids = await this.takeOverLeftoverEmulator(avdName, deviceId);
+    this.log(
+      ownedEmulatorPids.length > 0 ? `AVD "${avdName}" is already running on device ${deviceId} as a leftover this harness started; reusing it and taking it over (owned emulator PIDs: [${ownedEmulatorPids.join(", ")}]), so this run stops it.` : `AVD "${avdName}" is already running on device ${deviceId}, reusing.`
+    );
+    try {
+      await this.suppressErrorDialogs(deviceId);
+      await this.waitForBoot(deviceId, Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS, void 0);
+      await this.waitForDeviceReady(deviceId, timeouts);
+      await this.wakeScreen(deviceId);
+    } catch (error) {
+      if (ownedEmulatorPids.length > 0) {
+        await this.emulators.stopEmulator({ avdName, deviceId, ownedEmulatorPids });
+      }
+      throw error;
+    }
+    return { actualDeviceId: deviceId, ownedEmulatorPids };
   }
   /**
    * Runs one liveness probe, retrying once before calling it silence.
@@ -1312,9 +1395,14 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
     const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);
     const input = buildEmulatorArguments({ avdName, isHidden: isWindowHidden, shouldReuseSnapshot });
     const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);
+    const { environment, isNetsimLogGuarded } = buildEmulatorEnvironment(process.env);
     this.log(`Running: ${emulatorBinary} ${input.join(" ")}`);
+    this.log(
+      isNetsimLogGuarded ? `netsimd log level: RUST_LOG=${NETSIM_LOG_FILTER} (keeps its wifi-stats warning from growing its log without bound).` : `netsimd log level: RUST_LOG=${String(environment["RUST_LOG"])}, set by the caller \u2014 the harness's bounded default is off, and netsimd's log can grow without bound.`
+    );
     const child = spawn(emulatorBinary, input, {
       detached,
+      env: environment,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide
     });
@@ -1405,47 +1493,6 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
     }
     recordAppiumServerStopAttempt(params.port);
   }
-  /**
-   * Stops the emulator this run started, and **verifies** it stopped.
-   *
-   * The console shutdown goes first because it is the only path that releases
-   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a
-   * stale lock is what makes the next run fail with `Running multiple emulators
-   * with the same AVD` — a FATAL the emulator writes to its own stdout, where
-   * nobody sees it.
-   *
-   * @param params - The emulator process, the device it serves and the PIDs this run owns.
-   */
-  async stopAutoStartedEmulator(params) {
-    await this.killEmulatorConsole(params.deviceId);
-    killProcessTree(params.emulatorProcess);
-    const waitParams = {
-      deviceId: params.deviceId,
-      ownedEmulatorPids: params.ownedEmulatorPids,
-      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
-    };
-    let hasEscalated = false;
-    let isStopped = await this.waitForEmulatorStopped(waitParams);
-    if (!isStopped) {
-      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));
-      if (survivingPids.length > 0) {
-        hasEscalated = true;
-        this.log(
-          `Auto-started emulator outlived the launcher's process tree; escalating to the backend PID(s) this run started: [${survivingPids.join(", ")}].`
-        );
-        for (const pid of survivingPids) {
-          killProcessTreeByPid(pid);
-        }
-        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });
-      }
-    }
-    this.log(buildTeardownMessage({
-      evidence: `AVD "${params.avdName}" on device ${params.deviceId}`,
-      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),
-      subject: "Auto-started emulator",
-      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
-    }));
-  }
   /**
    * Best-effort teardown for `process.on('exit')`, which cannot await.
    *
@@ -1472,15 +1519,22 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
         clearAppiumServerMarker(params.port);
       }
     }
-    if (params.emulatorProcess) {
-      killProcessTree(params.emulatorProcess);
+    if (params.emulatorProcess || params.ownedEmulatorPids.length > 0) {
+      if (params.emulatorProcess) {
+        killProcessTree(params.emulatorProcess);
+      }
       const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));
       for (const pid of survivingPids) {
         killProcessTreeByPid(pid);
       }
-      this.log(
-        survivingPids.length > 0 ? `Auto-started emulator: stop requested and surviving backend PID(s) [${survivingPids.join(", ")}] killed \u2014 sync teardown cannot wait to confirm.` : "Auto-started emulator: stop requested, no process of this run left running."
-      );
+      if (survivingPids.length > 0) {
+        this.log(
+          `Auto-started emulator: stop requested and surviving emulator PID(s) [${survivingPids.join(", ")}] killed \u2014 sync teardown cannot wait to confirm.`
+        );
+      } else {
+        this.log("Auto-started emulator: stop requested, no process of this run left running.");
+        clearEmulatorMarkerIfStopped(params.avdName);
+      }
     }
   }
   /**
@@ -1489,7 +1543,8 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
    * @param params - Everything this run started.
    */
   async stopAutoStartedProcessesVerified(params) {
-    if (!params.appiumProcess && !params.emulatorProcess) {
+    const isEmulatorOwned = params.emulatorProcess !== void 0 || params.ownedEmulatorPids.length > 0;
+    if (!params.appiumProcess && !isEmulatorOwned) {
       return;
     }
     this.log("Stopping everything this run auto-started...");
@@ -1500,8 +1555,8 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
         url: params.url
       });
     }
-    if (params.emulatorProcess && params.deviceId !== void 0) {
-      await this.stopAutoStartedEmulator({
+    if (isEmulatorOwned) {
+      await this.emulators.stopEmulator({
         avdName: params.avdName,
         deviceId: params.deviceId,
         emulatorProcess: params.emulatorProcess,
@@ -1509,6 +1564,33 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
       });
     }
   }
+  /**
+   * Stops an emulator this run launched whose start failed before it could be
+   * handed back — the boot, idle or network wait gave up on it, or it never
+   * produced a device at all.
+   *
+   * The PIDs come from the same pre-launch snapshot a successful start uses. The
+   * device is whichever emulator appeared across the launch, in any state; when
+   * that is not exactly one, the stop goes by PIDs alone rather than guess.
+   *
+   * @param params - The launch, and what predated it.
+   */
+  async stopEmulatorAfterFailedStart(params) {
+    const ownedEmulatorPids = await this.listEmulatorBackendPids(params.emulatorPidsBefore);
+    let newDeviceIds = [];
+    try {
+      newDeviceIds = parseAdbDevices(await this.emulators.getDevicesOutput()).map((entry) => entry.deviceId).filter((deviceId) => checkIsEmulatorDeviceId(deviceId) && !params.deviceIdsBefore.includes(deviceId));
+    } catch (error) {
+      this.log(`Could not list devices while stopping the failed emulator: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    this.log(`Emulator "${params.avdName}" failed to start; stopping it (owned emulator PIDs: [${ownedEmulatorPids.join(", ")}]).`);
+    await this.emulators.stopEmulator({
+      avdName: params.avdName,
+      deviceId: newDeviceIds.length === 1 ? newDeviceIds[0] : void 0,
+      emulatorProcess: params.emulator.process,
+      ownedEmulatorPids
+    });
+  }
   async suppressErrorDialogs(deviceId) {
     this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);
     await new Promise((resolve) => {
@@ -1580,6 +1662,51 @@ Booting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of
       this.log(`Warning: failed to sweep leftover temp vaults: ${error instanceof Error ? error.message : "unknown error"}`);
     }
   }
+  /**
+   * Takes over the running emulator of an AVD when it is a leftover this harness
+   * started, so this run becomes the one responsible for stopping it.
+   *
+   * @param avdName - The AVD the device is serving.
+   * @param deviceId - The device serving it.
+   * @returns The emulator PIDs this run now owns; empty when the emulator is not a harness leftover.
+   */
+  async takeOverLeftoverEmulator(avdName, deviceId) {
+    const marker = readEmulatorMarker(avdName);
+    if (!marker) {
+      return [];
+    }
+    const processes = await this.emulators.queryHostProcesses();
+    if (processes === void 0) {
+      this.log(`Cannot tell whether AVD "${avdName}" is a leftover this harness started without a host process listing; reusing it without taking it over.`);
+      return [];
+    }
+    const liveEmulatorPids = selectEmulatorBackendPids({ knownPids: [], processes });
+    const verdict = resolveEmulatorMarkerVerdict({
+      currentPid: process.pid,
+      isOwnerAlive: checkIsProcessAlive(marker.ownerPid),
+      liveEmulatorPids,
+      marker
+    });
+    switch (verdict) {
+      case "harness-leftover": {
+        const ownedEmulatorPids = selectLiveMarkedPids(marker, liveEmulatorPids);
+        writeEmulatorMarker({ avdName, deviceId, ownedEmulatorPids, startedAtInMilliseconds: marker.startedAtInMilliseconds });
+        this.armEmulatorReaper(avdName, marker.startedAtInMilliseconds);
+        return ownedEmulatorPids;
+      }
+      case "in-use-by-live-run": {
+        this.log(`AVD "${avdName}" was started by a harness process that is still running (PID ${String(marker.ownerPid)}); that process stays responsible for stopping it.`);
+        return [];
+      }
+      case "stale-marker": {
+        clearEmulatorMarker(avdName);
+        return [];
+      }
+      default: {
+        return assertNever(verdict);
+      }
+    }
+  }
   async waitForAppiumReady(url, timeoutInMilliseconds, launch) {
     const start = Date.now();
     this.log(
@@ -1780,24 +1907,6 @@ ${outputTail}` : "";
    * @param deviceId - The device UDID to poll.
    * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.
    */
-  /**
-   * Polls until this run's emulator is gone, or the budget elapses.
-   *
-   * @param params - The device, the PIDs this run owns, and the budget.
-   * @returns `true` when the emulator disappeared within the budget.
-   */
-  async waitForEmulatorStopped(params) {
-    const deadline = Date.now() + params.timeoutInMilliseconds;
-    while (Date.now() < deadline) {
-      if (await this.checkIsEmulatorGone(params)) {
-        return true;
-      }
-      await new Promise((resolve) => {
-        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);
-      });
-    }
-    return false;
-  }
   async waitForNetworkValidated(deviceId, timeoutInMilliseconds) {
     if (timeoutInMilliseconds <= 0) {
       this.log(`Skipping network-ready wait for device ${deviceId} (timeout is 0).`);
@@ -1835,7 +1944,17 @@ ${outputTail}` : "";
       `Warning: device ${deviceId} reported no validated network within ${String(timeoutInMilliseconds)}ms (${diagnosis}); proceeding with session establishment anyway. Tests that reach the network will run against a device with no route, and may return EMPTY RESULTS rather than fail \u2014 read any empty-looking assertion failure below as a missing network first.`
     );
   }
-  async waitForNewDevice(deviceIdsBefore, emulator, timeouts) {
+  /**
+   * Waits for the emulator this run launched to produce a device, and for that
+   * device to become usable.
+   *
+   * @param deviceIdsBefore - The devices connected before the launch.
+   * @param emulator - The launcher, polled for an early exit.
+   * @param timeouts - The two post-boot readiness budgets.
+   * @param onDeviceAppeared - Called with the new device the moment it is listed, before the readiness gates.
+   * @returns The new device's id.
+   */
+  async waitForNewDevice(deviceIdsBefore, emulator, timeouts, onDeviceAppeared) {
     this.log(
       `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
     );
@@ -1846,6 +1965,7 @@ ${outputTail}` : "";
       if (newIds.length > 0) {
         const actualDeviceId = newIds[0] ?? "";
         this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);
+        onDeviceAppeared(actualDeviceId);
         await this.waitForBoot(actualDeviceId, deadline, emulator);
         await this.waitForDeviceReady(actualDeviceId, timeouts);
         await this.wakeScreen(actualDeviceId);
@@ -1896,6 +2016,12 @@ async function getOrCreateTransport(options) {
   cachedTransport = result;
   return result;
 }
+async function stopHarnessStartedEmulators() {
+  const reclaimer = new EmulatorReclaimer((message) => {
+    log(`[transport-factory:${ANDROID_APPIUM_TRANSPORT_TYPE}] ${message}`);
+  });
+  await reclaimer.reclaimLeftoverEmulators({ scope: "end-of-run" });
+}
 async function assertHarnessOwnedInstanceIsServing(host, port) {
   const cdpUrl = `http://${host}:${String(port)}`;
   try {
@@ -1906,9 +2032,6 @@ async function assertHarnessOwnedInstanceIsServing(host, port) {
   }
   throw buildOwnedInstanceExitedErrorFromMarker(cdpUrl, readOwnedInstanceExitMarker(port));
 }
-function buildHostProcessQuery() {
-  return process.platform === "win32" ? { command: "tasklist", commandArguments: ["/FO", "CSV", "/NH"] } : { command: "ps", commandArguments: ["-eo", "pid=,comm="] };
-}
 function buildPortOwnerQuery(port) {
   return process.platform === "win32" ? { command: "netstat", commandArguments: ["-ano"] } : { command: "lsof", commandArguments: ["-ti", `tcp:${String(port)}`] };
 }
@@ -1959,9 +2082,6 @@ function getSettledFailure(outcomes) {
 async function importWebdriverio() {
   return await import("webdriverio");
 }
-function parseHostProcessList(output) {
-  return process.platform === "win32" ? parseWindowsTaskList(output) : parsePosixProcessList(output);
-}
 function parsePortOwnerPids(params) {
   return process.platform === "win32" ? parseWindowsNetstatPids({ netstatOutput: params.output, port: params.port }) : parsePosixLsofPids(params.output);
 }
@@ -2064,6 +2184,7 @@ function stripForbiddenFetchHeaders(requestOptions) {
 }
 export {
   createTransportFromOptions,
-  getOrCreateTransport
+  getOrCreateTransport,
+  stopHarnessStartedEmulators
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\nimport type {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync,\n  statSync\n} from 'node:fs';\nimport http from 'node:http';\nimport {\n  homedir,\n  tmpdir\n} from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { AppiumServerMarker } from './appium-server-marker.mjs';\nimport type { AvdProbeResult } from './avd-probe-verdict.mjs';\nimport type { ProcessListEntry } from './emulator-backend.mjs';\nimport type { EmulatorLivenessProbeOutcome } from './emulator-liveness.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ProcessExitInfo } from './process-exit-message.mjs';\nimport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceConfig\n} from './transport-desktop-cdp.mjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\nimport type { WedgedAppiumServerReportReason } from './wedged-appium-server.mjs';\n\nimport {\n  checkIsDeviceListed,\n  listOnlineDeviceIds\n} from './adb-device-list.mjs';\nimport { resolveEmulatorBinaryPath } from './android-sdk.mjs';\nimport {\n  checkIsAppiumDriverInstalled,\n  UIAUTOMATOR2_DRIVER_NAME,\n  willAutoInstallAppiumDependencies\n} from './appium-dependencies.mjs';\nimport {\n  checkIsHarnessOwnedAppiumServer,\n  clearAppiumServerMarker,\n  readAppiumServerMarker,\n  recordAppiumServerStopAttempt,\n  writeAppiumServerMarker\n} from './appium-server-marker.mjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.mjs';\nimport {\n  checkAvdExists,\n  listAvailableAvds\n} from './avd-list.mjs';\nimport {\n  buildAvdProbeSummary,\n  buildUnreadableDevicesMessage,\n  checkIsEmulatorDeviceId,\n  classifyAvdProbe,\n  resolveAvdProbeVerdict\n} from './avd-probe-verdict.mjs';\nimport {\n  resolveInstallerCompatibilityAction,\n  willThrowOnIncompatibleInstaller,\n  willThrowOnSilentAsarFallback,\n  willWarnOnCompatibilityIssues\n} from './compatibility-options.mjs';\nimport { assertValidConfigDirectory } from './config-directory.mjs';\nimport { getSetupError } from './context-provider.mjs';\nimport {\n  checkDeviceIdle,\n  checkNetworkValidated,\n  resolveDeviceIdleTimeoutInMilliseconds,\n  resolveNetworkReadyTimeoutInMilliseconds\n} from './device-readiness.mjs';\nimport { buildEmulatorArguments } from './emulator-arguments.mjs';\nimport {\n  parsePosixProcessList,\n  parseWindowsTaskList,\n  selectEmulatorBackendPids\n} from './emulator-backend.mjs';\nimport {\n  buildEmulatorLivenessMessage,\n  resolveEmulatorLivenessVerdict\n} from './emulator-liveness.mjs';\nimport {\n  buildAvdSnapshotDirectoryCandidates,\n  buildSnapshotAgeMessage\n} from './emulator-snapshot.mjs';\nimport { exec } from './exec.mjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nimport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nimport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.mjs';\nimport {\n  HARNESS_TEMP_DIR_NAME,\n  OWNED_USER_DATA_DIR_PREFIX,\n  sweepDeviceLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { getObsidianConfigDirectory } from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.mjs';\nimport { compareVersions } from './obsidian-version.mjs';\nimport { readOwnedInstanceExitMarker } from './owned-instance-exit-marker.mjs';\nimport { buildOwnedInstanceExitedErrorFromMarker } from './owned-instance-exited-error.mjs';\nimport {\n  parsePosixLsofPids,\n  parseWindowsNetstatPids\n} from './port-owner.mjs';\nimport {\n  appendProcessOutputTail,\n  buildProcessExitMessage\n} from './process-exit-message.mjs';\nimport { checkIsProcessAlive } from './process-liveness.mjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.mjs';\nimport {\n  resolveAppiumSpawnFlags,\n  resolveEmulatorSpawnFlags\n} from './spawn-options.mjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.mjs';\nimport {\n  AppiumTransport,\n  DEFAULT_ANDROID_VAULT_BASE_PATH\n} from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport {\n  assertNever,\n  ensureNonNullable\n} from './type-guards.mjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.mjs';\nimport {\n  buildWedgedAppiumServerMessage,\n  checkIsAppiumStatusReady,\n  resolveWedgedAppiumServerRemedy\n} from './wedged-appium-server.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\n/*\n * How many times the AVD adoption probe asks a device which AVD it is serving.\n * One retry, because the alternative to an answer is refusing to launch: a\n * second 5s look is far cheaper than either a false refusal or the colliding\n * launch a discarded timeout used to authorize (see `avd-probe-verdict.ts`).\n */\nconst AVD_PROBE_ATTEMPT_COUNT = 2;\n/*\n * `dumpsys connectivity` is far larger than the other probes' output, and Node's\n * default 1 MiB `maxBuffer` would fail the call rather than truncate it \u2014 which\n * would read as \"not ready\" forever and burn the whole network budget.\n */\nconst ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8_388_608;\n/*\n * The connectivity dump gets a budget of its OWN, well above the 5s the other\n * probes share \u2014 not because the dump is slow (measured 0.9-2.4s on a responsive\n * guest, alongside `getprop`'s 0.7-2.1s), but because it runs in the window\n * where residual post-boot contention still inflates every `adb` round-trip\n * 25-50x (L19). At 5s it overran on EVERY poll of the first end-to-end run,\n * and an overrun is reported as \"no network\", so too small a budget does not\n * degrade this gate \u2014 it silently disables it while the gate claims the\n * opposite. 30s is ~15x the idle cost, which is that inflation with room.\n */\nconst ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_STOP_TIMEOUT_IN_MILLISECONDS = 15_000;\nconst ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS = 30_000;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\n/*\n * Budget for each of the two liveness probes taken immediately before the\n * session (see `emulator-liveness.ts`). Well above the 5s the preflight probes\n * share, because this one runs in the post-boot contention window that inflates\n * every `adb` round-trip 25-50x (L45) \u2014 and here a false \"no answer\" would\n * abort a run that was about to work, which is a worse error than waiting.\n * 15s is what the six hand-boots that measured the wedge used, and no healthy\n * guest came close to it: the failures hung indefinitely rather than answering\n * slowly.\n */\nconst DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS = 15_000;\n/*\n * How many times each liveness probe is asked before its silence is believed.\n * One retry, matching `AVD_PROBE_ATTEMPT_COUNT` and for the same reason: the\n * verdict aborts the run, so a second look is far cheaper than a wrong call.\n */\nconst DEVICE_LIVENESS_ATTEMPT_COUNT = 2;\n/*\n * How many emulators a run may boot before giving up. One retry: the wedge that\n * motivates it is not deterministic \u2014 measured 2026-09-05, a first emulator went\n * quiet 129s in and the replacement booted 11s later ran the whole suite \u2014 but a\n * cold boot costs ~90-220s, so a second failure is where the run should stop and\n * say so rather than keep paying.\n */\nconst EMULATOR_BOOT_ATTEMPT_COUNT = 2;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120_000;\nconst EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst EMULATOR_LIST_TIMEOUT_IN_MILLISECONDS = 10_000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 20_000;\n/*\n * 30s, not the 10s a `tasklist` costs on an idle host: this query runs in the\n * same post-boot contention window that inflates every `adb` round-trip 25-50x\n * (L45), and the first end-to-end run overran a 10s budget there \u2014 silently\n * disarming the teardown escalation. Sized like `ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS`,\n * for the same reason.\n */\nconst HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst HTTP_MULTIPLE_CHOICES = 300;\nconst HTTP_OK = 200;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120_000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120_000;\n/*\n * The sync teardown runs inside `process.on('exit')`, so this query blocks the\n * exit itself. Short on purpose: losing the escalation is better than holding\n * the handler for the async path's 30s, and the sync log never claims a\n * verified stop anyway.\n */\nconst SYNC_TEARDOWN_QUERY_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /**\n  The user's newest installed asar to provision as-is (no download).\n   */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /**\n  The app version to download and asar-swap onto the shell.\n   */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /**\n  The app version whose own installer shell to download (a downgrade).\n   */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Outcome of one `dumpsys connectivity` probe: exactly one field is set.\n *\n * A failed probe carries **why** it failed rather than collapsing into \"no\n * output\", because the two failures look nothing alike in practice and only one\n * of them is worth waiting out \u2014 a 30s timeout is a contended guest, while an\n * instant `error: closed` is a dead one.\n */\ninterface CheckIsEmulatorGoneParams {\n  /**\n  The device the emulator serves.\n   */\n  readonly deviceId: string;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface ConnectivityProbeResult {\n  /**\n  Why the probe failed, set iff it did not answer.\n   */\n  readonly failureReason?: string | undefined;\n\n  /**\n  The raw dump, set iff the probe answered.\n   */\n  readonly output?: string | undefined;\n}\n\n/**\n * The two post-boot readiness budgets, carried together so the started-device\n * and reused-device branches cannot drift apart on which gates they run.\n */\ninterface DeviceReadinessTimeouts {\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n}\n\n/**\n * The emulator's captured output, carried past boot so a failure during session\n * creation can still quote it.\n *\n * Boot used to be the end of the emulator's usefulness as a witness: the capture\n * was frozen the moment a device appeared, and nothing read it again. But the\n * lines that explain a wedge \u2014 `detected a hanging thread 'QEMU2 main loop'`,\n * netsim's `Unable to reconnect to packet streamer` \u2014 are printed *after* that,\n * while the harness is inside `establishSession`. So the window now closes when\n * the session is established rather than when the device appears, and this pair\n * is what the session path needs to hold to do that (see `emulator-liveness.ts`).\n */\ninterface EmulatorCapture {\n  /**\n  Returns the captured stdout+stderr tail (bounded to the most recent output).\n   */\n  readonly read: () => string;\n\n  /**\n  Freezes the tail. Called once the session is established and the emulator has nothing left to explain.\n   */\n  readonly stop: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /**\n  AVD name to connect to (starting a new emulator if not already running).\n   */\n  readonly avdName: string;\n\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started emulator window is shown (omitted \u2192 hidden).\n   */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started emulator may resume and refresh the AVD's boot snapshot (omitted \u2192 cold boot).\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /**\n  The actual device ID that is connected (may differ from the requested one).\n   */\n  readonly actualDeviceId: string;\n\n  /**\n   * The emulator's output capture, when this run started it. Absent for an\n   * adopted device, whose emulator this run never spawned and whose output it\n   * therefore never had.\n   */\n  readonly emulatorCapture?: EmulatorCapture | undefined;\n\n  /**\n  The emulator process, if one was auto-started.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n   * The emulator processes this run is responsible for killing \u2014 the launcher\n   * plus the QEMU backend it forked, identified by diffing the host's process\n   * list across the launch. Empty when the device was reused rather than\n   * started. See `emulator-backend.ts` for why the launcher's PID alone is not\n   * enough.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.establishSession}.\n */\ninterface EstablishSessionParams {\n  /**\n  The Android package the session drives.\n   */\n  readonly appId: string;\n\n  /**\n  The marker of the adopted server, when an earlier run of this harness left one.\n   */\n  readonly appiumServerMarker: AppiumServerMarker | undefined;\n\n  /**\n  Resolved timeout in milliseconds for a replacement Appium server to become ready.\n   */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /**\n  The device the session is established against.\n   */\n  readonly deviceId: string;\n\n  /**\n  Whether the server was adopted rather than started by this run.\n   */\n  readonly isAdoptedServer: boolean;\n\n  /**\n  Whether a replacement server's console window is shown (omitted \u2192 hidden).\n   */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /**\n  The Appium server port.\n   */\n  readonly port: number;\n\n  /**\n  Resolved WebDriverIO connection retry timeout in milliseconds.\n   */\n  readonly sessionConnectionRetryTimeoutInMilliseconds: number;\n\n  /**\n  Whether Appium auto-start is allowed \u2014 a `false` here also forbids replacing a wedged server.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  The Appium server URL.\n   */\n  readonly url: URL;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.establishSession}.\n */\ninterface EstablishSessionResult {\n  /**\n  The replacement Appium server process, when a wedged one had to be restarted.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The established session.\n   */\n  readonly browser: Awaited<ReturnType<typeof remote>>;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface HostCommandQuery {\n  /**\n  The executable to run.\n   */\n  readonly command: string;\n\n  /**\n  The command's arguments.\n   */\n  readonly commandArguments: string[];\n}\n\ninterface InstalledShell {\n  /**\n  Absolute path to the installed shell executable.\n   */\n  readonly exePath: string;\n\n  /**\n  The detected shell version, or `undefined` when it cannot be determined.\n   */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * A spawned child process (the Android emulator or the Appium server) together\n * with helpers to inspect its captured output and exit status.\n */\ninterface ParsePortOwnerPidsParams {\n  /**\n  Raw stdout of the platform's port query.\n   */\n  readonly output: string;\n\n  /**\n  The port that was queried.\n   */\n  readonly port: number;\n}\n\ninterface ProcessLaunch {\n  /**\n  The spawned process.\n   */\n  process: ChildProcess;\n\n  /**\n  Returns the exit / spawn-failure details once the process is no longer running, otherwise `undefined`.\n   */\n  readExitInfo: () => ProcessExitInfo | undefined;\n\n  /**\n  Returns the captured stdout+stderr (bounded to the most recent output).\n   */\n  readOutput: () => string;\n\n  /**\n  Stops accumulating output. Call once startup has succeeded.\n   */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface ReclaimUnstoppedAppiumServerParams {\n  /**\n  The marker that proves the leftover is this harness's own.\n   */\n  readonly marker: AppiumServerMarker;\n\n  /**\n  The port it is holding.\n   */\n  readonly port: number;\n\n  /**\n  Whether this run is allowed to start a replacement.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  The server's URL.\n   */\n  readonly url: URL;\n}\n\ninterface StartAppiumAndEmulatorParams {\n  /**\n  Resolved timeout in milliseconds for the auto-started Appium server to become ready.\n   */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /**\n  The Appium server URL.\n   */\n  readonly appiumUrl: URL;\n\n  /**\n  AVD name to start.\n   */\n  readonly avdName: string;\n\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started Appium server console window is shown (omitted \u2192 hidden).\n   */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /**\n  Whether the auto-started emulator window is shown (omitted \u2192 hidden).\n   */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n\n  /**\n  The Appium server port.\n   */\n  readonly port: number;\n\n  /**\n  Whether missing Appium dependencies may be auto-installed before the server is auto-started.\n   */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /**\n  Whether Appium auto-start is allowed.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  Whether the auto-started emulator may resume and refresh the AVD's boot snapshot (omitted \u2192 cold boot).\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /**\n  The actual device ID that is connected (may differ from the requested one).\n   */\n  readonly actualDeviceId: string;\n\n  /**\n  The Appium server process, if one was auto-started.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The adopted server's marker, when an earlier run of this harness left one.\n   */\n  readonly appiumServerMarker?: AppiumServerMarker | undefined;\n\n  /**\n  The emulator's output capture, when this run started it.\n   */\n  readonly emulatorCapture?: EmulatorCapture | undefined;\n\n  /**\n  The emulator process, if one was auto-started.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n   * Whether an already-listening server was adopted rather than started by this\n   * run. Only an adopted server can be the stale one `wedged-appium-server.ts`\n   * describes.\n   */\n  readonly isAdoptedAppiumServer: boolean;\n\n  /**\n  The emulator processes this run is responsible for killing; empty when the device was reused.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.sweepDeviceLeftoverVaults}.\n */\ninterface StopAutoStartedAppiumServerParams {\n  /**\n  The server process this run spawned.\n   */\n  readonly appiumProcess: ChildProcess;\n\n  /**\n  The port it was started on, whose marker is cleared or stamped by the outcome.\n   */\n  readonly port: number;\n\n  /**\n  The server's URL, polled to decide whether it actually stopped.\n   */\n  readonly url: URL;\n}\n\ninterface StopAutoStartedEmulatorParams {\n  /**\n  The AVD name, named in the warning so the leftover is identifiable.\n   */\n  readonly avdName: string;\n\n  /**\n  The device the emulator is serving, polled to decide whether it actually stopped.\n   */\n  readonly deviceId: string;\n\n  /**\n  The emulator launcher process this run spawned.\n   */\n  readonly emulatorProcess: ChildProcess;\n\n  /**\n  The emulator PIDs this run owns, escalated to when the launcher's tree kill leaves one behind.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface StopAutoStartedProcessesParams {\n  /**\n  The Appium server process, when this run started one.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The AVD name, for the emulator's warning.\n   */\n  readonly avdName: string;\n\n  /**\n  The device the emulator is serving, when this run started one.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator launcher process, when this run started one.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  The Appium port.\n   */\n  readonly port: number;\n\n  /**\n  The Appium server URL.\n   */\n  readonly url: URL;\n}\n\ninterface SweepDeviceLeftoverVaultsParams {\n  /**\n  The device UDID to sweep.\n   */\n  readonly deviceId: string;\n\n  /**\n  The device-side directory Obsidian Mobile stores its vaults in.\n   */\n  readonly vaultBasePath: string;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Parameters for {@link resolveAndReportCompatibility}.\n */\ninterface ResolveAndReportCompatibilityParams {\n  /**\n   * The app (asar) version that will be swapped onto the shell, or `undefined`\n   * when no asar-swap will happen (nothing is checked then).\n   */\n  readonly appVersion: string | undefined;\n\n  /**\n  The resolved installer/shell version, or `undefined`.\n   */\n  readonly installerVersion: string | undefined;\n\n  /**\n   * Whether an `'unrunnable'` verdict throws {@link IncompatibleInstallerVersionError}\n   * (`true`) or proceeds to launch with the verdict surfaced as data (`false`).\n   */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /**\n  Whether a `'nagged'` (or proceeding-`'unrunnable'`) verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n}\n\n/**\n * The slice of `webdriverio`'s surface the Appium factory calls, named so the\n * lazy load has a return type without a static import of the module itself.\n */\ninterface WaitForEmulatorStoppedParams {\n  /**\n  The device the emulator serves.\n   */\n  readonly deviceId: string;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  How long to wait for the emulator to disappear, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\ninterface WebdriverioModule {\n  /**\n  Reattaches to an existing WebDriver session.\n   */\n  readonly attach: typeof attach;\n\n  /**\n  Creates a new WebDriver session.\n   */\n  readonly remote: typeof remote;\n}\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const { attach } = await importWebdriverio();\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      shouldSweepLeftovers: willSweepLeftovers(options),\n      ...(options.appStartTimeoutInMilliseconds !== undefined && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds }),\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private buildWedgedMessage(params: EstablishSessionParams, reason: WedgedAppiumServerReportReason): string {\n    const marker = params.appiumServerMarker;\n    return buildWedgedAppiumServerMessage({\n      appiumOrigin: params.url.origin,\n      deviceId: params.deviceId,\n      reason,\n      ...(marker !== undefined && {\n        serverAgeInMilliseconds: Date.now() - marker.startedAtInMilliseconds,\n        serverPid: marker.pid\n      })\n    });\n  }\n\n  /**\n   * Preflight probe for an already-running server.\n   *\n   * Liveness is not readiness: resolving on *any* response adopts a server that\n   * is refusing sessions (a non-2xx `/status`, or one that reports itself\n   * shutting down) exactly like a healthy one. Rejecting instead hands those\n   * cases to the auto-start path. It cannot catch the wedged server of\n   * `wedged-appium-server.ts` \u2014 that one answers `ready: true` \u2014 which is why\n   * the wedge is recognized from the failed session instead.\n   *\n   * @param url - The Appium server URL.\n   */\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      /*\n       * `agent: false` \u2014 never a pooled socket. The global agent keeps sockets\n       * alive per host:port, so a probe after a server on that port was replaced\n       * can reuse the dead socket and fail with `ECONNRESET` regardless of what\n       * is listening now. That would make `waitForAppiumStopped` call a live\n       * server dead, and it is exactly the sequence the wedged-server restart\n       * performs. A fresh socket per probe costs nothing at this frequency.\n       */\n      const request = http.get(statusUrl, { agent: false, timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (response) => {\n        const statusCode = response.statusCode ?? 0;\n        if (statusCode < HTTP_OK || statusCode >= HTTP_MULTIPLE_CHOICES) {\n          response.resume();\n          reject(new Error(`Appium server at ${url.origin} answered /status with HTTP ${String(statusCode)}; it is not accepting sessions.`));\n          return;\n        }\n\n        response.setEncoding('utf-8');\n        let body = '';\n        response.on('data', (chunk: string) => {\n          body += chunk;\n        });\n        response.on('end', () => {\n          if (checkIsAppiumStatusReady(body)) {\n            resolve();\n            return;\n          }\n\n          reject(new Error(`Appium server at ${url.origin} reports it is not ready to accept new connections.`));\n        });\n      });\n      request.on('timeout', () => {\n        request.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      request.on('error', (error) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${error.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  /**\n   * Waits out the Appium port and reports whether it went quiet, rather than\n   * throwing as {@link waitForAppiumStopped} does.\n   *\n   * @param url - The Appium server URL.\n   * @param timeoutInMilliseconds - How long to wait.\n   * @returns `true` when nothing answers on the port any more.\n   */\n  private async checkIsAppiumStopped(url: URL, timeoutInMilliseconds: number): Promise<boolean> {\n    try {\n      await this.waitForAppiumStopped(url, timeoutInMilliseconds);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Checks whether adb still lists the device **in any state**, without letting\n   * an adb that itself fails count as evidence.\n   *\n   * Any state, not just `device`: a dying emulator answers `offline` while it is\n   * still the thing that is wrong (the distinction `adb-device-list.ts` draws\n   * for teardown, and the reasoning carries over). Reading `offline` as gone\n   * here would report `device-gone` for what is really a wedge, sending the\n   * reader to look for a vanished emulator that is in fact still sitting there.\n   *\n   * @param deviceId - The device to look for.\n   * @returns `true` when it is listed; `false` when it is not, or adb could not be run.\n   */\n  private async checkIsDeviceListedQuietly(deviceId: string): Promise<boolean> {\n    try {\n      return checkIsDeviceListed({ deviceId, devicesOutput: await this.getDevicesOutput() });\n    } catch (error: unknown) {\n      this.log(`Could not re-check the device listing: ${error instanceof Error ? error.message : String(error)}`);\n      return false;\n    }\n  }\n\n  /**\n   * Decides whether the emulator this run started is really gone.\n   *\n   * Two independent proofs, cheapest first: none of the PIDs this run owns is\n   * alive, and the device no longer appears in `adb devices` **in any state** (a\n   * dying emulator answers `offline` while it still holds the AVD).\n   *\n   * @param params - The device and the PIDs this run owns.\n   * @returns `true` when nothing of this run's emulator is left.\n   */\n  private async checkIsEmulatorGone(params: CheckIsEmulatorGoneParams): Promise<boolean> {\n    if (params.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid))) {\n      return false;\n    }\n\n    try {\n      return !checkIsDeviceListed({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });\n    } catch (error: unknown) {\n      /*\n       * An adb that cannot run is not evidence about the emulator \u2014 and the PID\n       * probe above has already said this run's processes are gone, which is the\n       * stronger of the two proofs.\n       */\n      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);\n      return true;\n    }\n  }\n\n  private async connectSession(params: EstablishSessionParams): Promise<Awaited<ReturnType<typeof remote>>> {\n    const { remote } = await importWebdriverio();\n    return remote({\n      capabilities: {\n        'appium:appActivity': APP_ACTIVITY,\n        'appium:appPackage': params.appId,\n        'appium:autoGrantPermissions': true,\n        'appium:automationName': 'UiAutomator2',\n        'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n        'appium:noReset': true,\n        'appium:udid': params.deviceId,\n        'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n        'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n        'platformName': 'Android'\n      },\n      connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n      connectionRetryTimeout: params.sessionConnectionRetryTimeoutInMilliseconds,\n      hostname: params.url.hostname,\n      logLevel: 'warn',\n      path: params.url.pathname,\n      port: params.port,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (Number.isNaN(port)) {\n      throw new TypeError(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let actualDeviceId: string | undefined;\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n    let ownedEmulatorPids: readonly number[] = [];\n\n    let result: StartAppiumAndEmulatorResult | undefined;\n\n    try {\n      /*\n       * Provision, then check the device is still answering \u2014 and when it is not\n       * and the emulator is ours, boot a fresh one instead of carrying on.\n       *\n       * A wedge is NOT deterministic, which is what justifies the retry. In the\n       * run that proved it (2026-09-05) the first emulator went quiet 129s in and\n       * the second, booted 11s later from the same AVD with the same arguments,\n       * established a session and drove the WebView to completion. An earlier\n       * draft of this work argued the opposite from the hand-boot data \u2014 that a\n       * re-boot buys the same failure 90s later \u2014 and that was simply wrong:\n       * every hand-boot was a first boot, so the data said nothing about second\n       * ones.\n       */\n      for (let attempt = 1; attempt <= EMULATOR_BOOT_ATTEMPT_COUNT; attempt++) {\n        result = await this.startAppiumAndEmulator({\n          appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n          appiumUrl: url,\n          avdName: options.avdName,\n          deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n          isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n          isEmulatorVisible: options.isEmulatorVisible,\n          networkReadyTimeoutInMilliseconds: resolveNetworkReadyTimeoutInMilliseconds(options),\n          port,\n          shouldAutoInstallAppiumDependencies: willAutoInstallAppiumDependencies(options),\n          shouldAutoStartAppium: options.shouldAutoStartAppium,\n          shouldReuseEmulatorSnapshot: options.shouldReuseEmulatorSnapshot\n        });\n\n        /*\n         * Only ever REPLACE this handle, never clear it. The retry leaves this\n         * run's Appium server running and swaps only the emulator, so the second\n         * pass finds that server reachable, ADOPTS it, and returns no process\n         * handle. Writing that `undefined` over the handle from the first pass\n         * would orphan the very server this run started \u2014 the leak L46 exists to\n         * prevent, reintroduced by the retry.\n         */\n        if (result.appiumProcess !== undefined) {\n          appiumProcess = result.appiumProcess;\n        }\n        emulatorProcess = result.emulatorProcess;\n        ownedEmulatorPids = result.ownedEmulatorPids;\n        actualDeviceId = result.actualDeviceId;\n\n        /*\n         * Before `remote()` launches Obsidian \u2014 the last point at which nothing\n         * has to enumerate the device's vaults yet.\n         */\n        if (willSweepLeftovers(options)) {\n          await this.sweepDeviceLeftoverVaults({\n            deviceId: actualDeviceId,\n            vaultBasePath: options.vaultBasePath ?? DEFAULT_ANDROID_VAULT_BASE_PATH\n          });\n        }\n\n        /*\n         * The last point at which a device that has gone quiet can still be\n         * reported as itself. Past here the failure belongs to Appium, which can\n         * only say the device is \"not in the list of connected devices\" \u2014 an\n         * error that names the one thing that is not wrong.\n         */\n        const diagnosis = await this.diagnoseDevice(actualDeviceId, result.emulatorCapture);\n        if (diagnosis === undefined) {\n          break;\n        }\n\n        /*\n         * Only an emulator this run started may be replaced. A device that was\n         * adopted (`ownedEmulatorPids` empty) is somebody else's to restart \u2014\n         * the same ownership line teardown draws in never sweeping `qemu*`.\n         */\n        const ownedEmulatorProcess = emulatorProcess;\n        const canRetry = attempt < EMULATOR_BOOT_ATTEMPT_COUNT && ownedEmulatorProcess !== undefined && ownedEmulatorPids.length > 0;\n        if (!canRetry) {\n          throw new Error(diagnosis);\n        }\n\n        this.log(`${diagnosis}\\n\\nBooting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of ${String(EMULATOR_BOOT_ATTEMPT_COUNT)}).`);\n        /*\n         * Disown BEFORE stopping, not after: this run hands the emulator over to\n         * `stopAutoStartedEmulator` and must not still be holding it if that\n         * throws, or the outer catch's teardown would go after the same\n         * processes a second time.\n         */\n        const doomedDeviceId = actualDeviceId;\n        const doomedPids = ownedEmulatorPids;\n        emulatorProcess = undefined;\n        ownedEmulatorPids = [];\n        actualDeviceId = undefined;\n        await this.stopAutoStartedEmulator({\n          avdName: options.avdName,\n          deviceId: doomedDeviceId,\n          emulatorProcess: ownedEmulatorProcess,\n          ownedEmulatorPids: doomedPids\n        });\n      }\n\n      if (result === undefined || actualDeviceId === undefined) {\n        throw new Error(`Could not provision an Android device for AVD \"${options.avdName}\".`);\n      }\n\n      const sessionResult = await this.establishSessionOrDiagnoseDevice(result.emulatorCapture, {\n        appId,\n        appiumServerMarker: result.appiumServerMarker,\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        deviceId: actualDeviceId,\n        isAdoptedServer: result.isAdoptedAppiumServer,\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        port,\n        sessionConnectionRetryTimeoutInMilliseconds: resolveSessionConnectionRetryTimeoutInMilliseconds(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium,\n        url\n      });\n\n      const browser = sessionResult.browser;\n      // A wedged adopted server is replaced by one this run owns, so it must be torn down like any other auto-started server.\n      if (sessionResult.appiumProcess !== undefined) {\n        appiumProcess = sessionResult.appiumProcess;\n      }\n\n      this.log('Appium session established.');\n      /*\n       * The emulator has nothing left to explain, so freeze its tail here rather\n       * than at boot. Everything up to this line \u2014 including the window in which\n       * a wedge surfaces \u2014 is now inside the captured output.\n       */\n      result.emulatorCapture?.stop();\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        shouldSweepLeftovers: willSweepLeftovers(options),\n        ...(options.appStartTimeoutInMilliseconds !== undefined && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds }),\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          await this.stopAutoStartedProcessesVerified(buildStopParams());\n        }\n      };\n\n      // Chain rather than replace: the transport's own sync teardown drops the trusted-input channel's\n      // Adb port forward, which would otherwise be stranded on the device by an abrupt exit.\n      const originalDisposeSync = appiumTransport.disposeSync.bind(appiumTransport);\n      transport.disposeSync = (): void => {\n        try {\n          originalDisposeSync();\n        } finally {\n          this.stopAutoStartedProcessesBestEffort(buildStopParams());\n        }\n      };\n\n      return transport;\n    } catch (error: unknown) {\n      await this.stopAutoStartedProcessesVerified(buildStopParams());\n      throw error;\n    }\n\n    function buildStopParams(): StopAutoStartedProcessesParams {\n      return {\n        appiumProcess,\n        avdName: options.avdName,\n        deviceId: actualDeviceId,\n        emulatorProcess,\n        ownedEmulatorPids,\n        port,\n        url\n      };\n    }\n  }\n\n  /**\n   * Describes an adopted server's provenance for the preflight log, so a stale\n   * leftover is visible in the transcript of a run that goes on to succeed \u2014 not\n   * only in the error of one that fails.\n   *\n   * @param marker - The marker read for the port, if any.\n   * @returns A short provenance description.\n   */\n  private describeAdoptedServer(marker: AppiumServerMarker | undefined): string {\n    if (!marker || !checkIsHarnessOwnedAppiumServer(marker)) {\n      return 'not started by this harness';\n    }\n\n    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    const unstoppedSuffix = marker.stopAttemptedAtInMilliseconds === undefined ? '' : ', and an earlier run failed to stop it';\n    return `started by an earlier run of this harness, pid ${String(marker.pid)}, up for ${String(ageInSeconds)}s${unstoppedSuffix}`;\n  }\n\n  /**\n   * Probes the device and returns the failure message when it is no longer\n   * usable, or `undefined` when it is fine.\n   *\n   * The readiness gates that run before this one are deliberately best-effort \u2014\n   * they warn and proceed \u2014 so nothing asked whether the device was still there\n   * at the moment it mattered. A guest that went quiet in the meantime was\n   * handed to Appium, which reported `Device <id> was not in the list of\n   * connected devices`; `adb devices` then listed it, and the trail went cold.\n   *\n   * The second probe is only paid for when the first one fails, and the verdict\n   * distinguishes a frozen guest from an unreachable emulator \u2014 see\n   * `emulator-liveness.ts` for the measurements behind that split.\n   *\n   * Returning the message rather than throwing it is what lets both callers use\n   * the same diagnosis: the provisioning loop decides whether to boot a fresh\n   * emulator, and the session path needs its own error to survive as the\n   * `cause`.\n   *\n   * @param deviceId - The device to probe.\n   * @param emulatorCapture - The emulator's output, when this run started it.\n   * @returns The diagnosis, or `undefined` when the device still answers.\n   */\n  private async diagnoseDevice(deviceId: string, emulatorCapture?: EmulatorCapture): Promise<string | undefined> {\n    const shellProbe = await this.probeDeviceShell(deviceId);\n    if (shellProbe === 'answered') {\n      return undefined;\n    }\n\n    this.log(`Device ${deviceId} did not answer \\`adb -s ${deviceId} shell\\`; checking whether the emulator itself is still alive...`);\n    const [consoleProbe, isListedByAdb] = await Promise.all([\n      this.probeEmulatorConsole(deviceId),\n      this.checkIsDeviceListedQuietly(deviceId)\n    ]);\n\n    const verdict = resolveEmulatorLivenessVerdict({\n      consoleProbe,\n      deviceId,\n      isListedByAdb,\n      shellProbe\n    });\n    this.log(`Device liveness: ${deviceId} shell=${shellProbe}, console=${consoleProbe} -> ${verdict}.`);\n\n    // Unreachable in practice \u2014 the verdict is only `'alive'` when the shell answered, which returned above \u2014 but it is what narrows the type for the builder.\n    if (verdict === 'alive') {\n      return undefined;\n    }\n\n    return buildEmulatorLivenessMessage({\n      deviceId,\n      emulatorOutput: emulatorCapture?.read() ?? '',\n      probeTimeoutInMilliseconds: DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS,\n      verdict\n    });\n  }\n\n  private dumpConnectivity(deviceId: string): Promise<ConnectivityProbeResult> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'dumpsys', 'connectivity'],\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout, stderr) => {\n          /*\n           * A failure carries its reason, NOT an empty string. The other probes\n           * collapse a failure into empty output because there \"empty\" and\n           * \"failed\" both mean not-idle, but here they mean different things and\n           * only one of them is about the network: a probe that never answers\n           * must not be reported as a guest without a route.\n           */\n          if (!error) {\n            resolve({ output: stdout });\n            return;\n          }\n\n          const detail = (stderr.trim() || error.message.trim()).split('\\n', 1)[0] ?? '';\n          resolve({\n            failureReason: error.killed\n              ? `no answer within ${String(ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS)}ms`\n              : detail || 'adb failed with no message'\n          });\n        }\n      );\n    });\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n\n    /*\n     * Re-verify: a global install can land under an npm prefix whose bin dir is\n     * not on the spawn PATH (e.g. a scoop/nvm-managed prefix), in which case\n     * `npx --no-install appium` still cannot resolve it. Fail fast with an\n     * actionable message rather than proceeding to auto-start a server that can\n     * never come up (which would otherwise spin out the full readiness timeout).\n     */\n    const verify = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n    if (verify.exitCode !== 0) {\n      throw new Error(\n        'Appium was installed via `npm install -g appium` but is still not resolvable via `npx --no-install appium`. '\n          + 'The npm global bin directory (see `npm config get prefix`) is likely not on PATH. Add it to PATH, or set '\n          + '`shouldAutoInstallAppiumDependencies: false` and install/manage Appium yourself.'\n      );\n    }\n    this.log(`Appium installed (version ${verify.stdout.trim() || 'unknown'}).`);\n  }\n\n  /**\n   * Fails fast when the requested AVD does not exist, before an emulator is\n   * spawned.\n   *\n   * Without this preflight a missing AVD name is only discovered after\n   * {@link startEmulator} spawns `emulator -avd <name>` and the boot never\n   * completes \u2014 a full {@link EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS} spin ending\n   * in a generic \"no new device appeared\". Instead this lists the configured\n   * AVDs up front and throws an actionable error naming the available ones. AVD\n   * creation is deliberately not automated (it requires a system-image download,\n   * license acceptance, and hardware/API-level choices).\n   *\n   * @param avdName - The requested AVD name.\n   */\n  private async ensureAvdExists(avdName: string): Promise<void> {\n    const emulatorBinary = resolveEmulatorBinaryPath();\n    this.log(`Verifying AVD \"${avdName}\" exists (${emulatorBinary} -list-avds)...`);\n\n    const [error, stdout] = await new Promise<[Error | null, string]>((resolve) => {\n      execFile(emulatorBinary, ['-list-avds'], { timeout: EMULATOR_LIST_TIMEOUT_IN_MILLISECONDS }, (execError, execStdout) => {\n        resolve([execError, execStdout]);\n      });\n    });\n\n    if (error) {\n      throw new Error(\n        `Failed to list AVDs via \\`${emulatorBinary} -list-avds\\`: ${error.message}. `\n          + 'Is the Android SDK emulator installed and ANDROID_HOME/ANDROID_SDK_ROOT correct?'\n      );\n    }\n\n    if (!checkAvdExists({ avdListOutput: stdout, avdName })) {\n      const available = listAvailableAvds(stdout);\n      throw new Error(\n        `Android AVD \"${avdName}\" not found. Available AVDs: ${available.length > 0 ? available.join(', ') : '(none)'}. `\n          + 'Create it (e.g. in the Android Studio Device Manager, or via `avdmanager create avd`), or set `avdName` to an existing AVD.'\n      );\n    }\n\n    this.log(`AVD \"${avdName}\" exists.`);\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible, networkReadyTimeoutInMilliseconds } = params;\n    const timeouts: DeviceReadinessTimeouts = { deviceIdleTimeoutInMilliseconds, networkReadyTimeoutInMilliseconds };\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const probeResults = await this.probeDevicesForAvd(avdName, deviceIdsBefore);\n    this.log(`AVD probe: ${buildAvdProbeSummary(probeResults)}.`);\n    const probeVerdict = resolveAvdProbeVerdict(probeResults);\n\n    switch (probeVerdict.verdict) {\n      case 'refuse': {\n        /*\n         * Silence is not a skip. Falling through to a launch here is what\n         * produced `FATAL | Running multiple emulators with the same AVD` \u2014\n         * see `avd-probe-verdict.ts` for the run this reproduces.\n         */\n        throw new Error(buildUnreadableDevicesMessage({\n          avdName,\n          probeTimeoutInMilliseconds: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,\n          unreadableDeviceIds: probeVerdict.unreadableDeviceIds\n        }));\n      }\n      case 'reuse': {\n        return await this.reuseConnectedDevice(avdName, probeVerdict.deviceId, timeouts);\n      }\n      case 'start-new': {\n        break;\n      }\n      default: {\n        return assertNever(probeVerdict);\n      }\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    await this.ensureAvdExists(avdName);\n    /*\n     * Snapshot the emulator processes that predate this launch, so the ones that\n     * appear across it can be identified as OURS. The launcher's PID is not\n     * enough to kill: under `-no-window` the process that holds the AVD is the\n     * `qemu-system-*-headless` backend it forks, which survives a `taskkill /T`\n     * of the launcher (see `emulator-backend.ts`). Diffing here \u2014 rather than\n     * sweeping `qemu*` at teardown \u2014 is what keeps the harness from killing\n     * somebody else's emulator.\n     */\n    const emulatorPidsBefore = await this.listEmulatorBackendPids([]);\n    const shouldReuseSnapshot = params.shouldReuseEmulatorSnapshot === true;\n    if (shouldReuseSnapshot) {\n      this.logSnapshotAge(avdName);\n    }\n    const emulator = this.startEmulator(avdName, shouldReuseSnapshot, isEmulatorVisible);\n\n    /*\n     * The capture is NOT stopped here any more. It used to be, in a `finally`\n     * the moment a device appeared \u2014 which froze the emulator's testimony\n     * exactly one step before the failure this harness could not explain. The\n     * hanging-thread and packet-streamer lines are printed later, while the run\n     * is inside `establishSession`. The window now closes there instead.\n     */\n    const actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, timeouts);\n\n    const ownedEmulatorPids = await this.listEmulatorBackendPids(emulatorPidsBefore);\n    this.log(\n      `Emulator \"${avdName}\" started, device ${actualDeviceId} is connected (owned emulator PIDs: [${ownedEmulatorPids.join(', ')}]).`\n    );\n    await this.suppressErrorDialogs(actualDeviceId);\n    return {\n      actualDeviceId,\n      emulatorCapture: { read: emulator.readOutput, stop: emulator.stopCapture },\n      emulatorProcess: emulator.process,\n      ownedEmulatorPids\n    };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  /**\n   * Establishes the WebDriverIO session, recognizing the one failure that blames\n   * the wrong subject: `Could not find a connected Android device` from a server\n   * whose adb is wedged while the host's own adb sees the device fine.\n   *\n   * A server an earlier run of this harness started is restarted and the session\n   * retried once \u2014 the confirmed remedy. A foreign or user-managed server is\n   * never killed; it is reported with a message that names the server.\n   *\n   * @param params - The session capabilities plus what is known about the server.\n   * @returns The session, and the replacement server process when one was started.\n   */\n  private async establishSession(params: EstablishSessionParams): Promise<EstablishSessionResult> {\n    this.log(\n      `Connecting to Appium (device=${params.deviceId}, app=${params.appId}, retryTimeout: ${String(params.sessionConnectionRetryTimeoutInMilliseconds)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n    );\n\n    try {\n      return { browser: await this.connectSession(params) };\n    } catch (error: unknown) {\n      const verdict = resolveWedgedAppiumServerRemedy({\n        connectedDeviceIds: await this.getConnectedDeviceIdsQuietly(),\n        deviceId: params.deviceId,\n        error,\n        isAdoptedServer: params.isAdoptedServer,\n        isAutoStartAllowed: params.shouldAutoStartAppium !== false,\n        isHarnessOwnedServer: checkIsHarnessOwnedAppiumServer(params.appiumServerMarker)\n      });\n\n      if (verdict.remedy === 'not-wedged') {\n        throw error;\n      }\n\n      if (verdict.remedy === 'report') {\n        throw new Error(this.buildWedgedMessage(params, verdict.reason), { cause: error });\n      }\n\n      return await this.restartWedgedServerAndRetry(params, error);\n    }\n  }\n\n  /**\n   * Establishes the session, and when that fails, asks the device whether it is\n   * still there before letting the failure stand.\n   *\n   * `establishSession` owns exactly one diagnosis \u2014 the stale Appium server \u2014\n   * and rethrows everything else untouched. That is right as far as it goes, but\n   * every signature this harness actually fails with on a wedged emulator falls\n   * into \"everything else\": `Device <id> was not in the list of connected\n   * devices`, `error: closed`, and a bare `POST /session` timeout. Rather than\n   * teaching the server module to recognize error strings that are not about the\n   * server, the device is simply re-probed here, where the device is known. A\n   * wedged emulator then reports itself, and the original error is kept as the\n   * `cause`.\n   *\n   * @param emulatorCapture - The emulator's output, when this run started it.\n   * @param params - The session parameters.\n   * @returns The established session.\n   */\n  private async establishSessionOrDiagnoseDevice(\n    emulatorCapture: EmulatorCapture | undefined,\n    params: EstablishSessionParams\n  ): Promise<EstablishSessionResult> {\n    try {\n      return await this.establishSession(params);\n    } catch (error: unknown) {\n      const diagnosis = await this.diagnoseDevice(params.deviceId, emulatorCapture);\n      if (diagnosis === undefined) {\n        throw error;\n      }\n\n      throw new Error(diagnosis, { cause: error });\n    }\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    return listOnlineDeviceIds(await this.getDevicesOutput());\n  }\n\n  /**\n   * Lists the host's connected devices for the wedged-server cross-check, where\n   * an adb that itself fails must not be read as evidence against the server.\n   *\n   * @returns The connected device IDs, or an empty list when adb could not be run.\n   */\n  private async getConnectedDeviceIdsQuietly(): Promise<string[]> {\n    try {\n      return await this.getConnectedDeviceIds();\n    } catch (error: unknown) {\n      this.log(`Could not re-check connected devices: ${error instanceof Error ? error.message : String(error)}`);\n      return [];\n    }\n  }\n\n  private getDeviceProperty(deviceId: string, property: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', property],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  /**\n   * Runs `adb devices` and returns its raw stdout.\n   *\n   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only\n   * the `device` state, and an emulator on its way out answers `offline` while\n   * still holding the AVD \u2014 see `adb-device-list.ts`.\n   *\n   * @returns The raw `adb devices` output.\n   * @throws If adb could not be run at all.\n   */\n  private getDevicesOutput(): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n  }\n\n  /**\n   * Asks the emulator to shut itself down over its console.\n   *\n   * Preferred over killing the process outright because it is the path that\n   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does\n   * not answer is reported and the caller falls through to the kill.\n   *\n   * @param deviceId - The emulator's device ID.\n   */\n  private killEmulatorConsole(deviceId: string): Promise<void> {\n    return new Promise<void>((resolve) => {\n      execFile('adb', ['-s', deviceId, 'emu', 'kill'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {\n        this.log(\n          error\n            ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}`\n            : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`\n        );\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Lists the emulator processes currently running on the host, excluding a set\n   * that is already accounted for.\n   *\n   * Called twice around a launch: with an empty `knownPids` to snapshot what\n   * predates it, then with that snapshot to name what the launch added \u2014 which\n   * is precisely the set this run owns.\n   *\n   * Best-effort: a listing that cannot be produced yields no PIDs, so an\n   * unavailable `tasklist`/`ps` degrades to \"nothing to escalate to\" rather than\n   * failing the run it is cleaning up for. **It says so, loudly** \u2014 an empty set\n   * that means \"no backend to own\" and one that means \"the query failed\" are\n   * otherwise the same log line, and the second silently disarms the escalation.\n   * That is not hypothetical: the first end-to-end run of this code logged\n   * `owned emulator PIDs: []` for a launch whose backend was demonstrably there,\n   * because `tasklist` overran a 10s budget on a host the wedged emulator had\n   * already slowed to the point where every `adb` call was timing out too \u2014 the\n   * same contention **L45** sizes `ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS` for, and\n   * the same \"wrong budget silently disables the check\" shape.\n   *\n   * A host always has processes, so a listing that parses to **zero** rows is a\n   * failed query however it exited, and is reported like one.\n   *\n   * @param knownPids - Emulator PIDs to exclude.\n   * @returns The emulator PIDs not in `knownPids`.\n   */\n  private async listEmulatorBackendPids(knownPids: readonly number[]): Promise<number[]> {\n    const query = buildHostProcessQuery();\n    const output = await new Promise<string>((resolve) => {\n      execFile(\n        query.command,\n        query.commandArguments,\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          if (error) {\n            this.log(`Warning: could not list host processes (\\`${query.command}\\`): ${error.message}`);\n          }\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n\n    const processes = parseHostProcessList(output);\n    if (processes.length === 0) {\n      this.log(\n        `Warning: \\`${query.command}\\` listed no processes, so this run cannot identify the emulator backend it owns. Teardown will fall back to \\`adb devices\\` alone and will have no PID to escalate to.`\n      );\n      return [];\n    }\n\n    return selectEmulatorBackendPids({ knownPids, processes });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  /**\n   * Finds the processes still listening on a port.\n   *\n   * This is the only real escalation available for the Appium server: the PID\n   * the harness holds is the shell wrapper it spawned, so re-killing it achieves\n   * nothing, while a socket still answering on the port is direct evidence of\n   * what survived.\n   *\n   * @param port - The port to query.\n   * @returns The listening PIDs, or an empty list when the query could not be run.\n   */\n  private listPortOwnerPids(port: number): Promise<number[]> {\n    const query = buildPortOwnerQuery(port);\n    return new Promise<number[]>((resolve) => {\n      execFile(\n        query.command,\n        query.commandArguments,\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // `lsof` exits non-zero when nothing holds the port, which is a legitimate empty answer.\n          resolve(parsePortOwnerPids({ output: error ? '' : stdout, port }));\n        }\n      );\n    });\n  }\n\n  /**\n   * Synchronous {@link listPortOwnerPids}, for the `process.on('exit')` teardown\n   * that cannot await.\n   *\n   * Its budget is deliberately **not** the async path's: this call blocks process\n   * exit outright, so it takes a short one and gives up rather than holding the\n   * exit handler for half a minute on a contended host. Giving up loses the\n   * escalation, which the sync path's log already admits it cannot confirm.\n   *\n   * @param port - The port to query.\n   * @returns The listening PIDs, or an empty list when the query could not be run in time.\n   */\n  private listPortOwnerPidsSync(port: number): number[] {\n    const query = buildPortOwnerQuery(port);\n    try {\n      const output = execFileSync(query.command, query.commandArguments, {\n        encoding: 'utf-8',\n        maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,\n        timeout: SYNC_TEARDOWN_QUERY_TIMEOUT_IN_MILLISECONDS\n      });\n      return parsePortOwnerPids({ output, port });\n    } catch {\n      return [];\n    }\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  /**\n   * Logs how old the snapshot a run has opted into resuming is.\n   *\n   * Best-effort: a missing snapshot is the normal state of a fresh AVD, not a\n   * failure, and this is a diagnostic rather than a gate.\n   *\n   * @param avdName - The AVD whose snapshot is about to be resumed.\n   */\n  private logSnapshotAge(avdName: string): void {\n    let savedAt: Date | undefined;\n\n    for (const candidate of buildAvdSnapshotDirectoryCandidates({ avdName, environment: process.env, homeDirectory: homedir() })) {\n      try {\n        savedAt = statSync(candidate).mtime;\n        break;\n      } catch {\n        // Not this AVD home \u2014 try the next candidate.\n      }\n    }\n\n    this.log(buildSnapshotAgeMessage({ avdName, savedAt }));\n  }\n\n  /**\n   * Reads one emulator's AVD name from its console, retrying once.\n   *\n   * The retry is what makes the refusal proportionate: the probe's whole budget\n   * is 5s, and a second look costs less than a colliding launch does. What it\n   * must never do is report a non-answer as an answer \u2014 the discarded `_error`\n   * this replaces resolved `''`, which compared unequal to the wanted AVD and so\n   * read as a definite \"some other AVD\".\n   *\n   * @param deviceId - The emulator to ask.\n   * @returns The AVD name it answered, or `undefined` when it did not answer.\n   */\n  private async probeAvdName(deviceId: string): Promise<string | undefined> {\n    for (let attempt = 1; attempt <= AVD_PROBE_ATTEMPT_COUNT; attempt++) {\n      const answer = await new Promise<string | undefined>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (error, stdout) => {\n            resolve(error ? undefined : stdout.split('\\n', 1)[0]?.trim());\n          }\n        );\n      });\n\n      if (answer !== undefined && answer.length > 0) {\n        return answer;\n      }\n\n      if (attempt < AVD_PROBE_ATTEMPT_COUNT) {\n        this.log(\n          `Device ${deviceId} did not answer \\`adb -s ${deviceId} emu avd name\\` within ${String(ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS)}ms; retrying once.`\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Asks every connected device which AVD it is serving.\n   *\n   * A device that is not a locally started emulator is never asked: its console\n   * cannot answer however healthy it is, and reading that as silence would\n   * refuse every run on a host with a handset plugged in \u2014 see\n   * `avd-probe-verdict.ts`.\n   *\n   * @param avdName - The AVD the run wants.\n   * @param deviceIds - The connected devices.\n   * @returns One outcome per device, in listed order.\n   */\n  private async probeDevicesForAvd(avdName: string, deviceIds: readonly string[]): Promise<AvdProbeResult[]> {\n    const results: AvdProbeResult[] = [];\n\n    for (const deviceId of deviceIds) {\n      const probedAvdName = checkIsEmulatorDeviceId(deviceId) ? await this.probeAvdName(deviceId) : undefined;\n      results.push({ deviceId, outcome: classifyAvdProbe({ avdName, deviceId, probedAvdName }) });\n    }\n\n    return results;\n  }\n\n  /**\n   * Asks the **guest** whether it is still scheduling work, via `adbd`.\n   *\n   * @param deviceId - The device to probe.\n   * @returns What it answered.\n   */\n  private probeDeviceShell(deviceId: string): Promise<EmulatorLivenessProbeOutcome> {\n    return this.runLivenessProbe(['-s', deviceId, 'shell', 'true']);\n  }\n\n  /**\n   * Asks the **emulator process** whether it is still running, via its console.\n   *\n   * The console is served by the emulator itself rather than by the guest, which\n   * is what makes it able to tell a frozen guest from a wedged emulator.\n   *\n   * @param deviceId - The device to probe.\n   * @returns What it answered.\n   */\n  private probeEmulatorConsole(deviceId: string): Promise<EmulatorLivenessProbeOutcome> {\n    return this.runLivenessProbe(['-s', deviceId, 'emu', 'avd', 'status']);\n  }\n\n  /**\n   * Replaces a leftover server an earlier run failed to stop, instead of\n   * adopting it.\n   *\n   * This is the other half of {@link stopAutoStartedAppiumServer}'s stamped\n   * marker, and it is the case that motivated the whole verified teardown: the\n   * leftover answers `/status` perfectly, is adopted, and then dies seconds into the session as\n   * it finally finishes shutting down \u2014 a failure that reads as a device or\n   * network fault. A server we know we already asked to die is not a server to\n   * build a suite on.\n   *\n   * @param params - The marker, the port and whether a replacement may be started.\n   * @returns `true` when the port was freed and a fresh server must be started.\n   */\n  private async reclaimUnstoppedAppiumServer(params: ReclaimUnstoppedAppiumServerParams): Promise<boolean> {\n    const stopAttemptedAtInMilliseconds = params.marker.stopAttemptedAtInMilliseconds ?? Date.now();\n    const ageInSeconds = Math.round((Date.now() - stopAttemptedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    const provenance = `the server on port ${String(params.port)} is a leftover an earlier run of this harness tried to stop ${String(ageInSeconds)}s ago and could not`;\n\n    if (params.shouldAutoStartAppium === false) {\n      this.log(`WARNING: ${provenance}. Auto-start is disabled, so this run adopts it anyway; if the session dies mid-flight, that is why.`);\n      return false;\n    }\n\n    this.log(`Refusing to adopt a known-doomed server: ${provenance}. Killing whatever holds the port and starting a fresh server...`);\n    for (const pid of await this.listPortOwnerPids(params.port)) {\n      killProcessTreeByPid(pid);\n    }\n    clearAppiumServerMarker(params.port);\n\n    if (await this.checkIsAppiumStopped(params.url, APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS)) {\n      return true;\n    }\n\n    this.log(`WARNING: ${provenance}, and it survived this run's kill too. Adopting it, which may fail mid-session.`);\n    return false;\n  }\n\n  /**\n   * Replaces a wedged server this harness started earlier and retries the\n   * session once.\n   *\n   * The old server is killed and the port is waited out before a replacement is\n   * started: a socket that keeps answering `/status` would let the readiness\n   * poll pass on the dying server, and a port that never goes quiet means the\n   * kill did not take \u2014 in which case starting anything on it is pointless.\n   *\n   * @param params - The session capabilities plus what is known about the server.\n   * @param originalError - The failure that convicted the server, logged so the diagnosis is on the record.\n   * @returns The session and the replacement server process.\n   */\n  private async restartWedgedServerAndRetry(params: EstablishSessionParams, originalError: unknown): Promise<EstablishSessionResult> {\n    const marker = ensureNonNullable(params.appiumServerMarker, 'A restart verdict requires the marker that proved ownership.');\n    this.log(\n      `Appium at ${params.url.origin} cannot see ${params.deviceId} although this host's adb can \u2014 the server this harness started earlier (pid ${String(marker.pid)}) is stale. Restarting it... (session failed with: ${originalError instanceof Error ? originalError.message : String(originalError)})`\n    );\n\n    killProcessTreeByPid(marker.pid);\n    clearAppiumServerMarker(params.port);\n\n    try {\n      await this.waitForAppiumStopped(params.url, APPIUM_STOP_TIMEOUT_IN_MILLISECONDS);\n    } catch (error: unknown) {\n      throw new Error(this.buildWedgedMessage(params, 'restart-did-not-help'), { cause: error });\n    }\n\n    const launch = this.startAppiumServer(params.port, params.isAppiumConsoleVisible);\n\n    try {\n      await this.waitForAppiumReady(params.url, params.appiumStartTimeoutInMilliseconds, launch);\n      this.log('Replacement Appium server is ready, retrying the session...');\n      return { appiumProcess: launch.process, browser: await this.connectSession(params) };\n    } catch (error: unknown) {\n      killProcessTree(launch.process);\n      clearAppiumServerMarker(params.port);\n      throw new Error(this.buildWedgedMessage(params, 'restart-did-not-help'), { cause: error });\n    }\n  }\n\n  /**\n   * Adopts a device already serving the requested AVD.\n   *\n   * @param avdName - The AVD it is serving.\n   * @param deviceId - The device to adopt.\n   * @param timeouts - The two post-boot readiness budgets.\n   * @returns The adopted device, owning no emulator PIDs.\n   */\n  private async reuseConnectedDevice(avdName: string, deviceId: string, timeouts: DeviceReadinessTimeouts): Promise<EnsureDeviceConnectedResult> {\n    this.log(`AVD \"${avdName}\" is already running on device ${deviceId}, reusing.`);\n    await this.suppressErrorDialogs(deviceId);\n    /*\n     * A reused device gets the SAME settle gate a harness-started one gets.\n     * Appearing in `adb devices` says only that adbd is up: the guest can\n     * still be running the boot animation or optimizing packages, and a\n     * session established against that contends with the churn and inflates\n     * every subsequent round-trip 25-50x (L19). Skipping the gate here is\n     * what let a release preflight spend its whole layout-ready budget on a\n     * handful of contended probes while `adb devices` reported `device`\n     * throughout. The same argument applies to the network gate: a device\n     * that has been up for seconds is exactly one with no validated network\n     * yet.\n     */\n    await this.waitForBoot(deviceId, Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS, undefined);\n    await this.waitForDeviceReady(deviceId, timeouts);\n    await this.wakeScreen(deviceId);\n    // A device this run did not start is not this run's to stop.\n    return { actualDeviceId: deviceId, ownedEmulatorPids: [] };\n  }\n\n  /**\n   * Runs one liveness probe, retrying once before calling it silence.\n   *\n   * Only success counts as an answer: a failed `adb ... emu` may be the adb\n   * server refusing an `offline` device rather than the console being dead, and\n   * the two are indistinguishable from here (see `emulator-liveness.ts`). The\n   * single retry is the same restraint `probeAvdName` applies for the same\n   * reason \u2014 a second look is far cheaper than a wrong verdict, and this one\n   * decides whether a run is aborted.\n   *\n   * @param input - The adb arguments.\n   * @returns Whether the probe got an answer.\n   */\n  private async runLivenessProbe(input: readonly string[]): Promise<EmulatorLivenessProbeOutcome> {\n    for (let attempt = 1; attempt <= DEVICE_LIVENESS_ATTEMPT_COUNT; attempt++) {\n      const isAnswered = await new Promise<boolean>((resolve) => {\n        execFile('adb', [...input], { timeout: DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS }, (error) => {\n          resolve(!error);\n        });\n      });\n\n      if (isAnswered) {\n        return 'answered';\n      }\n    }\n\n    return 'no-answer';\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, networkReadyTimeoutInMilliseconds, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium, shouldReuseEmulatorSnapshot } = params;\n\n    let needsAppiumStart = false;\n    let appiumServerMarker: AppiumServerMarker | undefined;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      appiumServerMarker = readAppiumServerMarker(port);\n      this.log(`Appium server is reachable (${this.describeAdoptedServer(appiumServerMarker)}).`);\n\n      if (appiumServerMarker?.stopAttemptedAtInMilliseconds !== undefined) {\n        needsAppiumStart = await this.reclaimUnstoppedAppiumServer({\n          marker: appiumServerMarker,\n          port,\n          shouldAutoStartAppium,\n          url: appiumUrl\n        });\n        if (needsAppiumStart) {\n          appiumServerMarker = undefined;\n        }\n      }\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumLaunch: ProcessLaunch | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumLaunch = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    const appiumProcess = appiumLaunch?.process;\n\n    /*\n     * `allSettled`, not `all`: the two halves start together, so a rejected\n     * Appium wait used to abandon an emulator that went on to boot perfectly \u2014\n     * the leak survived the very teardown that was supposed to prevent it,\n     * because the emulator's handle only exists inside the result `Promise.all`\n     * discarded. Both outcomes are collected so both can be stopped.\n     */\n    const [appiumOutcome, deviceOutcome] = await Promise.allSettled([\n      appiumLaunch\n        ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds, appiumLaunch).then(() => {\n          this.log('Auto-started Appium server is ready.');\n        })\n        : Promise.resolve(),\n      this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible, networkReadyTimeoutInMilliseconds, shouldReuseEmulatorSnapshot })\n    ]);\n\n    const deviceResult = deviceOutcome.status === 'fulfilled' ? deviceOutcome.value : undefined;\n\n    if (appiumOutcome.status === 'rejected' || deviceResult === undefined) {\n      await this.stopAutoStartedProcessesVerified({\n        appiumProcess,\n        avdName,\n        deviceId: deviceResult?.actualDeviceId,\n        emulatorProcess: deviceResult?.emulatorProcess,\n        ownedEmulatorPids: deviceResult?.ownedEmulatorPids ?? [],\n        port,\n        url: appiumUrl\n      });\n\n      throw getSettledFailure([appiumOutcome, deviceOutcome]);\n    }\n\n    return {\n      actualDeviceId: deviceResult.actualDeviceId,\n      appiumProcess,\n      appiumServerMarker,\n      emulatorCapture: deviceResult.emulatorCapture,\n      emulatorProcess: deviceResult.emulatorProcess,\n      isAdoptedAppiumServer: !needsAppiumStart,\n      ownedEmulatorPids: deviceResult.ownedEmulatorPids\n    };\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ProcessLaunch {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const { detached, windowsHide } = resolveAppiumSpawnFlags(isConsoleHidden);\n    /*\n     * `--no-install`: Appium is guaranteed present by `ensureAppiumInstalled`\n     * before we reach here, so pin npx to the installed copy. Without it, npx\n     * would silently try to download Appium fresh from the registry \u2014 a\n     * slow/hung failure in a hidden console \u2014 whenever it could not resolve the\n     * global install (e.g. a global prefix not on PATH). See `ensureAppiumInstalled`.\n     *\n     * Pipe stdout/stderr even when hidden (rather than discarding) so an early\n     * failure such as a crash or a missing driver is captured and surfaced\n     * immediately by `waitForAppiumReady`, mirroring `startEmulator`;\n     * `windowsHide` still suppresses the console window.\n     */\n    const child = spawn(`npx --no-install appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached,\n      shell: true,\n      stdio: isConsoleHidden ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'inherit', 'inherit'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: ProcessExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout?.on('data', appendOutput);\n    child.stderr?.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n    child.once('error', (error) => {\n      exitInfo = { code: null, signal: null, spawnError: error.message };\n    });\n\n    child.unref();\n\n    /*\n     * Record the server as ours before anything can adopt it. The marker is what\n     * lets a later run tell its own leftover server from a foreign one, and so\n     * whether restarting a wedged server is this harness's call to make \u2014 see\n     * `appium-server-marker.ts`.\n     */\n    if (child.pid !== undefined) {\n      writeAppiumServerMarker({ pid: child.pid, port });\n    }\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-APPIUM_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  private startEmulator(avdName: string, shouldReuseSnapshot: boolean, isEmulatorVisible?: boolean): ProcessLaunch {\n    const emulatorBinary = resolveEmulatorBinaryPath();\n    const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);\n    const input = buildEmulatorArguments({ avdName, isHidden: isWindowHidden, shouldReuseSnapshot });\n    const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);\n    this.log(`Running: ${emulatorBinary} ${input.join(' ')}`);\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, input, {\n      detached,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: ProcessExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n    /*\n     * A spawn failure (e.g. ENOENT for a missing/broken emulator binary) emits\n     * 'error', not 'exit'. Record it as a synthetic exit so the boot/new-device\n     * polls fail fast instead of spinning out the full boot timeout.\n     */\n    child.once('error', (error) => {\n      exitInfo = { code: null, signal: null, spawnError: error.message };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  /**\n   * Stops the Appium server this run started, and **verifies** it stopped.\n   *\n   * The port is the verdict: a socket still answering `/status` after the kill\n   * is the server, whatever the PID table says. When it is still there the\n   * listener is killed by port ownership \u2014 the only escalation that means\n   * anything, since re-killing the shell wrapper's PID would just repeat the\n   * kill that already failed.\n   *\n   * @param params - The server process, its port and its URL.\n   */\n  private async stopAutoStartedAppiumServer(params: StopAutoStartedAppiumServerParams): Promise<void> {\n    killProcessTree(params.appiumProcess);\n\n    let hasEscalated = false;\n    let isStopped = await this.checkIsAppiumStopped(params.url, APPIUM_STOP_TIMEOUT_IN_MILLISECONDS);\n\n    if (!isStopped) {\n      const ownerPids = await this.listPortOwnerPids(params.port);\n      if (ownerPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started Appium server still answers on ${params.url.origin} after its process tree was killed; escalating to the PID(s) holding the port: [${ownerPids.join(', ')}].`\n        );\n        for (const pid of ownerPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.checkIsAppiumStopped(params.url, APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS);\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: `port ${String(params.port)}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started Appium server',\n      timeoutInMilliseconds: APPIUM_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n\n    if (isStopped) {\n      // Drop the marker with the server it describes, so the next run cannot mistake a recycled PID for ours.\n      clearAppiumServerMarker(params.port);\n      return;\n    }\n\n    // Keep the marker, stamped: a leftover we could not kill must stay convictable by the next run.\n    recordAppiumServerStopAttempt(params.port);\n  }\n\n  /**\n   * Stops the emulator this run started, and **verifies** it stopped.\n   *\n   * The console shutdown goes first because it is the only path that releases\n   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a\n   * stale lock is what makes the next run fail with `Running multiple emulators\n   * with the same AVD` \u2014 a FATAL the emulator writes to its own stdout, where\n   * nobody sees it.\n   *\n   * @param params - The emulator process, the device it serves and the PIDs this run owns.\n   */\n  private async stopAutoStartedEmulator(params: StopAutoStartedEmulatorParams): Promise<void> {\n    await this.killEmulatorConsole(params.deviceId);\n    killProcessTree(params.emulatorProcess);\n\n    const waitParams: WaitForEmulatorStoppedParams = {\n      deviceId: params.deviceId,\n      ownedEmulatorPids: params.ownedEmulatorPids,\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    };\n\n    let hasEscalated = false;\n    let isStopped = await this.waitForEmulatorStopped(waitParams);\n\n    if (!isStopped) {\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      if (survivingPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started emulator outlived the launcher's process tree; escalating to the backend PID(s) this run started: [${survivingPids.join(', ')}].`\n        );\n        for (const pid of survivingPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: `AVD \"${params.avdName}\" on device ${params.deviceId}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started emulator',\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n  }\n\n  /**\n   * Best-effort teardown for `process.on('exit')`, which cannot await.\n   *\n   * It kills, looks once for a survivor still holding the Appium port or a\n   * still-live emulator PID, kills those too \u2014 and then says exactly that. It\n   * never claims a verified stop, because it cannot wait to earn one.\n   *\n   * @param params - Everything this run started.\n   */\n  private stopAutoStartedProcessesBestEffort(params: StopAutoStartedProcessesParams): void {\n    if (params.appiumProcess) {\n      killProcessTree(params.appiumProcess);\n      const ownerPids = this.listPortOwnerPidsSync(params.port);\n      for (const pid of ownerPids) {\n        killProcessTreeByPid(pid);\n      }\n\n      if (ownerPids.length > 0) {\n        this.log(\n          `Auto-started Appium server: stop requested and PID(s) [${ownerPids.join(', ')}] holding port ${String(params.port)} killed \u2014 sync teardown cannot wait to confirm.`\n        );\n        recordAppiumServerStopAttempt(params.port);\n      } else {\n        this.log(`Auto-started Appium server: stop requested, nothing left listening on port ${String(params.port)}.`);\n        clearAppiumServerMarker(params.port);\n      }\n    }\n\n    if (params.emulatorProcess) {\n      killProcessTree(params.emulatorProcess);\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      for (const pid of survivingPids) {\n        killProcessTreeByPid(pid);\n      }\n\n      this.log(\n        survivingPids.length > 0\n          ? `Auto-started emulator: stop requested and surviving backend PID(s) [${survivingPids.join(', ')}] killed \u2014 sync teardown cannot wait to confirm.`\n          : 'Auto-started emulator: stop requested, no process of this run left running.'\n      );\n    }\n  }\n\n  /**\n   * Stops everything this run auto-started, verifying each stop.\n   *\n   * @param params - Everything this run started.\n   */\n  private async stopAutoStartedProcessesVerified(params: StopAutoStartedProcessesParams): Promise<void> {\n    if (!params.appiumProcess && !params.emulatorProcess) {\n      return;\n    }\n\n    this.log('Stopping everything this run auto-started...');\n\n    if (params.appiumProcess) {\n      await this.stopAutoStartedAppiumServer({\n        appiumProcess: params.appiumProcess,\n        port: params.port,\n        url: params.url\n      });\n    }\n\n    if (params.emulatorProcess && params.deviceId !== undefined) {\n      await this.stopAutoStartedEmulator({\n        avdName: params.avdName,\n        deviceId: params.deviceId,\n        emulatorProcess: params.emulatorProcess,\n        ownedEmulatorPids: params.ownedEmulatorPids\n      });\n    }\n  }\n\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  /**\n   * Removes the `temp-vault-*` directories earlier runs left on the device.\n   *\n   * Runs **before** `remote()` launches Obsidian \u2014 the last moment at which\n   * nothing has to enumerate the device's vaults yet, and the only sweep that\n   * does not depend on a healthy WebView. That independence is the whole point:\n   * a run whose WebView died cannot unregister or delete its own vault, so\n   * without this each failure leaves residue that slows the next run's startup\n   * enumeration and makes the next failure likelier.\n   *\n   * Unconditional (no age gate) \u2014 Android runs hold the exclusive `android`\n   * setup lock, so no concurrent run can own a device vault, and an age gate\n   * would let a vault leaked minutes ago survive into this run. Best-effort: a\n   * failure is logged, not thrown.\n   *\n   * The removals go one directory at a time and the outcome is re-listed rather\n   * than inferred; {@link sweepDeviceLeftovers} explains why.\n   *\n   * @param params - The device and vault base path to sweep.\n   */\n  private async sweepDeviceLeftoverVaults(params: SweepDeviceLeftoverVaultsParams): Promise<void> {\n    const { deviceId, vaultBasePath } = params;\n\n    try {\n      const result = await sweepDeviceLeftovers({\n        listNames: async (): Promise<string[]> => {\n          const listing = await exec(\n            ['adb', '-s', deviceId, 'shell', 'ls', '-1', vaultBasePath],\n            { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS }\n          );\n          return listing.split('\\n');\n        },\n        removeDirectory: async (path: string): Promise<void> => {\n          await exec(\n            ['adb', '-s', deviceId, 'shell', 'rm', '-rf', path],\n            { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS }\n          );\n        },\n        vaultBasePath\n      });\n\n      if (result.removedCount === 0 && result.failedNames.length === 0) {\n        this.log(`No leftover temp vaults on device ${deviceId}.`);\n        return;\n      }\n\n      this.log(`Removed ${String(result.removedCount)} leftover temp vault(s) from ${vaultBasePath} on device ${deviceId}.`);\n\n      if (result.failedNames.length > 0) {\n        this.log(\n          `Warning: ${String(result.failedNames.length)} leftover temp vault(s) could not be removed and will be retried next run: ${result.failedNames.join(', ')}`\n        );\n      }\n    } catch (error: unknown) {\n      this.log(`Warning: failed to sweep leftover temp vaults: ${error instanceof Error ? error.message : 'unknown error'}`);\n    }\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number, launch: ProcessLaunch): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      /*\n       * If the server process already died (crashed, or never started), stop\n       * polling and surface why \u2014 otherwise a doomed server spins out the whole\n       * readiness timeout with no diagnostics, the original symptom this exists\n       * to prevent.\n       */\n      const exitInfo = launch.readExitInfo();\n      if (exitInfo) {\n        throw buildDeathError(exitInfo);\n      }\n\n      try {\n        await this.checkAppiumReachable(url);\n        launch.stopCapture();\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    const finalExitInfo = launch.readExitInfo();\n    if (finalExitInfo) {\n      throw buildDeathError(finalExitInfo);\n    }\n\n    const outputTail = launch.readOutput().trim();\n    const outputSection = outputTail.length > 0 ? `\\n\\nAppium server output (tail):\\n${outputTail}` : '';\n    throw new Error(`Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms.${outputSection}`);\n\n    function buildDeathError(exitInfo: ProcessExitInfo): Error {\n      return new Error(buildProcessExitMessage({\n        exitInfo,\n        output: launch.readOutput(),\n        outputLabel: 'Appium server output',\n        subject: 'Auto-started Appium server'\n      }));\n    }\n  }\n\n  /**\n   * Waits until nothing answers `/status` on the port any more.\n   *\n   * @param url - The Appium server URL.\n   * @param timeoutInMilliseconds - How long to wait before giving up.\n   * @throws If the port is still served when the timeout elapses.\n   */\n  private async waitForAppiumStopped(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const deadline = Date.now() + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n      } catch {\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Something is still serving ${url.origin} ${String(timeoutInMilliseconds)}ms after the Appium server was killed.`\n    );\n  }\n\n  /**\n   * Polls `sys.boot_completed` until the device reports a finished boot.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param deadline - The absolute time at which to give up.\n   * @param emulator - The emulator this run started, so its early death fails fast instead of polling out the deadline. Omitted for a reused device, which this run did not launch and cannot inspect.\n   */\n  private async waitForBoot(deviceId: string, deadline: number, emulator: ProcessLaunch | undefined): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator?.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildProcessExitMessage({\n          exitInfo,\n          output: emulator?.readOutput() ?? '',\n          outputLabel: 'Emulator output',\n          subject: 'Android emulator'\n        }));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    /*\n     * The tail goes on the TIMEOUT too, not only on the exit. An emulator that\n     * prints `FATAL | Running multiple emulators with the same AVD` and then\n     * lingers never sets `exitInfo`, so this used to be the whole of what the\n     * reader got \u2014 a budget, with the explanation captured and discarded.\n     */\n    throw new Error(appendProcessOutputTail(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`,\n      { output: emulator?.readOutput() ?? '', outputLabel: 'Emulator output' }\n    ));\n  }\n\n  /**\n   * Waits for a booted emulator to become idle before the session is\n   * established \u2014 whether this run started it or found it already running.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * A **reused** device needs this every bit as much as a started one: being\n   * listed in `adb devices` says only that adbd answers, and the churn it does\n   * not gate is paid later by whatever polls the WebView.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProperty, packageListOutput] = await Promise.all([\n        this.getDeviceProperty(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProperty, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  /**\n   * Runs both post-boot readiness gates, in order, on a device that has just\n   * reported `sys.boot_completed`.\n   *\n   * The single owner of \"which gates a device passes before a session\", so the\n   * started-device and reused-device branches cannot diverge on it \u2014 the branch\n   * that skipped a gate entirely is the hole a reused device once fell into (**L43**).\n   *\n   * @param deviceId - The device UDID to gate on.\n   * @param timeouts - The two resolved budgets.\n   */\n  private async waitForDeviceReady(deviceId: string, timeouts: DeviceReadinessTimeouts): Promise<void> {\n    await this.waitForDeviceIdle(deviceId, timeouts.deviceIdleTimeoutInMilliseconds);\n    await this.waitForNetworkValidated(deviceId, timeouts.networkReadyTimeoutInMilliseconds);\n  }\n\n  /**\n   * Waits for a booted emulator to have a **validated default network** before\n   * the session is established.\n   *\n   * The idle gate above says nothing about connectivity, and its two signals are\n   * satisfied well before the default network is created and validated \u2014 that\n   * lands ~80s into guest uptime, tens of seconds after the boot flag on a fast\n   * host. A suite started in that gap does not merely run slowly: a test\n   * that reaches the network runs to completion against a silently **empty\n   * result**, which no assertion inside the suite can distinguish from a\n   * genuinely empty response. Only a readiness gate can catch that, which is why\n   * this exists (see {@link checkNetworkValidated}, which also records why the\n   * three obvious connectivity probes are all wrong).\n   *\n   * Best-effort, on the same contract as the idle gate: if no validated network\n   * appears within the budget it logs a warning **naming the missing network**\n   * and proceeds (an offline AVD is still a usable one for suites that never\n   * touch the network), and a budget of `0` skips the wait entirely. The warning\n   * is the point \u2014 the failure it precedes otherwise surfaces as a bare\n   * `WebDriverError: script timeout` naming the transport, which reads as a\n   * harness defect rather than a missing route.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  /**\n   * Polls until this run's emulator is gone, or the budget elapses.\n   *\n   * @param params - The device, the PIDs this run owns, and the budget.\n   * @returns `true` when the emulator disappeared within the budget.\n   */\n  private async waitForEmulatorStopped(params: WaitForEmulatorStoppedParams): Promise<boolean> {\n    const deadline = Date.now() + params.timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      if (await this.checkIsEmulatorGone(params)) {\n        return true;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return false;\n  }\n\n  private async waitForNetworkValidated(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping network-ready wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to report a validated network (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    let probeFailureCount = 0;\n    let lastFailureReason = '';\n\n    while (Date.now() < deadline) {\n      const probe = await this.dumpConnectivity(deviceId);\n      const elapsed = String(Date.now() - start);\n      const connectivityOutput = probe.output;\n\n      if (connectivityOutput === undefined) {\n        probeFailureCount++;\n        lastFailureReason = probe.failureReason ?? 'unknown adb failure';\n        this.log(\n          `Device ${deviceId} connectivity probe failed (elapsed: ${elapsed}ms): ${lastFailureReason}. Retrying...`\n        );\n      } else if (checkNetworkValidated({ connectivityOutput })) {\n        this.log(`Device ${deviceId} has a validated network after ${elapsed}ms.`);\n        return;\n      } else {\n        this.log(`Device ${deviceId} has no validated network yet (elapsed: ${elapsed}ms). Retrying...`);\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    /*\n     * Two different diagnoses, never merged into one sentence: a guest that\n     * answered and reported no network is offline, while a guest that never\n     * answered says nothing about its network and everything about itself.\n     */\n    const diagnosis = probeFailureCount > 0\n      ? `${String(probeFailureCount)} of its connectivity probes failed, last \"${lastFailureReason}\", so the guest may be wedged rather than offline`\n      : 'it answered every probe and reported no validated default network';\n    this.log(\n      `Warning: device ${deviceId} reported no validated network within ${String(timeoutInMilliseconds)}ms (${diagnosis}); `\n        + 'proceeding with session establishment anyway. Tests that reach the network will run against a device with no route, '\n        + 'and may return EMPTY RESULTS rather than fail \u2014 read any empty-looking assertion failure below as a missing network first.'\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[], emulator: ProcessLaunch, timeouts: DeviceReadinessTimeouts): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceReady(actualDeviceId, timeouts);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildProcessExitMessage({\n          exitInfo,\n          output: emulator.readOutput(),\n          outputLabel: 'Emulator output',\n          subject: 'Android emulator'\n        }));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    // As in `waitForBoot`: an emulator that hangs has as much to say as one that dies.\n    throw new Error(appendProcessOutputTail(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`,\n      { output: emulator.readOutput(), outputLabel: 'Emulator output' }\n    ));\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * This is the single entry point every worker-side caller uses for the **ambient**\n * transport, so it is also where a failed global setup is turned into a failing test.\n * A failed setup publishes no transport options, and `undefined` options mean the owned\n * **desktop** CDP default \u2014 so without this guard an Android project's suite would run\n * on desktop and then die on an unrelated CDP error, hiding the real cause (**L9**).\n * The setup path itself is unaffected: `coreSetup` builds its transport through\n * {@link createTransportFromOptions} with explicit options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns The cached or newly created transport.\n * @throws {IntegrationSetupFailedError} When this project's global setup failed.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const setupError = getSetupError();\n  if (setupError) {\n    throw new IntegrationSetupFailedError(setupError);\n  }\n\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Verifies the harness-owned instance a worker was told to attach to is still\n * serving CDP, before handing back a transport that can only fail against it.\n *\n * This is the once-per-file check: transport creation is cached per worker, so\n * a live instance pays one loopback request per test file and a dead one turns\n * the whole file into a single named error, raised before the first test. It\n * replaces the `ECONNREFUSED`-per-file cascade a mid-run death used to produce \u2014\n * and the per-file probe consumers were writing into their own `setupFiles` to\n * get the same effect.\n *\n * Only for the harness's own instances: a plain attach targets a foreign\n * Obsidian whose absence is the user's to resolve, and `preflightCheck` already\n * has a story for it.\n *\n * @param host - The CDP host to probe.\n * @param port - The CDP port to probe.\n * @throws {OwnedInstanceExitedError} When nothing is serving CDP on the port.\n */\nasync function assertHarnessOwnedInstanceIsServing(host: string, port: number): Promise<void> {\n  const cdpUrl = `http://${host}:${String(port)}`;\n  try {\n    const response = await fetch(`${cdpUrl}/json/version`);\n    await response.body?.cancel();\n    return;\n  } catch {\n    // Nothing is listening \u2014 the instance the global setup launched is gone.\n  }\n\n  throw buildOwnedInstanceExitedErrorFromMarker(cdpUrl, readOwnedInstanceExitMarker(port));\n}\n\n/**\n * Builds the platform's \"list every process\" query.\n *\n * @returns The command and arguments to run.\n */\nfunction buildHostProcessQuery(): HostCommandQuery {\n  return process.platform === 'win32'\n    ? { command: 'tasklist', commandArguments: ['/FO', 'CSV', '/NH'] }\n    : { command: 'ps', commandArguments: ['-eo', 'pid=,comm='] };\n}\n\n/**\n * Builds the platform's \"who holds this port\" query.\n *\n * `netstat` cannot filter by port, so the whole table comes back and the parser\n * does the matching; `lsof` filters server-side and answers with bare PIDs.\n *\n * @param port - The port to query.\n * @returns The command and arguments to run.\n */\nfunction buildPortOwnerQuery(port: number): HostCommandQuery {\n  return process.platform === 'win32'\n    ? { command: 'netstat', commandArguments: ['-ano'] }\n    : { command: 'lsof', commandArguments: ['-ti', `tcp:${String(port)}`] };\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    if (options.isHarnessOwnedInstance) {\n      await assertHarnessOwnedInstanceIsServing(options.host ?? 'localhost', options.port);\n    }\n    return new DesktopCdpTransport(normalizeOptionalProperties<DesktopCdpTransportConfig>({\n      cdpHost: options.host,\n      cdpPort: options.port,\n      commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds,\n      isHarnessOwnedInstance: options.isHarnessOwnedInstance\n    }));\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  // Before `resolveOwnedInstanceConfig`, which may download and cache an installer shell:\n  // A structurally invalid config folder name cannot become valid later, so paying for a\n  // Provisioning round-trip first would only delay the same failure.\n  if (options?.configDirectory !== undefined) {\n    assertValidConfigDirectory(options.configDirectory);\n  }\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport(normalizeOptionalProperties<DesktopCdpTransportConfig>({\n    cdpHost: options?.host,\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    configDirectory: options?.configDirectory,\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    isObsidianAppVisible: options?.isObsidianAppVisible,\n    ownedInstance,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnSilentAsarFallback: willThrowOnSilentAsarFallback(options?.shouldThrowOnSilentAsarFallback),\n    shouldWarnOnCompatibilityIssues: willWarnOnCompatibilityIssues(options?.shouldWarnOnCompatibilityIssues)\n  }));\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDirectory(): string {\n  const root = join(tmpdir(), HARNESS_TEMP_DIR_NAME);\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_DIR_PREFIX));\n}\n\n/**\n * Returns the first rejection reason among settled outcomes.\n *\n * @param outcomes - The settled outcomes, at least one of which is expected to have rejected.\n * @returns The first rejection reason, or a stand-in error when none rejected.\n */\nfunction getSettledFailure(outcomes: readonly PromiseSettledResult<unknown>[]): unknown {\n  for (const outcome of outcomes) {\n    if (outcome.status === 'rejected') {\n      return outcome.reason;\n    }\n  }\n\n  return new Error('Android provisioning failed without naming a reason.');\n}\n\n/**\n * Loads `webdriverio` on demand.\n *\n * The load is deferred because a static import would drag the whole WebDriver\n * stack (`webdriverio` + `@wdio/*` + `archiver`/`cheerio`/`jszip`) into every\n * consumer of this package's index \u2014 `evalInObsidian` reaches this module \u2014 when\n * only the Appium transport needs it. Nothing on the desktop CDP path touches\n * `webdriverio` at all.\n *\n * It also keeps `chalk` out of that graph. `@wdio/logger` imports `chalk@5`,\n * whose internal `#supports-color` subpath import Jest's VM-modules linker fails\n * to link, so an eagerly-imported `webdriverio` kills a Jest ESM suite at import\n * with `ReferenceError: Cannot access 'supportsColor' before initialization`\n * before a single test runs \u2014 which is what once made `test:jest` red. A\n * `moduleNameMapper` cannot patch it: the mapper is bypassed for `#` specifiers.\n *\n * @returns A {@link Promise} that resolves to the `webdriverio` entry points the\n * Appium factory calls.\n */\nasync function importWebdriverio(): Promise<WebdriverioModule> {\n  // eslint-disable-next-line no-restricted-syntax -- `webdriverio` is Appium-only, so it must be loaded lazily: a static import would drag the whole WebDriver stack into every consumer of this package's index, and `chalk` with it (see the doc comment).\n  return await import('webdriverio');\n}\n\n/**\n * Parses a host process listing with the platform's parser.\n *\n * @param output - Raw stdout of {@link buildHostProcessQuery}'s command.\n * @returns The listed processes.\n */\nfunction parseHostProcessList(output: string): ProcessListEntry[] {\n  return process.platform === 'win32' ? parseWindowsTaskList(output) : parsePosixProcessList(output);\n}\n\n/**\n * Parses a port-owner listing with the platform's parser.\n *\n * @param params - The raw output and the port that was queried.\n * @returns The PIDs holding the port.\n */\nfunction parsePortOwnerPids(params: ParsePortOwnerPidsParams): number[] {\n  return process.platform === 'win32'\n    ? parseWindowsNetstatPids({ netstatOutput: params.output, port: params.port })\n    : parsePosixLsofPids(params.output);\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: for an installer below the app's run floor either throws\n * {@link IncompatibleInstallerVersionError} (when\n * {@link ResolveAndReportCompatibilityParams.shouldThrowOnIncompatibleInstaller})\n * or proceeds to launch with a warning; for a runnable-but-below-recommended\n * installer logs a warning. Both warnings are suppressed when\n * {@link ResolveAndReportCompatibilityParams.shouldWarnOnCompatibilityIssues} is\n * `false`.\n *\n * @param params - The resolved versions and the warn/throw knobs.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction resolveAndReportCompatibility(params: ResolveAndReportCompatibilityParams): InstallerCompatibility | undefined {\n  const { appVersion, installerVersion, shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues } = params;\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = resolveInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  const action = resolveInstallerCompatibilityAction({\n    shouldThrowOnIncompatibleInstaller,\n    shouldWarnOnCompatibilityIssues,\n    tier: compatibility.tier\n  });\n\n  if (action === 'throw') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (action === 'warn-unrunnable') {\n    log(\n      `[transport-factory:obsidian-cdp] Obsidian installer ${ensureNonNullable(compatibility.installerVersion)} is below the `\n        + `run floor ${ensureNonNullable(compatibility.minRunnableInstallerVersion)} for Obsidian ${compatibility.appVersion}; `\n        + 'proceeding to launch (shouldThrowOnIncompatibleInstaller is false) \u2014 the boot will likely dead-boot.'\n    );\n  } else if (action === 'warn-nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDirectory());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link resolveInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = resolveAndReportCompatibility({\n    appVersion: swapAppVersion,\n    installerVersion: shellVersion,\n    shouldThrowOnIncompatibleInstaller: willThrowOnIncompatibleInstaller(options?.shouldThrowOnIncompatibleInstaller),\n    shouldWarnOnCompatibilityIssues: willWarnOnCompatibilityIssues(options?.shouldWarnOnCompatibilityIssues)\n  });\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n\n    userDataDirectory: createOwnedUserDataDirectory()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\nimport type {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport {\n  execFile,\n  execFileSync,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync,\n  statSync\n} from 'node:fs';\nimport http from 'node:http';\nimport {\n  homedir,\n  tmpdir\n} from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { AppiumServerMarker } from './appium-server-marker.mjs';\nimport type { AvdProbeResult } from './avd-probe-verdict.mjs';\nimport type { EmulatorLivenessProbeOutcome } from './emulator-liveness.mjs';\nimport type { HostCommandQuery } from './emulator-reclaim.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ProcessExitInfo } from './process-exit-message.mjs';\nimport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceConfig\n} from './transport-desktop-cdp.mjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\nimport type { WedgedAppiumServerReportReason } from './wedged-appium-server.mjs';\n\nimport {\n  checkIsDeviceListed,\n  listOnlineDeviceIds,\n  parseAdbDevices\n} from './adb-device-list.mjs';\nimport { resolveEmulatorBinaryPath } from './android-sdk.mjs';\nimport {\n  checkIsAppiumDriverInstalled,\n  UIAUTOMATOR2_DRIVER_NAME,\n  willAutoInstallAppiumDependencies\n} from './appium-dependencies.mjs';\nimport {\n  checkIsHarnessOwnedAppiumServer,\n  clearAppiumServerMarker,\n  readAppiumServerMarker,\n  recordAppiumServerStopAttempt,\n  writeAppiumServerMarker\n} from './appium-server-marker.mjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveScriptTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.mjs';\nimport {\n  checkAvdExists,\n  listAvailableAvds\n} from './avd-list.mjs';\nimport {\n  buildAvdProbeSummary,\n  buildUnreadableDevicesMessage,\n  checkIsEmulatorDeviceId,\n  classifyAvdProbe,\n  resolveAvdProbeVerdict\n} from './avd-probe-verdict.mjs';\nimport {\n  resolveInstallerCompatibilityAction,\n  willThrowOnIncompatibleInstaller,\n  willThrowOnSilentAsarFallback,\n  willWarnOnCompatibilityIssues\n} from './compatibility-options.mjs';\nimport { assertValidConfigDirectory } from './config-directory.mjs';\nimport { getSetupError } from './context-provider.mjs';\nimport {\n  checkDeviceIdle,\n  checkNetworkValidated,\n  resolveDeviceIdleTimeoutInMilliseconds,\n  resolveNetworkReadyTimeoutInMilliseconds\n} from './device-readiness.mjs';\nimport {\n  buildEmulatorArguments,\n  buildEmulatorEnvironment,\n  NETSIM_LOG_FILTER\n} from './emulator-arguments.mjs';\nimport { selectEmulatorBackendPids } from './emulator-backend.mjs';\nimport {\n  buildEmulatorLivenessMessage,\n  resolveEmulatorLivenessVerdict\n} from './emulator-liveness.mjs';\nimport {\n  checkIsMarkedEmulatorRunning,\n  clearEmulatorMarker,\n  clearEmulatorMarkerIfStopped,\n  readEmulatorMarker,\n  resolveEmulatorMarkerVerdict,\n  selectLiveMarkedPids,\n  writeEmulatorMarker\n} from './emulator-marker.mjs';\nimport { spawnEmulatorReaper } from './emulator-reaper.mjs';\nimport {\n  ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,\n  ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,\n  EmulatorReclaimer,\n  HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS\n} from './emulator-reclaim.mjs';\nimport {\n  buildAvdSnapshotDirectoryCandidates,\n  buildSnapshotAgeMessage\n} from './emulator-snapshot.mjs';\nimport { exec } from './exec.mjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nimport { resolveInstallerCompatibility } from './installer-compatibility.mjs';\nimport { IntegrationSetupFailedError } from './integration-setup-failed-error.mjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.mjs';\nimport {\n  HARNESS_TEMP_DIR_NAME,\n  OWNED_USER_DATA_DIR_PREFIX,\n  sweepDeviceLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { getObsidianConfigDirectory } from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.mjs';\nimport { compareVersions } from './obsidian-version.mjs';\nimport { readOwnedInstanceExitMarker } from './owned-instance-exit-marker.mjs';\nimport { buildOwnedInstanceExitedErrorFromMarker } from './owned-instance-exited-error.mjs';\nimport {\n  parsePosixLsofPids,\n  parseWindowsNetstatPids\n} from './port-owner.mjs';\nimport {\n  appendProcessOutputTail,\n  buildProcessExitMessage\n} from './process-exit-message.mjs';\nimport { checkIsProcessAlive } from './process-liveness.mjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.mjs';\nimport {\n  resolveAppiumSpawnFlags,\n  resolveEmulatorSpawnFlags\n} from './spawn-options.mjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.mjs';\nimport {\n  AppiumTransport,\n  DEFAULT_ANDROID_VAULT_BASE_PATH\n} from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport {\n  assertNever,\n  ensureNonNullable\n} from './type-guards.mjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.mjs';\nimport {\n  buildWedgedAppiumServerMessage,\n  checkIsAppiumStatusReady,\n  resolveWedgedAppiumServerRemedy\n} from './wedged-appium-server.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\n/*\n * How many times the AVD adoption probe asks a device which AVD it is serving.\n * One retry, because the alternative to an answer is refusing to launch: a\n * second 5s look is far cheaper than either a false refusal or the colliding\n * launch a discarded timeout used to authorize (see `avd-probe-verdict.ts`).\n */\nconst AVD_PROBE_ATTEMPT_COUNT = 2;\n/*\n * The connectivity dump gets a budget of its OWN, well above the 5s the other\n * probes share \u2014 not because the dump is slow (measured 0.9-2.4s on a responsive\n * guest, alongside `getprop`'s 0.7-2.1s), but because it runs in the window\n * where residual post-boot contention still inflates every `adb` round-trip\n * 25-50x (L19). At 5s it overran on EVERY poll of the first end-to-end run,\n * and an overrun is reported as \"no network\", so too small a budget does not\n * degrade this gate \u2014 it silently disables it while the gate claims the\n * opposite. 30s is ~15x the idle cost, which is that inflation with room.\n */\nconst ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_STOP_TIMEOUT_IN_MILLISECONDS = 15_000;\nconst ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS = 30_000;\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst ANDROID_APPIUM_TRANSPORT_TYPE: ObsidianAndroidAppiumTransportOptions['type'] = 'obsidian-android-appium';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\n/*\n * Budget for each of the two liveness probes taken immediately before the\n * session (see `emulator-liveness.ts`). Well above the 5s the preflight probes\n * share, because this one runs in the post-boot contention window that inflates\n * every `adb` round-trip 25-50x (L45) \u2014 and here a false \"no answer\" would\n * abort a run that was about to work, which is a worse error than waiting.\n * 15s is what the six hand-boots that measured the wedge used, and no healthy\n * guest came close to it: the failures hung indefinitely rather than answering\n * slowly.\n */\nconst DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS = 15_000;\n/*\n * How many times each liveness probe is asked before its silence is believed.\n * One retry, matching `AVD_PROBE_ATTEMPT_COUNT` and for the same reason: the\n * verdict aborts the run, so a second look is far cheaper than a wrong call.\n */\nconst DEVICE_LIVENESS_ATTEMPT_COUNT = 2;\n/*\n * How many emulators a run may boot before giving up. One retry: the wedge that\n * motivates it is not deterministic \u2014 measured 2026-09-05, a first emulator went\n * quiet 129s in and the replacement booted 11s later ran the whole suite \u2014 but a\n * cold boot costs ~90-220s, so a second failure is where the run should stop and\n * say so rather than keep paying.\n */\nconst EMULATOR_BOOT_ATTEMPT_COUNT = 2;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120_000;\nconst EMULATOR_LIST_TIMEOUT_IN_MILLISECONDS = 10_000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst HTTP_MULTIPLE_CHOICES = 300;\nconst HTTP_OK = 200;\n// The W3C default, restated because `timeouts` is set as a whole bag; no element is ever located implicitly here.\nconst IMPLICIT_WAIT_TIMEOUT_IN_MILLISECONDS = 0;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS = 2000;\n/*\n * How long the server waits for a new command before assuming the client quit\n * and ending the session. Appium reads `newCommandTimeout` in SECONDS, which the\n * name this constant used to carry (`COMMAND_TIMEOUT_IN_MILLISECONDS`) got\n * wrong \u2014 the value was always the intended five minutes, and only the unit in\n * the name was a lie. It is unrelated to the per-script cap, which is\n * `timeouts.script`.\n */\nconst NEW_COMMAND_TIMEOUT_IN_SECONDS = 300;\n// The W3C default, restated for the same reason as the implicit wait above.\nconst PAGE_LOAD_TIMEOUT_IN_MILLISECONDS = 300_000;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120_000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120_000;\n/*\n * The sync teardown runs inside `process.on('exit')`, so this query blocks the\n * exit itself. Short on purpose: losing the escalation is better than holding\n * the handler for the async path's 30s, and the sync log never claims a\n * verified stop anyway.\n */\nconst SYNC_TEARDOWN_QUERY_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /**\n  The user's newest installed asar to provision as-is (no download).\n   */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /**\n  The app version to download and asar-swap onto the shell.\n   */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /**\n  The app version whose own installer shell to download (a downgrade).\n   */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Outcome of one `dumpsys connectivity` probe: exactly one field is set.\n *\n * A failed probe carries **why** it failed rather than collapsing into \"no\n * output\", because the two failures look nothing alike in practice and only one\n * of them is worth waiting out \u2014 a 30s timeout is a contended guest, while an\n * instant `error: closed` is a dead one.\n */\ninterface ConnectivityProbeResult {\n  /**\n  Why the probe failed, set iff it did not answer.\n   */\n  readonly failureReason?: string | undefined;\n\n  /**\n  The raw dump, set iff the probe answered.\n   */\n  readonly output?: string | undefined;\n}\n\n/**\n * The two post-boot readiness budgets, carried together so the started-device\n * and reused-device branches cannot drift apart on which gates they run.\n */\ninterface DeviceReadinessTimeouts {\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n}\n\n/**\n * The emulator's captured output, carried past boot so a failure during session\n * creation can still quote it.\n *\n * Boot used to be the end of the emulator's usefulness as a witness: the capture\n * was frozen the moment a device appeared, and nothing read it again. But the\n * lines that explain a wedge \u2014 `detected a hanging thread 'QEMU2 main loop'`,\n * netsim's `Unable to reconnect to packet streamer` \u2014 are printed *after* that,\n * while the harness is inside `establishSession`. So the window now closes when\n * the session is established rather than when the device appears, and this pair\n * is what the session path needs to hold to do that (see `emulator-liveness.ts`).\n */\ninterface EmulatorCapture {\n  /**\n  Returns the captured stdout+stderr tail (bounded to the most recent output).\n   */\n  readonly read: () => string;\n\n  /**\n  Freezes the tail. Called once the session is established and the emulator has nothing left to explain.\n   */\n  readonly stop: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /**\n  AVD name to connect to (starting a new emulator if not already running).\n   */\n  readonly avdName: string;\n\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started emulator window is shown (omitted \u2192 hidden).\n   */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started emulator may resume and refresh the AVD's boot snapshot (omitted \u2192 cold boot).\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /**\n  The actual device ID that is connected (may differ from the requested one).\n   */\n  readonly actualDeviceId: string;\n\n  /**\n   * The emulator's output capture, when this run started it. Absent for an\n   * adopted device, whose emulator this run never spawned and whose output it\n   * therefore never had.\n   */\n  readonly emulatorCapture?: EmulatorCapture | undefined;\n\n  /**\n  The emulator process, if one was auto-started.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n   * The emulator processes this run is responsible for killing \u2014 the launcher\n   * plus the QEMU backend it forked, identified by diffing the host's process\n   * list across the launch. Empty when the device was reused rather than\n   * started. See `emulator-backend.ts` for why the launcher's PID alone is not\n   * enough.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.establishSession}.\n */\ninterface EstablishSessionParams {\n  /**\n  The Android package the session drives.\n   */\n  readonly appId: string;\n\n  /**\n  The marker of the adopted server, when an earlier run of this harness left one.\n   */\n  readonly appiumServerMarker: AppiumServerMarker | undefined;\n\n  /**\n  Resolved timeout in milliseconds for a replacement Appium server to become ready.\n   */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /**\n  The device the session is established against.\n   */\n  readonly deviceId: string;\n\n  /**\n  Whether the server was adopted rather than started by this run.\n   */\n  readonly isAdoptedServer: boolean;\n\n  /**\n  Whether a replacement server's console window is shown (omitted \u2192 hidden).\n   */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /**\n  The Appium server port.\n   */\n  readonly port: number;\n\n  /**\n  Resolved per-script (per-`evalInObsidian`) cap in milliseconds, sent as the W3C `timeouts.script` capability.\n   */\n  readonly scriptTimeoutInMilliseconds: number;\n\n  /**\n  Resolved WebDriverIO connection retry timeout in milliseconds.\n   */\n  readonly sessionConnectionRetryTimeoutInMilliseconds: number;\n\n  /**\n  Whether Appium auto-start is allowed \u2014 a `false` here also forbids replacing a wedged server.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  The Appium server URL.\n   */\n  readonly url: URL;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.establishSession}.\n */\ninterface EstablishSessionResult {\n  /**\n  The replacement Appium server process, when a wedged one had to be restarted.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The established session.\n   */\n  readonly browser: Awaited<ReturnType<typeof remote>>;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface InstalledShell {\n  /**\n  Absolute path to the installed shell executable.\n   */\n  readonly exePath: string;\n\n  /**\n  The detected shell version, or `undefined` when it cannot be determined.\n   */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * A spawned child process (the Android emulator or the Appium server) together\n * with helpers to inspect its captured output and exit status.\n */\ninterface ParsePortOwnerPidsParams {\n  /**\n  Raw stdout of the platform's port query.\n   */\n  readonly output: string;\n\n  /**\n  The port that was queried.\n   */\n  readonly port: number;\n}\n\ninterface ProcessLaunch {\n  /**\n  The spawned process.\n   */\n  process: ChildProcess;\n\n  /**\n  Returns the exit / spawn-failure details once the process is no longer running, otherwise `undefined`.\n   */\n  readExitInfo: () => ProcessExitInfo | undefined;\n\n  /**\n  Returns the captured stdout+stderr (bounded to the most recent output).\n   */\n  readOutput: () => string;\n\n  /**\n  Stops accumulating output. Call once startup has succeeded.\n   */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface ReclaimUnstoppedAppiumServerParams {\n  /**\n  The marker that proves the leftover is this harness's own.\n   */\n  readonly marker: AppiumServerMarker;\n\n  /**\n  The port it is holding.\n   */\n  readonly port: number;\n\n  /**\n  Whether this run is allowed to start a replacement.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  The server's URL.\n   */\n  readonly url: URL;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.recordEmulatorLaunchDevice}.\n */\ninterface RecordEmulatorLaunchDeviceParams {\n  /**\n  The AVD whose launch was recorded.\n   */\n  readonly avdName: string;\n\n  /**\n  The device that has just appeared in ADB.\n   */\n  readonly deviceId: string;\n\n  /**\n  When the emulator was launched \u2014 what identifies the launch this device belongs to.\n   */\n  readonly launchedAtInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.recordEmulatorLaunch}.\n */\ninterface RecordEmulatorLaunchParams {\n  /**\n  The AVD being started.\n   */\n  readonly avdName: string;\n\n  /**\n  The launcher just spawned for it.\n   */\n  readonly emulator: ProcessLaunch;\n\n  /**\n  When it was launched, which every later write of this marker keeps.\n   */\n  readonly launchedAtInMilliseconds: number;\n\n  /**\n  The emulator processes that predate the launch, so the backend it forks can be identified without a second snapshot.\n   */\n  readonly preLaunchEmulatorPids: readonly number[];\n}\n\ninterface StartAppiumAndEmulatorParams {\n  /**\n  Resolved timeout in milliseconds for the auto-started Appium server to become ready.\n   */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /**\n  The Appium server URL.\n   */\n  readonly appiumUrl: URL;\n\n  /**\n  AVD name to start.\n   */\n  readonly avdName: string;\n\n  /**\n  Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it).\n   */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /**\n  Whether the auto-started Appium server console window is shown (omitted \u2192 hidden).\n   */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /**\n  Whether the auto-started emulator window is shown (omitted \u2192 hidden).\n   */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /**\n  Resolved timeout in milliseconds for the network-ready wait (`0` skips it).\n   */\n  readonly networkReadyTimeoutInMilliseconds: number;\n\n  /**\n  The Appium server port.\n   */\n  readonly port: number;\n\n  /**\n  Whether missing Appium dependencies may be auto-installed before the server is auto-started.\n   */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /**\n  Whether Appium auto-start is allowed.\n   */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n\n  /**\n  Whether the auto-started emulator may resume and refresh the AVD's boot snapshot (omitted \u2192 cold boot).\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /**\n  The actual device ID that is connected (may differ from the requested one).\n   */\n  readonly actualDeviceId: string;\n\n  /**\n  The Appium server process, if one was auto-started.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The adopted server's marker, when an earlier run of this harness left one.\n   */\n  readonly appiumServerMarker?: AppiumServerMarker | undefined;\n\n  /**\n  The emulator's output capture, when this run started it.\n   */\n  readonly emulatorCapture?: EmulatorCapture | undefined;\n\n  /**\n  The emulator process, if one was auto-started.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n   * Whether an already-listening server was adopted rather than started by this\n   * run. Only an adopted server can be the stale one `wedged-appium-server.ts`\n   * describes.\n   */\n  readonly isAdoptedAppiumServer: boolean;\n\n  /**\n  The emulator processes this run is responsible for killing; empty when the device was reused.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.sweepDeviceLeftoverVaults}.\n */\ninterface StopAutoStartedAppiumServerParams {\n  /**\n  The server process this run spawned.\n   */\n  readonly appiumProcess: ChildProcess;\n\n  /**\n  The port it was started on, whose marker is cleared or stamped by the outcome.\n   */\n  readonly port: number;\n\n  /**\n  The server's URL, polled to decide whether it actually stopped.\n   */\n  readonly url: URL;\n}\n\ninterface StopAutoStartedProcessesParams {\n  /**\n  The Appium server process, when this run started one.\n   */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /**\n  The AVD name, for the emulator's warning.\n   */\n  readonly avdName: string;\n\n  /**\n  The device the emulator is serving, when this run started one.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator launcher process, when this run started one.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n  The emulator PIDs this run owns \u2014 started, or taken over as a leftover. Non-empty means the emulator is this run's to stop.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  The Appium port.\n   */\n  readonly port: number;\n\n  /**\n  The Appium server URL.\n   */\n  readonly url: URL;\n}\n\ninterface StopEmulatorAfterFailedStartParams {\n  /**\n  The AVD the emulator was started for.\n   */\n  readonly avdName: string;\n\n  /**\n  The online devices listed before the launch.\n   */\n  readonly deviceIdsBefore: readonly string[];\n\n  /**\n  The launch that failed.\n   */\n  readonly emulator: ProcessLaunch;\n\n  /**\n  The emulator processes that predate the launch, and are therefore not this run's.\n   */\n  readonly emulatorPidsBefore: readonly number[];\n}\n\ninterface SweepDeviceLeftoverVaultsParams {\n  /**\n  The device UDID to sweep.\n   */\n  readonly deviceId: string;\n\n  /**\n  The device-side directory Obsidian Mobile stores its vaults in.\n   */\n  readonly vaultBasePath: string;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Parameters for {@link resolveAndReportCompatibility}.\n */\ninterface ResolveAndReportCompatibilityParams {\n  /**\n   * The app (asar) version that will be swapped onto the shell, or `undefined`\n   * when no asar-swap will happen (nothing is checked then).\n   */\n  readonly appVersion: string | undefined;\n\n  /**\n  The resolved installer/shell version, or `undefined`.\n   */\n  readonly installerVersion: string | undefined;\n\n  /**\n   * Whether an `'unrunnable'` verdict throws {@link IncompatibleInstallerVersionError}\n   * (`true`) or proceeds to launch with the verdict surfaced as data (`false`).\n   */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /**\n  Whether a `'nagged'` (or proceeding-`'unrunnable'`) verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n}\n\n/**\n * The slice of `webdriverio`'s surface the Appium factory calls, named so the\n * lazy load has a return type without a static import of the module itself.\n */\ninterface WebdriverioModule {\n  /**\n  Reattaches to an existing WebDriver session.\n   */\n  readonly attach: typeof attach;\n\n  /**\n  Creates a new WebDriver session.\n   */\n  readonly remote: typeof remote;\n}\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly emulators: EmulatorReclaimer;\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n    this.emulators = new EmulatorReclaimer((message) => {\n      this.log(message);\n    });\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  /**\n   * Arms the emulator reaper (`emulator-reaper.ts`) for an emulator this run has\n   * just recorded as its own.\n   *\n   * @param avdName - The AVD whose marker was just written.\n   * @param startedAtInMilliseconds - The emulator's launch time, as the marker records it.\n   */\n  private armEmulatorReaper(avdName: string, startedAtInMilliseconds: number): void {\n    spawnEmulatorReaper({\n      avdName,\n      log: (message) => {\n        this.log(message);\n      },\n      startedAtInMilliseconds\n    });\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const { attach } = await importWebdriverio();\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      // The session this reattaches to was created with the same resolution, so the number reported on a\n      // Script timeout is the one that session is actually enforcing.\n      scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),\n      shouldSweepLeftovers: willSweepLeftovers(options),\n      ...(options.appStartTimeoutInMilliseconds !== undefined && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds }),\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private buildWedgedMessage(params: EstablishSessionParams, reason: WedgedAppiumServerReportReason): string {\n    const marker = params.appiumServerMarker;\n    return buildWedgedAppiumServerMessage({\n      appiumOrigin: params.url.origin,\n      deviceId: params.deviceId,\n      reason,\n      ...(marker !== undefined && {\n        serverAgeInMilliseconds: Date.now() - marker.startedAtInMilliseconds,\n        serverPid: marker.pid\n      })\n    });\n  }\n\n  /**\n   * Preflight probe for an already-running server.\n   *\n   * Liveness is not readiness: resolving on *any* response adopts a server that\n   * is refusing sessions (a non-2xx `/status`, or one that reports itself\n   * shutting down) exactly like a healthy one. Rejecting instead hands those\n   * cases to the auto-start path. It cannot catch the wedged server of\n   * `wedged-appium-server.ts` \u2014 that one answers `ready: true` \u2014 which is why\n   * the wedge is recognized from the failed session instead.\n   *\n   * @param url - The Appium server URL.\n   */\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      /*\n       * `agent: false` \u2014 never a pooled socket. The global agent keeps sockets\n       * alive per host:port, so a probe after a server on that port was replaced\n       * can reuse the dead socket and fail with `ECONNRESET` regardless of what\n       * is listening now. That would make `waitForAppiumStopped` call a live\n       * server dead, and it is exactly the sequence the wedged-server restart\n       * performs. A fresh socket per probe costs nothing at this frequency.\n       */\n      const request = http.get(statusUrl, { agent: false, timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (response) => {\n        const statusCode = response.statusCode ?? 0;\n        if (statusCode < HTTP_OK || statusCode >= HTTP_MULTIPLE_CHOICES) {\n          response.resume();\n          reject(new Error(`Appium server at ${url.origin} answered /status with HTTP ${String(statusCode)}; it is not accepting sessions.`));\n          return;\n        }\n\n        response.setEncoding('utf-8');\n        let body = '';\n        response.on('data', (chunk: string) => {\n          body += chunk;\n        });\n        response.on('end', () => {\n          if (checkIsAppiumStatusReady(body)) {\n            resolve();\n            return;\n          }\n\n          reject(new Error(`Appium server at ${url.origin} reports it is not ready to accept new connections.`));\n        });\n      });\n      request.on('timeout', () => {\n        request.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      request.on('error', (error) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${error.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  /**\n   * Waits out the Appium port and reports whether it went quiet, rather than\n   * throwing as {@link waitForAppiumStopped} does.\n   *\n   * @param url - The Appium server URL.\n   * @param timeoutInMilliseconds - How long to wait.\n   * @returns `true` when nothing answers on the port any more.\n   */\n  private async checkIsAppiumStopped(url: URL, timeoutInMilliseconds: number): Promise<boolean> {\n    try {\n      await this.waitForAppiumStopped(url, timeoutInMilliseconds);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Checks whether adb still lists the device **in any state**, without letting\n   * an adb that itself fails count as evidence.\n   *\n   * Any state, not just `device`: a dying emulator answers `offline` while it is\n   * still the thing that is wrong (the distinction `adb-device-list.ts` draws\n   * for teardown, and the reasoning carries over). Reading `offline` as gone\n   * here would report `device-gone` for what is really a wedge, sending the\n   * reader to look for a vanished emulator that is in fact still sitting there.\n   *\n   * @param deviceId - The device to look for.\n   * @returns `true` when it is listed; `false` when it is not, or adb could not be run.\n   */\n  private async checkIsDeviceListedQuietly(deviceId: string): Promise<boolean> {\n    try {\n      return checkIsDeviceListed({ deviceId, devicesOutput: await this.emulators.getDevicesOutput() });\n    } catch (error: unknown) {\n      this.log(`Could not re-check the device listing: ${error instanceof Error ? error.message : String(error)}`);\n      return false;\n    }\n  }\n\n  private async connectSession(params: EstablishSessionParams): Promise<Awaited<ReturnType<typeof remote>>> {\n    const { remote } = await importWebdriverio();\n    return remote({\n      capabilities: {\n        'appium:appActivity': APP_ACTIVITY,\n        'appium:appPackage': params.appId,\n        'appium:autoGrantPermissions': true,\n        'appium:automationName': 'UiAutomator2',\n        'appium:newCommandTimeout': NEW_COMMAND_TIMEOUT_IN_SECONDS,\n        'appium:noReset': true,\n        'appium:udid': params.deviceId,\n        'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n        'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n        'platformName': 'Android',\n        /*\n         * `script` is declared so the per-closure cap is a number this harness owns and states, but the\n         * Declaration is NOT what enforces it: UiAutomator2 was measured accepting this, reporting it\n         * Back as 30000 from the WebView context, and never acting on it \u2014 over-cap closures ran past a\n         * 60s ceiling without one `script timeout`. `AppiumTransport.evaluate` enforces the same number\n         * Node-side, and this stays because it is free, it is the honest declaration of the intended\n         * Budget, and it would start working on its own if a future driver honoured it. The other two are\n         * Restated at their W3C defaults only because the capability is all-or-nothing \u2014 WebDriverIO's\n         * `Timeouts` type has no partial form \u2014 so they change nothing.\n         */\n        'timeouts': {\n          implicit: IMPLICIT_WAIT_TIMEOUT_IN_MILLISECONDS,\n          pageLoad: PAGE_LOAD_TIMEOUT_IN_MILLISECONDS,\n          script: params.scriptTimeoutInMilliseconds\n        }\n      },\n      connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n      connectionRetryTimeout: params.sessionConnectionRetryTimeoutInMilliseconds,\n      hostname: params.url.hostname,\n      logLevel: 'warn',\n      path: params.url.pathname,\n      port: params.port,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (Number.isNaN(port)) {\n      throw new TypeError(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let actualDeviceId: string | undefined;\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n    let ownedEmulatorPids: readonly number[] = [];\n\n    let result: StartAppiumAndEmulatorResult | undefined;\n\n    try {\n      /*\n       * Provision, then check the device is still answering \u2014 and when it is not\n       * and the emulator is ours, boot a fresh one instead of carrying on.\n       *\n       * A wedge is NOT deterministic, which is what justifies the retry. In the\n       * run that proved it (2026-09-05) the first emulator went quiet 129s in and\n       * the second, booted 11s later from the same AVD with the same arguments,\n       * established a session and drove the WebView to completion. An earlier\n       * draft of this work argued the opposite from the hand-boot data \u2014 that a\n       * re-boot buys the same failure 90s later \u2014 and that was simply wrong:\n       * every hand-boot was a first boot, so the data said nothing about second\n       * ones.\n       */\n      for (let attempt = 1; attempt <= EMULATOR_BOOT_ATTEMPT_COUNT; attempt++) {\n        result = await this.startAppiumAndEmulator({\n          appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n          appiumUrl: url,\n          avdName: options.avdName,\n          deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n          isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n          isEmulatorVisible: options.isEmulatorVisible,\n          networkReadyTimeoutInMilliseconds: resolveNetworkReadyTimeoutInMilliseconds(options),\n          port,\n          shouldAutoInstallAppiumDependencies: willAutoInstallAppiumDependencies(options),\n          shouldAutoStartAppium: options.shouldAutoStartAppium,\n          shouldReuseEmulatorSnapshot: options.shouldReuseEmulatorSnapshot\n        });\n\n        /*\n         * Only ever REPLACE this handle, never clear it. The retry leaves this\n         * run's Appium server running and swaps only the emulator, so the second\n         * pass finds that server reachable, ADOPTS it, and returns no process\n         * handle. Writing that `undefined` over the handle from the first pass\n         * would orphan the very server this run started \u2014 the leak L46 exists to\n         * prevent, reintroduced by the retry.\n         */\n        if (result.appiumProcess !== undefined) {\n          appiumProcess = result.appiumProcess;\n        }\n        emulatorProcess = result.emulatorProcess;\n        ownedEmulatorPids = result.ownedEmulatorPids;\n        actualDeviceId = result.actualDeviceId;\n\n        /*\n         * Before `remote()` launches Obsidian \u2014 the last point at which nothing\n         * has to enumerate the device's vaults yet.\n         */\n        if (willSweepLeftovers(options)) {\n          await this.sweepDeviceLeftoverVaults({\n            deviceId: actualDeviceId,\n            vaultBasePath: options.vaultBasePath ?? DEFAULT_ANDROID_VAULT_BASE_PATH\n          });\n        }\n\n        /*\n         * The last point at which a device that has gone quiet can still be\n         * reported as itself. Past here the failure belongs to Appium, which can\n         * only say the device is \"not in the list of connected devices\" \u2014 an\n         * error that names the one thing that is not wrong.\n         */\n        const diagnosis = await this.diagnoseDevice(actualDeviceId, result.emulatorCapture);\n        if (diagnosis === undefined) {\n          break;\n        }\n\n        /*\n         * Only an emulator this run owns may be replaced \u2014 one it started, or a\n         * leftover of this harness it took over. A device that was merely\n         * adopted (`ownedEmulatorPids` empty) is somebody else's to restart \u2014\n         * the same ownership line teardown draws in never sweeping `qemu*`.\n         */\n        const ownedEmulatorProcess = emulatorProcess;\n        const canRetry = attempt < EMULATOR_BOOT_ATTEMPT_COUNT && ownedEmulatorPids.length > 0;\n        if (!canRetry) {\n          throw new Error(diagnosis);\n        }\n\n        this.log(`${diagnosis}\\n\\nBooting a fresh emulator and trying once more (attempt ${String(attempt + 1)} of ${String(EMULATOR_BOOT_ATTEMPT_COUNT)}).`);\n        /*\n         * Disown BEFORE stopping, not after: this run hands the emulator over to\n         * `stopEmulator` and must not still be holding it if that throws, or the\n         * outer catch's teardown would go after the same processes a second\n         * time.\n         */\n        const doomedDeviceId = actualDeviceId;\n        const doomedPids = ownedEmulatorPids;\n        emulatorProcess = undefined;\n        ownedEmulatorPids = [];\n        actualDeviceId = undefined;\n        await this.emulators.stopEmulator({\n          avdName: options.avdName,\n          deviceId: doomedDeviceId,\n          emulatorProcess: ownedEmulatorProcess,\n          ownedEmulatorPids: doomedPids\n        });\n      }\n\n      if (result === undefined || actualDeviceId === undefined) {\n        throw new Error(`Could not provision an Android device for AVD \"${options.avdName}\".`);\n      }\n\n      const sessionResult = await this.establishSessionOrDiagnoseDevice(result.emulatorCapture, {\n        appId,\n        appiumServerMarker: result.appiumServerMarker,\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        deviceId: actualDeviceId,\n        isAdoptedServer: result.isAdoptedAppiumServer,\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        port,\n        scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),\n        sessionConnectionRetryTimeoutInMilliseconds: resolveSessionConnectionRetryTimeoutInMilliseconds(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium,\n        url\n      });\n\n      const browser = sessionResult.browser;\n      // A wedged adopted server is replaced by one this run owns, so it must be torn down like any other auto-started server.\n      if (sessionResult.appiumProcess !== undefined) {\n        appiumProcess = sessionResult.appiumProcess;\n      }\n\n      this.log('Appium session established.');\n      /*\n       * The emulator has nothing left to explain, so freeze its tail here rather\n       * than at boot. Everything up to this line \u2014 including the window in which\n       * a wedge surfaces \u2014 is now inside the captured output.\n       */\n      result.emulatorCapture?.stop();\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        // The same number the session was created with above, so a script timeout reports the cap that killed it.\n        scriptTimeoutInMilliseconds: resolveScriptTimeoutInMilliseconds(options),\n        shouldSweepLeftovers: willSweepLeftovers(options),\n        ...(options.appStartTimeoutInMilliseconds !== undefined && { appStartTimeoutInMilliseconds: options.appStartTimeoutInMilliseconds }),\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          await this.stopAutoStartedProcessesVerified(buildStopParams());\n        }\n      };\n\n      // Chain rather than replace: the transport's own sync teardown drops the trusted-input channel's\n      // Adb port forward, which would otherwise be stranded on the device by an abrupt exit.\n      const originalDisposeSync = appiumTransport.disposeSync.bind(appiumTransport);\n      transport.disposeSync = (): void => {\n        try {\n          originalDisposeSync();\n        } finally {\n          this.stopAutoStartedProcessesBestEffort(buildStopParams());\n        }\n      };\n\n      return transport;\n    } catch (error: unknown) {\n      await this.stopAutoStartedProcessesVerified(buildStopParams());\n      throw error;\n    }\n\n    function buildStopParams(): StopAutoStartedProcessesParams {\n      return {\n        appiumProcess,\n        avdName: options.avdName,\n        deviceId: actualDeviceId,\n        emulatorProcess,\n        ownedEmulatorPids,\n        port,\n        url\n      };\n    }\n  }\n\n  /**\n   * Describes an adopted server's provenance for the preflight log, so a stale\n   * leftover is visible in the transcript of a run that goes on to succeed \u2014 not\n   * only in the error of one that fails.\n   *\n   * @param marker - The marker read for the port, if any.\n   * @returns A short provenance description.\n   */\n  private describeAdoptedServer(marker: AppiumServerMarker | undefined): string {\n    if (!marker || !checkIsHarnessOwnedAppiumServer(marker)) {\n      return 'not started by this harness';\n    }\n\n    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    const unstoppedSuffix = marker.stopAttemptedAtInMilliseconds === undefined ? '' : ', and an earlier run failed to stop it';\n    return `started by an earlier run of this harness, pid ${String(marker.pid)}, up for ${String(ageInSeconds)}s${unstoppedSuffix}`;\n  }\n\n  /**\n   * Probes the device and returns the failure message when it is no longer\n   * usable, or `undefined` when it is fine.\n   *\n   * The readiness gates that run before this one are deliberately best-effort \u2014\n   * they warn and proceed \u2014 so nothing asked whether the device was still there\n   * at the moment it mattered. A guest that went quiet in the meantime was\n   * handed to Appium, which reported `Device <id> was not in the list of\n   * connected devices`; `adb devices` then listed it, and the trail went cold.\n   *\n   * The second probe is only paid for when the first one fails, and the verdict\n   * distinguishes a frozen guest from an unreachable emulator \u2014 see\n   * `emulator-liveness.ts` for the measurements behind that split.\n   *\n   * Returning the message rather than throwing it is what lets both callers use\n   * the same diagnosis: the provisioning loop decides whether to boot a fresh\n   * emulator, and the session path needs its own error to survive as the\n   * `cause`.\n   *\n   * @param deviceId - The device to probe.\n   * @param emulatorCapture - The emulator's output, when this run started it.\n   * @returns The diagnosis, or `undefined` when the device still answers.\n   */\n  private async diagnoseDevice(deviceId: string, emulatorCapture?: EmulatorCapture): Promise<string | undefined> {\n    const shellProbe = await this.probeDeviceShell(deviceId);\n    if (shellProbe === 'answered') {\n      return undefined;\n    }\n\n    this.log(`Device ${deviceId} did not answer \\`adb -s ${deviceId} shell\\`; checking whether the emulator itself is still alive...`);\n    const [consoleProbe, isListedByAdb] = await Promise.all([\n      this.probeEmulatorConsole(deviceId),\n      this.checkIsDeviceListedQuietly(deviceId)\n    ]);\n\n    const verdict = resolveEmulatorLivenessVerdict({\n      consoleProbe,\n      deviceId,\n      isListedByAdb,\n      shellProbe\n    });\n    this.log(`Device liveness: ${deviceId} shell=${shellProbe}, console=${consoleProbe} -> ${verdict}.`);\n\n    // Unreachable in practice \u2014 the verdict is only `'alive'` when the shell answered, which returned above \u2014 but it is what narrows the type for the builder.\n    if (verdict === 'alive') {\n      return undefined;\n    }\n\n    return buildEmulatorLivenessMessage({\n      deviceId,\n      emulatorOutput: emulatorCapture?.read() ?? '',\n      probeTimeoutInMilliseconds: DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS,\n      verdict\n    });\n  }\n\n  private dumpConnectivity(deviceId: string): Promise<ConnectivityProbeResult> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'dumpsys', 'connectivity'],\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout, stderr) => {\n          /*\n           * A failure carries its reason, NOT an empty string. The other probes\n           * collapse a failure into empty output because there \"empty\" and\n           * \"failed\" both mean not-idle, but here they mean different things and\n           * only one of them is about the network: a probe that never answers\n           * must not be reported as a guest without a route.\n           */\n          if (!error) {\n            resolve({ output: stdout });\n            return;\n          }\n\n          const detail = (stderr.trim() || error.message.trim()).split('\\n', 1)[0] ?? '';\n          resolve({\n            failureReason: error.killed\n              ? `no answer within ${String(ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS)}ms`\n              : detail || 'adb failed with no message'\n          });\n        }\n      );\n    });\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n\n    /*\n     * Re-verify: a global install can land under an npm prefix whose bin dir is\n     * not on the spawn PATH (e.g. a scoop/nvm-managed prefix), in which case\n     * `npx --no-install appium` still cannot resolve it. Fail fast with an\n     * actionable message rather than proceeding to auto-start a server that can\n     * never come up (which would otherwise spin out the full readiness timeout).\n     */\n    const verify = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n    if (verify.exitCode !== 0) {\n      throw new Error(\n        'Appium was installed via `npm install -g appium` but is still not resolvable via `npx --no-install appium`. '\n          + 'The npm global bin directory (see `npm config get prefix`) is likely not on PATH. Add it to PATH, or set '\n          + '`shouldAutoInstallAppiumDependencies: false` and install/manage Appium yourself.'\n      );\n    }\n    this.log(`Appium installed (version ${verify.stdout.trim() || 'unknown'}).`);\n  }\n\n  /**\n   * Fails fast when the requested AVD does not exist, before an emulator is\n   * spawned.\n   *\n   * Without this preflight a missing AVD name is only discovered after\n   * {@link startEmulator} spawns `emulator -avd <name>` and the boot never\n   * completes \u2014 a full {@link EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS} spin ending\n   * in a generic \"no new device appeared\". Instead this lists the configured\n   * AVDs up front and throws an actionable error naming the available ones. AVD\n   * creation is deliberately not automated (it requires a system-image download,\n   * license acceptance, and hardware/API-level choices).\n   *\n   * @param avdName - The requested AVD name.\n   */\n  private async ensureAvdExists(avdName: string): Promise<void> {\n    const emulatorBinary = resolveEmulatorBinaryPath();\n    this.log(`Verifying AVD \"${avdName}\" exists (${emulatorBinary} -list-avds)...`);\n\n    const [error, stdout] = await new Promise<[Error | null, string]>((resolve) => {\n      execFile(emulatorBinary, ['-list-avds'], { timeout: EMULATOR_LIST_TIMEOUT_IN_MILLISECONDS }, (execError, execStdout) => {\n        resolve([execError, execStdout]);\n      });\n    });\n\n    if (error) {\n      throw new Error(\n        `Failed to list AVDs via \\`${emulatorBinary} -list-avds\\`: ${error.message}. `\n          + 'Is the Android SDK emulator installed and ANDROID_HOME/ANDROID_SDK_ROOT correct?'\n      );\n    }\n\n    if (!checkAvdExists({ avdListOutput: stdout, avdName })) {\n      const available = listAvailableAvds(stdout);\n      throw new Error(\n        `Android AVD \"${avdName}\" not found. Available AVDs: ${available.length > 0 ? available.join(', ') : '(none)'}. `\n          + 'Create it (e.g. in the Android Studio Device Manager, or via `avdmanager create avd`), or set `avdName` to an existing AVD.'\n      );\n    }\n\n    this.log(`AVD \"${avdName}\" exists.`);\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible, networkReadyTimeoutInMilliseconds } = params;\n    const timeouts: DeviceReadinessTimeouts = { deviceIdleTimeoutInMilliseconds, networkReadyTimeoutInMilliseconds };\n    /*\n     * Before the device listing, so a leftover stopped here is not listed. Only\n     * OTHER AVDs: a leftover of this one is worth adopting (and owning) below.\n     * This is the sequence that filled the drive: a leaked `obsidian_test` sat\n     * beside every later run, each of which probed it as `other-avd`, booted\n     * its own emulator next to it, and left it running.\n     */\n    await this.emulators.reclaimLeftoverEmulators({ exceptAvdName: avdName, scope: 'preflight' });\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const probeResults = await this.probeDevicesForAvd(avdName, deviceIdsBefore);\n    this.log(`AVD probe: ${buildAvdProbeSummary(probeResults)}.`);\n    const probeVerdict = resolveAvdProbeVerdict(probeResults);\n\n    switch (probeVerdict.verdict) {\n      case 'refuse': {\n        /*\n         * Silence is not a skip. Falling through to a launch here is what\n         * produced `FATAL | Running multiple emulators with the same AVD` \u2014\n         * see `avd-probe-verdict.ts` for the run this reproduces.\n         */\n        throw new Error(buildUnreadableDevicesMessage({\n          avdName,\n          probeTimeoutInMilliseconds: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,\n          unreadableDeviceIds: probeVerdict.unreadableDeviceIds\n        }));\n      }\n      case 'reuse': {\n        return await this.reuseConnectedDevice(avdName, probeVerdict.deviceId, timeouts);\n      }\n      case 'start-new': {\n        break;\n      }\n      default: {\n        return assertNever(probeVerdict);\n      }\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    await this.ensureAvdExists(avdName);\n    /*\n     * Snapshot the emulator processes that predate this launch, so the ones that\n     * appear across it can be identified as OURS. The launcher's PID is not\n     * enough to kill: under `-no-window` the process that holds the AVD is the\n     * `qemu-system-*-headless` backend it forks, which survives a `taskkill /T`\n     * of the launcher (see `emulator-backend.ts`). Diffing here \u2014 rather than\n     * sweeping `qemu*` at teardown \u2014 is what keeps the harness from killing\n     * somebody else's emulator.\n     */\n    const emulatorPidsBefore = await this.listEmulatorBackendPids([]);\n    const shouldReuseSnapshot = params.shouldReuseEmulatorSnapshot === true;\n    if (shouldReuseSnapshot) {\n      this.logSnapshotAge(avdName);\n    }\n    const launchedAtInMilliseconds = Date.now();\n    const emulator = this.startEmulator(avdName, shouldReuseSnapshot, isEmulatorVisible);\n    const isRecordedFromLaunch = this.recordEmulatorLaunch({ avdName, emulator, launchedAtInMilliseconds, preLaunchEmulatorPids: emulatorPidsBefore });\n\n    /*\n     * The capture is NOT stopped here any more. It used to be, in a `finally`\n     * the moment a device appeared \u2014 which froze the emulator's testimony\n     * exactly one step before the failure this harness could not explain. The\n     * hanging-thread and packet-streamer lines are printed later, while the run\n     * is inside `establishSession`. The window now closes there instead.\n     */\n    let actualDeviceId: string;\n    try {\n      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, timeouts, (deviceId) => {\n        this.recordEmulatorLaunchDevice({ avdName, deviceId, launchedAtInMilliseconds });\n      });\n    } catch (error: unknown) {\n      /*\n       * This emulator is ours and this is the last point anything holds it: a\n       * rejection here reaches the caller with no device result, so its\n       * teardown has no process to stop. A boot that failed a readiness gate \u2014\n       * the idle wait, the network wait \u2014 used to leave a running emulator\n       * behind exactly this way.\n       */\n      await this.stopEmulatorAfterFailedStart({ avdName, deviceIdsBefore, emulator, emulatorPidsBefore });\n      throw error;\n    }\n\n    const ownedEmulatorPids = await this.listEmulatorBackendPids(emulatorPidsBefore);\n    this.log(\n      `Emulator \"${avdName}\" started, device ${actualDeviceId} is connected (owned emulator PIDs: [${ownedEmulatorPids.join(', ')}]).`\n    );\n    /*\n     * Recorded here \u2014 including when this code runs in a test worker, which is\n     * the case the in-memory ownership lost: the worker dies without a\n     * teardown, and the marker is what lets the run's global teardown, or the\n     * next run, find and stop what it started. This write completes the record\n     * the launch opened: same launch time, now with the QEMU backend the\n     * launcher forked, which is the process that actually holds the AVD.\n     */\n    writeEmulatorMarker({ avdName, deviceId: actualDeviceId, ownedEmulatorPids, startedAtInMilliseconds: launchedAtInMilliseconds });\n    if (!isRecordedFromLaunch) {\n      // The marker covers a run that ends or is followed by another; the reaper covers one killed with nothing after it.\n      this.armEmulatorReaper(avdName, launchedAtInMilliseconds);\n    }\n    await this.suppressErrorDialogs(actualDeviceId);\n    return {\n      actualDeviceId,\n      emulatorCapture: { read: emulator.readOutput, stop: emulator.stopCapture },\n      emulatorProcess: emulator.process,\n      ownedEmulatorPids\n    };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  /**\n   * Establishes the WebDriverIO session, recognizing the one failure that blames\n   * the wrong subject: `Could not find a connected Android device` from a server\n   * whose adb is wedged while the host's own adb sees the device fine.\n   *\n   * A server an earlier run of this harness started is restarted and the session\n   * retried once \u2014 the confirmed remedy. A foreign or user-managed server is\n   * never killed; it is reported with a message that names the server.\n   *\n   * @param params - The session capabilities plus what is known about the server.\n   * @returns The session, and the replacement server process when one was started.\n   */\n  private async establishSession(params: EstablishSessionParams): Promise<EstablishSessionResult> {\n    this.log(\n      `Connecting to Appium (device=${params.deviceId}, app=${params.appId}, retryTimeout: ${String(params.sessionConnectionRetryTimeoutInMilliseconds)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n    );\n\n    try {\n      return { browser: await this.connectSession(params) };\n    } catch (error: unknown) {\n      const verdict = resolveWedgedAppiumServerRemedy({\n        connectedDeviceIds: await this.getConnectedDeviceIdsQuietly(),\n        deviceId: params.deviceId,\n        error,\n        isAdoptedServer: params.isAdoptedServer,\n        isAutoStartAllowed: params.shouldAutoStartAppium !== false,\n        isHarnessOwnedServer: checkIsHarnessOwnedAppiumServer(params.appiumServerMarker)\n      });\n\n      if (verdict.remedy === 'not-wedged') {\n        throw error;\n      }\n\n      if (verdict.remedy === 'report') {\n        throw new Error(this.buildWedgedMessage(params, verdict.reason), { cause: error });\n      }\n\n      return await this.restartWedgedServerAndRetry(params, error);\n    }\n  }\n\n  /**\n   * Establishes the session, and when that fails, asks the device whether it is\n   * still there before letting the failure stand.\n   *\n   * `establishSession` owns exactly one diagnosis \u2014 the stale Appium server \u2014\n   * and rethrows everything else untouched. That is right as far as it goes, but\n   * every signature this harness actually fails with on a wedged emulator falls\n   * into \"everything else\": `Device <id> was not in the list of connected\n   * devices`, `error: closed`, and a bare `POST /session` timeout. Rather than\n   * teaching the server module to recognize error strings that are not about the\n   * server, the device is simply re-probed here, where the device is known. A\n   * wedged emulator then reports itself, and the original error is kept as the\n   * `cause`.\n   *\n   * @param emulatorCapture - The emulator's output, when this run started it.\n   * @param params - The session parameters.\n   * @returns The established session.\n   */\n  private async establishSessionOrDiagnoseDevice(\n    emulatorCapture: EmulatorCapture | undefined,\n    params: EstablishSessionParams\n  ): Promise<EstablishSessionResult> {\n    try {\n      return await this.establishSession(params);\n    } catch (error: unknown) {\n      const diagnosis = await this.diagnoseDevice(params.deviceId, emulatorCapture);\n      if (diagnosis === undefined) {\n        throw error;\n      }\n\n      throw new Error(diagnosis, { cause: error });\n    }\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    return listOnlineDeviceIds(await this.emulators.getDevicesOutput());\n  }\n\n  /**\n   * Lists the host's connected devices for the wedged-server cross-check, where\n   * an adb that itself fails must not be read as evidence against the server.\n   *\n   * @returns The connected device IDs, or an empty list when adb could not be run.\n   */\n  private async getConnectedDeviceIdsQuietly(): Promise<string[]> {\n    try {\n      return await this.getConnectedDeviceIds();\n    } catch (error: unknown) {\n      this.log(`Could not re-check connected devices: ${error instanceof Error ? error.message : String(error)}`);\n      return [];\n    }\n  }\n\n  private getDeviceProperty(deviceId: string, property: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', property],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  /**\n   * Lists the emulator processes currently running on the host, excluding a set\n   * that is already accounted for.\n   *\n   * Called twice around a launch: with an empty `knownPids` to snapshot what\n   * predates it, then with that snapshot to name what the launch added \u2014 which\n   * is precisely the set this run owns.\n   *\n   * Best-effort: a listing that cannot be produced yields no PIDs, so an\n   * unavailable `tasklist`/`ps` degrades to \"nothing to escalate to\" rather than\n   * failing the run it is cleaning up for. **It says so, loudly** \u2014 an empty set\n   * that means \"no backend to own\" and one that means \"the query failed\" are\n   * otherwise the same log line, and the second silently disarms the escalation.\n   * That is not hypothetical: the first end-to-end run of this code logged\n   * `owned emulator PIDs: []` for a launch whose backend was demonstrably there,\n   * because `tasklist` overran a 10s budget on a host the wedged emulator had\n   * already slowed to the point where every `adb` call was timing out too \u2014 the\n   * same contention **L45** sizes `ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS` for, and\n   * the same \"wrong budget silently disables the check\" shape.\n   *\n   * A host always has processes, so a listing that parses to **zero** rows is a\n   * failed query however it exited, and is reported like one.\n   *\n   * @param knownPids - Emulator PIDs to exclude.\n   * @returns The emulator PIDs not in `knownPids`.\n   */\n  private async listEmulatorBackendPids(knownPids: readonly number[]): Promise<number[]> {\n    const processes = await this.emulators.queryHostProcesses();\n    if (processes === undefined) {\n      this.log(\n        'Warning: the host process listing failed, so this run cannot identify the emulator backend it owns. Teardown will fall back to `adb devices` alone and will have no PID to escalate to.'\n      );\n      return [];\n    }\n\n    return selectEmulatorBackendPids({ knownPids, processes });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  /**\n   * Finds the processes still listening on a port.\n   *\n   * This is the only real escalation available for the Appium server: the PID\n   * the harness holds is the shell wrapper it spawned, so re-killing it achieves\n   * nothing, while a socket still answering on the port is direct evidence of\n   * what survived.\n   *\n   * @param port - The port to query.\n   * @returns The listening PIDs, or an empty list when the query could not be run.\n   */\n  private listPortOwnerPids(port: number): Promise<number[]> {\n    const query = buildPortOwnerQuery(port);\n    return new Promise<number[]>((resolve) => {\n      execFile(\n        query.command,\n        query.commandArguments,\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // `lsof` exits non-zero when nothing holds the port, which is a legitimate empty answer.\n          resolve(parsePortOwnerPids({ output: error ? '' : stdout, port }));\n        }\n      );\n    });\n  }\n\n  /**\n   * Synchronous {@link listPortOwnerPids}, for the `process.on('exit')` teardown\n   * that cannot await.\n   *\n   * Its budget is deliberately **not** the async path's: this call blocks process\n   * exit outright, so it takes a short one and gives up rather than holding the\n   * exit handler for half a minute on a contended host. Giving up loses the\n   * escalation, which the sync path's log already admits it cannot confirm.\n   *\n   * @param port - The port to query.\n   * @returns The listening PIDs, or an empty list when the query could not be run in time.\n   */\n  private listPortOwnerPidsSync(port: number): number[] {\n    const query = buildPortOwnerQuery(port);\n    try {\n      const output = execFileSync(query.command, query.commandArguments, {\n        encoding: 'utf-8',\n        maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,\n        timeout: SYNC_TEARDOWN_QUERY_TIMEOUT_IN_MILLISECONDS\n      });\n      return parsePortOwnerPids({ output, port });\n    } catch {\n      return [];\n    }\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  /**\n   * Logs how old the snapshot a run has opted into resuming is.\n   *\n   * Best-effort: a missing snapshot is the normal state of a fresh AVD, not a\n   * failure, and this is a diagnostic rather than a gate.\n   *\n   * @param avdName - The AVD whose snapshot is about to be resumed.\n   */\n  private logSnapshotAge(avdName: string): void {\n    let savedAt: Date | undefined;\n\n    for (const candidate of buildAvdSnapshotDirectoryCandidates({ avdName, environment: process.env, homeDirectory: homedir() })) {\n      try {\n        savedAt = statSync(candidate).mtime;\n        break;\n      } catch {\n        // Not this AVD home \u2014 try the next candidate.\n      }\n    }\n\n    this.log(buildSnapshotAgeMessage({ avdName, savedAt }));\n  }\n\n  /**\n   * Reads one emulator's AVD name from its console, retrying once.\n   *\n   * The retry is what makes the refusal proportionate: the probe's whole budget\n   * is 5s, and a second look costs less than a colliding launch does. What it\n   * must never do is report a non-answer as an answer \u2014 the discarded `_error`\n   * this replaces resolved `''`, which compared unequal to the wanted AVD and so\n   * read as a definite \"some other AVD\".\n   *\n   * @param deviceId - The emulator to ask.\n   * @returns The AVD name it answered, or `undefined` when it did not answer.\n   */\n  private async probeAvdName(deviceId: string): Promise<string | undefined> {\n    for (let attempt = 1; attempt <= AVD_PROBE_ATTEMPT_COUNT; attempt++) {\n      const answer = await new Promise<string | undefined>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (error, stdout) => {\n            resolve(error ? undefined : stdout.split('\\n', 1)[0]?.trim());\n          }\n        );\n      });\n\n      if (answer !== undefined && answer.length > 0) {\n        return answer;\n      }\n\n      if (attempt < AVD_PROBE_ATTEMPT_COUNT) {\n        this.log(\n          `Device ${deviceId} did not answer \\`adb -s ${deviceId} emu avd name\\` within ${String(ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS)}ms; retrying once.`\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Asks every connected device which AVD it is serving.\n   *\n   * A device that is not a locally started emulator is never asked: its console\n   * cannot answer however healthy it is, and reading that as silence would\n   * refuse every run on a host with a handset plugged in \u2014 see\n   * `avd-probe-verdict.ts`.\n   *\n   * @param avdName - The AVD the run wants.\n   * @param deviceIds - The connected devices.\n   * @returns One outcome per device, in listed order.\n   */\n  private async probeDevicesForAvd(avdName: string, deviceIds: readonly string[]): Promise<AvdProbeResult[]> {\n    const results: AvdProbeResult[] = [];\n\n    for (const deviceId of deviceIds) {\n      const probedAvdName = checkIsEmulatorDeviceId(deviceId) ? await this.probeAvdName(deviceId) : undefined;\n      results.push({ deviceId, outcome: classifyAvdProbe({ avdName, deviceId, probedAvdName }) });\n    }\n\n    return results;\n  }\n\n  /**\n   * Asks the **guest** whether it is still scheduling work, via `adbd`.\n   *\n   * @param deviceId - The device to probe.\n   * @returns What it answered.\n   */\n  private probeDeviceShell(deviceId: string): Promise<EmulatorLivenessProbeOutcome> {\n    return this.runLivenessProbe(['-s', deviceId, 'shell', 'true']);\n  }\n\n  /**\n   * Asks the **emulator process** whether it is still running, via its console.\n   *\n   * The console is served by the emulator itself rather than by the guest, which\n   * is what makes it able to tell a frozen guest from a wedged emulator.\n   *\n   * @param deviceId - The device to probe.\n   * @returns What it answered.\n   */\n  private probeEmulatorConsole(deviceId: string): Promise<EmulatorLivenessProbeOutcome> {\n    return this.runLivenessProbe(['-s', deviceId, 'emu', 'avd', 'status']);\n  }\n\n  /**\n   * Replaces a leftover server an earlier run failed to stop, instead of\n   * adopting it.\n   *\n   * This is the other half of {@link stopAutoStartedAppiumServer}'s stamped\n   * marker, and it is the case that motivated the whole verified teardown: the\n   * leftover answers `/status` perfectly, is adopted, and then dies seconds into the session as\n   * it finally finishes shutting down \u2014 a failure that reads as a device or\n   * network fault. A server we know we already asked to die is not a server to\n   * build a suite on.\n   *\n   * @param params - The marker, the port and whether a replacement may be started.\n   * @returns `true` when the port was freed and a fresh server must be started.\n   */\n  private async reclaimUnstoppedAppiumServer(params: ReclaimUnstoppedAppiumServerParams): Promise<boolean> {\n    const stopAttemptedAtInMilliseconds = params.marker.stopAttemptedAtInMilliseconds ?? Date.now();\n    const ageInSeconds = Math.round((Date.now() - stopAttemptedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    const provenance = `the server on port ${String(params.port)} is a leftover an earlier run of this harness tried to stop ${String(ageInSeconds)}s ago and could not`;\n\n    if (params.shouldAutoStartAppium === false) {\n      this.log(`WARNING: ${provenance}. Auto-start is disabled, so this run adopts it anyway; if the session dies mid-flight, that is why.`);\n      return false;\n    }\n\n    this.log(`Refusing to adopt a known-doomed server: ${provenance}. Killing whatever holds the port and starting a fresh server...`);\n    for (const pid of await this.listPortOwnerPids(params.port)) {\n      killProcessTreeByPid(pid);\n    }\n    clearAppiumServerMarker(params.port);\n\n    if (await this.checkIsAppiumStopped(params.url, APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS)) {\n      return true;\n    }\n\n    this.log(`WARNING: ${provenance}, and it survived this run's kill too. Adopting it, which may fail mid-session.`);\n    return false;\n  }\n\n  /**\n   * Records an emulator as this run's the moment it is launched, before it has\n   * a device \u2014 and arms its reaper there.\n   *\n   * The marker used to be written once the device connected, about 45s into a\n   * cold boot, and the reaper with it. A runner killed inside that window left a\n   * running emulator with **no marker at all**, which every later run correctly\n   * refuses to touch (**L46**) and no reaper was watching: the leftover was\n   * nobody's to stop, for ever. A launch-time marker closes that window with the\n   * one thing already known \u2014 the launcher's PID, which `emulator-backend.ts`\n   * counts as an emulator process, so the marker convicts as a\n   * `harness-leftover` exactly like a completed one \u2014 plus the pre-launch\n   * snapshot, which is what lets a later reclaim identify the backend the\n   * launcher forks without having been there to watch it.\n   *\n   * **It never overwrites a marker whose processes are still running.** A launch\n   * can happen while an older emulator of the same AVD is still up and recorded\n   * \u2014 an `offline` leftover the probe cannot see, which is the launch that dies\n   * on `Running multiple emulators with the same AVD`. Clobbering that marker\n   * would erase the only record of a running emulator, the very thing\n   * `clearEmulatorMarkerIfStopped` exists to prevent. In that case the record\n   * waits for the success path, as before.\n   *\n   * @param params - The AVD, its launcher, and when it was launched.\n   * @returns `true` when the launch was recorded and its reaper armed.\n   */\n  private recordEmulatorLaunch(params: RecordEmulatorLaunchParams): boolean {\n    const { avdName } = params;\n    const launcherPid = params.emulator.process.pid;\n    if (launcherPid === undefined) {\n      this.log(`The emulator launcher for AVD \"${avdName}\" reported no PID, so its launch cannot be recorded; it is recorded once its device connects.`);\n      return false;\n    }\n\n    const existingMarker = readEmulatorMarker(avdName);\n    if (existingMarker && (selectLiveMarkedPids(existingMarker, params.preLaunchEmulatorPids).length > 0 || checkIsMarkedEmulatorRunning(existingMarker))) {\n      this.log(`Not recording the launch of AVD \"${avdName}\" yet: its existing marker still names a running process, and that record is the only one of an emulator that may still be up.`);\n      return false;\n    }\n\n    writeEmulatorMarker({\n      avdName,\n      ownedEmulatorPids: [launcherPid],\n      preLaunchEmulatorPids: params.preLaunchEmulatorPids,\n      startedAtInMilliseconds: params.launchedAtInMilliseconds\n    });\n    this.log(`Recorded the emulator launch for AVD \"${avdName}\" (launcher PID ${String(launcherPid)}) before its device exists, so a kill during the boot still leaves it convictable.`);\n    this.armEmulatorReaper(avdName, params.launchedAtInMilliseconds);\n    return true;\n  }\n\n  /**\n   * Fills the device into the marker this launch wrote, as soon as one appears.\n   *\n   * Worth its own write because the console shutdown is the only stop that\n   * releases the AVD's `multiinstance.lock` (**L46**), and it needs a device to\n   * talk to. Deliberately **no** host process listing here: that query is\n   * budgeted at {@link HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS} for exactly\n   * this contended window, and spending it inside the boot path would eat the\n   * readiness budgets that follow. The backend PIDs arrive with the success\n   * write, one listing, as before.\n   *\n   * Only ever fills in **this** launch's marker: one carrying another launch\n   * time, or a device already, belongs to an emulator this run did not start.\n   *\n   * @param params - The AVD, the device that appeared, and the launch it belongs to.\n   */\n  private recordEmulatorLaunchDevice(params: RecordEmulatorLaunchDeviceParams): void {\n    const { avdName, deviceId } = params;\n    const marker = readEmulatorMarker(avdName);\n    if (!marker || marker.deviceId !== undefined || marker.startedAtInMilliseconds !== params.launchedAtInMilliseconds) {\n      return;\n    }\n\n    writeEmulatorMarker({\n      avdName,\n      deviceId,\n      ownedEmulatorPids: marker.ownedEmulatorPids,\n      // Still provisional: the backend's PID arrives with the success write, and until then the diff is what convicts it.\n      preLaunchEmulatorPids: marker.preLaunchEmulatorPids,\n      startedAtInMilliseconds: marker.startedAtInMilliseconds\n    });\n    this.log(`Recorded device ${deviceId} against the launch marker for AVD \"${avdName}\", so a stop from here on can shut it down over its console.`);\n  }\n\n  /**\n   * Replaces a wedged server this harness started earlier and retries the\n   * session once.\n   *\n   * The old server is killed and the port is waited out before a replacement is\n   * started: a socket that keeps answering `/status` would let the readiness\n   * poll pass on the dying server, and a port that never goes quiet means the\n   * kill did not take \u2014 in which case starting anything on it is pointless.\n   *\n   * @param params - The session capabilities plus what is known about the server.\n   * @param originalError - The failure that convicted the server, logged so the diagnosis is on the record.\n   * @returns The session and the replacement server process.\n   */\n  private async restartWedgedServerAndRetry(params: EstablishSessionParams, originalError: unknown): Promise<EstablishSessionResult> {\n    const marker = ensureNonNullable(params.appiumServerMarker, 'A restart verdict requires the marker that proved ownership.');\n    this.log(\n      `Appium at ${params.url.origin} cannot see ${params.deviceId} although this host's adb can \u2014 the server this harness started earlier (pid ${String(marker.pid)}) is stale. Restarting it... (session failed with: ${originalError instanceof Error ? originalError.message : String(originalError)})`\n    );\n\n    killProcessTreeByPid(marker.pid);\n    clearAppiumServerMarker(params.port);\n\n    try {\n      await this.waitForAppiumStopped(params.url, APPIUM_STOP_TIMEOUT_IN_MILLISECONDS);\n    } catch (error: unknown) {\n      throw new Error(this.buildWedgedMessage(params, 'restart-did-not-help'), { cause: error });\n    }\n\n    const launch = this.startAppiumServer(params.port, params.isAppiumConsoleVisible);\n\n    try {\n      await this.waitForAppiumReady(params.url, params.appiumStartTimeoutInMilliseconds, launch);\n      this.log('Replacement Appium server is ready, retrying the session...');\n      return { appiumProcess: launch.process, browser: await this.connectSession(params) };\n    } catch (error: unknown) {\n      killProcessTree(launch.process);\n      clearAppiumServerMarker(params.port);\n      throw new Error(this.buildWedgedMessage(params, 'restart-did-not-help'), { cause: error });\n    }\n  }\n\n  /**\n   * Adopts a device already serving the requested AVD.\n   *\n   * @param avdName - The AVD it is serving.\n   * @param deviceId - The device to adopt.\n   * @param timeouts - The two post-boot readiness budgets.\n   * @returns The adopted device, owning the emulator's PIDs only when it is a leftover this harness started.\n   */\n  private async reuseConnectedDevice(avdName: string, deviceId: string, timeouts: DeviceReadinessTimeouts): Promise<EnsureDeviceConnectedResult> {\n    /*\n     * A device this run did not start is not this run's to stop \u2014 unless this\n     * harness started it and nothing live is responsible for it any more. Then\n     * it is taken over, so this run's teardown stops it and a leaked emulator\n     * serves at most one more run instead of living for ever.\n     */\n    const ownedEmulatorPids = await this.takeOverLeftoverEmulator(avdName, deviceId);\n    this.log(\n      ownedEmulatorPids.length > 0\n        ? `AVD \"${avdName}\" is already running on device ${deviceId} as a leftover this harness started; reusing it and taking it over (owned emulator PIDs: [${ownedEmulatorPids.join(', ')}]), so this run stops it.`\n        : `AVD \"${avdName}\" is already running on device ${deviceId}, reusing.`\n    );\n\n    try {\n      await this.suppressErrorDialogs(deviceId);\n      /*\n       * A reused device gets the SAME settle gate a harness-started one gets.\n       * Appearing in `adb devices` says only that adbd is up: the guest can\n       * still be running the boot animation or optimizing packages, and a\n       * session established against that contends with the churn and inflates\n       * every subsequent round-trip 25-50x (L19). Skipping the gate here is\n       * what let a release preflight spend its whole layout-ready budget on a\n       * handful of contended probes while `adb devices` reported `device`\n       * throughout. The same argument applies to the network gate: a device\n       * that has been up for seconds is exactly one with no validated network\n       * yet.\n       */\n      await this.waitForBoot(deviceId, Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS, undefined);\n      await this.waitForDeviceReady(deviceId, timeouts);\n      await this.wakeScreen(deviceId);\n    } catch (error: unknown) {\n      // As with a launch that fails its gates: a rejection here hands the caller nothing to stop.\n      if (ownedEmulatorPids.length > 0) {\n        await this.emulators.stopEmulator({ avdName, deviceId, ownedEmulatorPids });\n      }\n      throw error;\n    }\n\n    return { actualDeviceId: deviceId, ownedEmulatorPids };\n  }\n\n  /**\n   * Runs one liveness probe, retrying once before calling it silence.\n   *\n   * Only success counts as an answer: a failed `adb ... emu` may be the adb\n   * server refusing an `offline` device rather than the console being dead, and\n   * the two are indistinguishable from here (see `emulator-liveness.ts`). The\n   * single retry is the same restraint `probeAvdName` applies for the same\n   * reason \u2014 a second look is far cheaper than a wrong verdict, and this one\n   * decides whether a run is aborted.\n   *\n   * @param input - The adb arguments.\n   * @returns Whether the probe got an answer.\n   */\n  private async runLivenessProbe(input: readonly string[]): Promise<EmulatorLivenessProbeOutcome> {\n    for (let attempt = 1; attempt <= DEVICE_LIVENESS_ATTEMPT_COUNT; attempt++) {\n      const isAnswered = await new Promise<boolean>((resolve) => {\n        execFile('adb', [...input], { timeout: DEVICE_LIVENESS_TIMEOUT_IN_MILLISECONDS }, (error) => {\n          resolve(!error);\n        });\n      });\n\n      if (isAnswered) {\n        return 'answered';\n      }\n    }\n\n    return 'no-answer';\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, networkReadyTimeoutInMilliseconds, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium, shouldReuseEmulatorSnapshot } = params;\n\n    let needsAppiumStart = false;\n    let appiumServerMarker: AppiumServerMarker | undefined;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      appiumServerMarker = readAppiumServerMarker(port);\n      this.log(`Appium server is reachable (${this.describeAdoptedServer(appiumServerMarker)}).`);\n\n      if (appiumServerMarker?.stopAttemptedAtInMilliseconds !== undefined) {\n        needsAppiumStart = await this.reclaimUnstoppedAppiumServer({\n          marker: appiumServerMarker,\n          port,\n          shouldAutoStartAppium,\n          url: appiumUrl\n        });\n        if (needsAppiumStart) {\n          appiumServerMarker = undefined;\n        }\n      }\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumLaunch: ProcessLaunch | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumLaunch = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    const appiumProcess = appiumLaunch?.process;\n\n    /*\n     * `allSettled`, not `all`: the two halves start together, so a rejected\n     * Appium wait used to abandon an emulator that went on to boot perfectly \u2014\n     * the leak survived the very teardown that was supposed to prevent it,\n     * because the emulator's handle only exists inside the result `Promise.all`\n     * discarded. Both outcomes are collected so both can be stopped.\n     */\n    const [appiumOutcome, deviceOutcome] = await Promise.allSettled([\n      appiumLaunch\n        ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds, appiumLaunch).then(() => {\n          this.log('Auto-started Appium server is ready.');\n        })\n        : Promise.resolve(),\n      this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible, networkReadyTimeoutInMilliseconds, shouldReuseEmulatorSnapshot })\n    ]);\n\n    const deviceResult = deviceOutcome.status === 'fulfilled' ? deviceOutcome.value : undefined;\n\n    if (appiumOutcome.status === 'rejected' || deviceResult === undefined) {\n      await this.stopAutoStartedProcessesVerified({\n        appiumProcess,\n        avdName,\n        deviceId: deviceResult?.actualDeviceId,\n        emulatorProcess: deviceResult?.emulatorProcess,\n        ownedEmulatorPids: deviceResult?.ownedEmulatorPids ?? [],\n        port,\n        url: appiumUrl\n      });\n\n      throw getSettledFailure([appiumOutcome, deviceOutcome]);\n    }\n\n    return {\n      actualDeviceId: deviceResult.actualDeviceId,\n      appiumProcess,\n      appiumServerMarker,\n      emulatorCapture: deviceResult.emulatorCapture,\n      emulatorProcess: deviceResult.emulatorProcess,\n      isAdoptedAppiumServer: !needsAppiumStart,\n      ownedEmulatorPids: deviceResult.ownedEmulatorPids\n    };\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ProcessLaunch {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const { detached, windowsHide } = resolveAppiumSpawnFlags(isConsoleHidden);\n    /*\n     * `--no-install`: Appium is guaranteed present by `ensureAppiumInstalled`\n     * before we reach here, so pin npx to the installed copy. Without it, npx\n     * would silently try to download Appium fresh from the registry \u2014 a\n     * slow/hung failure in a hidden console \u2014 whenever it could not resolve the\n     * global install (e.g. a global prefix not on PATH). See `ensureAppiumInstalled`.\n     *\n     * Pipe stdout/stderr even when hidden (rather than discarding) so an early\n     * failure such as a crash or a missing driver is captured and surfaced\n     * immediately by `waitForAppiumReady`, mirroring `startEmulator`;\n     * `windowsHide` still suppresses the console window.\n     */\n    const child = spawn(`npx --no-install appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached,\n      shell: true,\n      stdio: isConsoleHidden ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'inherit', 'inherit'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: ProcessExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout?.on('data', appendOutput);\n    child.stderr?.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n    child.once('error', (error) => {\n      exitInfo = { code: null, signal: null, spawnError: error.message };\n    });\n\n    child.unref();\n\n    /*\n     * Record the server as ours before anything can adopt it. The marker is what\n     * lets a later run tell its own leftover server from a foreign one, and so\n     * whether restarting a wedged server is this harness's call to make \u2014 see\n     * `appium-server-marker.ts`.\n     */\n    if (child.pid !== undefined) {\n      writeAppiumServerMarker({ pid: child.pid, port });\n    }\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-APPIUM_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  private startEmulator(avdName: string, shouldReuseSnapshot: boolean, isEmulatorVisible?: boolean): ProcessLaunch {\n    const emulatorBinary = resolveEmulatorBinaryPath();\n    const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);\n    const input = buildEmulatorArguments({ avdName, isHidden: isWindowHidden, shouldReuseSnapshot });\n    const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);\n    const { environment, isNetsimLogGuarded } = buildEmulatorEnvironment(process.env);\n    this.log(`Running: ${emulatorBinary} ${input.join(' ')}`);\n    this.log(\n      isNetsimLogGuarded\n        ? `netsimd log level: RUST_LOG=${NETSIM_LOG_FILTER} (keeps its wifi-stats warning from growing its log without bound).`\n        : `netsimd log level: RUST_LOG=${String(environment['RUST_LOG'])}, set by the caller \u2014 the harness's bounded default is off, and netsimd's log can grow without bound.`\n    );\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, input, {\n      detached,\n      env: environment,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: ProcessExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n    /*\n     * A spawn failure (e.g. ENOENT for a missing/broken emulator binary) emits\n     * 'error', not 'exit'. Record it as a synthetic exit so the boot/new-device\n     * polls fail fast instead of spinning out the full boot timeout.\n     */\n    child.once('error', (error) => {\n      exitInfo = { code: null, signal: null, spawnError: error.message };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  /**\n   * Stops the Appium server this run started, and **verifies** it stopped.\n   *\n   * The port is the verdict: a socket still answering `/status` after the kill\n   * is the server, whatever the PID table says. When it is still there the\n   * listener is killed by port ownership \u2014 the only escalation that means\n   * anything, since re-killing the shell wrapper's PID would just repeat the\n   * kill that already failed.\n   *\n   * @param params - The server process, its port and its URL.\n   */\n  private async stopAutoStartedAppiumServer(params: StopAutoStartedAppiumServerParams): Promise<void> {\n    killProcessTree(params.appiumProcess);\n\n    let hasEscalated = false;\n    let isStopped = await this.checkIsAppiumStopped(params.url, APPIUM_STOP_TIMEOUT_IN_MILLISECONDS);\n\n    if (!isStopped) {\n      const ownerPids = await this.listPortOwnerPids(params.port);\n      if (ownerPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started Appium server still answers on ${params.url.origin} after its process tree was killed; escalating to the PID(s) holding the port: [${ownerPids.join(', ')}].`\n        );\n        for (const pid of ownerPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.checkIsAppiumStopped(params.url, APPIUM_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS);\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: `port ${String(params.port)}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started Appium server',\n      timeoutInMilliseconds: APPIUM_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n\n    if (isStopped) {\n      // Drop the marker with the server it describes, so the next run cannot mistake a recycled PID for ours.\n      clearAppiumServerMarker(params.port);\n      return;\n    }\n\n    // Keep the marker, stamped: a leftover we could not kill must stay convictable by the next run.\n    recordAppiumServerStopAttempt(params.port);\n  }\n\n  /**\n   * Best-effort teardown for `process.on('exit')`, which cannot await.\n   *\n   * It kills, looks once for a survivor still holding the Appium port or a\n   * still-live emulator PID, kills those too \u2014 and then says exactly that. It\n   * never claims a verified stop, because it cannot wait to earn one.\n   *\n   * @param params - Everything this run started.\n   */\n  private stopAutoStartedProcessesBestEffort(params: StopAutoStartedProcessesParams): void {\n    if (params.appiumProcess) {\n      killProcessTree(params.appiumProcess);\n      const ownerPids = this.listPortOwnerPidsSync(params.port);\n      for (const pid of ownerPids) {\n        killProcessTreeByPid(pid);\n      }\n\n      if (ownerPids.length > 0) {\n        this.log(\n          `Auto-started Appium server: stop requested and PID(s) [${ownerPids.join(', ')}] holding port ${String(params.port)} killed \u2014 sync teardown cannot wait to confirm.`\n        );\n        recordAppiumServerStopAttempt(params.port);\n      } else {\n        this.log(`Auto-started Appium server: stop requested, nothing left listening on port ${String(params.port)}.`);\n        clearAppiumServerMarker(params.port);\n      }\n    }\n\n    if (params.emulatorProcess || params.ownedEmulatorPids.length > 0) {\n      if (params.emulatorProcess) {\n        killProcessTree(params.emulatorProcess);\n      }\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      for (const pid of survivingPids) {\n        killProcessTreeByPid(pid);\n      }\n\n      if (survivingPids.length > 0) {\n        // Keep the marker: nothing here waited to see these die, so the next run must still be able to convict them.\n        this.log(\n          `Auto-started emulator: stop requested and surviving emulator PID(s) [${survivingPids.join(', ')}] killed \u2014 sync teardown cannot wait to confirm.`\n        );\n      } else {\n        this.log('Auto-started emulator: stop requested, no process of this run left running.');\n        clearEmulatorMarkerIfStopped(params.avdName);\n      }\n    }\n  }\n\n  /**\n   * Stops everything this run auto-started, verifying each stop.\n   *\n   * @param params - Everything this run started.\n   */\n  private async stopAutoStartedProcessesVerified(params: StopAutoStartedProcessesParams): Promise<void> {\n    const isEmulatorOwned = params.emulatorProcess !== undefined || params.ownedEmulatorPids.length > 0;\n    if (!params.appiumProcess && !isEmulatorOwned) {\n      return;\n    }\n\n    this.log('Stopping everything this run auto-started...');\n\n    if (params.appiumProcess) {\n      await this.stopAutoStartedAppiumServer({\n        appiumProcess: params.appiumProcess,\n        port: params.port,\n        url: params.url\n      });\n    }\n\n    if (isEmulatorOwned) {\n      await this.emulators.stopEmulator({\n        avdName: params.avdName,\n        deviceId: params.deviceId,\n        emulatorProcess: params.emulatorProcess,\n        ownedEmulatorPids: params.ownedEmulatorPids\n      });\n    }\n  }\n\n  /**\n   * Stops an emulator this run launched whose start failed before it could be\n   * handed back \u2014 the boot, idle or network wait gave up on it, or it never\n   * produced a device at all.\n   *\n   * The PIDs come from the same pre-launch snapshot a successful start uses. The\n   * device is whichever emulator appeared across the launch, in any state; when\n   * that is not exactly one, the stop goes by PIDs alone rather than guess.\n   *\n   * @param params - The launch, and what predated it.\n   */\n  private async stopEmulatorAfterFailedStart(params: StopEmulatorAfterFailedStartParams): Promise<void> {\n    const ownedEmulatorPids = await this.listEmulatorBackendPids(params.emulatorPidsBefore);\n    let newDeviceIds: string[] = [];\n    try {\n      newDeviceIds = parseAdbDevices(await this.emulators.getDevicesOutput())\n        .map((entry) => entry.deviceId)\n        .filter((deviceId) => checkIsEmulatorDeviceId(deviceId) && !params.deviceIdsBefore.includes(deviceId));\n    } catch (error: unknown) {\n      this.log(`Could not list devices while stopping the failed emulator: ${error instanceof Error ? error.message : String(error)}`);\n    }\n\n    this.log(`Emulator \"${params.avdName}\" failed to start; stopping it (owned emulator PIDs: [${ownedEmulatorPids.join(', ')}]).`);\n    await this.emulators.stopEmulator({\n      avdName: params.avdName,\n      deviceId: newDeviceIds.length === 1 ? newDeviceIds[0] : undefined,\n      emulatorProcess: params.emulator.process,\n      ownedEmulatorPids\n    });\n  }\n\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  /**\n   * Removes the `temp-vault-*` directories earlier runs left on the device.\n   *\n   * Runs **before** `remote()` launches Obsidian \u2014 the last moment at which\n   * nothing has to enumerate the device's vaults yet, and the only sweep that\n   * does not depend on a healthy WebView. That independence is the whole point:\n   * a run whose WebView died cannot unregister or delete its own vault, so\n   * without this each failure leaves residue that slows the next run's startup\n   * enumeration and makes the next failure likelier.\n   *\n   * Unconditional (no age gate) \u2014 Android runs hold the exclusive `android`\n   * setup lock, so no concurrent run can own a device vault, and an age gate\n   * would let a vault leaked minutes ago survive into this run. Best-effort: a\n   * failure is logged, not thrown.\n   *\n   * The removals go one directory at a time and the outcome is re-listed rather\n   * than inferred; {@link sweepDeviceLeftovers} explains why.\n   *\n   * @param params - The device and vault base path to sweep.\n   */\n  private async sweepDeviceLeftoverVaults(params: SweepDeviceLeftoverVaultsParams): Promise<void> {\n    const { deviceId, vaultBasePath } = params;\n\n    try {\n      const result = await sweepDeviceLeftovers({\n        listNames: async (): Promise<string[]> => {\n          const listing = await exec(\n            ['adb', '-s', deviceId, 'shell', 'ls', '-1', vaultBasePath],\n            { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS }\n          );\n          return listing.split('\\n');\n        },\n        removeDirectory: async (path: string): Promise<void> => {\n          await exec(\n            ['adb', '-s', deviceId, 'shell', 'rm', '-rf', path],\n            { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_SWEEP_TIMEOUT_IN_MILLISECONDS }\n          );\n        },\n        vaultBasePath\n      });\n\n      if (result.removedCount === 0 && result.failedNames.length === 0) {\n        this.log(`No leftover temp vaults on device ${deviceId}.`);\n        return;\n      }\n\n      this.log(`Removed ${String(result.removedCount)} leftover temp vault(s) from ${vaultBasePath} on device ${deviceId}.`);\n\n      if (result.failedNames.length > 0) {\n        this.log(\n          `Warning: ${String(result.failedNames.length)} leftover temp vault(s) could not be removed and will be retried next run: ${result.failedNames.join(', ')}`\n        );\n      }\n    } catch (error: unknown) {\n      this.log(`Warning: failed to sweep leftover temp vaults: ${error instanceof Error ? error.message : 'unknown error'}`);\n    }\n  }\n\n  /**\n   * Takes over the running emulator of an AVD when it is a leftover this harness\n   * started, so this run becomes the one responsible for stopping it.\n   *\n   * @param avdName - The AVD the device is serving.\n   * @param deviceId - The device serving it.\n   * @returns The emulator PIDs this run now owns; empty when the emulator is not a harness leftover.\n   */\n  private async takeOverLeftoverEmulator(avdName: string, deviceId: string): Promise<number[]> {\n    const marker = readEmulatorMarker(avdName);\n    if (!marker) {\n      return [];\n    }\n\n    const processes = await this.emulators.queryHostProcesses();\n    if (processes === undefined) {\n      this.log(`Cannot tell whether AVD \"${avdName}\" is a leftover this harness started without a host process listing; reusing it without taking it over.`);\n      return [];\n    }\n\n    const liveEmulatorPids = selectEmulatorBackendPids({ knownPids: [], processes });\n    const verdict = resolveEmulatorMarkerVerdict({\n      currentPid: process.pid,\n      isOwnerAlive: checkIsProcessAlive(marker.ownerPid),\n      liveEmulatorPids,\n      marker\n    });\n\n    switch (verdict) {\n      case 'harness-leftover': {\n        const ownedEmulatorPids = selectLiveMarkedPids(marker, liveEmulatorPids);\n        writeEmulatorMarker({ avdName, deviceId, ownedEmulatorPids, startedAtInMilliseconds: marker.startedAtInMilliseconds });\n        /*\n         * The reaper the earlier run armed may still be watching this emulator\n         * \u2014 the launch time it keys on survives a takeover \u2014 but an emulator\n         * started by an older version of the harness has none. A second reaper\n         * costs nothing: whichever takes the lock first stops the emulator, and\n         * the other then finds the marker gone and exits.\n         */\n        this.armEmulatorReaper(avdName, marker.startedAtInMilliseconds);\n        return ownedEmulatorPids;\n      }\n      case 'in-use-by-live-run': {\n        this.log(`AVD \"${avdName}\" was started by a harness process that is still running (PID ${String(marker.ownerPid)}); that process stays responsible for stopping it.`);\n        return [];\n      }\n      case 'stale-marker': {\n        clearEmulatorMarker(avdName);\n        return [];\n      }\n      default: {\n        return assertNever(verdict);\n      }\n    }\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number, launch: ProcessLaunch): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      /*\n       * If the server process already died (crashed, or never started), stop\n       * polling and surface why \u2014 otherwise a doomed server spins out the whole\n       * readiness timeout with no diagnostics, the original symptom this exists\n       * to prevent.\n       */\n      const exitInfo = launch.readExitInfo();\n      if (exitInfo) {\n        throw buildDeathError(exitInfo);\n      }\n\n      try {\n        await this.checkAppiumReachable(url);\n        launch.stopCapture();\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    const finalExitInfo = launch.readExitInfo();\n    if (finalExitInfo) {\n      throw buildDeathError(finalExitInfo);\n    }\n\n    const outputTail = launch.readOutput().trim();\n    const outputSection = outputTail.length > 0 ? `\\n\\nAppium server output (tail):\\n${outputTail}` : '';\n    throw new Error(`Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms.${outputSection}`);\n\n    function buildDeathError(exitInfo: ProcessExitInfo): Error {\n      return new Error(buildProcessExitMessage({\n        exitInfo,\n        output: launch.readOutput(),\n        outputLabel: 'Appium server output',\n        subject: 'Auto-started Appium server'\n      }));\n    }\n  }\n\n  /**\n   * Waits until nothing answers `/status` on the port any more.\n   *\n   * @param url - The Appium server URL.\n   * @param timeoutInMilliseconds - How long to wait before giving up.\n   * @throws If the port is still served when the timeout elapses.\n   */\n  private async waitForAppiumStopped(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const deadline = Date.now() + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n      } catch {\n        return;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Something is still serving ${url.origin} ${String(timeoutInMilliseconds)}ms after the Appium server was killed.`\n    );\n  }\n\n  /**\n   * Polls `sys.boot_completed` until the device reports a finished boot.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param deadline - The absolute time at which to give up.\n   * @param emulator - The emulator this run started, so its early death fails fast instead of polling out the deadline. Omitted for a reused device, which this run did not launch and cannot inspect.\n   */\n  private async waitForBoot(deviceId: string, deadline: number, emulator: ProcessLaunch | undefined): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator?.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildProcessExitMessage({\n          exitInfo,\n          output: emulator?.readOutput() ?? '',\n          outputLabel: 'Emulator output',\n          subject: 'Android emulator'\n        }));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    /*\n     * The tail goes on the TIMEOUT too, not only on the exit. An emulator that\n     * prints `FATAL | Running multiple emulators with the same AVD` and then\n     * lingers never sets `exitInfo`, so this used to be the whole of what the\n     * reader got \u2014 a budget, with the explanation captured and discarded.\n     */\n    throw new Error(appendProcessOutputTail(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`,\n      { output: emulator?.readOutput() ?? '', outputLabel: 'Emulator output' }\n    ));\n  }\n\n  /**\n   * Waits for a booted emulator to become idle before the session is\n   * established \u2014 whether this run started it or found it already running.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * A **reused** device needs this every bit as much as a started one: being\n   * listed in `adb devices` says only that adbd answers, and the churn it does\n   * not gate is paid later by whatever polls the WebView.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProperty, packageListOutput] = await Promise.all([\n        this.getDeviceProperty(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProperty, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  /**\n   * Runs both post-boot readiness gates, in order, on a device that has just\n   * reported `sys.boot_completed`.\n   *\n   * The single owner of \"which gates a device passes before a session\", so the\n   * started-device and reused-device branches cannot diverge on it \u2014 the branch\n   * that skipped a gate entirely is the hole a reused device once fell into (**L43**).\n   *\n   * @param deviceId - The device UDID to gate on.\n   * @param timeouts - The two resolved budgets.\n   */\n  private async waitForDeviceReady(deviceId: string, timeouts: DeviceReadinessTimeouts): Promise<void> {\n    await this.waitForDeviceIdle(deviceId, timeouts.deviceIdleTimeoutInMilliseconds);\n    await this.waitForNetworkValidated(deviceId, timeouts.networkReadyTimeoutInMilliseconds);\n  }\n\n  /**\n   * Waits for a booted emulator to have a **validated default network** before\n   * the session is established.\n   *\n   * The idle gate above says nothing about connectivity, and its two signals are\n   * satisfied well before the default network is created and validated \u2014 that\n   * lands ~80s into guest uptime, tens of seconds after the boot flag on a fast\n   * host. A suite started in that gap does not merely run slowly: a test\n   * that reaches the network runs to completion against a silently **empty\n   * result**, which no assertion inside the suite can distinguish from a\n   * genuinely empty response. Only a readiness gate can catch that, which is why\n   * this exists (see {@link checkNetworkValidated}, which also records why the\n   * three obvious connectivity probes are all wrong).\n   *\n   * Best-effort, on the same contract as the idle gate: if no validated network\n   * appears within the budget it logs a warning **naming the missing network**\n   * and proceeds (an offline AVD is still a usable one for suites that never\n   * touch the network), and a budget of `0` skips the wait entirely. The warning\n   * is the point \u2014 the failure it precedes otherwise surfaces as a bare\n   * `WebDriverError: script timeout` naming the transport, which reads as a\n   * harness defect rather than a missing route.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForNetworkValidated(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping network-ready wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to report a validated network (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    let probeFailureCount = 0;\n    let lastFailureReason = '';\n\n    while (Date.now() < deadline) {\n      const probe = await this.dumpConnectivity(deviceId);\n      const elapsed = String(Date.now() - start);\n      const connectivityOutput = probe.output;\n\n      if (connectivityOutput === undefined) {\n        probeFailureCount++;\n        lastFailureReason = probe.failureReason ?? 'unknown adb failure';\n        this.log(\n          `Device ${deviceId} connectivity probe failed (elapsed: ${elapsed}ms): ${lastFailureReason}. Retrying...`\n        );\n      } else if (checkNetworkValidated({ connectivityOutput })) {\n        this.log(`Device ${deviceId} has a validated network after ${elapsed}ms.`);\n        return;\n      } else {\n        this.log(`Device ${deviceId} has no validated network yet (elapsed: ${elapsed}ms). Retrying...`);\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, NETWORK_READY_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    /*\n     * Two different diagnoses, never merged into one sentence: a guest that\n     * answered and reported no network is offline, while a guest that never\n     * answered says nothing about its network and everything about itself.\n     */\n    const diagnosis = probeFailureCount > 0\n      ? `${String(probeFailureCount)} of its connectivity probes failed, last \"${lastFailureReason}\", so the guest may be wedged rather than offline`\n      : 'it answered every probe and reported no validated default network';\n    this.log(\n      `Warning: device ${deviceId} reported no validated network within ${String(timeoutInMilliseconds)}ms (${diagnosis}); `\n        + 'proceeding with session establishment anyway. Tests that reach the network will run against a device with no route, '\n        + 'and may return EMPTY RESULTS rather than fail \u2014 read any empty-looking assertion failure below as a missing network first.'\n    );\n  }\n\n  /**\n   * Waits for the emulator this run launched to produce a device, and for that\n   * device to become usable.\n   *\n   * @param deviceIdsBefore - The devices connected before the launch.\n   * @param emulator - The launcher, polled for an early exit.\n   * @param timeouts - The two post-boot readiness budgets.\n   * @param onDeviceAppeared - Called with the new device the moment it is listed, before the readiness gates.\n   * @returns The new device's id.\n   */\n  private async waitForNewDevice(\n    deviceIdsBefore: string[],\n    emulator: ProcessLaunch,\n    timeouts: DeviceReadinessTimeouts,\n    onDeviceAppeared: (deviceId: string) => void\n  ): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        onDeviceAppeared(actualDeviceId);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceReady(actualDeviceId, timeouts);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildProcessExitMessage({\n          exitInfo,\n          output: emulator.readOutput(),\n          outputLabel: 'Emulator output',\n          subject: 'Android emulator'\n        }));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    // As in `waitForBoot`: an emulator that hangs has as much to say as one that dies.\n    throw new Error(appendProcessOutputTail(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`,\n      { output: emulator.readOutput(), outputLabel: 'Emulator output' }\n    ));\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * This is the single entry point every worker-side caller uses for the **ambient**\n * transport, so it is also where a failed global setup is turned into a failing test.\n * A failed setup publishes no transport options, and `undefined` options mean the owned\n * **desktop** CDP default \u2014 so without this guard an Android project's suite would run\n * on desktop and then die on an unrelated CDP error, hiding the real cause (**L9**).\n * The setup path itself is unaffected: `coreSetup` builds its transport through\n * {@link createTransportFromOptions} with explicit options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns The cached or newly created transport.\n * @throws {IntegrationSetupFailedError} When this project's global setup failed.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const setupError = getSetupError();\n  if (setupError) {\n    throw new IntegrationSetupFailedError(setupError);\n  }\n\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Stops every emulator this harness started whose run can no longer stop it\n * itself, verifying each stop.\n *\n * For the global teardown of a Vitest project whose transport lives in its test\n * workers rather than in a transport global setup: the worker auto-starts the\n * emulator, Vitest ends the worker without a teardown, and only the main\n * process's teardown gets a turn \u2014 holding no handle to the emulator, but able\n * to find it by its marker (`emulator-marker.ts`).\n *\n * Call it while holding the `android` setup lock (L7): that is what guarantees\n * no other Android run is using a marked emulator. Emulators without a marker are\n * never touched.\n */\nexport async function stopHarnessStartedEmulators(): Promise<void> {\n  const reclaimer = new EmulatorReclaimer((message) => {\n    log(`[transport-factory:${ANDROID_APPIUM_TRANSPORT_TYPE}] ${message}`);\n  });\n  await reclaimer.reclaimLeftoverEmulators({ scope: 'end-of-run' });\n}\n\n/**\n * Verifies the harness-owned instance a worker was told to attach to is still\n * serving CDP, before handing back a transport that can only fail against it.\n *\n * This is the once-per-file check: transport creation is cached per worker, so\n * a live instance pays one loopback request per test file and a dead one turns\n * the whole file into a single named error, raised before the first test. It\n * replaces the `ECONNREFUSED`-per-file cascade a mid-run death used to produce \u2014\n * and the per-file probe consumers were writing into their own `setupFiles` to\n * get the same effect.\n *\n * Only for the harness's own instances: a plain attach targets a foreign\n * Obsidian whose absence is the user's to resolve, and `preflightCheck` already\n * has a story for it.\n *\n * @param host - The CDP host to probe.\n * @param port - The CDP port to probe.\n * @throws {OwnedInstanceExitedError} When nothing is serving CDP on the port.\n */\nasync function assertHarnessOwnedInstanceIsServing(host: string, port: number): Promise<void> {\n  const cdpUrl = `http://${host}:${String(port)}`;\n  try {\n    const response = await fetch(`${cdpUrl}/json/version`);\n    await response.body?.cancel();\n    return;\n  } catch {\n    // Nothing is listening \u2014 the instance the global setup launched is gone.\n  }\n\n  throw buildOwnedInstanceExitedErrorFromMarker(cdpUrl, readOwnedInstanceExitMarker(port));\n}\n\n/**\n * Builds the platform's \"who holds this port\" query.\n *\n * `netstat` cannot filter by port, so the whole table comes back and the parser\n * does the matching; `lsof` filters server-side and answers with bare PIDs.\n *\n * @param port - The port to query.\n * @returns The command and arguments to run.\n */\nfunction buildPortOwnerQuery(port: number): HostCommandQuery {\n  return process.platform === 'win32'\n    ? { command: 'netstat', commandArguments: ['-ano'] }\n    : { command: 'lsof', commandArguments: ['-ti', `tcp:${String(port)}`] };\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    if (options.isHarnessOwnedInstance) {\n      await assertHarnessOwnedInstanceIsServing(options.host ?? 'localhost', options.port);\n    }\n    return new DesktopCdpTransport(normalizeOptionalProperties<DesktopCdpTransportConfig>({\n      cdpHost: options.host,\n      cdpPort: options.port,\n      commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds,\n      isHarnessOwnedInstance: options.isHarnessOwnedInstance\n    }));\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  // Before `resolveOwnedInstanceConfig`, which may download and cache an installer shell:\n  // A structurally invalid config folder name cannot become valid later, so paying for a\n  // Provisioning round-trip first would only delay the same failure.\n  if (options?.configDirectory !== undefined) {\n    assertValidConfigDirectory(options.configDirectory);\n  }\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport(normalizeOptionalProperties<DesktopCdpTransportConfig>({\n    cdpHost: options?.host,\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    configDirectory: options?.configDirectory,\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    isObsidianAppVisible: options?.isObsidianAppVisible,\n    ownedInstance,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnSilentAsarFallback: willThrowOnSilentAsarFallback(options?.shouldThrowOnSilentAsarFallback),\n    shouldWarnOnCompatibilityIssues: willWarnOnCompatibilityIssues(options?.shouldWarnOnCompatibilityIssues)\n  }));\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDirectory(): string {\n  const root = join(tmpdir(), HARNESS_TEMP_DIR_NAME);\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_DIR_PREFIX));\n}\n\n/**\n * Returns the first rejection reason among settled outcomes.\n *\n * @param outcomes - The settled outcomes, at least one of which is expected to have rejected.\n * @returns The first rejection reason, or a stand-in error when none rejected.\n */\nfunction getSettledFailure(outcomes: readonly PromiseSettledResult<unknown>[]): unknown {\n  for (const outcome of outcomes) {\n    if (outcome.status === 'rejected') {\n      return outcome.reason;\n    }\n  }\n\n  return new Error('Android provisioning failed without naming a reason.');\n}\n\n/**\n * Loads `webdriverio` on demand.\n *\n * The load is deferred because a static import would drag the whole WebDriver\n * stack (`webdriverio` + `@wdio/*` + `archiver`/`cheerio`/`jszip`) into every\n * consumer of this package's index \u2014 `evalInObsidian` reaches this module \u2014 when\n * only the Appium transport needs it. Nothing on the desktop CDP path touches\n * `webdriverio` at all.\n *\n * It also keeps `chalk` out of that graph. `@wdio/logger` imports `chalk@5`,\n * whose internal `#supports-color` subpath import Jest's VM-modules linker fails\n * to link, so an eagerly-imported `webdriverio` kills a Jest ESM suite at import\n * with `ReferenceError: Cannot access 'supportsColor' before initialization`\n * before a single test runs \u2014 which is what once made `test:jest` red. A\n * `moduleNameMapper` cannot patch it: the mapper is bypassed for `#` specifiers.\n *\n * @returns A {@link Promise} that resolves to the `webdriverio` entry points the\n * Appium factory calls.\n */\nasync function importWebdriverio(): Promise<WebdriverioModule> {\n  // eslint-disable-next-line no-restricted-syntax -- `webdriverio` is Appium-only, so it must be loaded lazily: a static import would drag the whole WebDriver stack into every consumer of this package's index, and `chalk` with it (see the doc comment).\n  return await import('webdriverio');\n}\n\n/**\n * Parses a port-owner listing with the platform's parser.\n *\n * @param params - The raw output and the port that was queried.\n * @returns The PIDs holding the port.\n */\nfunction parsePortOwnerPids(params: ParsePortOwnerPidsParams): number[] {\n  return process.platform === 'win32'\n    ? parseWindowsNetstatPids({ netstatOutput: params.output, port: params.port })\n    : parsePosixLsofPids(params.output);\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: for an installer below the app's run floor either throws\n * {@link IncompatibleInstallerVersionError} (when\n * {@link ResolveAndReportCompatibilityParams.shouldThrowOnIncompatibleInstaller})\n * or proceeds to launch with a warning; for a runnable-but-below-recommended\n * installer logs a warning. Both warnings are suppressed when\n * {@link ResolveAndReportCompatibilityParams.shouldWarnOnCompatibilityIssues} is\n * `false`.\n *\n * @param params - The resolved versions and the warn/throw knobs.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction resolveAndReportCompatibility(params: ResolveAndReportCompatibilityParams): InstallerCompatibility | undefined {\n  const { appVersion, installerVersion, shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues } = params;\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = resolveInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  const action = resolveInstallerCompatibilityAction({\n    shouldThrowOnIncompatibleInstaller,\n    shouldWarnOnCompatibilityIssues,\n    tier: compatibility.tier\n  });\n\n  if (action === 'throw') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (action === 'warn-unrunnable') {\n    log(\n      `[transport-factory:obsidian-cdp] Obsidian installer ${ensureNonNullable(compatibility.installerVersion)} is below the `\n        + `run floor ${ensureNonNullable(compatibility.minRunnableInstallerVersion)} for Obsidian ${compatibility.appVersion}; `\n        + 'proceeding to launch (shouldThrowOnIncompatibleInstaller is false) \u2014 the boot will likely dead-boot.'\n    );\n  } else if (action === 'warn-nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDirectory());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link resolveInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = resolveAndReportCompatibility({\n    appVersion: swapAppVersion,\n    installerVersion: shellVersion,\n    shouldThrowOnIncompatibleInstaller: willThrowOnIncompatibleInstaller(options?.shouldThrowOnIncompatibleInstaller),\n    shouldWarnOnCompatibilityIssues: willWarnOnCompatibilityIssues(options?.shouldWarnOnCompatibilityIssues)\n  });\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n\n    userDataDirectory: createOwnedUserDataDirectory()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
