obsidian-integration-testing 15.0.0 → 17.0.0

package/dist/lib/esm/adb.d.mts

@@ -32,6 +32,16 @@ export interface RunAdbParams {
      * The device to address, as `adb devices` lists it.
      */
     readonly deviceId: string;
+    /**
+     * How long to give the call before killing it, in milliseconds.
+     *
+     * Omitted — the default — the call waits indefinitely, which is right for the
+     * capture helpers: a screencap of a big framebuffer is slow, not stuck. A
+     * caller that is *identifying* a device it may not own passes one, because
+     * there the whole point is to give up on a wedged guest rather than hang the
+     * run behind it.
+     */
+    readonly timeoutInMilliseconds?: number | undefined;
 }
 /**
  * Runs `adb -s <deviceId> <commandArguments>` and returns stdout **undecoded**.

package/dist/lib/esm/adb.mjs

@@ -3,7 +3,7 @@ const OUTPUT_MAX_BUFFER_IN_BYTES = 67108864;
 async function runAdbBinary(params) {
   const commandArguments = ["-s", params.deviceId, ...params.commandArguments];
   return await new Promise((resolve, reject) => {
-    execFile("adb", commandArguments, { encoding: "buffer", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {
+    execFile("adb", commandArguments, { encoding: "buffer", maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES, timeout: params.timeoutInMilliseconds }, (error, stdout) => {
       if (error) {
         reject(new Error(`Failed to run 'adb ${commandArguments.join(" ")}': ${error.message}. Is ADB installed and in PATH?`));
         return;
@@ -32,4 +32,4 @@ export {
   runAdbText,
   runAdbTextWithoutDevice
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/adb.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Runs `adb` and hands back what it printed \u2014 as text, or as raw bytes.\n *\n * The harness already shells out to `adb` in half a dozen places inside\n * `transport-factory` / `transport-appium`, but always through `exec`, which\n * decodes stdout as UTF-8. That is fine for `devices` and `settings get` and\n * fatally wrong for `exec-out screencap -p`, whose stdout is a PNG: decoding it\n * as text corrupts every byte above 0x7F. Hence the two runners here \u2014 the same\n * command shape, differing only in whether the output is decoded.\n *\n * These are the process layer for the device-facing helpers a capture suite\n * uses (`device-screenshot`, `device-settings`, `soft-keyboard`); they are not a\n * general-purpose adb wrapper and deliberately do not try to become one.\n *\n * Every function here shells out, so the whole module is integration-time code.\n * That is also why the parsing and geometry these helpers depend on live in\n * their own modules \u2014 the same split `adb-device-list` already has from the\n * transport factory, so a sort rule can never move a unit-tested function\n * inside a coverage-ignored block.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport { execFile } from 'node:child_process';\n\n/**\n * Parameters for {@link runAdbBinary} and {@link runAdbText}.\n */\nexport interface RunAdbParams {\n  /**\n   * The arguments to pass after `-s <deviceId>`, e.g. `['shell', 'input', 'tap', '10', '20']`.\n   */\n  readonly commandArguments: readonly string[];\n\n  /**\n   * The device to address, as `adb devices` lists it.\n   */\n  readonly deviceId: string;\n\n  /**\n   * How long to give the call before killing it, in milliseconds.\n   *\n   * Omitted \u2014 the default \u2014 the call waits indefinitely, which is right for the\n   * capture helpers: a screencap of a big framebuffer is slow, not stuck. A\n   * caller that is *identifying* a device it may not own passes one, because\n   * there the whole point is to give up on a wedged guest rather than hang the\n   * run behind it.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n}\n\n/**\n * A screencap of a 900x1600 device runs to about 100 KB, but a tablet AVD's framebuffer is several MB and\n * the default 1 MiB `maxBuffer` fails the call rather than returning a usable image.\n */\nconst OUTPUT_MAX_BUFFER_IN_BYTES = 67_108_864;\n\n/**\n * Runs `adb -s <deviceId> <commandArguments>` and returns stdout **undecoded**.\n *\n * @param params - The device and the arguments to run.\n * @returns A {@link Promise} that resolves to the raw stdout bytes.\n * @throws Error if adb could not be run, or exited non-zero.\n */\n// eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `RunAdbParams` is one bag shared by `runAdbBinary` and `runAdbText`, so no per-owner name can satisfy both.\nexport async function runAdbBinary(params: RunAdbParams): Promise<Uint8Array> {\n  const commandArguments = ['-s', params.deviceId, ...params.commandArguments];\n\n  return await new Promise((resolve, reject) => {\n    execFile('adb', commandArguments, { encoding: 'buffer', maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES, timeout: params.timeoutInMilliseconds }, (error, stdout) => {\n      if (error) {\n        reject(new Error(`Failed to run 'adb ${commandArguments.join(' ')}': ${error.message}. Is ADB installed and in PATH?`));\n        return;\n      }\n\n      resolve(stdout);\n    });\n  });\n}\n\n/**\n * Runs `adb -s <deviceId> <commandArguments>` and returns stdout as trimmed text.\n *\n * @param params - The device and the arguments to run.\n * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.\n * @throws Error if adb could not be run, or exited non-zero.\n */\n// eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `RunAdbParams` is one bag shared by `runAdbBinary` and `runAdbText`, so no per-owner name can satisfy both.\nexport async function runAdbText(params: RunAdbParams): Promise<string> {\n  const stdout = await runAdbBinary(params);\n  return new TextDecoder().decode(stdout).trim();\n}\n\n/**\n * Runs `adb <commandArguments>` with no device selected.\n *\n * Only `devices` needs this \u2014 every other call in this family addresses one device.\n *\n * @param commandArguments - The arguments to run.\n * @returns A {@link Promise} that resolves to stdout, with surrounding whitespace removed.\n * @throws Error if adb could not be run, or exited non-zero.\n */\nexport async function runAdbTextWithoutDevice(commandArguments: readonly string[]): Promise<string> {\n  return await new Promise((resolve, reject) => {\n    execFile('adb', [...commandArguments], { encoding: 'utf-8', maxBuffer: OUTPUT_MAX_BUFFER_IN_BYTES }, (error, stdout) => {\n      if (error) {\n        reject(new Error(`Failed to run 'adb ${commandArguments.join(' ')}': ${error.message}. Is ADB installed and in PATH?`));\n        return;\n      }\n\n      resolve(stdout.trim());\n    });\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAyBA,SAAS,gBAAgB;AAgCzB,MAAM,6BAA6B;AAUnC,eAAsB,aAAa,QAA2C;AAC5E,QAAM,mBAAmB,CAAC,MAAM,OAAO,UAAU,GAAG,OAAO,gBAAgB;AAE3E,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,aAAS,OAAO,kBAAkB,EAAE,UAAU,UAAU,WAAW,4BAA4B,SAAS,OAAO,sBAAsB,GAAG,CAAC,OAAO,WAAW;AACzJ,UAAI,OAAO;AACT,eAAO,IAAI,MAAM,sBAAsB,iBAAiB,KAAK,GAAG,CAAC,MAAM,MAAM,OAAO,iCAAiC,CAAC;AACtH;AAAA,MACF;AAEA,cAAQ,MAAM;AAAA,IAChB,CAAC;AAAA,EACH,CAAC;AACH;AAUA,eAAsB,WAAW,QAAuC;AACtE,QAAM,SAAS,MAAM,aAAa,MAAM;AACxC,SAAO,IAAI,YAAY,EAAE,OAAO,MAAM,EAAE,KAAK;AAC/C;AAWA,eAAsB,wBAAwB,kBAAsD;AAClG,SAAO,MAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,aAAS,OAAO,CAAC,GAAG,gBAAgB,GAAG,EAAE,UAAU,SAAS,WAAW,2BAA2B,GAAG,CAAC,OAAO,WAAW;AACtH,UAAI,OAAO;AACT,eAAO,IAAI,MAAM,sBAAsB,iBAAiB,KAAK,GAAG,CAAC,MAAM,MAAM,OAAO,iCAAiC,CAAC;AACtH;AAAA,MACF;AAEA,cAAQ,OAAO,KAAK,CAAC;AAAA,IACvB,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/avd-name-channel.d.mts

@@ -0,0 +1,152 @@
+/**
+ * @file
+ *
+ * The channels a run can ask *"which AVD is this device serving?"*, and the
+ * order to ask them in.
+ *
+ * **L47** made the adoption probe refuse rather than collide when a device did
+ * not answer. It asked that question over the emulator's **console** — a second
+ * TCP port, with its own auth token and its own ways of wedging, entirely
+ * separate from the `adbd` channel every other call in the run travels. So a
+ * single emulator whose console is wedged — routinely **another project's**,
+ * with the bulk runner sweeping several projects at once — took every Obsidian
+ * Android suite on the machine out of service:
+ *
+ * ```text
+ * [transport-factory:obsidian-android-appium] AVD probe: emulator-5570=no-answer.
+ * Error: AVD "obsidian_test": device emulator-5570 did not answer `adb -s emulator-5570 emu avd name` ...
+ * ```
+ *
+ * `adb devices` listed `emulator-5570` as `device` and adb itself was perfectly
+ * responsive throughout; only its console was gone. The refusal was right —
+ * launching a second copy of an AVD hits `FATAL | Running multiple emulators
+ * with the same AVD is an experimental feature` — but it was keyed on the one
+ * channel the run does **not** otherwise depend on.
+ *
+ * The AVD name is also a guest system property, readable over the same `adbd`
+ * channel the run needs anyway, so it cannot be wedged independently of the
+ * connection the run is about to use:
+ *
+ * ```text
+ * adb -s <device> shell getprop ro.boot.qemu.avd_name     # modern images
+ * adb -s <device> shell getprop ro.kernel.qemu.avd_name   # older images
+ * ```
+ *
+ * Hence this ordering: property first, console only as a fallback for an image
+ * that reports neither. The hard refusal stays for the genuinely-unknowable
+ * device — a silent one may well be the AVD's holder — it is simply reached far
+ * less often.
+ *
+ * **A dead channel is not asked twice.** When the `adb shell` call itself fails
+ * or times out, the second property key is skipped: it travels the same channel
+ * that has just proved unusable, and would only spend another full timeout to
+ * learn the same thing. An *answered* but empty property is the opposite — the
+ * channel is alive and the image simply does not carry that key — so the
+ * cheaper sibling key is worth asking. That distinction is what keeps a wedged
+ * device's worst case at two timeouts per attempt rather than three.
+ *
+ * Pure and unit-tested; the `adb` round-trips live in `transport-factory` and
+ * `resolve-emulator-device-id`, which are integration-time code.
+ */
+/**
+ * One way of asking a device which AVD it was started from.
+ *
+ * `getprop-boot` and `getprop-kernel` travel `adbd` — the channel the run
+ * depends on anyway; `console` is the emulator's own TCP console, which can
+ * wedge on its own.
+ */
+export type AvdNameChannel = 'console' | 'getprop-boot' | 'getprop-kernel';
+/**
+ * What one channel answered.
+ *
+ * The two fields are deliberately independent: a channel can respond and report
+ * **nothing** (an image without that property), which is a fact about the
+ * image, while a channel that did not respond is a fact about the channel.
+ * Collapsing them is the defect **L47** fixed one level up.
+ */
+export interface AvdNameChannelAnswer {
+    /**
+    Whether the command itself completed — regardless of what it reported.
+     */
+    readonly didRespond: boolean;
+    /**
+    The AVD name it reported, or `''` when it reported none.
+     */
+    readonly reportedAvdName: string;
+}
+/**
+ * Parameters for {@link buildAvdNameChannelArguments}.
+ */
+export interface BuildAvdNameChannelArgumentsParams {
+    /**
+    The channel to ask.
+     */
+    readonly channel: AvdNameChannel;
+    /**
+    The device to address, or a placeholder such as `<device>` when building a message about several.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Parameters for {@link resolveNextAvdNameChannel}.
+ */
+export interface ResolveNextAvdNameChannelParams {
+    /**
+    The channel that was just asked.
+     */
+    readonly channel: AvdNameChannel;
+    /**
+    Whether that channel's command completed at all.
+     */
+    readonly didChannelRespond: boolean;
+}
+/**
+ * The channel a probe starts with: the guest property, over `adbd`.
+ */
+export declare const FIRST_AVD_NAME_CHANNEL: AvdNameChannel;
+/**
+ * Builds the `adb` arguments that ask one channel for the AVD name.
+ *
+ * @param params - The channel to ask and the device to address.
+ * @returns The arguments to pass to `adb`, starting with `-s <deviceId>`.
+ */
+export declare function buildAvdNameChannelArguments(params: BuildAvdNameChannelArgumentsParams): string[];
+/**
+ * Builds the `adb` arguments that follow `-s <deviceId>`.
+ *
+ * Split from {@link buildAvdNameChannelArguments} because the two callers
+ * address their device differently: `transport-factory` shells out to `adb`
+ * itself, while `resolve-emulator-device-id` goes through `adb.ts`, which
+ * prepends `-s <deviceId>` of its own.
+ *
+ * @param channel - The channel to ask.
+ * @returns The command arguments, without any device selection.
+ */
+export declare function buildAvdNameChannelCommand(channel: AvdNameChannel): string[];
+/**
+ * Renders `adb` arguments as the command line a reader can paste.
+ *
+ * Built from the arguments the run actually passes rather than written out a
+ * second time, so a message can never quote a command the code does not run.
+ *
+ * @param commandArguments - The arguments passed to `adb`.
+ * @returns The full command line.
+ */
+export declare function describeAdbCommand(commandArguments: readonly string[]): string;
+/**
+ * Reads the AVD name out of what a channel printed.
+ *
+ * Both channels answer on the first line — `getprop` prints the value (an empty
+ * line when the property is unset), the console prints the name and then `OK`.
+ *
+ * @param stdout - What the command printed.
+ * @returns The reported AVD name, or `''` when it reported none.
+ */
+export declare function parseAvdNameAnswer(stdout: string): string;
+/**
+ * Picks the next channel to ask after one failed to identify the device.
+ *
+ * @param params - The channel just asked, and whether its command completed.
+ * @returns The next channel, or `undefined` once every channel has been asked.
+ */
+export declare function resolveNextAvdNameChannel(params: ResolveNextAvdNameChannelParams): AvdNameChannel | undefined;

package/dist/lib/esm/avd-name-channel.mjs

@@ -0,0 +1,45 @@
+import { assertNever } from "./type-guards.mjs";
+const FIRST_AVD_NAME_CHANNEL = "getprop-boot";
+const AVD_NAME_PROPERTY_BY_CHANNEL = {
+  "getprop-boot": "ro.boot.qemu.avd_name",
+  "getprop-kernel": "ro.kernel.qemu.avd_name"
+};
+function buildAvdNameChannelArguments(params) {
+  return ["-s", params.deviceId, ...buildAvdNameChannelCommand(params.channel)];
+}
+function buildAvdNameChannelCommand(channel) {
+  return channel === "console" ? ["emu", "avd", "name"] : ["shell", "getprop", AVD_NAME_PROPERTY_BY_CHANNEL[channel]];
+}
+function describeAdbCommand(commandArguments) {
+  return `adb ${commandArguments.join(" ")}`;
+}
+function parseAvdNameAnswer(stdout) {
+  const lineBreakIndex = stdout.indexOf("\n");
+  const firstLine = lineBreakIndex === -1 ? stdout : stdout.slice(0, lineBreakIndex);
+  return firstLine.trim();
+}
+function resolveNextAvdNameChannel(params) {
+  switch (params.channel) {
+    case "console": {
+      return void 0;
+    }
+    case "getprop-boot": {
+      return params.didChannelRespond ? "getprop-kernel" : "console";
+    }
+    case "getprop-kernel": {
+      return "console";
+    }
+    default: {
+      return assertNever(params.channel);
+    }
+  }
+}
+export {
+  FIRST_AVD_NAME_CHANNEL,
+  buildAvdNameChannelArguments,
+  buildAvdNameChannelCommand,
+  describeAdbCommand,
+  parseAvdNameAnswer,
+  resolveNextAvdNameChannel
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/avd-name-channel.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The channels a run can ask *\"which AVD is this device serving?\"*, and the\n * order to ask them in.\n *\n * **L47** made the adoption probe refuse rather than collide when a device did\n * not answer. It asked that question over the emulator's **console** \u2014 a second\n * TCP port, with its own auth token and its own ways of wedging, entirely\n * separate from the `adbd` channel every other call in the run travels. So a\n * single emulator whose console is wedged \u2014 routinely **another project's**,\n * with the bulk runner sweeping several projects at once \u2014 took every Obsidian\n * Android suite on the machine out of service:\n *\n * ```text\n * [transport-factory:obsidian-android-appium] AVD probe: emulator-5570=no-answer.\n * Error: AVD \"obsidian_test\": device emulator-5570 did not answer `adb -s emulator-5570 emu avd name` ...\n * ```\n *\n * `adb devices` listed `emulator-5570` as `device` and adb itself was perfectly\n * responsive throughout; only its console was gone. The refusal was right \u2014\n * launching a second copy of an AVD hits `FATAL | Running multiple emulators\n * with the same AVD is an experimental feature` \u2014 but it was keyed on the one\n * channel the run does **not** otherwise depend on.\n *\n * The AVD name is also a guest system property, readable over the same `adbd`\n * channel the run needs anyway, so it cannot be wedged independently of the\n * connection the run is about to use:\n *\n * ```text\n * adb -s <device> shell getprop ro.boot.qemu.avd_name     # modern images\n * adb -s <device> shell getprop ro.kernel.qemu.avd_name   # older images\n * ```\n *\n * Hence this ordering: property first, console only as a fallback for an image\n * that reports neither. The hard refusal stays for the genuinely-unknowable\n * device \u2014 a silent one may well be the AVD's holder \u2014 it is simply reached far\n * less often.\n *\n * **A dead channel is not asked twice.** When the `adb shell` call itself fails\n * or times out, the second property key is skipped: it travels the same channel\n * that has just proved unusable, and would only spend another full timeout to\n * learn the same thing. An *answered* but empty property is the opposite \u2014 the\n * channel is alive and the image simply does not carry that key \u2014 so the\n * cheaper sibling key is worth asking. That distinction is what keeps a wedged\n * device's worst case at two timeouts per attempt rather than three.\n *\n * Pure and unit-tested; the `adb` round-trips live in `transport-factory` and\n * `resolve-emulator-device-id`, which are integration-time code.\n */\n\nimport { assertNever } from './type-guards.mjs';\n\n/**\n * One way of asking a device which AVD it was started from.\n *\n * `getprop-boot` and `getprop-kernel` travel `adbd` \u2014 the channel the run\n * depends on anyway; `console` is the emulator's own TCP console, which can\n * wedge on its own.\n */\nexport type AvdNameChannel = 'console' | 'getprop-boot' | 'getprop-kernel';\n\n/**\n * What one channel answered.\n *\n * The two fields are deliberately independent: a channel can respond and report\n * **nothing** (an image without that property), which is a fact about the\n * image, while a channel that did not respond is a fact about the channel.\n * Collapsing them is the defect **L47** fixed one level up.\n */\nexport interface AvdNameChannelAnswer {\n  /**\n  Whether the command itself completed \u2014 regardless of what it reported.\n   */\n  readonly didRespond: boolean;\n\n  /**\n  The AVD name it reported, or `''` when it reported none.\n   */\n  readonly reportedAvdName: string;\n}\n\n/**\n * Parameters for {@link buildAvdNameChannelArguments}.\n */\nexport interface BuildAvdNameChannelArgumentsParams {\n  /**\n  The channel to ask.\n   */\n  readonly channel: AvdNameChannel;\n\n  /**\n  The device to address, or a placeholder such as `<device>` when building a message about several.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * Parameters for {@link resolveNextAvdNameChannel}.\n */\nexport interface ResolveNextAvdNameChannelParams {\n  /**\n  The channel that was just asked.\n   */\n  readonly channel: AvdNameChannel;\n\n  /**\n  Whether that channel's command completed at all.\n   */\n  readonly didChannelRespond: boolean;\n}\n\n/**\n * The channel a probe starts with: the guest property, over `adbd`.\n */\nexport const FIRST_AVD_NAME_CHANNEL: AvdNameChannel = 'getprop-boot';\n\n/**\n * The system property each `getprop` channel reads.\n *\n * `ro.boot.qemu.avd_name` is what current system images carry;\n * `ro.kernel.qemu.avd_name` is the older spelling, still present on images the\n * harness supports.\n */\nconst AVD_NAME_PROPERTY_BY_CHANNEL = {\n  'getprop-boot': 'ro.boot.qemu.avd_name',\n  'getprop-kernel': 'ro.kernel.qemu.avd_name'\n} as const;\n\n/**\n * Builds the `adb` arguments that ask one channel for the AVD name.\n *\n * @param params - The channel to ask and the device to address.\n * @returns The arguments to pass to `adb`, starting with `-s <deviceId>`.\n */\nexport function buildAvdNameChannelArguments(params: BuildAvdNameChannelArgumentsParams): string[] {\n  return ['-s', params.deviceId, ...buildAvdNameChannelCommand(params.channel)];\n}\n\n/**\n * Builds the `adb` arguments that follow `-s <deviceId>`.\n *\n * Split from {@link buildAvdNameChannelArguments} because the two callers\n * address their device differently: `transport-factory` shells out to `adb`\n * itself, while `resolve-emulator-device-id` goes through `adb.ts`, which\n * prepends `-s <deviceId>` of its own.\n *\n * @param channel - The channel to ask.\n * @returns The command arguments, without any device selection.\n */\nexport function buildAvdNameChannelCommand(channel: AvdNameChannel): string[] {\n  return channel === 'console' ? ['emu', 'avd', 'name'] : ['shell', 'getprop', AVD_NAME_PROPERTY_BY_CHANNEL[channel]];\n}\n\n/**\n * Renders `adb` arguments as the command line a reader can paste.\n *\n * Built from the arguments the run actually passes rather than written out a\n * second time, so a message can never quote a command the code does not run.\n *\n * @param commandArguments - The arguments passed to `adb`.\n * @returns The full command line.\n */\nexport function describeAdbCommand(commandArguments: readonly string[]): string {\n  return `adb ${commandArguments.join(' ')}`;\n}\n\n/**\n * Reads the AVD name out of what a channel printed.\n *\n * Both channels answer on the first line \u2014 `getprop` prints the value (an empty\n * line when the property is unset), the console prints the name and then `OK`.\n *\n * @param stdout - What the command printed.\n * @returns The reported AVD name, or `''` when it reported none.\n */\nexport function parseAvdNameAnswer(stdout: string): string {\n  /*\n   * Sliced rather than an indexed read with a `?? ''` fallback: no input can\n   * reach that fallback, and the per-file coverage gate then reports it as an\n   * uncovered branch for the rest of the file's life.\n   */\n  const lineBreakIndex = stdout.indexOf('\\n');\n  const firstLine = lineBreakIndex === -1 ? stdout : stdout.slice(0, lineBreakIndex);\n\n  return firstLine.trim();\n}\n\n/**\n * Picks the next channel to ask after one failed to identify the device.\n *\n * @param params - The channel just asked, and whether its command completed.\n * @returns The next channel, or `undefined` once every channel has been asked.\n */\nexport function resolveNextAvdNameChannel(params: ResolveNextAvdNameChannelParams): AvdNameChannel | undefined {\n  switch (params.channel) {\n    case 'console': {\n      return undefined;\n    }\n    case 'getprop-boot': {\n      /*\n       * A `getprop` that never came back says the `adbd` channel is unusable,\n       * so the sibling key \u2014 which travels that same channel \u2014 would only spend\n       * another full timeout. A channel that answered nothing says only that\n       * this image does not carry that key, which the sibling may well carry.\n       */\n      return params.didChannelRespond ? 'getprop-kernel' : 'console';\n    }\n    case 'getprop-kernel': {\n      return 'console';\n    }\n    default: {\n      return assertNever(params.channel);\n    }\n  }\n}\n"],
  "mappings": "AAmDA,SAAS,mBAAmB;AAgErB,MAAM,yBAAyC;AAStD,MAAM,+BAA+B;AAAA,EACnC,gBAAgB;AAAA,EAChB,kBAAkB;AACpB;AAQO,SAAS,6BAA6B,QAAsD;AACjG,SAAO,CAAC,MAAM,OAAO,UAAU,GAAG,2BAA2B,OAAO,OAAO,CAAC;AAC9E;AAaO,SAAS,2BAA2B,SAAmC;AAC5E,SAAO,YAAY,YAAY,CAAC,OAAO,OAAO,MAAM,IAAI,CAAC,SAAS,WAAW,6BAA6B,OAAO,CAAC;AACpH;AAWO,SAAS,mBAAmB,kBAA6C;AAC9E,SAAO,OAAO,iBAAiB,KAAK,GAAG,CAAC;AAC1C;AAWO,SAAS,mBAAmB,QAAwB;AAMzD,QAAM,iBAAiB,OAAO,QAAQ,IAAI;AAC1C,QAAM,YAAY,mBAAmB,KAAK,SAAS,OAAO,MAAM,GAAG,cAAc;AAEjF,SAAO,UAAU,KAAK;AACxB;AAQO,SAAS,0BAA0B,QAAqE;AAC7G,UAAQ,OAAO,SAAS;AAAA,IACtB,KAAK,WAAW;AACd,aAAO;AAAA,IACT;AAAA,IACA,KAAK,gBAAgB;AAOnB,aAAO,OAAO,oBAAoB,mBAAmB;AAAA,IACvD;AAAA,IACA,KAAK,kBAAkB;AACrB,aAAO;AAAA,IACT;AAAA,IACA,SAAS;AACP,aAAO,YAAY,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/esm/avd-probe-verdict.d.mts

@@ -26,6 +26,13 @@
  * to answer it — a wedged emulator times out every `adb` call — which is the
  * condition under which a colliding launch does the most damage.
  *
+ * **What the probe ASKS moved since; what it decides did not.** The question
+ * now travels the guest property over `adbd` first and the emulator console only
+ * as a fallback (`avd-name-channel.ts`), because keying a machine-wide refusal
+ * on the console alone let one wedged emulator — usually another project's —
+ * stop every Android run on the host. The four outcomes and the three verdicts
+ * here are unchanged: silence is still not a skip, it is simply far rarer.
+ *
  * Kept separate from the integration-only `transport-factory` (excluded from
  * unit tests) so the classification stays unit-testable — the factory itself
  * shells out to `adb`.

package/dist/lib/esm/avd-probe-verdict.mjs

@@ -1,3 +1,8 @@
+import {
+  buildAvdNameChannelArguments,
+  describeAdbCommand,
+  FIRST_AVD_NAME_CHANNEL
+} from "./avd-name-channel.mjs";
 import { assertNever } from "./type-guards.mjs";
 const EMULATOR_DEVICE_ID_PATTERN = /^emulator-\d+$/;
 function buildAvdProbeSummary(results) {
@@ -7,10 +12,16 @@ function buildUnreadableDevicesMessage(params) {
   const deviceList = params.unreadableDeviceIds.join(", ");
   const isSingle = params.unreadableDeviceIds.length === 1;
   const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;
-  const command = isSingle ? `adb -s ${deviceList} emu avd name` : "adb -s <device> emu avd name";
+  const deviceLabel = isSingle ? deviceList : "<device>";
+  const propertyCommand = describeAdbCommand(buildAvdNameChannelArguments({ channel: FIRST_AVD_NAME_CHANNEL, deviceId: deviceLabel }));
+  const consoleCommand = describeAdbCommand(buildAvdNameChannelArguments({ channel: "console", deviceId: deviceLabel }));
   const holder = isSingle ? "it is" : "one of them is";
-  const remedy = isSingle ? "Kill the unresponsive device" : "Kill the unresponsive devices";
-  return `AVD "${params.avdName}": ${subject} did not answer \`${command}\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide (\`FATAL | Running multiple emulators with the same AVD is an experimental feature\`), which the emulator reports only to its own stdout. ${remedy}, or run \`adb kill-server\`, then retry.`;
+  const identified = isSingle ? "identified itself" : "identified themselves";
+  const owner = isSingle ? "A device this run cannot read is most likely ANOTHER run's" : "Devices this run cannot read are most likely OTHER runs'";
+  const killing = isSingle ? "killing it" : "killing them";
+  const ownership = isSingle ? "the device is yours" : "the devices are yours";
+  const otherRun = isSingle ? "that run" : "those runs";
+  return `AVD "${params.avdName}": ${subject} ${identified} over neither \`${propertyCommand}\` (the guest property, over adbd) nor \`${consoleCommand}\` (the emulator's own console) within ${String(params.probeTimeoutInMilliseconds)}ms each (retried once), so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide (\`FATAL | Running multiple emulators with the same AVD is an experimental feature\`), which the emulator reports only to its own stdout. ${owner}: ${killing}, or running \`adb kill-server\`, destroys work this run cannot see, so do that only once you know ${ownership}. Otherwise wait for ${otherRun} to finish, and retry once \`adb devices\` no longer lists it.`;
 }
 function checkIsEmulatorDeviceId(deviceId) {
   return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);
@@ -53,4 +64,4 @@ export {
   classifyAvdProbe,
   resolveAvdProbeVerdict
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/avd-probe-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the AVD adoption probe \u2014 deciding, from what each\n * connected device answered, whether this run may reuse one, must start its\n * own emulator, or cannot safely do either.\n *\n * The probe (`adb -s <device> emu avd name`) used to discard its error and\n * resolve `''`, so a call that **never answered** was indistinguishable from one\n * that answered *\"a different AVD\"*. Both fell through to \"start a new\n * emulator\", which collides with the emulator already serving that AVD:\n *\n * ```text\n * 14:27:52.114  Checking existing devices for AVD \"obsidian_test\"... (connected: [emulator-5554])\n * 14:27:57.170  AVD \"obsidian_test\" not found on any existing device, starting a new emulator...\n * ```\n *\n * 5.056s apart \u2014 exactly the probe's own timeout. The launch that followed hit\n * `FATAL | Running multiple emulators with the same AVD is an experimental\n * feature`, which the emulator writes to its own stdout. **A probe that never\n * answered is not evidence that the answer is no** \u2014 the same distinction\n * `adb-device-list.ts` draws between `offline` and absent, and the same one\n * the connectivity probe draws between a failed dump and a missing network.\n *\n * Worse, the probe is asked its question precisely when the guest is least able\n * to answer it \u2014 a wedged emulator times out every `adb` call \u2014 which is the\n * condition under which a colliding launch does the most damage.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification stays unit-testable \u2014 the factory itself\n * shells out to `adb`.\n */\n\nimport { assertNever } from './type-guards.mjs';\n\n/**\n * What one device answered when asked which AVD it is serving.\n *\n * `not-an-emulator` and `other-avd` are both legitimate skips; only\n * `no-answer` is the silence that must never be read as one.\n */\nexport type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';\n\n/**\n * The run cannot tell whether the AVD is already running, so it must not launch.\n */\nexport interface AvdProbeRefuseVerdict {\n  /**\n  The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.\n   */\n  readonly unreadableDeviceIds: string[];\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'refuse';\n}\n\n/**\n * One device's probe outcome.\n */\nexport interface AvdProbeResult {\n  /**\n  The device UDID, e.g. `emulator-5554`.\n   */\n  readonly deviceId: string;\n\n  /**\n  What the device answered.\n   */\n  readonly outcome: AvdProbeOutcome;\n}\n\n/**\n * The AVD is already running, on a device this run may adopt.\n */\nexport interface AvdProbeReuseVerdict {\n  /**\n  The device already serving the requested AVD.\n   */\n  readonly deviceId: string;\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'reuse';\n}\n\n/**\n * Every device answered, none is serving the AVD, so launching cannot collide.\n */\nexport interface AvdProbeStartNewVerdict {\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'start-new';\n}\n\n/**\n * What the run may do, given every device's probe outcome.\n */\nexport type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;\n\n/**\n * Parameters for {@link buildUnreadableDevicesMessage}.\n */\nexport interface BuildUnreadableDevicesMessageParams {\n  /**\n  The AVD the run wanted.\n   */\n  readonly avdName: string;\n\n  /**\n  The budget each probe attempt was given, in milliseconds.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  The devices that did not answer.\n   */\n  readonly unreadableDeviceIds: readonly string[];\n}\n\n/**\n * Parameters for {@link classifyAvdProbe}.\n */\nexport interface ClassifyAvdProbeParams {\n  /**\n  The AVD the run wants.\n   */\n  readonly avdName: string;\n\n  /**\n  The device that was probed.\n   */\n  readonly deviceId: string;\n\n  /**\n  The AVD name the device answered, or `undefined` when it did not answer at all.\n   */\n  readonly probedAvdName?: string | undefined;\n}\n\n/**\n * Matches the device IDs adb gives emulators started the way this harness\n * starts them: `emulator -avd <name>`, whose console lands on a local port.\n *\n * Only such a device can collide with this run's launch, so only such a device's\n * silence is worth refusing over. A physical handset (an arbitrary serial) or a\n * TCP-attached device answers `adb \u2026 emu avd name` with an error however healthy\n * it is; reading that as \"did not answer\" would block every run on a host with a\n * phone plugged in, which is a worse defect than the one this module fixes.\n */\nconst EMULATOR_DEVICE_ID_PATTERN = /^emulator-\\d+$/;\n\n/**\n * Builds the summary line naming what each device answered.\n *\n * The old log printed only the conclusion (`not found on any existing device`),\n * which is exactly the line that was wrong; printing the evidence next to it is\n * what makes a bad conclusion visible without a second run.\n *\n * @param results - Every device's probe outcome.\n * @returns The summary, or `no devices` when nothing was connected.\n */\nexport function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string {\n  return results.length === 0 ? 'no devices' : results.map((result) => `${result.deviceId}=${result.outcome}`).join(', ');\n}\n\n/**\n * Builds the refusal message for devices that could not be read.\n *\n * Names the device, the AVD, the budget, the consequence and the recovery \u2014 the\n * shape `teardown-verdict.ts` uses for its own warning, because a message that\n * stops a run has to leave the reader able to unblock it.\n *\n * @param params - The AVD, the probe budget, and the devices that did not answer.\n * @returns The refusal message.\n */\nexport function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string {\n  /*\n   * When there is exactly one device the joined list IS its ID, so the singular\n   * wording needs no index access \u2014 and no unreachable fallback for one.\n   */\n  const deviceList = params.unreadableDeviceIds.join(', ');\n  const isSingle = params.unreadableDeviceIds.length === 1;\n\n  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;\n  const command = isSingle ? `adb -s ${deviceList} emu avd name` : 'adb -s <device> emu avd name';\n  const holder = isSingle ? 'it is' : 'one of them is';\n  const remedy = isSingle ? 'Kill the unresponsive device' : 'Kill the unresponsive devices';\n\n  return `AVD \"${params.avdName}\": ${subject} did not answer \\`${command}\\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), `\n    + `so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide `\n    + '(`FATAL | Running multiple emulators with the same AVD is an experimental feature`), which the emulator reports only to its own stdout. '\n    + `${remedy}, or run \\`adb kill-server\\`, then retry.`;\n}\n\n/**\n * Decides whether a device can hold an AVD this run could collide with.\n *\n * @param deviceId - The device UDID to judge.\n * @returns `true` for a locally started emulator, whose console this run can ask.\n */\nexport function checkIsEmulatorDeviceId(deviceId: string): boolean {\n  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);\n}\n\n/**\n * Classifies one device's probe.\n *\n * @param params - The AVD wanted, the device probed, and what it answered.\n * @returns The outcome.\n */\nexport function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome {\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'not-an-emulator';\n  }\n\n  if (params.probedAvdName === undefined || params.probedAvdName.length === 0) {\n    return 'no-answer';\n  }\n\n  return params.probedAvdName === params.avdName ? 'match' : 'other-avd';\n}\n\n/**\n * Decides what the run may do, from every device's probe outcome.\n *\n * **A match wins over an unreadable sibling.** Once the requested AVD is found\n * and reusable, an unrelated wedged device is somebody else's problem and must\n * not block a run that has everything it needs \u2014 the same restraint\n * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only\n * when nothing matched does silence become decisive, because only then would the\n * run go on to launch.\n *\n * @param results - Every device's probe outcome.\n * @returns The verdict.\n */\nexport function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict {\n  const unreadableDeviceIds: string[] = [];\n\n  for (const result of results) {\n    switch (result.outcome) {\n      case 'match': {\n        return { deviceId: result.deviceId, verdict: 'reuse' };\n      }\n      case 'no-answer': {\n        unreadableDeviceIds.push(result.deviceId);\n        break;\n      }\n      case 'not-an-emulator':\n      case 'other-avd': {\n        break;\n      }\n      default: {\n        return assertNever(result.outcome);\n      }\n    }\n  }\n\n  return unreadableDeviceIds.length > 0 ? { unreadableDeviceIds, verdict: 'refuse' } : { verdict: 'start-new' };\n}\n"],
  "mappings": "AAiCA,SAAS,mBAAmB;AAwH5B,MAAM,6BAA6B;AAY5B,SAAS,qBAAqB,SAA4C;AAC/E,SAAO,QAAQ,WAAW,IAAI,eAAe,QAAQ,IAAI,CAAC,WAAW,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,EAAE,EAAE,KAAK,IAAI;AACxH;AAYO,SAAS,8BAA8B,QAAqD;AAKjG,QAAM,aAAa,OAAO,oBAAoB,KAAK,IAAI;AACvD,QAAM,WAAW,OAAO,oBAAoB,WAAW;AAEvD,QAAM,UAAU,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU;AACzE,QAAM,UAAU,WAAW,UAAU,UAAU,kBAAkB;AACjE,QAAM,SAAS,WAAW,UAAU;AACpC,QAAM,SAAS,WAAW,iCAAiC;AAE3D,SAAO,QAAQ,OAAO,OAAO,MAAM,OAAO,qBAAqB,OAAO,aAAa,OAAO,OAAO,0BAA0B,CAAC,sDACrF,MAAM,kNAEtC,MAAM;AACf;AAQO,SAAS,wBAAwB,UAA2B;AACjE,SAAO,2BAA2B,KAAK,QAAQ;AACjD;AAQO,SAAS,iBAAiB,QAAiD;AAChF,MAAI,CAAC,wBAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,kBAAkB,UAAa,OAAO,cAAc,WAAW,GAAG;AAC3E,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,kBAAkB,OAAO,UAAU,UAAU;AAC7D;AAeO,SAAS,uBAAuB,SAAqD;AAC1F,QAAM,sBAAgC,CAAC;AAEvC,aAAW,UAAU,SAAS;AAC5B,YAAQ,OAAO,SAAS;AAAA,MACtB,KAAK,SAAS;AACZ,eAAO,EAAE,UAAU,OAAO,UAAU,SAAS,QAAQ;AAAA,MACvD;AAAA,MACA,KAAK,aAAa;AAChB,4BAAoB,KAAK,OAAO,QAAQ;AACxC;AAAA,MACF;AAAA,MACA,KAAK;AAAA,MACL,KAAK,aAAa;AAChB;AAAA,MACF;AAAA,MACA,SAAS;AACP,eAAO,YAAY,OAAO,OAAO;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAEA,SAAO,oBAAoB,SAAS,IAAI,EAAE,qBAAqB,SAAS,SAAS,IAAI,EAAE,SAAS,YAAY;AAC9G;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/avd-probe-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the AVD adoption probe \u2014 deciding, from what each\n * connected device answered, whether this run may reuse one, must start its\n * own emulator, or cannot safely do either.\n *\n * The probe (`adb -s <device> emu avd name`) used to discard its error and\n * resolve `''`, so a call that **never answered** was indistinguishable from one\n * that answered *\"a different AVD\"*. Both fell through to \"start a new\n * emulator\", which collides with the emulator already serving that AVD:\n *\n * ```text\n * 14:27:52.114  Checking existing devices for AVD \"obsidian_test\"... (connected: [emulator-5554])\n * 14:27:57.170  AVD \"obsidian_test\" not found on any existing device, starting a new emulator...\n * ```\n *\n * 5.056s apart \u2014 exactly the probe's own timeout. The launch that followed hit\n * `FATAL | Running multiple emulators with the same AVD is an experimental\n * feature`, which the emulator writes to its own stdout. **A probe that never\n * answered is not evidence that the answer is no** \u2014 the same distinction\n * `adb-device-list.ts` draws between `offline` and absent, and the same one\n * the connectivity probe draws between a failed dump and a missing network.\n *\n * Worse, the probe is asked its question precisely when the guest is least able\n * to answer it \u2014 a wedged emulator times out every `adb` call \u2014 which is the\n * condition under which a colliding launch does the most damage.\n *\n * **What the probe ASKS moved since; what it decides did not.** The question\n * now travels the guest property over `adbd` first and the emulator console only\n * as a fallback (`avd-name-channel.ts`), because keying a machine-wide refusal\n * on the console alone let one wedged emulator \u2014 usually another project's \u2014\n * stop every Android run on the host. The four outcomes and the three verdicts\n * here are unchanged: silence is still not a skip, it is simply far rarer.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification stays unit-testable \u2014 the factory itself\n * shells out to `adb`.\n */\n\nimport {\n  buildAvdNameChannelArguments,\n  describeAdbCommand,\n  FIRST_AVD_NAME_CHANNEL\n} from './avd-name-channel.mjs';\nimport { assertNever } from './type-guards.mjs';\n\n/**\n * What one device answered when asked which AVD it is serving.\n *\n * `not-an-emulator` and `other-avd` are both legitimate skips; only\n * `no-answer` is the silence that must never be read as one.\n */\nexport type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';\n\n/**\n * The run cannot tell whether the AVD is already running, so it must not launch.\n */\nexport interface AvdProbeRefuseVerdict {\n  /**\n  The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.\n   */\n  readonly unreadableDeviceIds: string[];\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'refuse';\n}\n\n/**\n * One device's probe outcome.\n */\nexport interface AvdProbeResult {\n  /**\n  The device UDID, e.g. `emulator-5554`.\n   */\n  readonly deviceId: string;\n\n  /**\n  What the device answered.\n   */\n  readonly outcome: AvdProbeOutcome;\n}\n\n/**\n * The AVD is already running, on a device this run may adopt.\n */\nexport interface AvdProbeReuseVerdict {\n  /**\n  The device already serving the requested AVD.\n   */\n  readonly deviceId: string;\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'reuse';\n}\n\n/**\n * Every device answered, none is serving the AVD, so launching cannot collide.\n */\nexport interface AvdProbeStartNewVerdict {\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'start-new';\n}\n\n/**\n * What the run may do, given every device's probe outcome.\n */\nexport type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;\n\n/**\n * Parameters for {@link buildUnreadableDevicesMessage}.\n */\nexport interface BuildUnreadableDevicesMessageParams {\n  /**\n  The AVD the run wanted.\n   */\n  readonly avdName: string;\n\n  /**\n  The budget each probe attempt was given, in milliseconds.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  The devices that did not answer.\n   */\n  readonly unreadableDeviceIds: readonly string[];\n}\n\n/**\n * Parameters for {@link classifyAvdProbe}.\n */\nexport interface ClassifyAvdProbeParams {\n  /**\n  The AVD the run wants.\n   */\n  readonly avdName: string;\n\n  /**\n  The device that was probed.\n   */\n  readonly deviceId: string;\n\n  /**\n  The AVD name the device answered, or `undefined` when it did not answer at all.\n   */\n  readonly probedAvdName?: string | undefined;\n}\n\n/**\n * Matches the device IDs adb gives emulators started the way this harness\n * starts them: `emulator -avd <name>`, whose console lands on a local port.\n *\n * Only such a device can collide with this run's launch, so only such a device's\n * silence is worth refusing over. A physical handset (an arbitrary serial) or a\n * TCP-attached device carries no `qemu` AVD property and errors on `adb \u2026 emu\n * avd name` however healthy it is; reading either as \"did not answer\" would\n * block every run on a host with a phone plugged in, which is a worse defect\n * than the one this module fixes.\n */\nconst EMULATOR_DEVICE_ID_PATTERN = /^emulator-\\d+$/;\n\n/**\n * Builds the summary line naming what each device answered.\n *\n * The old log printed only the conclusion (`not found on any existing device`),\n * which is exactly the line that was wrong; printing the evidence next to it is\n * what makes a bad conclusion visible without a second run.\n *\n * @param results - Every device's probe outcome.\n * @returns The summary, or `no devices` when nothing was connected.\n */\nexport function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string {\n  return results.length === 0 ? 'no devices' : results.map((result) => `${result.deviceId}=${result.outcome}`).join(', ');\n}\n\n/**\n * Builds the refusal message for devices that could not be read.\n *\n * Names the device, the AVD, the budget, the consequence and the recovery \u2014 the\n * shape `teardown-verdict.ts` uses for its own warning, because a message that\n * stops a run has to leave the reader able to unblock it.\n *\n * @param params - The AVD, the probe budget, and the devices that did not answer.\n * @returns The refusal message.\n */\nexport function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string {\n  /*\n   * When there is exactly one device the joined list IS its ID, so the singular\n   * wording needs no index access \u2014 and no unreachable fallback for one.\n   */\n  const deviceList = params.unreadableDeviceIds.join(', ');\n  const isSingle = params.unreadableDeviceIds.length === 1;\n\n  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;\n  const deviceLabel = isSingle ? deviceList : '<device>';\n  const propertyCommand = describeAdbCommand(buildAvdNameChannelArguments({ channel: FIRST_AVD_NAME_CHANNEL, deviceId: deviceLabel }));\n  const consoleCommand = describeAdbCommand(buildAvdNameChannelArguments({ channel: 'console', deviceId: deviceLabel }));\n  const holder = isSingle ? 'it is' : 'one of them is';\n  const identified = isSingle ? 'identified itself' : 'identified themselves';\n  const owner = isSingle ? 'A device this run cannot read is most likely ANOTHER run\\'s' : 'Devices this run cannot read are most likely OTHER runs\\'';\n  const killing = isSingle ? 'killing it' : 'killing them';\n  const ownership = isSingle ? 'the device is yours' : 'the devices are yours';\n  const otherRun = isSingle ? 'that run' : 'those runs';\n\n  return `AVD \"${params.avdName}\": ${subject} ${identified} over neither \\`${propertyCommand}\\` (the guest property, over adbd) `\n    + `nor \\`${consoleCommand}\\` (the emulator's own console) within ${String(params.probeTimeoutInMilliseconds)}ms each (retried once), `\n    + `so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide `\n    + '(`FATAL | Running multiple emulators with the same AVD is an experimental feature`), which the emulator reports only to its own stdout. '\n    + `${owner}: ${killing}, or running \\`adb kill-server\\`, destroys work this run cannot see, so do that only once you know ${ownership}. `\n    + `Otherwise wait for ${otherRun} to finish, and retry once \\`adb devices\\` no longer lists it.`;\n}\n\n/**\n * Decides whether a device can hold an AVD this run could collide with.\n *\n * @param deviceId - The device UDID to judge.\n * @returns `true` for a locally started emulator, whose console this run can ask.\n */\nexport function checkIsEmulatorDeviceId(deviceId: string): boolean {\n  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);\n}\n\n/**\n * Classifies one device's probe.\n *\n * @param params - The AVD wanted, the device probed, and what it answered.\n * @returns The outcome.\n */\nexport function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome {\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'not-an-emulator';\n  }\n\n  if (params.probedAvdName === undefined || params.probedAvdName.length === 0) {\n    return 'no-answer';\n  }\n\n  return params.probedAvdName === params.avdName ? 'match' : 'other-avd';\n}\n\n/**\n * Decides what the run may do, from every device's probe outcome.\n *\n * **A match wins over an unreadable sibling.** Once the requested AVD is found\n * and reusable, an unrelated wedged device is somebody else's problem and must\n * not block a run that has everything it needs \u2014 the same restraint\n * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only\n * when nothing matched does silence become decisive, because only then would the\n * run go on to launch.\n *\n * @param results - Every device's probe outcome.\n * @returns The verdict.\n */\nexport function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict {\n  const unreadableDeviceIds: string[] = [];\n\n  for (const result of results) {\n    switch (result.outcome) {\n      case 'match': {\n        return { deviceId: result.deviceId, verdict: 'reuse' };\n      }\n      case 'no-answer': {\n        unreadableDeviceIds.push(result.deviceId);\n        break;\n      }\n      case 'not-an-emulator':\n      case 'other-avd': {\n        break;\n      }\n      default: {\n        return assertNever(result.outcome);\n      }\n    }\n  }\n\n  return unreadableDeviceIds.length > 0 ? { unreadableDeviceIds, verdict: 'refuse' } : { verdict: 'start-new' };\n}\n"],
  "mappings": "AAwCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AAyH5B,MAAM,6BAA6B;AAY5B,SAAS,qBAAqB,SAA4C;AAC/E,SAAO,QAAQ,WAAW,IAAI,eAAe,QAAQ,IAAI,CAAC,WAAW,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,EAAE,EAAE,KAAK,IAAI;AACxH;AAYO,SAAS,8BAA8B,QAAqD;AAKjG,QAAM,aAAa,OAAO,oBAAoB,KAAK,IAAI;AACvD,QAAM,WAAW,OAAO,oBAAoB,WAAW;AAEvD,QAAM,UAAU,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU;AACzE,QAAM,cAAc,WAAW,aAAa;AAC5C,QAAM,kBAAkB,mBAAmB,6BAA6B,EAAE,SAAS,wBAAwB,UAAU,YAAY,CAAC,CAAC;AACnI,QAAM,iBAAiB,mBAAmB,6BAA6B,EAAE,SAAS,WAAW,UAAU,YAAY,CAAC,CAAC;AACrH,QAAM,SAAS,WAAW,UAAU;AACpC,QAAM,aAAa,WAAW,sBAAsB;AACpD,QAAM,QAAQ,WAAW,+DAAgE;AACzF,QAAM,UAAU,WAAW,eAAe;AAC1C,QAAM,YAAY,WAAW,wBAAwB;AACrD,QAAM,WAAW,WAAW,aAAa;AAEzC,SAAO,QAAQ,OAAO,OAAO,MAAM,OAAO,IAAI,UAAU,mBAAmB,eAAe,4CAC7E,cAAc,0CAA0C,OAAO,OAAO,0BAA0B,CAAC,2DACvE,MAAM,kNAEtC,KAAK,KAAK,OAAO,sGAAsG,SAAS,wBAC7G,QAAQ;AACpC;AAQO,SAAS,wBAAwB,UAA2B;AACjE,SAAO,2BAA2B,KAAK,QAAQ;AACjD;AAQO,SAAS,iBAAiB,QAAiD;AAChF,MAAI,CAAC,wBAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,kBAAkB,UAAa,OAAO,cAAc,WAAW,GAAG;AAC3E,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,kBAAkB,OAAO,UAAU,UAAU;AAC7D;AAeO,SAAS,uBAAuB,SAAqD;AAC1F,QAAM,sBAAgC,CAAC;AAEvC,aAAW,UAAU,SAAS;AAC5B,YAAQ,OAAO,SAAS;AAAA,MACtB,KAAK,SAAS;AACZ,eAAO,EAAE,UAAU,OAAO,UAAU,SAAS,QAAQ;AAAA,MACvD;AAAA,MACA,KAAK,aAAa;AAChB,4BAAoB,KAAK,OAAO,QAAQ;AACxC;AAAA,MACF;AAAA,MACA,KAAK;AAAA,MACL,KAAK,aAAa;AAChB;AAAA,MACF;AAAA,MACA,SAAS;AACP,eAAO,YAAY,OAAO,OAAO;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAEA,SAAO,oBAAoB,SAAS,IAAI,EAAE,qBAAqB,SAAS,SAAS,IAAI,EAAE,SAAS,YAAY;AAC9G;",
  "names": []
}


package/dist/lib/esm/device-screenshot.d.mts

@@ -12,7 +12,9 @@
  * `adb exec-out screencap -p` reads the framebuffer instead, which is the same
  * route the trusted-input passes already use. The trade is deliberate and worth
  * writing down at every call site: a device capture carries the status-bar clock
- * and battery, so it is **not byte-reproducible** the way a page capture is.
+ * and battery, so it is **not byte-reproducible as captured** the way a page
+ * capture is. `paintOutStatusBar` is what makes one — it removes the band those
+ * live in — and a frame that is going to be committed has to go through it.
  * Reach for this only for the shots that need the keyboard; leave the rest on
  * `captureObsidianScreenshot`.
  */

package/dist/lib/esm/device-screenshot.mjs

@@ -15,4 +15,4 @@ async function captureDeviceScreenshot(params) {
 export {
   captureDeviceScreenshot
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RldmljZS1zY3JlZW5zaG90LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUGhvdG9ncmFwaHMgdGhlIERFVklDRSwgbm90IHRoZSB3ZWIgcGFnZS5cbiAqXG4gKiBgY2FwdHVyZU9ic2lkaWFuU2NyZWVuc2hvdGAgZ29lcyB0aHJvdWdoIEFwcGl1bSBpbiB0aGUgV2ViVmlldyBjb250ZXh0LCBzbyBvblxuICogQW5kcm9pZCBpdCBjYXB0dXJlcyB0aGUgcGFnZTogbm8gc3RhdHVzIGJhciwgYW5kIFx1MjAxNCB0aGUgcmVhc29uIHRoaXMgZXhpc3RzIFx1MjAxNFxuICogbm8gc29mdCBrZXlib2FyZCwgYmVjYXVzZSB0aGUgSU1FIGlzIGEgc3lzdGVtIHdpbmRvdyBhbmQgbm90IHBhcnQgb2YgdGhlXG4gKiBwYWdlLiBBIGZyYW1lIHRoYXQgaXMgbWVhbnQgdG8gc2hvdyB3aGF0IGEgcGhvbmUgbG9va3MgbGlrZSB0aGVyZWZvcmUgY2Fubm90XG4gKiBiZSB0YWtlbiB0aGF0IHdheS5cbiAqXG4gKiBgYWRiIGV4ZWMtb3V0IHNjcmVlbmNhcCAtcGAgcmVhZHMgdGhlIGZyYW1lYnVmZmVyIGluc3RlYWQsIHdoaWNoIGlzIHRoZSBzYW1lXG4gKiByb3V0ZSB0aGUgdHJ1c3RlZC1pbnB1dCBwYXNzZXMgYWxyZWFkeSB1c2UuIFRoZSB0cmFkZSBpcyBkZWxpYmVyYXRlIGFuZCB3b3J0aFxuICogd3JpdGluZyBkb3duIGF0IGV2ZXJ5IGNhbGwgc2l0ZTogYSBkZXZpY2UgY2FwdHVyZSBjYXJyaWVzIHRoZSBzdGF0dXMtYmFyIGNsb2NrXG4gKiBhbmQgYmF0dGVyeSwgc28gaXQgaXMgKipub3QgYnl0ZS1yZXByb2R1Y2libGUqKiB0aGUgd2F5IGEgcGFnZSBjYXB0dXJlIGlzLlxuICogUmVhY2ggZm9yIHRoaXMgb25seSBmb3IgdGhlIHNob3RzIHRoYXQgbmVlZCB0aGUga2V5Ym9hcmQ7IGxlYXZlIHRoZSByZXN0IG9uXG4gKiBgY2FwdHVyZU9ic2lkaWFuU2NyZWVuc2hvdGAuXG4gKi9cblxuaW1wb3J0IHsgcnVuQWRiQmluYXJ5IH0gZnJvbSAnLi9hZGIubWpzJztcbmltcG9ydCB7IGlzUG5nIH0gZnJvbSAnLi9jYXB0dXJlLXNjcmVlbnNob3QubWpzJztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgY2FwdHVyZURldmljZVNjcmVlbnNob3R9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENhcHR1cmVEZXZpY2VTY3JlZW5zaG90UGFyYW1zIHtcbiAgLyoqXG4gICAqIFRoZSBkZXZpY2UgdG8gcGhvdG9ncmFwaC5cbiAgICovXG4gIHJlYWRvbmx5IGRldmljZUlkOiBzdHJpbmc7XG59XG5cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBJbnRlZ3JhdGlvbi10aW1lIGNvZGUgKHNoZWxscyBvdXQgdG8gYSByZWFsIGRldmljZSkgY292ZXJlZCBieSBpbnRlZ3JhdGlvbiB0ZXN0cywgbm90IHVuaXQgdGVzdHMuICovXG5cbi8qKlxuICogQ2FwdHVyZXMgdGhlIGRldmljZSdzIGZyYW1lYnVmZmVyIGFzIGEgUE5HLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgZGV2aWNlIHRvIHBob3RvZ3JhcGguXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIHRvIHRoZSByYXcgUE5HIGJ5dGVzLlxuICogQHRocm93cyBFcnJvciBpZiB3aGF0IGNhbWUgYmFjayBpcyBub3QgYSBQTkcgXHUyMDE0IHdoaWNoIGlzIHdoYXQgYSB0cnVuY2F0ZWQgb3IgdGV4dC1kZWNvZGVkIGNhcHR1cmUgbG9va3NcbiAqICAgbGlrZSwgYW5kIGlzIGZhciBjaGVhcGVyIHRvIGNhdGNoIGhlcmUgdGhhbiBpbiBhbiBpbWFnZSBkaWZmLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY2FwdHVyZURldmljZVNjcmVlbnNob3QocGFyYW1zOiBDYXB0dXJlRGV2aWNlU2NyZWVuc2hvdFBhcmFtcyk6IFByb21pc2U8VWludDhBcnJheT4ge1xuICBjb25zdCBieXRlcyA9IGF3YWl0IHJ1bkFkYkJpbmFyeSh7XG4gICAgY29tbWFuZEFyZ3VtZW50czogWydleGVjLW91dCcsICdzY3JlZW5jYXAnLCAnLXAnXSxcbiAgICBkZXZpY2VJZDogcGFyYW1zLmRldmljZUlkXG4gIH0pO1xuXG4gIGlmICghaXNQbmcoYnl0ZXMpKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgYGNhcHR1cmVEZXZpY2VTY3JlZW5zaG90OiAke3BhcmFtcy5kZXZpY2VJZH0gcmV0dXJuZWQgJHtTdHJpbmcoYnl0ZXMubGVuZ3RoKX0gYnl0ZXMgdGhhdCBhcmUgbm90IGEgUE5HLiBgXG4gICAgICAgICsgJ0EgZGV2aWNlIHRoYXQgaXMgc3RpbGwgYm9vdGluZywgb3IgYW4gYWRiIHRyYW5zcG9ydCB0aGF0IGRlY29kZWQgdGhlIHN0cmVhbSBhcyB0ZXh0LCBib3RoIGxvb2sgbGlrZSB0aGlzLidcbiAgICApO1xuICB9XG5cbiAgcmV0dXJuIGJ5dGVzO1xufVxuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBbUJBLFNBQVMsb0JBQW9CO0FBQzdCLFNBQVMsYUFBYTtBQXNCdEIsZUFBc0Isd0JBQXdCLFFBQTREO0FBQ3hHLFFBQU0sUUFBUSxNQUFNLGFBQWE7QUFBQSxJQUMvQixrQkFBa0IsQ0FBQyxZQUFZLGFBQWEsSUFBSTtBQUFBLElBQ2hELFVBQVUsT0FBTztBQUFBLEVBQ25CLENBQUM7QUFFRCxNQUFJLENBQUMsTUFBTSxLQUFLLEdBQUc7QUFDakIsVUFBTSxJQUFJO0FBQUEsTUFDUiw0QkFBNEIsT0FBTyxRQUFRLGFBQWEsT0FBTyxNQUFNLE1BQU0sQ0FBQztBQUFBLElBRTlFO0FBQUEsRUFDRjtBQUVBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/emulator-backend.d.mts

@@ -24,6 +24,49 @@
  * integration-only `transport-factory` so the parsing and the selection stay
  * unit-testable.
  */
+/**
+ * Parameters for {@link checkIsNoMatchReported}.
+ */
+export interface CheckIsNoMatchReportedParams {
+    /**
+    The query's stdout.
+     */
+    readonly output: string;
+    /**
+    The query that produced it.
+     */
+    readonly query: EmulatorProcessQuery;
+}
+/**
+ * One command that lists (some of) the host's emulator processes.
+ */
+export interface EmulatorProcessQuery {
+    /**
+    The executable.
+     */
+    readonly command: string;
+    /**
+    Its arguments.
+     */
+    readonly commandArguments: readonly string[];
+    /**
+    Whether the command asks only for emulator image names rather than for every process on the host — which is what makes an empty answer legitimate.
+     */
+    readonly isFiltered: boolean;
+}
+/**
+ * Parameters for {@link parseEmulatorProcessQueryOutput}.
+ */
+export interface ParseEmulatorProcessQueryOutputParams {
+    /**
+    The query's stdout.
+     */
+    readonly output: string;
+    /**
+    The query that produced it.
+     */
+    readonly query: EmulatorProcessQuery;
+}
 /**
  * One process from a host process listing.
  */
@@ -50,6 +93,44 @@ export interface SelectEmulatorBackendPidsParams {
      */
     readonly processes: readonly ProcessListEntry[];
 }
+/**
+ * Builds the commands that list the host's emulator processes.
+ *
+ * **On Windows the query is filtered to the emulator image names, and that is a
+ * measured decision.** A whole-host `tasklist` does per-process work for every
+ * row, so it pays the host's contention once per process: during an emulator
+ * boot it measured p50 2.9s and max 92.2s over ~530 rows, and with every core
+ * saturated one call stalled for 120.9s — until the load exited — where the
+ * filtered call never exceeded 505ms (2026-09-23, n=8 each). The per-row cost is
+ * work the filter skips, so the filtered query does not inherit it.
+ *
+ * **On POSIX the whole-host `ps` is kept.** It reads `/proc` and was never
+ * measured slow, and a whole-host listing keeps the invariant that zero rows
+ * means a failed query — which `pgrep`'s exit 1 on no match would muddy.
+ *
+ * @param platform - The host platform, e.g. `process.platform`.
+ * @returns The queries to run; their parsed rows together are the answer.
+ */
+export declare function buildEmulatorProcessQueries(platform: NodeJS.Platform): EmulatorProcessQuery[];
+/**
+ * Checks whether a query affirmatively reported that nothing matched.
+ *
+ * Only a **filtered** query can say that: a whole-host listing always has rows,
+ * so an empty one is never an answer. A filtered query that printed nothing at
+ * all is not an answer either — silence and "no emulator is running" must stay
+ * distinguishable, or a failed query reads as a host with no emulator on it.
+ *
+ * @param params - The query and its stdout.
+ * @returns Whether the query's output carries its own no-match notice.
+ */
+export declare function checkIsNoMatchReported(params: CheckIsNoMatchReportedParams): boolean;
+/**
+ * Parses the output of one of {@link buildEmulatorProcessQueries}' commands.
+ *
+ * @param params - The query and its stdout.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parseEmulatorProcessQueryOutput(params: ParseEmulatorProcessQueryOutputParams): ProcessListEntry[];
 /**
  * Parses `ps -eo pid=,comm=` output.
  *

package/dist/lib/esm/emulator-backend.mjs

@@ -1,7 +1,22 @@
 const EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\w.-]+|qemu-system-[\w.-]+)$/;
+const EMULATOR_IMAGE_NAME_PREFIXES = ["emulator", "qemu-system"];
+const TASK_LIST_NO_MATCH_NOTICE_PATTERN = /^INFO: /m;
 const EXECUTABLE_SUFFIX_PATTERN = /\.exe$/;
 const RADIX_DECIMAL = 10;
 const TASK_LIST_FIELDS_READ = 2;
+function buildEmulatorProcessQueries(platform) {
+  return platform === "win32" ? EMULATOR_IMAGE_NAME_PREFIXES.map((prefix) => ({
+    command: "tasklist",
+    commandArguments: ["/FO", "CSV", "/NH", "/FI", `IMAGENAME eq ${prefix}*`],
+    isFiltered: true
+  })) : [{ command: "ps", commandArguments: ["-eo", "pid=,comm="], isFiltered: false }];
+}
+function checkIsNoMatchReported(params) {
+  return params.query.isFiltered && TASK_LIST_NO_MATCH_NOTICE_PATTERN.test(params.output);
+}
+function parseEmulatorProcessQueryOutput(params) {
+  return params.query.command === "tasklist" ? parseWindowsTaskList(params.output) : parsePosixProcessList(params.output);
+}
 function parsePosixProcessList(processListOutput) {
   const entries = [];
   for (const rawLine of processListOutput.split("\n")) {
@@ -38,8 +53,11 @@ function checkIsEmulatorBackendName(name) {
   return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ""));
 }
 export {
+  buildEmulatorProcessQueries,
+  checkIsNoMatchReported,
+  parseEmulatorProcessQueryOutput,
   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": "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": []
}

+//# 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 * Parameters for {@link checkIsNoMatchReported}.\n */\nexport interface CheckIsNoMatchReportedParams {\n  /**\n  The query's stdout.\n   */\n  readonly output: string;\n\n  /**\n  The query that produced it.\n   */\n  readonly query: EmulatorProcessQuery;\n}\n\n/**\n * One command that lists (some of) the host's emulator processes.\n */\nexport interface EmulatorProcessQuery {\n  /**\n  The executable.\n   */\n  readonly command: string;\n\n  /**\n  Its arguments.\n   */\n  readonly commandArguments: readonly string[];\n\n  /**\n  Whether the command asks only for emulator image names rather than for every process on the host \u2014 which is what makes an empty answer legitimate.\n   */\n  readonly isFiltered: boolean;\n}\n\n/**\n * Parameters for {@link parseEmulatorProcessQueryOutput}.\n */\nexport interface ParseEmulatorProcessQueryOutputParams {\n  /**\n  The query's stdout.\n   */\n  readonly output: string;\n\n  /**\n  The query that produced it.\n   */\n  readonly query: EmulatorProcessQuery;\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.-]+)$/;\n/**\n * The image-name prefixes `tasklist` is asked for \u2014 every name\n * `EMULATOR_BACKEND_NAME_PATTERN` accepts starts with one of them.\n *\n * One call per prefix, because `tasklist`'s `/FI` clauses are ANDed: there is\n * no way to OR two image names in a single call.\n */\nconst EMULATOR_IMAGE_NAME_PREFIXES = ['emulator', 'qemu-system'] as const;\n\n/**\n * The notice `tasklist` prints on stdout, with exit 0, when a filter matched\n * nothing: `INFO: No tasks are running which match the specified criteria.`\n * Only the `INFO:` prefix is matched; a localized Windows that words it\n * differently reads as a silent empty answer, which is reported as a failed\n * query \u2014 the safe direction, since a failed query kills nothing.\n */\nconst TASK_LIST_NO_MATCH_NOTICE_PATTERN = /^INFO: /m;\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 * Builds the commands that list the host's emulator processes.\n *\n * **On Windows the query is filtered to the emulator image names, and that is a\n * measured decision.** A whole-host `tasklist` does per-process work for every\n * row, so it pays the host's contention once per process: during an emulator\n * boot it measured p50 2.9s and max 92.2s over ~530 rows, and with every core\n * saturated one call stalled for 120.9s \u2014 until the load exited \u2014 where the\n * filtered call never exceeded 505ms (2026-09-23, n=8 each). The per-row cost is\n * work the filter skips, so the filtered query does not inherit it.\n *\n * **On POSIX the whole-host `ps` is kept.** It reads `/proc` and was never\n * measured slow, and a whole-host listing keeps the invariant that zero rows\n * means a failed query \u2014 which `pgrep`'s exit 1 on no match would muddy.\n *\n * @param platform - The host platform, e.g. `process.platform`.\n * @returns The queries to run; their parsed rows together are the answer.\n */\nexport function buildEmulatorProcessQueries(platform: NodeJS.Platform): EmulatorProcessQuery[] {\n  return platform === 'win32'\n    ? EMULATOR_IMAGE_NAME_PREFIXES.map((prefix) => ({\n      command: 'tasklist',\n      commandArguments: ['/FO', 'CSV', '/NH', '/FI', `IMAGENAME eq ${prefix}*`],\n      isFiltered: true\n    }))\n    : [{ command: 'ps', commandArguments: ['-eo', 'pid=,comm='], isFiltered: false }];\n}\n\n/**\n * Checks whether a query affirmatively reported that nothing matched.\n *\n * Only a **filtered** query can say that: a whole-host listing always has rows,\n * so an empty one is never an answer. A filtered query that printed nothing at\n * all is not an answer either \u2014 silence and \"no emulator is running\" must stay\n * distinguishable, or a failed query reads as a host with no emulator on it.\n *\n * @param params - The query and its stdout.\n * @returns Whether the query's output carries its own no-match notice.\n */\nexport function checkIsNoMatchReported(params: CheckIsNoMatchReportedParams): boolean {\n  return params.query.isFiltered && TASK_LIST_NO_MATCH_NOTICE_PATTERN.test(params.output);\n}\n\n/**\n * Parses the output of one of {@link buildEmulatorProcessQueries}' commands.\n *\n * @param params - The query and its stdout.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parseEmulatorProcessQueryOutput(params: ParseEmulatorProcessQueryOutputParams): ProcessListEntry[] {\n  return params.query.command === 'tasklist' ? parseWindowsTaskList(params.output) : parsePosixProcessList(params.output);\n}\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": "AA+GA,MAAM,gCAAgC;AAQtC,MAAM,+BAA+B,CAAC,YAAY,aAAa;AAS/D,MAAM,oCAAoC;AAC1C,MAAM,4BAA4B;AAClC,MAAM,gBAAgB;AAItB,MAAM,wBAAwB;AAoBvB,SAAS,4BAA4B,UAAmD;AAC7F,SAAO,aAAa,UAChB,6BAA6B,IAAI,CAAC,YAAY;AAAA,IAC9C,SAAS;AAAA,IACT,kBAAkB,CAAC,OAAO,OAAO,OAAO,OAAO,gBAAgB,MAAM,GAAG;AAAA,IACxE,YAAY;AAAA,EACd,EAAE,IACA,CAAC,EAAE,SAAS,MAAM,kBAAkB,CAAC,OAAO,YAAY,GAAG,YAAY,MAAM,CAAC;AACpF;AAaO,SAAS,uBAAuB,QAA+C;AACpF,SAAO,OAAO,MAAM,cAAc,kCAAkC,KAAK,OAAO,MAAM;AACxF;AAQO,SAAS,gCAAgC,QAAmE;AACjH,SAAO,OAAO,MAAM,YAAY,aAAa,qBAAqB,OAAO,MAAM,IAAI,sBAAsB,OAAO,MAAM;AACxH;AAQO,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": []
}
