obsidian-integration-testing 12.0.0 → 12.1.1

package/dist/lib/cjs/device-settings.cjs

@@ -0,0 +1,88 @@
+"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 device_settings_exports = {};
+__export(device_settings_exports, {
+  deleteDeviceSetting: () => deleteDeviceSetting,
+  readDeviceSetting: () => readDeviceSetting,
+  withSoftKeyboardEnabled: () => withSoftKeyboardEnabled,
+  writeDeviceSetting: () => writeDeviceSetting
+});
+module.exports = __toCommonJS(device_settings_exports);
+var import_adb = require("./adb.cjs");
+var import_device_setting_restore = require("./device-setting-restore.cjs");
+var import_device_settings_command = require("./device-settings-command.cjs");
+const SOFT_KEYBOARD_SETTING_NAME = "show_ime_with_hard_keyboard";
+const SOFT_KEYBOARD_SETTING_ON = "1";
+async function deleteDeviceSetting(params) {
+  await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: import_device_settings_command.DeviceSettingVerb.Delete
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function readDeviceSetting(params) {
+  return await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      verb: import_device_settings_command.DeviceSettingVerb.Get
+    }),
+    deviceId: params.deviceId
+  });
+}
+async function withSoftKeyboardEnabled(params) {
+  const settingParams = {
+    deviceId: params.deviceId,
+    name: SOFT_KEYBOARD_SETTING_NAME
+  };
+  const previousValue = await readDeviceSetting(settingParams);
+  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });
+  try {
+    return await params.callback();
+  } finally {
+    const restore = (0, import_device_setting_restore.resolveDeviceSettingRestore)(previousValue);
+    if (restore.kind === import_device_setting_restore.DeviceSettingRestoreKind.Delete) {
+      await deleteDeviceSetting(settingParams);
+    } else {
+      await writeDeviceSetting({ ...settingParams, value: restore.value });
+    }
+  }
+}
+async function writeDeviceSetting(params) {
+  await (0, import_adb.runAdbText)({
+    commandArguments: (0, import_device_settings_command.buildDeviceSettingsCommandArguments)({
+      name: params.name,
+      ...params.namespace !== void 0 && { namespace: params.namespace },
+      value: params.value,
+      verb: import_device_settings_command.DeviceSettingVerb.Put
+    }),
+    deviceId: params.deviceId
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteDeviceSetting,
+  readDeviceSetting,
+  withSoftKeyboardEnabled,
+  writeDeviceSetting
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/device-settings.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and writes Android device settings \u2014 and wraps the one setting a\n * screenshot suite has to change.\n *\n * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the\n * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`\n * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the\n * work, and puts the device back exactly as it found it \u2014 including restoring a\n * setting that had never been written, which takes a delete rather than a write\n * (see `device-setting-restore`).\n *\n * Every function here shells out, so the whole module is integration-time code;\n * the restore decision and the argument list it depends on are unit-tested in\n * their own modules.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport type { DeviceSettingNamespace } from './device-settings-command.cjs';\n\nimport { runAdbText } from './adb.cjs';\nimport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nimport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\n\n/**\n * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.\n */\nexport interface DeviceSettingParams {\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n\n  /**\n   * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.\n   */\n  readonly name: string;\n\n  /**\n   * The settings namespace the name lives in.\n   *\n   * @default {@link DeviceSettingNamespace.Secure}\n   */\n  readonly namespace?: DeviceSettingNamespace;\n}\n\n/**\n * Parameters for {@link withSoftKeyboardEnabled}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithSoftKeyboardEnabledParams<T> {\n  /**\n   * The work to run while the on-screen keyboard is permitted.\n   */\n  readonly callback: (this: void) => Promise<T>;\n\n  /**\n   * The device to address.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * Parameters for {@link writeDeviceSetting}.\n */\nexport interface WriteDeviceSettingParams extends DeviceSettingParams {\n  /**\n   * The value to write.\n   */\n  readonly value: string;\n}\n\n/**\n * The setting deciding whether Android draws a keyboard while a hardware one is attached.\n */\nconst SOFT_KEYBOARD_SETTING_NAME = 'show_ime_with_hard_keyboard';\n\nconst SOFT_KEYBOARD_SETTING_ON = '1';\n\n/**\n * Clears a device setting, returning it to never-having-been-written.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves once the setting is gone.\n */\nexport async function deleteDeviceSetting(params: DeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Delete\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Reads a device setting.\n *\n * @param params - The device, the setting and its namespace.\n * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never\n *   been written.\n */\nexport async function readDeviceSetting(params: DeviceSettingParams): Promise<string> {\n  return await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      verb: DeviceSettingVerb.Get\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.\n *\n * The restore runs whether the callback succeeded or threw \u2014 a suite that dies mid-capture must not leave\n * the device configured differently than it found it.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The device and the work to run.\n * @returns A {@link Promise} that resolves to whatever the callback returned.\n */\nexport async function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T> {\n  const settingParams: DeviceSettingParams = {\n    deviceId: params.deviceId,\n    name: SOFT_KEYBOARD_SETTING_NAME\n  };\n\n  const previousValue = await readDeviceSetting(settingParams);\n  await writeDeviceSetting({ ...settingParams, value: SOFT_KEYBOARD_SETTING_ON });\n\n  try {\n    return await params.callback();\n  } finally {\n    const restore = resolveDeviceSettingRestore(previousValue);\n    if (restore.kind === DeviceSettingRestoreKind.Delete) {\n      await deleteDeviceSetting(settingParams);\n    } else {\n      await writeDeviceSetting({ ...settingParams, value: restore.value });\n    }\n  }\n}\n\n/**\n * Writes a device setting.\n *\n * @param params - The device, the setting, its namespace and the value to write.\n * @returns A {@link Promise} that resolves once the setting is written.\n */\nexport async function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void> {\n  await runAdbText({\n    commandArguments: buildDeviceSettingsCommandArguments({\n      name: params.name,\n      ...(params.namespace !== undefined && { namespace: params.namespace }),\n      value: params.value,\n      verb: DeviceSettingVerb.Put\n    }),\n    deviceId: params.deviceId\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,iBAA2B;AAC3B,oCAGO;AACP,qCAGO;AAsDP,MAAM,6BAA6B;AAEnC,MAAM,2BAA2B;AAQjC,eAAsB,oBAAoB,QAA4C;AACpF,YAAM,uBAAW;AAAA,IACf,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AASA,eAAsB,kBAAkB,QAA8C;AACpF,SAAO,UAAM,uBAAW;AAAA,IACtB,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AAYA,eAAsB,wBAA2B,QAAsD;AACrG,QAAM,gBAAqC;AAAA,IACzC,UAAU,OAAO;AAAA,IACjB,MAAM;AAAA,EACR;AAEA,QAAM,gBAAgB,MAAM,kBAAkB,aAAa;AAC3D,QAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,yBAAyB,CAAC;AAE9E,MAAI;AACF,WAAO,MAAM,OAAO,SAAS;AAAA,EAC/B,UAAE;AACA,UAAM,cAAU,2DAA4B,aAAa;AACzD,QAAI,QAAQ,SAAS,uDAAyB,QAAQ;AACpD,YAAM,oBAAoB,aAAa;AAAA,IACzC,OAAO;AACL,YAAM,mBAAmB,EAAE,GAAG,eAAe,OAAO,QAAQ,MAAM,CAAC;AAAA,IACrE;AAAA,EACF;AACF;AAQA,eAAsB,mBAAmB,QAAiD;AACxF,YAAM,uBAAW;AAAA,IACf,sBAAkB,oEAAoC;AAAA,MACpD,MAAM,OAAO;AAAA,MACb,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,MACpE,OAAO,OAAO;AAAA,MACd,MAAM,iDAAkB;AAAA,IAC1B,CAAC;AAAA,IACD,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;",
  "names": []
}


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

@@ -0,0 +1,94 @@
+/**
+ * @file
+ *
+ * Reads and writes Android device settings — and wraps the one setting a
+ * screenshot suite has to change.
+ *
+ * The screenshot AVDs are built `hw.keyboard=yes`, so Android suppresses the
+ * on-screen keyboard even where the page asks for one. `show_ime_with_hard_keyboard`
+ * is what turns it back on. {@link withSoftKeyboardEnabled} flips it, runs the
+ * work, and puts the device back exactly as it found it — including restoring a
+ * setting that had never been written, which takes a delete rather than a write
+ * (see `device-setting-restore`).
+ *
+ * Every function here shells out, so the whole module is integration-time code;
+ * the restore decision and the argument list it depends on are unit-tested in
+ * their own modules.
+ */
+import type { DeviceSettingNamespace } from './device-settings-command.cjs';
+/**
+ * Parameters for {@link deleteDeviceSetting} and {@link readDeviceSetting}.
+ */
+export interface DeviceSettingParams {
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+    /**
+     * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.
+     */
+    readonly name: string;
+    /**
+     * The settings namespace the name lives in.
+     *
+     * @default {@link DeviceSettingNamespace.Secure}
+     */
+    readonly namespace?: DeviceSettingNamespace;
+}
+/**
+ * Parameters for {@link withSoftKeyboardEnabled}.
+ *
+ * @typeParam T - What the wrapped work returns.
+ */
+export interface WithSoftKeyboardEnabledParams<T> {
+    /**
+     * The work to run while the on-screen keyboard is permitted.
+     */
+    readonly callback: (this: void) => Promise<T>;
+    /**
+     * The device to address.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link writeDeviceSetting}.
+ */
+export interface WriteDeviceSettingParams extends DeviceSettingParams {
+    /**
+     * The value to write.
+     */
+    readonly value: string;
+}
+/**
+ * Clears a device setting, returning it to never-having-been-written.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves once the setting is gone.
+ */
+export declare function deleteDeviceSetting(params: DeviceSettingParams): Promise<void>;
+/**
+ * Reads a device setting.
+ *
+ * @param params - The device, the setting and its namespace.
+ * @returns A {@link Promise} that resolves to the setting's value, or the literal `null` when it has never
+ *   been written.
+ */
+export declare function readDeviceSetting(params: DeviceSettingParams): Promise<string>;
+/**
+ * Permits the on-screen keyboard for the duration of a callback, then restores the device exactly.
+ *
+ * The restore runs whether the callback succeeded or threw — a suite that dies mid-capture must not leave
+ * the device configured differently than it found it.
+ *
+ * @typeParam T - What the wrapped work returns.
+ * @param params - The device and the work to run.
+ * @returns A {@link Promise} that resolves to whatever the callback returned.
+ */
+export declare function withSoftKeyboardEnabled<T>(params: WithSoftKeyboardEnabledParams<T>): Promise<T>;
+/**
+ * Writes a device setting.
+ *
+ * @param params - The device, the setting, its namespace and the value to write.
+ * @returns A {@link Promise} that resolves once the setting is written.
+ */
+export declare function writeDeviceSetting(params: WriteDeviceSettingParams): Promise<void>;

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,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

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-device-id.cjs

@@ -0,0 +1,32 @@
+"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_device_id_exports = {};
+__export(emulator_device_id_exports, {
+  selectEmulatorDeviceId: () => selectEmulatorDeviceId
+});
+module.exports = __toCommonJS(emulator_device_id_exports);
+function selectEmulatorDeviceId(params) {
+  const match = params.candidates.find((candidate) => candidate.avdName === params.avdName);
+  return match ? match.deviceId : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectEmulatorDeviceId
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/emulator-device-id.d.cts

@@ -0,0 +1,49 @@
+/**
+ * @file
+ *
+ * Picks the running emulator that belongs to a named AVD.
+ *
+ * A capture suite must never take "the first device `adb devices` lists". Two
+ * things routinely make that the wrong device on this fleet: a physical phone is
+ * often plugged into the same machine, and the harness's own `obsidian_test` AVD
+ * runs at a different geometry than the `obsidian_screenshots` AVD sized to the
+ * store's frame. Picking by position silently photographs the wrong screen at
+ * the wrong size, and the dimension assertion that would have caught it fires
+ * several minutes later, after the run.
+ *
+ * Pure and unit-tested; the `adb` round-trips that gather the AVD names live in
+ * `resolve-emulator-device-id`.
+ */
+/**
+ * One running emulator, paired with the AVD it was started from.
+ */
+export interface EmulatorDeviceCandidate {
+    /**
+     * The AVD name the emulator reports, e.g. `obsidian_screenshots`.
+     */
+    readonly avdName: string;
+    /**
+     * The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link selectEmulatorDeviceId}.
+ */
+export interface SelectEmulatorDeviceIdParams {
+    /**
+     * The AVD name to match.
+     */
+    readonly avdName: string;
+    /**
+     * Every running emulator, with the AVD each was started from.
+     */
+    readonly candidates: readonly EmulatorDeviceCandidate[];
+}
+/**
+ * Picks the emulator started from a named AVD.
+ *
+ * @param params - The AVD to match and the running emulators to match against.
+ * @returns The matching device UDID, or `null` when no running emulator carries that AVD name.
+ */
+export declare function selectEmulatorDeviceId(params: SelectEmulatorDeviceIdParams): null | string;

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": []
}
