obsidian-integration-testing 12.0.0 → 12.1.0

package/dist/lib/cjs/device-readiness.d.cts

@@ -1,24 +1,41 @@
 /**
  * @file
  *
- * Pure helpers for deciding when a freshly-booted Android emulator is idle
- * enough to establish an Appium session, plus resolving the idle-wait timeout
- * from the transport options. Kept separate from the integration-only
+ * Pure helpers for deciding when a freshly-booted Android emulator is ready
+ * enough to establish an Appium session, plus resolving the two readiness-wait
+ * timeouts from the transport options. Kept separate from the integration-only
  * `transport-factory` so the parsing and default resolution stay unit-testable
  * (the factory itself needs a real emulator and is excluded from unit tests).
  *
- * `sys.boot_completed` fires *before* the guest is actually idle: package
- * optimization (`dex2oat`) and system services keep churning after it, so a
- * session established the instant it fires makes every one of UiAutomator2's
- * serialized `adb` round-trips contend with that work and inflate ~3x. Gating
- * the session on a later, quieter signal (the boot animation has stopped and
- * the package manager is serving) lets it run against an idle guest instead.
+ * Readiness is two independent questions, waited on in two phases:
+ *
+ * 1. **Is the guest idle?** `sys.boot_completed` fires *before* it is: package
+ *    optimization (`dex2oat`) and system services keep churning after it, so a
+ *    session established the instant it fires makes every one of UiAutomator2's
+ *    serialized `adb` round-trips contend with that work and inflate ~3x. Gating
+ *    the session on a later, quieter signal (the boot animation has stopped and
+ *    the package manager is serving) lets it run against an idle guest instead.
+ * 2. **Does the guest have a network?** Both idle signals are true well *before*
+ *    the default network is created and validated — that lands ~80s into guest
+ *    uptime, tens of seconds after the idle gate clears — and neither says
+ *    anything about connectivity, so an idle-only gate hands the suite a device
+ *    with no route. See {@link checkNetworkValidated} for the measurement and
+ *    for why the three obvious connectivity probes are all wrong here.
  */
 import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.cjs';
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.networkReadyTimeoutInMilliseconds}.
+ *
+ * The budget starts *after* `sys.boot_completed`, where the measured wait on a
+ * cold WHPX emulator is ~30s (validation at ~80s from boot, against a boot flag
+ * at ~56s). The default is headroom for the starved/CI regime the other Android
+ * budgets are already sized for, not the expected cost.
+ */
+export declare const DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS = 120000;
 /**
  * Parameters for {@link checkDeviceIdle}.
  */
@@ -32,6 +49,15 @@ export interface CheckDeviceIdleParams {
      */
     readonly packageListOutput: string;
 }
+/**
+ * Parameters for {@link checkNetworkValidated}.
+ */
+export interface CheckNetworkValidatedParams {
+    /**
+    Raw stdout of `adb shell dumpsys connectivity`.
+     */
+    readonly connectivityOutput: string;
+}
 /**
  * Decides whether a booted emulator is idle enough to start an Appium session,
  * from the raw output of the two probe commands.
@@ -45,6 +71,42 @@ export interface CheckDeviceIdleParams {
  * @returns `true` when the guest is idle enough to proceed.
  */
 export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
+/**
+ * Decides whether a booted emulator has a working network, from the raw output
+ * of `adb shell dumpsys connectivity`.
+ *
+ * Ready means the dump names an **active default network** *and* that network's
+ * own agent info reports validation — either an `IS_VALIDATED` score policy or a
+ * non-zero `firstValidated` timestamp. Both are required: a default network
+ * exists for seconds before it validates, and during that window it carries no
+ * usable route.
+ *
+ * Why this matters at all: the two {@link checkDeviceIdle} signals are satisfied
+ * well before this one. Validation lands ~70-80s into guest uptime — measured on
+ * `obsidian_test`, `created 70635 firstValidated 72681`, and on a cold boot of
+ * `obsidian_screenshots`, `created 66870 firstValidated 79870`, which at 85s
+ * uptime still scored `EVER_EVALUATED&IS_UNMETERED` with no `IS_VALIDATED` and
+ * no `firstValidated` field at all. Against a boot flag at ~56s that leaves a
+ * gap of tens of seconds on a fast host, and more on a slow one. A suite started
+ * in that gap does not merely run slowly: a test that reaches the network runs
+ * to completion against a silently empty result, which no assertion inside the
+ * suite can tell apart from a genuinely empty feed.
+ *
+ * `dumpsys connectivity` is the honest source, and the three probes that look
+ * like better ones are all wrong — each of them misled a full day of
+ * investigation before this was understood:
+ *
+ * - `ip route` shows **no** default route on a healthy device: Android uses
+ *   per-network policy routing, and the route lives in table 1015, not `main`.
+ * - `ping` fails on a healthy device: QEMU user-mode NAT does not forward ICMP
+ *   on Windows hosts.
+ * - `getprop net.dns1` is empty on every modern Android: DNS went per-network
+ *   in 8/9.
+ *
+ * @param params - The sampled probe output.
+ * @returns `true` when the guest has a validated default network.
+ */
+export declare function checkNetworkValidated(params: CheckNetworkValidatedParams): boolean;
 /**
  * Resolves the post-boot device-idle wait timeout, applying the default when
  * the option is omitted.
@@ -57,3 +119,15 @@ export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
  * @returns The timeout in milliseconds.
  */
 export declare function resolveDeviceIdleTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
+/**
+ * Resolves the network-ready wait timeout, applying the default when the option
+ * is omitted.
+ *
+ * This bounds how long the factory waits, after the idle gate, for the guest to
+ * report a validated default network (see {@link checkNetworkValidated}) before
+ * establishing the session. A value of `0` skips the wait entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveNetworkReadyTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

package/dist/lib/cjs/emulator-arguments.cjs

@@ -23,7 +23,11 @@ __export(emulator_arguments_exports, {
 module.exports = __toCommonJS(emulator_arguments_exports);
 const DNS_SERVER = "8.8.8.8";
 function buildEmulatorArguments(params) {
-  const emulatorArguments = ["-avd", params.avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+  const emulatorArguments = ["-avd", params.avdName];
+  if (!params.shouldReuseSnapshot) {
+    emulatorArguments.push("-no-snapshot-load", "-no-snapshot-save");
+  }
+  emulatorArguments.push("-dns-server", DNS_SERVER);
   if (params.isHidden) {
     emulatorArguments.push("-no-window");
   }
@@ -33,4 +37,4 @@ function buildEmulatorArguments(params) {
 0 && (module.exports = {
   buildEmulatorArguments
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3VtZW50cy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKi9cblxuY29uc3QgRE5TX1NFUlZFUiA9ICc4LjguOC44JztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRFbXVsYXRvckFyZ3VtZW50c30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQnVpbGRFbXVsYXRvckFyZ3VtZW50c1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHJ1biB0aGUgZW11bGF0b3IgaGVhZGxlc3MgKGAtbm8td2luZG93YCksIHNvIGl0IG5ldmVyIHN0ZWFsc1xuICAgKiBmb2N1cy4gUmVzb2x2ZWQgZnJvbSB0aGUgYGlzRW11bGF0b3JWaXNpYmxlYCB0cmFuc3BvcnQgb3B0aW9uLlxuICAgKi9cbiAgcmVhZG9ubHkgaXNIaWRkZW46IGJvb2xlYW47XG59XG5cbi8qKlxuICogQnVpbGRzIHRoZSBhcmd1bWVudCBsaXN0IGZvciBzcGF3bmluZyB0aGUgQW5kcm9pZCBlbXVsYXRvci5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIGVtdWxhdG9yIGFyZ3VtZW50IHBhcmFtZXRlcnMuXG4gKiBAcmV0dXJucyBUaGUgYXJndW1lbnQgYXJyYXkgdG8gcGFzcyB0byB0aGUgZW11bGF0b3IgYmluYXJ5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRFbXVsYXRvckFyZ3VtZW50cyhwYXJhbXM6IEJ1aWxkRW11bGF0b3JBcmd1bWVudHNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGVtdWxhdG9yQXJndW1lbnRzID0gWyctYXZkJywgcGFyYW1zLmF2ZE5hbWUsICctbm8tc25hcHNob3Qtc2F2ZScsICctZG5zLXNlcnZlcicsIEROU19TRVJWRVJdO1xuICBpZiAocGFyYW1zLmlzSGlkZGVuKSB7XG4gICAgZW11bGF0b3JBcmd1bWVudHMucHVzaCgnLW5vLXdpbmRvdycpO1xuICB9XG4gIHJldHVybiBlbXVsYXRvckFyZ3VtZW50cztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFNQSxNQUFNLGFBQWE7QUF3QlosU0FBUyx1QkFBdUIsUUFBZ0Q7QUFDckYsUUFBTSxvQkFBb0IsQ0FBQyxRQUFRLE9BQU8sU0FBUyxxQkFBcUIsZUFBZSxVQUFVO0FBQ2pHLE1BQUksT0FBTyxVQUFVO0FBQ25CLHNCQUFrQixLQUFLLFlBQVk7QUFBQSxFQUNyQztBQUNBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3VtZW50cy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKlxuICogKipUaGUgaGFybmVzcyBvd25zIHRoZSBzbmFwc2hvdCBpdCBsb2Fkcywgb3IgaXQgbG9hZHMgbm9uZS4qKiBUaGlzIGZpbGUgdXNlZFxuICogdG8gcGFzcyBgLW5vLXNuYXBzaG90LXNhdmVgIGFsb25lIFx1MjAxNCB0aGUgb25lIGNvbWJpbmF0aW9uIHRoYXQgaXMgbmV2ZXJcbiAqIGNvcnJlY3QuIEl0IG5ldmVyICp3cml0ZXMqIGBkZWZhdWx0X2Jvb3RgLCB5ZXQgZXZlcnkgcnVuICpyZXN1bWVkKiBpdCwgc28gdGhlXG4gKiBndWVzdCBlYWNoIHJ1biBzdGFydGVkIGZyb20gd2FzIHN0YXRlIG5vdGhpbmcgaGFkIHZhbGlkYXRlZCBzaW5jZSB3aGVuZXZlciBhXG4gKiBodW1hbiBsYXN0IHNhdmVkIGl0LiBNZWFzdXJlZCAyMDI2LTA5LTAzLCBzYW1lIEFWRCBiYWNrIHRvIGJhY2s6XG4gKlxuICogfCBMYXVuY2ggfCBSZXN1bHQgfFxuICogfCAtLS0gfCAtLS0gfFxuICogfCBzbmFwc2hvdCByZXN1bWVkIChgLW5vLXNuYXBzaG90LXNhdmVgIGFsb25lKSB8IGd1ZXN0IGRpZXMgfjkwcyBpbiwgZXZlcnkgdGltZSB8XG4gKiB8IGAtbm8tc25hcHNob3QtbG9hZGAgKGNvbGQpIHwgYm9vdGVkIGluIDUwcywgYWxpdmUgYXQgNjAvMTIwLzE4MC8yNDBzIHxcbiAqXG4gKiBBIHJlc3VtZWQgc25hcHNob3Qgcm90cyBzaWxlbnRseSwgYW5kIHRoZSBmYWlsdXJlIGl0IGV2ZW50dWFsbHkgcHJvZHVjZXMgXHUyMDE0XG4gKiBhIGRldmljZSB0aGF0IHNlcnZlcyBhZGIsIGFjY2VwdHMgYSBzZXNzaW9uIGFuZCB0aGVuIGRyb3BzIGBvZmZsaW5lYCBhXG4gKiBoYWxmLW1pbnV0ZSBsYXRlciBcdTIwMTQgaXMgaW5kaXN0aW5ndWlzaGFibGUgZnJvbSBhIGNvZGUgcmVncmVzc2lvbi4gU28gdGhlXG4gKiBkZWZhdWx0IGlzIGEgZnVsbCBjb2xkIGJvb3QsIGFuZCBzbmFwc2hvdCByZXVzZSBpcyBhbiBleHBsaWNpdCBvcHQtaW4gdGhhdFxuICogdGFrZXMgKipib3RoKiogaGFsdmVzOiBsb2FkIGFuZCBzYXZlIHRvZ2V0aGVyLCBzbyB0aGUgc25hcHNob3QgdGhlIG5leHQgcnVuXG4gKiByZXN1bWVzIGlzIG9uZSB0aGlzIHJ1biB3cm90ZS5cbiAqL1xuXG5jb25zdCBETlNfU0VSVkVSID0gJzguOC44LjgnO1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHtAbGluayBidWlsZEVtdWxhdG9yQXJndW1lbnRzfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZEVtdWxhdG9yQXJndW1lbnRzUGFyYW1zIHtcbiAgLyoqXG4gIFRoZSBBbmRyb2lkIFZpcnR1YWwgRGV2aWNlIG5hbWUuXG4gICAqL1xuICByZWFkb25seSBhdmROYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdG8gcnVuIHRoZSBlbXVsYXRvciBoZWFkbGVzcyAoYC1uby13aW5kb3dgKSwgc28gaXQgbmV2ZXIgc3RlYWxzXG4gICAqIGZvY3VzLiBSZXNvbHZlZCBmcm9tIHRoZSBgaXNFbXVsYXRvclZpc2libGVgIHRyYW5zcG9ydCBvcHRpb24uXG4gICAqL1xuICByZWFkb25seSBpc0hpZGRlbjogYm9vbGVhbjtcblxuICAvKipcbiAgICogV2hldGhlciB0aGUgZW11bGF0b3IgbWF5IHJlc3VtZSBcdTIwMTQgYW5kIHJlZnJlc2ggXHUyMDE0IHRoZSBBVkQncyBzYXZlZCBib290XG4gICAqIHNuYXBzaG90LiBSZXNvbHZlZCBmcm9tIHRoZSBgc2hvdWxkUmV1c2VFbXVsYXRvclNuYXBzaG90YCB0cmFuc3BvcnQgb3B0aW9uLlxuICAgKlxuICAgKiBgZmFsc2VgICh0aGUgZGVmYXVsdCkgY29sZC1ib290cyBoZXJtZXRpY2FsbHkuIGB0cnVlYCBidXlzIGJhY2sgdGhlIH4xMTJzXG4gICAqIGJvb3Qgb24gYSBwZXJzaXN0ZW50IHJ1bm5lciwgYXQgdGhlIGNvc3Qgb2YgdGVzdCBpc29sYXRpb24uXG4gICAqL1xuICByZWFkb25seSBzaG91bGRSZXVzZVNuYXBzaG90OiBib29sZWFuO1xufVxuXG4vKipcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBlbXVsYXRvciBhcmd1bWVudCBwYXJhbWV0ZXJzLlxuICogQHJldHVybnMgVGhlIGFyZ3VtZW50IGFycmF5IHRvIHBhc3MgdG8gdGhlIGVtdWxhdG9yIGJpbmFyeS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkRW11bGF0b3JBcmd1bWVudHMocGFyYW1zOiBCdWlsZEVtdWxhdG9yQXJndW1lbnRzUGFyYW1zKTogc3RyaW5nW10ge1xuICBjb25zdCBlbXVsYXRvckFyZ3VtZW50cyA9IFsnLWF2ZCcsIHBhcmFtcy5hdmROYW1lXTtcbiAgLypcbiAgICogQm90aCBmbGFncyBvciBuZWl0aGVyOiBsb2FkaW5nIHdpdGhvdXQgc2F2aW5nIGlzIHRoZSByZXN1bWUtd2hhdC13ZS1uZXZlci1cbiAgICogd3JvdGUgY29tYmluYXRpb24gdGhpcyBmaWxlJ3MgaGVhZGVyIGV4aXN0cyB0byBydWxlIG91dC5cbiAgICovXG4gIGlmICghcGFyYW1zLnNob3VsZFJldXNlU25hcHNob3QpIHtcbiAgICBlbXVsYXRvckFyZ3VtZW50cy5wdXNoKCctbm8tc25hcHNob3QtbG9hZCcsICctbm8tc25hcHNob3Qtc2F2ZScpO1xuICB9XG4gIGVtdWxhdG9yQXJndW1lbnRzLnB1c2goJy1kbnMtc2VydmVyJywgRE5TX1NFUlZFUik7XG4gIGlmIChwYXJhbXMuaXNIaWRkZW4pIHtcbiAgICBlbXVsYXRvckFyZ3VtZW50cy5wdXNoKCctbm8td2luZG93Jyk7XG4gIH1cbiAgcmV0dXJuIGVtdWxhdG9yQXJndW1lbnRzO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQXdCQSxNQUFNLGFBQWE7QUFpQ1osU0FBUyx1QkFBdUIsUUFBZ0Q7QUFDckYsUUFBTSxvQkFBb0IsQ0FBQyxRQUFRLE9BQU8sT0FBTztBQUtqRCxNQUFJLENBQUMsT0FBTyxxQkFBcUI7QUFDL0Isc0JBQWtCLEtBQUsscUJBQXFCLG1CQUFtQjtBQUFBLEVBQ2pFO0FBQ0Esb0JBQWtCLEtBQUssZUFBZSxVQUFVO0FBQ2hELE1BQUksT0FBTyxVQUFVO0FBQ25CLHNCQUFrQixLQUFLLFlBQVk7QUFBQSxFQUNyQztBQUNBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/cjs/emulator-arguments.d.cts

@@ -2,6 +2,24 @@
  * @file
  *
  * Builds the argument list for spawning the Android emulator.
+ *
+ * **The harness owns the snapshot it loads, or it loads none.** This file used
+ * to pass `-no-snapshot-save` alone — the one combination that is never
+ * correct. It never *writes* `default_boot`, yet every run *resumed* it, so the
+ * guest each run started from was state nothing had validated since whenever a
+ * human last saved it. Measured 2026-09-03, same AVD back to back:
+ *
+ * | Launch | Result |
+ * | --- | --- |
+ * | snapshot resumed (`-no-snapshot-save` alone) | guest dies ~90s in, every time |
+ * | `-no-snapshot-load` (cold) | booted in 50s, alive at 60/120/180/240s |
+ *
+ * A resumed snapshot rots silently, and the failure it eventually produces —
+ * a device that serves adb, accepts a session and then drops `offline` a
+ * half-minute later — is indistinguishable from a code regression. So the
+ * default is a full cold boot, and snapshot reuse is an explicit opt-in that
+ * takes **both** halves: load and save together, so the snapshot the next run
+ * resumes is one this run wrote.
  */
 /**
  * Parameters for {@link buildEmulatorArguments}.
@@ -16,6 +34,14 @@ export interface BuildEmulatorArgumentsParams {
      * focus. Resolved from the `isEmulatorVisible` transport option.
      */
     readonly isHidden: boolean;
+    /**
+     * Whether the emulator may resume — and refresh — the AVD's saved boot
+     * snapshot. Resolved from the `shouldReuseEmulatorSnapshot` transport option.
+     *
+     * `false` (the default) cold-boots hermetically. `true` buys back the ~112s
+     * boot on a persistent runner, at the cost of test isolation.
+     */
+    readonly shouldReuseSnapshot: boolean;
 }
 /**
  * Builds the argument list for spawning the Android emulator.

package/dist/lib/cjs/emulator-backend.cjs

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var emulator_backend_exports = {};
+__export(emulator_backend_exports, {
+  parsePosixProcessList: () => parsePosixProcessList,
+  parseWindowsTaskList: () => parseWindowsTaskList,
+  selectEmulatorBackendPids: () => selectEmulatorBackendPids
+});
+module.exports = __toCommonJS(emulator_backend_exports);
+const EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\w.-]+|qemu-system-[\w.-]+)$/;
+const EXECUTABLE_SUFFIX_PATTERN = /\.exe$/;
+const RADIX_DECIMAL = 10;
+const TASK_LIST_FIELDS_READ = 2;
+function parsePosixProcessList(processListOutput) {
+  const entries = [];
+  for (const rawLine of processListOutput.split("\n")) {
+    const line = rawLine.trim();
+    const separatorIndex = line.indexOf(" ");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);
+    if (Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });
+  }
+  return entries;
+}
+function parseWindowsTaskList(taskListOutput) {
+  const entries = [];
+  for (const rawLine of taskListOutput.split("\n")) {
+    const [rawName = "", rawPid = ""] = rawLine.trim().replaceAll('"', "").split(",", TASK_LIST_FIELDS_READ);
+    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);
+    if (rawName.length === 0 || Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: rawName, pid });
+  }
+  return entries;
+}
+function selectEmulatorBackendPids(params) {
+  return params.processes.filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid)).map((entry) => entry.pid);
+}
+function checkIsEmulatorBackendName(name) {
+  const baseName = name.slice(Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\")) + 1);
+  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ""));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePosixProcessList,
+  parseWindowsTaskList,
+  selectEmulatorBackendPids
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-backend.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for finding the Android emulator process that **outlives the pid\n * the harness killed**.\n *\n * Under `-no-window` the emulator's backend process is\n * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the\n * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The\n * launcher exits or is killed, and the backend is what actually holds the AVD's\n * `multiinstance.lock` and the console/adb ports \u2014 so `taskkill /F /T` against\n * the launcher's pid reports success while the emulator keeps running. Every\n * later run against that AVD then dies with `Running multiple emulators with the\n * same AVD is an experimental feature`, which never reaches the user because the\n * emulator writes it to its own stdout.\n *\n * Note that the obvious filter \u2014 `-Name qemu-system-x86_64` / matching that\n * exact image name \u2014 does **not** match the `-headless` build, which is how the\n * leftover stays invisible through several rounds of \"no emulator is running\".\n *\n * Ownership is decided by a **pre-launch snapshot**: a backend already running\n * before this run started its own belongs to somebody else (another AVD, or one\n * the user booted by hand) and is never touched. Kept separate from the\n * integration-only `transport-factory` so the parsing and the selection stay\n * unit-testable.\n */\n\n/**\n * One process from a host process listing.\n */\nexport interface ProcessListEntry {\n  /**\n  The process/image name, as the platform's listing reports it.\n   */\n  readonly name: string;\n\n  /**\n  The process ID.\n   */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link selectEmulatorBackendPids}.\n */\nexport interface SelectEmulatorBackendPidsParams {\n  /**\n  Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.\n   */\n  readonly knownPids: readonly number[];\n\n  /**\n  The host's current process listing.\n   */\n  readonly processes: readonly ProcessListEntry[];\n}\n\n/**\n * Matches the emulator launcher and both QEMU backend builds \u2014 crucially\n * including the `-headless` suffix `-no-window` runs produce.\n */\nconst EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\\w.-]+|qemu-system-[\\w.-]+)$/;\nconst EXECUTABLE_SUFFIX_PATTERN = /\\.exe$/;\nconst RADIX_DECIMAL = 10;\n/**\n * Only the image name and the PID are read, so the split stops after them.\n */\nconst TASK_LIST_FIELDS_READ = 2;\n\n/**\n * Parses `ps -eo pid=,comm=` output.\n *\n * @param processListOutput - Raw stdout of the `ps` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parsePosixProcessList(processListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of processListOutput.split('\\n')) {\n    const line = rawLine.trim();\n    const separatorIndex = line.indexOf(' ');\n    if (separatorIndex === -1) {\n      continue;\n    }\n\n    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);\n    if (Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });\n  }\n\n  return entries;\n}\n\n/**\n * Parses `tasklist /FO CSV /NH` output.\n *\n * Only the first two fields are read \u2014 the image name and the PID \u2014 so the\n * memory column's own commas cannot confuse the split.\n *\n * @param taskListOutput - Raw stdout of the `tasklist` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of taskListOutput.split('\\n')) {\n    const [rawName = '', rawPid = ''] = rawLine.trim().replaceAll('\"', '').split(',', TASK_LIST_FIELDS_READ);\n    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);\n    if (rawName.length === 0 || Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: rawName, pid });\n  }\n\n  return entries;\n}\n\n/**\n * Selects the emulator processes this run is responsible for killing.\n *\n * @param params - The current listing plus the PIDs that predate this run's emulator.\n * @returns The PIDs of emulator processes this run owns, in listed order.\n */\nexport function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[] {\n  return params.processes\n    .filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid))\n    .map((entry) => entry.pid);\n}\n\nfunction checkIsEmulatorBackendName(name: string): boolean {\n  const baseName = name.slice(Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\\\')) + 1);\n  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ''));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6DA,MAAM,gCAAgC;AACtC,MAAM,4BAA4B;AAClC,MAAM,gBAAgB;AAItB,MAAM,wBAAwB;AAQvB,SAAS,sBAAsB,mBAA+C;AACnF,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,kBAAkB,MAAM,IAAI,GAAG;AACnD,UAAM,OAAO,QAAQ,KAAK;AAC1B,UAAM,iBAAiB,KAAK,QAAQ,GAAG;AACvC,QAAI,mBAAmB,IAAI;AACzB;AAAA,IACF;AAEA,UAAM,MAAM,OAAO,SAAS,KAAK,MAAM,GAAG,cAAc,GAAG,aAAa;AACxE,QAAI,OAAO,MAAM,GAAG,GAAG;AACrB;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,KAAK,MAAM,iBAAiB,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;AAAA,EACnE;AAEA,SAAO;AACT;AAWO,SAAS,qBAAqB,gBAA4C;AAC/E,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,eAAe,MAAM,IAAI,GAAG;AAChD,UAAM,CAAC,UAAU,IAAI,SAAS,EAAE,IAAI,QAAQ,KAAK,EAAE,WAAW,KAAK,EAAE,EAAE,MAAM,KAAK,qBAAqB;AACvG,UAAM,MAAM,OAAO,SAAS,QAAQ,aAAa;AACjD,QAAI,QAAQ,WAAW,KAAK,OAAO,MAAM,GAAG,GAAG;AAC7C;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,SAAS,IAAI,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;AAQO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,OAAO,UACX,OAAO,CAAC,UAAU,2BAA2B,MAAM,IAAI,KAAK,CAAC,OAAO,UAAU,SAAS,MAAM,GAAG,CAAC,EACjG,IAAI,CAAC,UAAU,MAAM,GAAG;AAC7B;AAEA,SAAS,2BAA2B,MAAuB;AACzD,QAAM,WAAW,KAAK,MAAM,KAAK,IAAI,KAAK,YAAY,GAAG,GAAG,KAAK,YAAY,IAAI,CAAC,IAAI,CAAC;AACvF,SAAO,8BAA8B,KAAK,SAAS,YAAY,EAAE,QAAQ,2BAA2B,EAAE,CAAC;AACzG;",
  "names": []
}


package/dist/lib/cjs/emulator-backend.d.cts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Pure helpers for finding the Android emulator process that **outlives the pid
+ * the harness killed**.
+ *
+ * Under `-no-window` the emulator's backend process is
+ * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the
+ * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The
+ * launcher exits or is killed, and the backend is what actually holds the AVD's
+ * `multiinstance.lock` and the console/adb ports — so `taskkill /F /T` against
+ * the launcher's pid reports success while the emulator keeps running. Every
+ * later run against that AVD then dies with `Running multiple emulators with the
+ * same AVD is an experimental feature`, which never reaches the user because the
+ * emulator writes it to its own stdout.
+ *
+ * Note that the obvious filter — `-Name qemu-system-x86_64` / matching that
+ * exact image name — does **not** match the `-headless` build, which is how the
+ * leftover stays invisible through several rounds of "no emulator is running".
+ *
+ * Ownership is decided by a **pre-launch snapshot**: a backend already running
+ * before this run started its own belongs to somebody else (another AVD, or one
+ * the user booted by hand) and is never touched. Kept separate from the
+ * integration-only `transport-factory` so the parsing and the selection stay
+ * unit-testable.
+ */
+/**
+ * One process from a host process listing.
+ */
+export interface ProcessListEntry {
+    /**
+    The process/image name, as the platform's listing reports it.
+     */
+    readonly name: string;
+    /**
+    The process ID.
+     */
+    readonly pid: number;
+}
+/**
+ * Parameters for {@link selectEmulatorBackendPids}.
+ */
+export interface SelectEmulatorBackendPidsParams {
+    /**
+    Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.
+     */
+    readonly knownPids: readonly number[];
+    /**
+    The host's current process listing.
+     */
+    readonly processes: readonly ProcessListEntry[];
+}
+/**
+ * Parses `ps -eo pid=,comm=` output.
+ *
+ * @param processListOutput - Raw stdout of the `ps` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parsePosixProcessList(processListOutput: string): ProcessListEntry[];
+/**
+ * Parses `tasklist /FO CSV /NH` output.
+ *
+ * Only the first two fields are read — the image name and the PID — so the
+ * memory column's own commas cannot confuse the split.
+ *
+ * @param taskListOutput - Raw stdout of the `tasklist` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[];
+/**
+ * Selects the emulator processes this run is responsible for killing.
+ *
+ * @param params - The current listing plus the PIDs that predate this run's emulator.
+ * @returns The PIDs of emulator processes this run owns, in listed order.
+ */
+export declare function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[];

package/dist/lib/cjs/emulator-liveness.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var emulator_liveness_exports = {};
+__export(emulator_liveness_exports, {
+  buildEmulatorLivenessMessage: () => buildEmulatorLivenessMessage,
+  resolveEmulatorLivenessVerdict: () => resolveEmulatorLivenessVerdict
+});
+module.exports = __toCommonJS(emulator_liveness_exports);
+var import_avd_probe_verdict = require("./avd-probe-verdict.cjs");
+var import_process_exit_message = require("./process-exit-message.cjs");
+function buildEmulatorLivenessMessage(params) {
+  const budget = `${String(params.probeTimeoutInMilliseconds)}ms`;
+  const diagnosis = {
+    "device-gone": [
+      "The host's `adb devices` no longer lists it, so it is no longer serving adb at all.",
+      "Either the emulator exited, or it wedged badly enough to drop off adb \u2014 the emulator output below is the best evidence for which.",
+      "An emulator this run started is replaced automatically once, so seeing this means the replacement did not survive either. Check that nothing else on this host stops emulators, and that the emulator build and system image are sound."
+    ],
+    "emulator-wedged": [
+      `Neither the guest (\`adb -s ${params.deviceId} shell\`) nor the emulator's own console (\`adb -s ${params.deviceId} emu avd status\`) answered within ${budget}.`,
+      "The console is served by the emulator process, not by the guest, so its silence means the EMULATOR is wedged \u2014 not the guest, not the Appium server, and not the device being absent.",
+      "`adb devices` will still list this device and will mislead you: nothing is left running to update that state.",
+      "A wedged emulator does not come back, so retrying the session against it cannot succeed. One this run started is replaced with a fresh boot automatically, which means seeing this message is the replacement failing too.",
+      "If it recurs at the same point in every run, the fault is below the harness \u2014 and the first thing to check is what filters this host's sockets. Endpoint-security, content-blocking and VPN products install socket filter drivers in the path of every socket call the emulator makes, the console's localhost connection included; stopping that service has fixed exactly this signature. After that, the emulator build, the system image and the host hypervisor."
+    ],
+    "guest-unresponsive": [
+      `The guest (\`adb -s ${params.deviceId} shell\`) did not answer within ${budget}, but the emulator's own console did.`,
+      "So the emulator process is healthy and the guest is frozen or too starved to schedule `adbd`.",
+      "A contended host is the usual cause; `deviceIdleTimeoutInMilliseconds` is the budget that governs waiting one out.",
+      "But if it recurs at the same point in every run, no timeout will fix it, and the host is not merely busy. Check what filters this host's sockets first \u2014 a content-blocking, endpoint-security or VPN socket filter driver produces this verdict as readily as it produces a fully wedged emulator \u2014 then the emulator build, the system image and the host hypervisor."
+    ]
+  };
+  const lines = [
+    `Device ${params.deviceId} stopped answering before the Appium session could be established.`,
+    ...diagnosis[params.verdict]
+  ];
+  return (0, import_process_exit_message.appendProcessOutputTail)(lines.join("\n"), { output: params.emulatorOutput, outputLabel: "Emulator output" });
+}
+function resolveEmulatorLivenessVerdict(params) {
+  if (params.shellProbe === "answered") {
+    return "alive";
+  }
+  if (!params.isListedByAdb) {
+    return "device-gone";
+  }
+  if (!(0, import_avd_probe_verdict.checkIsEmulatorDeviceId)(params.deviceId)) {
+    return "guest-unresponsive";
+  }
+  return params.consoleProbe === "answered" ? "guest-unresponsive" : "emulator-wedged";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildEmulatorLivenessMessage,
+  resolveEmulatorLivenessVerdict
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of whether the device a run is about to drive is still\n * **there** \u2014 and, when it is not, which of the two very different things went\n * wrong: the guest froze, or the emulator process itself did.\n *\n * The readiness gates in `device-readiness.ts` answer *\"is the guest ready\n * yet?\"*, and both are deliberately best-effort: they warn and proceed. Nothing\n * asked *\"is it still answering?\"* at the moment the session is created, so a\n * guest that stopped answering between the last gate and `remote()` was handed\n * to Appium anyway. What the operator then saw was Appium's own report:\n *\n * ```text\n * WebDriverError: Device emulator-5554 was not in the list of connected devices\n *   when running \"http://localhost:4723/session\" with method \"POST\"\n * ```\n *\n * \u2014 measured on this host 2026-09-05, after 515s. That names the device, and\n * `adb devices` then lists the device happily, so it sends the reader to the one\n * diagnostic that cannot help. The same trap `wedged-appium-server.ts` exists to\n * escape, one layer further down.\n *\n * ## The console is what tells the two apart\n *\n * `adb -s <device> emu <command>` is served by the **emulator's own console**,\n * not by the guest's `adbd`. So the two probes answer different questions, and\n * the pair is a diagnosis where either alone is a guess:\n *\n * | `adb shell` | `adb emu` | What it means |\n * | --- | --- | --- |\n * | succeeds | \u2014 | Alive. Proceed. |\n * | fails | succeeds | The **guest** is frozen or too busy to schedule `adbd`. |\n * | fails | fails | The **emulator process** is unreachable. Nothing will recover it. |\n *\n * Only a *successful* console probe clears the emulator \u2014 see\n * {@link EmulatorLivenessProbeOutcome} for why a failed one cannot be read as\n * the emulator answering.\n *\n * Measured 2026-09-05 across six hand-boots on this host \u2014 two AVDs and five\n * argument sets \u2014 every one of which reached the bottom row 64\u201392s after boot:\n *\n * ```text\n * 80s  emulator console (QEMU, not the guest): HUNG\n * 80s  qemu-system-x86_64-headless (pid 10004): cpu=0% rss=5.82GB\n * ```\n *\n * **0% CPU** \u2014 blocked, not spinning \u2014 and a console that cannot answer. That is\n * the QEMU main loop, below anything the guest, the GPU stack, the network\n * simulator or the AVD's size can explain (each was eliminated by measurement,\n * not by argument). It also explains the two downstream symptoms that had always\n * looked like separate faults: `adb devices` keeps reporting `device` because\n * nothing is left running to update that state, and the teardown's\n * `adb emu kill` hangs for its full budget because it is asking the wedged\n * console to shut itself down.\n *\n * The harness already *observed* the second half of this \u2014 teardown logs\n * `Emulator console shutdown for emulator-5554 did not answer` \u2014 but only after\n * the run had already failed with an error blaming the device. This module moves\n * that observation to where it changes the verdict instead of annotating it.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification and the message stay unit-testable \u2014 the\n * factory itself shells out to `adb`.\n */\n\nimport { checkIsEmulatorDeviceId } from './avd-probe-verdict.cjs';\nimport { appendProcessOutputTail } from './process-exit-message.cjs';\n\n/**\n * Parameters for {@link buildEmulatorLivenessMessage}.\n */\nexport interface BuildEmulatorLivenessMessageParams {\n  /**\n  The device the run was about to drive.\n   */\n  readonly deviceId: string;\n\n  /**\n  The emulator's captured stdout+stderr tail, when this run started it (empty when none).\n   */\n  readonly emulatorOutput: string;\n\n  /**\n  The per-probe budget, so the message states what \"did not answer\" was measured against.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  Which failure this is. `'alive'` is not a failure and has no message.\n   */\n  readonly verdict: Exclude<EmulatorLivenessVerdict, 'alive'>;\n}\n\n/**\n * Whether a probe got an answer from the thing it was asking.\n *\n * Two-valued on purpose. An earlier draft split failures into \"errored\" and\n * \"timed out\" and read an errored console as *the emulator speaking, with a\n * refusal* \u2014 which is wrong, and wrong in the exact way this module exists to\n * avoid. `adb -s <device> emu <command>` is routed by the **adb server**: when\n * the device is `offline` adb refuses on the spot and never reaches the console,\n * so the error is adb's, not the emulator's. Measured 2026-09-05, where that\n * draft logged `shell=errored, console=errored -> guest-unresponsive` for a\n * device whose emulator then had to be killed by PID because `adb emu kill`\n * could not reach it either. Only a **successful** probe is an answer.\n */\nexport type EmulatorLivenessProbeOutcome = 'answered' | 'no-answer';\n\n/**\n * Whether the device is still usable, and if not, which layer failed.\n *\n * - `'alive'` \u2014 the guest answered. Proceed.\n * - `'device-gone'` \u2014 the host's adb no longer lists it at all.\n * - `'emulator-wedged'` \u2014 neither the guest nor the emulator's own console\n *   answers. The emulator process is stuck; retrying anything against this\n *   device cannot succeed.\n * - `'guest-unresponsive'` \u2014 the console answers but the guest does not, so the\n *   emulator is alive and the guest is frozen or starved.\n */\nexport type EmulatorLivenessVerdict = 'alive' | 'device-gone' | 'emulator-wedged' | 'guest-unresponsive';\n\n/**\n * Parameters for {@link resolveEmulatorLivenessVerdict}.\n */\nexport interface ResolveEmulatorLivenessVerdictParams {\n  /**\n   * Whether `adb -s <device> emu avd status` succeeded \u2014 reaching the\n   * **emulator console**, served by the emulator process rather than by the\n   * guest.\n   *\n   * Meaningful only for an `emulator-<port>` device: the console fails against a\n   * physical handset however healthy it is, which is why a non-emulator is never\n   * convicted on it (the trap `avd-probe-verdict.ts` documents).\n   */\n  readonly consoleProbe: EmulatorLivenessProbeOutcome;\n\n  /**\n  The device the run is about to drive.\n   */\n  readonly deviceId: string;\n\n  /**\n  Whether the host's `adb devices` still lists the device in any state.\n   */\n  readonly isListedByAdb: boolean;\n\n  /**\n  What `adb -s <device> shell true` answered \u2014 the **guest**, via `adbd`.\n   */\n  readonly shellProbe: EmulatorLivenessProbeOutcome;\n}\n\n/**\n * Builds the message for a device that stopped answering, naming the layer that\n * failed and the evidence for it.\n *\n * @param params - The verdict, the device, the probe budget and the emulator's output.\n * @returns The message.\n */\nexport function buildEmulatorLivenessMessage(params: BuildEmulatorLivenessMessageParams): string {\n  const budget = `${String(params.probeTimeoutInMilliseconds)}ms`;\n\n  /*\n   * A `Record` keyed by the verdict rather than a `switch`: exhaustiveness comes\n   * from the type, with no unreachable `default` arm to explain or to cover.\n   * Same shape as `resolveRemedyAdvice` in `wedged-appium-server.ts`.\n   */\n  const diagnosis: Record<Exclude<EmulatorLivenessVerdict, 'alive'>, string[]> = {\n    'device-gone': [\n      'The host\\'s `adb devices` no longer lists it, so it is no longer serving adb at all.',\n      'Either the emulator exited, or it wedged badly enough to drop off adb \u2014 the emulator output below is the best evidence for which.',\n      'An emulator this run started is replaced automatically once, so seeing this means the replacement did not survive either. Check that nothing else on this host stops emulators, and that the emulator build and system image are sound.'\n    ],\n    'emulator-wedged': [\n      `Neither the guest (\\`adb -s ${params.deviceId} shell\\`) nor the emulator's own console (\\`adb -s ${params.deviceId} emu avd status\\`) answered within ${budget}.`,\n      'The console is served by the emulator process, not by the guest, so its silence means the EMULATOR is wedged \u2014 not the guest, not the Appium server, and not the device being absent.',\n      '`adb devices` will still list this device and will mislead you: nothing is left running to update that state.',\n      'A wedged emulator does not come back, so retrying the session against it cannot succeed. One this run started is replaced with a fresh boot automatically, which means seeing this message is the replacement failing too.',\n      'If it recurs at the same point in every run, the fault is below the harness \u2014 and the first thing to check is what filters this host\\'s sockets. Endpoint-security, content-blocking and VPN products install socket filter drivers in the path of every socket call the emulator makes, the console\\'s localhost connection included; stopping that service has fixed exactly this signature. After that, the emulator build, the system image and the host hypervisor.'\n    ],\n    'guest-unresponsive': [\n      `The guest (\\`adb -s ${params.deviceId} shell\\`) did not answer within ${budget}, but the emulator's own console did.`,\n      'So the emulator process is healthy and the guest is frozen or too starved to schedule `adbd`.',\n      'A contended host is the usual cause; `deviceIdleTimeoutInMilliseconds` is the budget that governs waiting one out.',\n      'But if it recurs at the same point in every run, no timeout will fix it, and the host is not merely busy. Check what filters this host\\'s sockets first \u2014 a content-blocking, endpoint-security or VPN socket filter driver produces this verdict as readily as it produces a fully wedged emulator \u2014 then the emulator build, the system image and the host hypervisor.'\n    ]\n  };\n\n  const lines = [\n    `Device ${params.deviceId} stopped answering before the Appium session could be established.`,\n    ...diagnosis[params.verdict]\n  ];\n\n  return appendProcessOutputTail(lines.join('\\n'), { output: params.emulatorOutput, outputLabel: 'Emulator output' });\n}\n\n/**\n * Decides whether the device is still usable, and which layer failed when it is\n * not.\n *\n * A guest that answers settles it on its own \u2014 a console probe is only consulted\n * when the guest has already gone quiet, so a healthy run never pays for it.\n *\n * @param params - What each probe answered, and whether adb still lists the device.\n * @returns The verdict.\n */\nexport function resolveEmulatorLivenessVerdict(params: ResolveEmulatorLivenessVerdictParams): EmulatorLivenessVerdict {\n  if (params.shellProbe === 'answered') {\n    return 'alive';\n  }\n\n  if (!params.isListedByAdb) {\n    return 'device-gone';\n  }\n\n  /*\n   * `adb \u2026 emu` errors against a physical handset however healthy it is, so its\n   * silence is not evidence there. Only an `emulator-<port>` device has a\n   * console whose silence can convict it \u2014 the same restraint `classifyAvdProbe`\n   * shows in never probing a non-emulator at all.\n   */\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'guest-unresponsive';\n  }\n\n  return params.consoleProbe === 'answered' ? 'guest-unresponsive' : 'emulator-wedged';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkEA,+BAAwC;AACxC,kCAAwC;AA6FjC,SAAS,6BAA6B,QAAoD;AAC/F,QAAM,SAAS,GAAG,OAAO,OAAO,0BAA0B,CAAC;AAO3D,QAAM,YAAyE;AAAA,IAC7E,eAAe;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,mBAAmB;AAAA,MACjB,+BAA+B,OAAO,QAAQ,sDAAsD,OAAO,QAAQ,sCAAsC,MAAM;AAAA,MAC/J;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,sBAAsB;AAAA,MACpB,uBAAuB,OAAO,QAAQ,mCAAmC,MAAM;AAAA,MAC/E;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ;AAAA,IACZ,UAAU,OAAO,QAAQ;AAAA,IACzB,GAAG,UAAU,OAAO,OAAO;AAAA,EAC7B;AAEA,aAAO,qDAAwB,MAAM,KAAK,IAAI,GAAG,EAAE,QAAQ,OAAO,gBAAgB,aAAa,kBAAkB,CAAC;AACpH;AAYO,SAAS,+BAA+B,QAAuE;AACpH,MAAI,OAAO,eAAe,YAAY;AACpC,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,OAAO,eAAe;AACzB,WAAO;AAAA,EACT;AAQA,MAAI,KAAC,kDAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,iBAAiB,aAAa,uBAAuB;AACrE;",
  "names": []
}


package/dist/lib/cjs/emulator-liveness.d.cts

@@ -0,0 +1,158 @@
+/**
+ * @file
+ *
+ * Pure classification of whether the device a run is about to drive is still
+ * **there** — and, when it is not, which of the two very different things went
+ * wrong: the guest froze, or the emulator process itself did.
+ *
+ * The readiness gates in `device-readiness.ts` answer *"is the guest ready
+ * yet?"*, and both are deliberately best-effort: they warn and proceed. Nothing
+ * asked *"is it still answering?"* at the moment the session is created, so a
+ * guest that stopped answering between the last gate and `remote()` was handed
+ * to Appium anyway. What the operator then saw was Appium's own report:
+ *
+ * ```text
+ * WebDriverError: Device emulator-5554 was not in the list of connected devices
+ *   when running "http://localhost:4723/session" with method "POST"
+ * ```
+ *
+ * — measured on this host 2026-09-05, after 515s. That names the device, and
+ * `adb devices` then lists the device happily, so it sends the reader to the one
+ * diagnostic that cannot help. The same trap `wedged-appium-server.ts` exists to
+ * escape, one layer further down.
+ *
+ * ## The console is what tells the two apart
+ *
+ * `adb -s <device> emu <command>` is served by the **emulator's own console**,
+ * not by the guest's `adbd`. So the two probes answer different questions, and
+ * the pair is a diagnosis where either alone is a guess:
+ *
+ * | `adb shell` | `adb emu` | What it means |
+ * | --- | --- | --- |
+ * | succeeds | — | Alive. Proceed. |
+ * | fails | succeeds | The **guest** is frozen or too busy to schedule `adbd`. |
+ * | fails | fails | The **emulator process** is unreachable. Nothing will recover it. |
+ *
+ * Only a *successful* console probe clears the emulator — see
+ * {@link EmulatorLivenessProbeOutcome} for why a failed one cannot be read as
+ * the emulator answering.
+ *
+ * Measured 2026-09-05 across six hand-boots on this host — two AVDs and five
+ * argument sets — every one of which reached the bottom row 64–92s after boot:
+ *
+ * ```text
+ * 80s  emulator console (QEMU, not the guest): HUNG
+ * 80s  qemu-system-x86_64-headless (pid 10004): cpu=0% rss=5.82GB
+ * ```
+ *
+ * **0% CPU** — blocked, not spinning — and a console that cannot answer. That is
+ * the QEMU main loop, below anything the guest, the GPU stack, the network
+ * simulator or the AVD's size can explain (each was eliminated by measurement,
+ * not by argument). It also explains the two downstream symptoms that had always
+ * looked like separate faults: `adb devices` keeps reporting `device` because
+ * nothing is left running to update that state, and the teardown's
+ * `adb emu kill` hangs for its full budget because it is asking the wedged
+ * console to shut itself down.
+ *
+ * The harness already *observed* the second half of this — teardown logs
+ * `Emulator console shutdown for emulator-5554 did not answer` — but only after
+ * the run had already failed with an error blaming the device. This module moves
+ * that observation to where it changes the verdict instead of annotating it.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the classification and the message stay unit-testable — the
+ * factory itself shells out to `adb`.
+ */
+/**
+ * Parameters for {@link buildEmulatorLivenessMessage}.
+ */
+export interface BuildEmulatorLivenessMessageParams {
+    /**
+    The device the run was about to drive.
+     */
+    readonly deviceId: string;
+    /**
+    The emulator's captured stdout+stderr tail, when this run started it (empty when none).
+     */
+    readonly emulatorOutput: string;
+    /**
+    The per-probe budget, so the message states what "did not answer" was measured against.
+     */
+    readonly probeTimeoutInMilliseconds: number;
+    /**
+    Which failure this is. `'alive'` is not a failure and has no message.
+     */
+    readonly verdict: Exclude<EmulatorLivenessVerdict, 'alive'>;
+}
+/**
+ * Whether a probe got an answer from the thing it was asking.
+ *
+ * Two-valued on purpose. An earlier draft split failures into "errored" and
+ * "timed out" and read an errored console as *the emulator speaking, with a
+ * refusal* — which is wrong, and wrong in the exact way this module exists to
+ * avoid. `adb -s <device> emu <command>` is routed by the **adb server**: when
+ * the device is `offline` adb refuses on the spot and never reaches the console,
+ * so the error is adb's, not the emulator's. Measured 2026-09-05, where that
+ * draft logged `shell=errored, console=errored -> guest-unresponsive` for a
+ * device whose emulator then had to be killed by PID because `adb emu kill`
+ * could not reach it either. Only a **successful** probe is an answer.
+ */
+export type EmulatorLivenessProbeOutcome = 'answered' | 'no-answer';
+/**
+ * Whether the device is still usable, and if not, which layer failed.
+ *
+ * - `'alive'` — the guest answered. Proceed.
+ * - `'device-gone'` — the host's adb no longer lists it at all.
+ * - `'emulator-wedged'` — neither the guest nor the emulator's own console
+ *   answers. The emulator process is stuck; retrying anything against this
+ *   device cannot succeed.
+ * - `'guest-unresponsive'` — the console answers but the guest does not, so the
+ *   emulator is alive and the guest is frozen or starved.
+ */
+export type EmulatorLivenessVerdict = 'alive' | 'device-gone' | 'emulator-wedged' | 'guest-unresponsive';
+/**
+ * Parameters for {@link resolveEmulatorLivenessVerdict}.
+ */
+export interface ResolveEmulatorLivenessVerdictParams {
+    /**
+     * Whether `adb -s <device> emu avd status` succeeded — reaching the
+     * **emulator console**, served by the emulator process rather than by the
+     * guest.
+     *
+     * Meaningful only for an `emulator-<port>` device: the console fails against a
+     * physical handset however healthy it is, which is why a non-emulator is never
+     * convicted on it (the trap `avd-probe-verdict.ts` documents).
+     */
+    readonly consoleProbe: EmulatorLivenessProbeOutcome;
+    /**
+    The device the run is about to drive.
+     */
+    readonly deviceId: string;
+    /**
+    Whether the host's `adb devices` still lists the device in any state.
+     */
+    readonly isListedByAdb: boolean;
+    /**
+    What `adb -s <device> shell true` answered — the **guest**, via `adbd`.
+     */
+    readonly shellProbe: EmulatorLivenessProbeOutcome;
+}
+/**
+ * Builds the message for a device that stopped answering, naming the layer that
+ * failed and the evidence for it.
+ *
+ * @param params - The verdict, the device, the probe budget and the emulator's output.
+ * @returns The message.
+ */
+export declare function buildEmulatorLivenessMessage(params: BuildEmulatorLivenessMessageParams): string;
+/**
+ * Decides whether the device is still usable, and which layer failed when it is
+ * not.
+ *
+ * A guest that answers settles it on its own — a console probe is only consulted
+ * when the guest has already gone quiet, so a healthy run never pays for it.
+ *
+ * @param params - What each probe answered, and whether adb still lists the device.
+ * @returns The verdict.
+ */
+export declare function resolveEmulatorLivenessVerdict(params: ResolveEmulatorLivenessVerdictParams): EmulatorLivenessVerdict;