obsidian-integration-testing 16.0.0 → 17.0.1

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

@@ -12,14 +12,14 @@
  * `OBSIDIAN_METADATA` global — which the factory's import graph reaches —
  * cannot load at all. So nothing this module imports may reach it either.
  */
-import type { ChildProcess } from 'node:child_process';
+import type { ChildProcess, ExecFileException } from 'node:child_process';
 import type { ProcessListEntry } from './emulator-backend.mjs';
 /**
  * Budget for one quick `adb` call — `adb devices`, a console command.
  */
 export declare const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;
 export declare const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8388608;
-export declare const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 30000;
+export declare const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 120000;
 /**
  * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.
  */
@@ -74,6 +74,29 @@ export interface HostCommandQuery {
      */
     readonly commandArguments: string[];
 }
+/**
+ * Everything one host process listing left behind, kept together so the
+ * classification sees the whole picture.
+ *
+ * `execFile`'s callback discards nothing here — not stderr, and not a *failed*
+ * call's partial stdout. The old code kept only `error.message`, which for
+ * `execFile` is `Command failed: <cmd>` plus stderr, so a killed child (empty
+ * stderr) produced a line naming the command and nothing else.
+ */
+export interface HostProcessQueryResult {
+    /**
+    `execFile`'s error, or `null` when the listing succeeded.
+     */
+    readonly error: ExecFileException | null;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    Whatever the child wrote to stdout — a partial listing when the call failed part-way.
+     */
+    readonly standardOutput: string;
+}
 /**
  * Finds, stops and verifies the harness's emulators, reporting through the
  * caller's log so each caller keeps its own prefix.
@@ -98,16 +121,34 @@ export declare class EmulatorReclaimer {
      */
     getDevicesOutput(): Promise<string>;
     /**
-     * Lists every process on the host.
+     * Lists the host's emulator processes — every process whose image name could
+     * be the launcher or a QEMU backend, and on POSIX every process on the host.
+     *
+     * On Windows this is two **filtered** `tasklist` calls rather than one
+     * whole-host listing (`buildEmulatorProcessQueries` carries the measurement
+     * that made the switch), run in parallel. A filtered call may legitimately
+     * find nothing, but only when it says so: a clean exit with neither a row nor
+     * `tasklist`'s own no-match notice is still a failed query, and comes back as
+     * `undefined` exactly like one that did not run — never as an empty list a
+     * caller could read as "no emulator is running".
+     *
+     * Each failed call logs **one** line, from `host-process-query-verdict.ts`,
+     * naming which way it failed. The predecessor logged two contradictory ones
+     * for a single failure — `could not list host processes` immediately followed
+     * by `listed no processes` — because a failed call resolved `''`, which then
+     * parsed to zero rows and tripped the zero-row check as well.
      *
-     * A host always has processes, so a listing that parses to **zero** rows is a
-     * failed query however it exited, and comes back as `undefined` exactly like
-     * one that did not run — never as an empty list a caller could read as "no
-     * emulator is running".
+     * **If any call fails, the whole answer is `undefined`**, and a failed call's
+     * partial stdout is parsed but never returned: the owned PID set is the
+     * difference between two answers, so a half answer — one image name's
+     * processes without the other's, or a truncated listing — would both miss a
+     * process this run owns and claim one it does not, and killing a process the
+     * run does not own is the one thing **L46** forbids. The row count goes into
+     * the log instead, as the evidence that the command was working.
      *
-     * @returns The host's processes, or `undefined` when the listing failed.
+     * @returns The host's emulator processes, or `undefined` when a query failed.
      */
-    queryHostProcesses(): Promise<ProcessListEntry[] | undefined>;
+    queryEmulatorProcesses(): Promise<ProcessListEntry[] | undefined>;
     /**
      * Stops the emulators this harness started that no live run is responsible
      * for, and drops the markers that no longer describe a running emulator.
@@ -169,6 +210,13 @@ export declare class EmulatorReclaimer {
      * @param scope - Whether an emulator another live harness process owns is spared.
      */
     private reclaimLeftoverEmulator;
+    /**
+     * Runs one of the emulator process queries and classifies how it ended.
+     *
+     * @param query - The query.
+     * @returns Its parsed rows, or `undefined` when it failed.
+     */
+    private runEmulatorProcessQuery;
     /**
      * Polls until this run's emulator is gone, or the budget elapses.
      *

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

@@ -2,8 +2,9 @@ import { execFile } from "node:child_process";
 import process from "node:process";
 import { checkIsDeviceListed } from "./adb-device-list.mjs";
 import {
-  parsePosixProcessList,
-  parseWindowsTaskList,
+  buildEmulatorProcessQueries,
+  checkIsNoMatchReported,
+  parseEmulatorProcessQueryOutput,
   selectEmulatorBackendPids
 } from "./emulator-backend.mjs";
 import {
@@ -13,6 +14,10 @@ import {
   resolveEmulatorMarkerVerdict,
   selectLiveMarkedPids
 } from "./emulator-marker.mjs";
+import {
+  buildHostProcessQueryMessage,
+  resolveHostProcessQueryOutcome
+} from "./host-process-query-verdict.mjs";
 import {
   killProcessTree,
   killProcessTreeByPid
@@ -24,7 +29,7 @@ import {
 } from "./teardown-verdict.mjs";
 const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5e3;
 const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8388608;
-const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 3e4;
+const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 12e4;
 const EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5e3;
 const EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 2e4;
@@ -64,34 +69,41 @@ class EmulatorReclaimer {
     });
   }
   /**
-   * Lists every process on the host.
+   * Lists the host's emulator processes — every process whose image name could
+   * be the launcher or a QEMU backend, and on POSIX every process on the host.
+   *
+   * On Windows this is two **filtered** `tasklist` calls rather than one
+   * whole-host listing (`buildEmulatorProcessQueries` carries the measurement
+   * that made the switch), run in parallel. A filtered call may legitimately
+   * find nothing, but only when it says so: a clean exit with neither a row nor
+   * `tasklist`'s own no-match notice is still a failed query, and comes back as
+   * `undefined` exactly like one that did not run — never as an empty list a
+   * caller could read as "no emulator is running".
    *
-   * A host always has processes, so a listing that parses to **zero** rows is a
-   * failed query however it exited, and comes back as `undefined` exactly like
-   * one that did not run — never as an empty list a caller could read as "no
-   * emulator is running".
+   * Each failed call logs **one** line, from `host-process-query-verdict.ts`,
+   * naming which way it failed. The predecessor logged two contradictory ones
+   * for a single failure — `could not list host processes` immediately followed
+   * by `listed no processes` — because a failed call resolved `''`, which then
+   * parsed to zero rows and tripped the zero-row check as well.
    *
-   * @returns The host's processes, or `undefined` when the listing failed.
+   * **If any call fails, the whole answer is `undefined`**, and a failed call's
+   * partial stdout is parsed but never returned: the owned PID set is the
+   * difference between two answers, so a half answer — one image name's
+   * processes without the other's, or a truncated listing — would both miss a
+   * process this run owns and claim one it does not, and killing a process the
+   * run does not own is the one thing **L46** forbids. The row count goes into
+   * the log instead, as the evidence that the command was working.
+   *
+   * @returns The host's emulator processes, or `undefined` when a query failed.
    */
-  async queryHostProcesses() {
-    const query = buildHostProcessQuery();
-    const output = await new Promise((resolve) => {
-      execFile(
-        query.command,
-        query.commandArguments,
-        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },
-        (error, stdout) => {
-          if (error) {
-            this.log(`Warning: could not list host processes (\`${query.command}\`): ${error.message}`);
-          }
-          resolve(error ? "" : stdout);
-        }
-      );
-    });
-    const processes = parseHostProcessList(output);
-    if (processes.length === 0) {
-      this.log(`Warning: \`${query.command}\` listed no processes.`);
-      return void 0;
+  async queryEmulatorProcesses() {
+    const answers = await Promise.all(buildEmulatorProcessQueries(process.platform).map((query) => this.runEmulatorProcessQuery(query)));
+    const processes = [];
+    for (const answer of answers) {
+      if (answer === void 0) {
+        return void 0;
+      }
+      processes.push(...answer);
     }
     return processes;
   }
@@ -114,7 +126,7 @@ class EmulatorReclaimer {
     if (markers.length === 0) {
       return;
     }
-    const processes = await this.queryHostProcesses();
+    const processes = await this.queryEmulatorProcesses();
     if (processes === void 0) {
       this.log(`Cannot judge ${String(markers.length)} emulator marker(s) without a host process listing; leaving them for a later run.`);
       return;
@@ -254,6 +266,48 @@ class EmulatorReclaimer {
       ownedEmulatorPids: selectLiveMarkedPids(marker, liveEmulatorPids)
     });
   }
+  /**
+   * Runs one of the emulator process queries and classifies how it ended.
+   *
+   * @param query - The query.
+   * @returns Its parsed rows, or `undefined` when it failed.
+   */
+  async runEmulatorProcessQuery(query) {
+    const startedAtInMilliseconds = Date.now();
+    const result = await new Promise((resolve) => {
+      execFile(
+        query.command,
+        [...query.commandArguments],
+        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },
+        (error, stdout, stderr) => {
+          resolve({ error, standardError: stderr, standardOutput: stdout });
+        }
+      );
+    });
+    const processes = parseEmulatorProcessQueryOutput({ output: result.standardOutput, query });
+    const outcome = resolveHostProcessQueryOutcome({
+      errorCode: result.error?.code ?? null,
+      hasFailed: result.error !== null,
+      hasReportedNoMatch: checkIsNoMatchReported({ output: result.standardOutput, query }),
+      isKilled: result.error?.killed ?? false,
+      rowCount: processes.length,
+      standardError: result.standardError
+    });
+    const message = buildHostProcessQueryMessage({
+      command: [query.command, ...query.commandArguments].join(" "),
+      elapsedInMilliseconds: Date.now() - startedAtInMilliseconds,
+      exitCode: typeof result.error?.code === "number" ? result.error.code : null,
+      outcome,
+      partialRowCount: processes.length,
+      signal: result.error?.signal ?? null,
+      standardError: result.standardError,
+      timeoutInMilliseconds: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
+    });
+    if (message !== void 0) {
+      this.log(message);
+    }
+    return outcome === "listed" ? processes : void 0;
+  }
   /**
    * Polls until this run's emulator is gone, or the budget elapses.
    *
@@ -273,19 +327,13 @@ class EmulatorReclaimer {
     return false;
   }
 }
-function buildHostProcessQuery() {
-  return process.platform === "win32" ? { command: "tasklist", commandArguments: ["/FO", "CSV", "/NH"] } : { command: "ps", commandArguments: ["-eo", "pid=,comm="] };
-}
 function describeMarkedEmulator(marker) {
   return marker.deviceId === void 0 ? `AVD "${marker.avdName}" (no device: it was still booting when it was recorded)` : `AVD "${marker.avdName}" on device ${marker.deviceId}`;
 }
-function parseHostProcessList(output) {
-  return process.platform === "win32" ? parseWindowsTaskList(output) : parsePosixProcessList(output);
-}
 export {
   ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,
   ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,
   EmulatorReclaimer,
   HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-reclaim.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Stops the emulators this harness started, and **verifies** each stop \u2014 the\n * marker-driven half of emulator ownership (`emulator-marker.ts`, **L56**).\n *\n * It lives apart from `transport-factory.ts` so that a process with no business\n * loading the whole transport stack can still stop an emulator correctly. That\n * process is the emulator reaper (`emulator-reaper.ts`): it runs detached from\n * any test runner, and in this repo's own suites it runs straight from source\n * under Node's type stripping, where a module reading the build-time\n * `OBSIDIAN_METADATA` global \u2014 which the factory's import graph reaches \u2014\n * cannot load at all. So nothing this module imports may reach it either.\n */\n\n/* v8 ignore start -- Integration-time emulator management covered by the Android integration suite, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { execFile } from 'node:child_process';\nimport process from 'node:process';\n\nimport type { ProcessListEntry } from './emulator-backend.mjs';\nimport type { EmulatorMarker } from './emulator-marker.mjs';\n\nimport { checkIsDeviceListed } from './adb-device-list.mjs';\nimport {\n  parsePosixProcessList,\n  parseWindowsTaskList,\n  selectEmulatorBackendPids\n} from './emulator-backend.mjs';\nimport {\n  clearEmulatorMarker,\n  clearEmulatorMarkerIfStopped,\n  listEmulatorMarkers,\n  resolveEmulatorMarkerVerdict,\n  selectLiveMarkedPids\n} from './emulator-marker.mjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.mjs';\nimport { checkIsProcessAlive } from './process-liveness.mjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.mjs';\n\n/**\n * Budget for one quick `adb` call \u2014 `adb devices`, a console command.\n */\nexport const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/*\n * `dumpsys connectivity` is far larger than the other probes' output, and Node's\n * default 1 MiB `maxBuffer` would fail the call rather than truncate it \u2014 which\n * would read as \"not ready\" forever and burn the whole network budget. A host\n * process listing shares the same ceiling.\n */\nexport const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8_388_608;\n\n/*\n * 30s, not the 10s a `tasklist` costs on an idle host: this query runs in the\n * same post-boot contention window that inflates every `adb` round-trip 25-50x\n * (L45), and the first end-to-end run overran a 10s budget there \u2014 silently\n * disarming the teardown escalation. Sized like `ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS`,\n * for the same reason.\n */\nexport const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 30_000;\n\nconst EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 20_000;\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.\n */\nexport interface EmulatorReclaimerReclaimLeftoverEmulatorsParams {\n  /**\n  An AVD whose leftover is left alone \u2014 the one a preflight is about to adopt instead.\n   */\n  readonly exceptAvdName?: string | undefined;\n\n  /**\n   * `'preflight'` spares an emulator another live harness process still owns.\n   * `'end-of-run'` does not: the caller holds the `android` lock with no run in\n   * flight \u2014 the run's own global teardown, or the emulator reaper after the\n   * run is gone \u2014 so that owner can only be one of the finished run's\n   * processes, which no longer has a turn to stop it.\n   */\n  readonly scope: 'end-of-run' | 'preflight';\n}\n\n/**\n * Parameters for {@link EmulatorReclaimer.stopEmulator}.\n */\nexport interface EmulatorReclaimerStopEmulatorParams {\n  /**\n  The AVD name, named in the warning so the leftover is identifiable, and the key of its marker.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device the emulator is serving, shut down over its console and polled\n   * to decide whether it actually stopped. `undefined` when the emulator failed\n   * before any device appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n   * The emulator launcher process this run spawned. `undefined` for a leftover\n   * this run took over, whose launcher belonged to another process.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n  The emulator PIDs this run owns, escalated to when the console and the launcher's tree kill leave one behind.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * A host command and its arguments.\n */\nexport interface HostCommandQuery {\n  /**\n  The executable to run.\n   */\n  readonly command: string;\n\n  /**\n  The command's arguments.\n   */\n  readonly commandArguments: string[];\n}\n\ninterface EmulatorReclaimerCheckIsEmulatorGoneParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared \u2014 the PIDs are then the only proof.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface EmulatorReclaimerWaitForEmulatorStoppedParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  How long to wait for the emulator to disappear, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Finds, stops and verifies the harness's emulators, reporting through the\n * caller's log so each caller keeps its own prefix.\n */\nexport class EmulatorReclaimer {\n  private readonly log: (message: string) => void;\n\n  /**\n   * Creates a reclaimer that reports under the caller's own log prefix.\n   *\n   * @param log - Receives every progress and verdict line.\n   */\n  public constructor(log: (message: string) => void) {\n    this.log = log;\n  }\n\n  /**\n   * Runs `adb devices` and returns its raw stdout.\n   *\n   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only\n   * the `device` state, and an emulator on its way out answers `offline` while\n   * still holding the AVD \u2014 see `adb-device-list.ts`.\n   *\n   * @returns The raw `adb devices` output.\n   * @throws If adb could not be run at all.\n   */\n  public getDevicesOutput(): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n  }\n\n  /**\n   * Lists every process on the host.\n   *\n   * A host always has processes, so a listing that parses to **zero** rows is a\n   * failed query however it exited, and comes back as `undefined` exactly like\n   * one that did not run \u2014 never as an empty list a caller could read as \"no\n   * emulator is running\".\n   *\n   * @returns The host's processes, or `undefined` when the listing failed.\n   */\n  public async queryHostProcesses(): Promise<ProcessListEntry[] | undefined> {\n    const query = buildHostProcessQuery();\n    const output = await new Promise<string>((resolve) => {\n      execFile(\n        query.command,\n        query.commandArguments,\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          if (error) {\n            this.log(`Warning: could not list host processes (\\`${query.command}\\`): ${error.message}`);\n          }\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n\n    const processes = parseHostProcessList(output);\n    if (processes.length === 0) {\n      this.log(`Warning: \\`${query.command}\\` listed no processes.`);\n      return undefined;\n    }\n\n    return processes;\n  }\n\n  /**\n   * Stops the emulators this harness started that no live run is responsible\n   * for, and drops the markers that no longer describe a running emulator.\n   *\n   * Only ever acts on a **marker-verified** emulator: one whose marker names a\n   * PID that is still a live emulator process. An emulator without a marker \u2014\n   * booted by hand, by CI, or by another tool \u2014 is never touched, which keeps\n   * the L46 line: never a `qemu*` sweep.\n   *\n   * Callers must hold the `android` setup lock (L7), which is what makes a\n   * leftover safe to stop: no other Android run can be mid-flight on it.\n   *\n   * @param params - Which AVD to leave alone, and whether this run is ending.\n   */\n  public async reclaimLeftoverEmulators(params: EmulatorReclaimerReclaimLeftoverEmulatorsParams): Promise<void> {\n    const markers = listEmulatorMarkers().filter((marker) => marker.avdName !== params.exceptAvdName);\n    if (markers.length === 0) {\n      return;\n    }\n\n    const processes = await this.queryHostProcesses();\n    if (processes === undefined) {\n      // Without a listing every marker would read as stale, and deleting them would leave the leftovers impossible to convict.\n      this.log(`Cannot judge ${String(markers.length)} emulator marker(s) without a host process listing; leaving them for a later run.`);\n      return;\n    }\n\n    const liveEmulatorPids = selectEmulatorBackendPids({ knownPids: [], processes });\n    for (const marker of markers) {\n      await this.reclaimLeftoverEmulator(marker, liveEmulatorPids, params.scope);\n    }\n  }\n\n  /**\n   * Stops an emulator this harness owns, and **verifies** it stopped.\n   *\n   * The console shutdown goes first because it is the only path that releases\n   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a\n   * stale lock is what makes the next run fail with `Running multiple emulators\n   * with the same AVD` \u2014 a FATAL the emulator writes to its own stdout, where\n   * nobody sees it.\n   *\n   * Works without a launcher handle too: a leftover this run took over has only\n   * its PIDs, which is all the escalation below ever needed. The marker goes\n   * only with a **verified** stop, so an emulator that outlived this attempt\n   * stays convictable by the next one.\n   *\n   * @param params - The emulator process, the device it serves and the PIDs this run owns.\n   */\n  public async stopEmulator(params: EmulatorReclaimerStopEmulatorParams): Promise<void> {\n    if (params.deviceId !== undefined) {\n      await this.killEmulatorConsole(params.deviceId);\n    }\n    if (params.emulatorProcess) {\n      killProcessTree(params.emulatorProcess);\n    }\n\n    const waitParams: EmulatorReclaimerWaitForEmulatorStoppedParams = {\n      deviceId: params.deviceId,\n      ownedEmulatorPids: params.ownedEmulatorPids,\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    };\n\n    let hasEscalated = false;\n    let isStopped = await this.waitForEmulatorStopped(waitParams);\n\n    if (!isStopped) {\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      if (survivingPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started emulator outlived its console shutdown and the launcher's process tree; escalating to the emulator PID(s) this run owns: [${survivingPids.join(', ')}].`\n        );\n        for (const pid of survivingPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: params.deviceId === undefined ? `AVD \"${params.avdName}\"` : `AVD \"${params.avdName}\" on device ${params.deviceId}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started emulator',\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n\n    if (isStopped) {\n      clearEmulatorMarkerIfStopped(params.avdName);\n    }\n  }\n\n  /**\n   * Decides whether the emulator this run started is really gone.\n   *\n   * Two independent proofs, cheapest first: none of the PIDs this run owns is\n   * alive, and the device no longer appears in `adb devices` **in any state** (a\n   * dying emulator answers `offline` while it still holds the AVD).\n   *\n   * @param params - The device and the PIDs this run owns.\n   * @returns `true` when nothing of this run's emulator is left.\n   */\n  private async checkIsEmulatorGone(params: EmulatorReclaimerCheckIsEmulatorGoneParams): Promise<boolean> {\n    if (params.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid))) {\n      return false;\n    }\n\n    if (params.deviceId === undefined) {\n      return true;\n    }\n\n    try {\n      return !checkIsDeviceListed({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });\n    } catch (error: unknown) {\n      /*\n       * An adb that cannot run is not evidence about the emulator \u2014 and the PID\n       * probe above has already said this run's processes are gone, which is the\n       * stronger of the two proofs.\n       */\n      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);\n      return true;\n    }\n  }\n\n  /**\n   * Asks the emulator to shut itself down over its console.\n   *\n   * Preferred over killing the process outright because it is the path that\n   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does\n   * not answer is reported and the caller falls through to the kill.\n   *\n   * @param deviceId - The emulator's device ID.\n   */\n  private killEmulatorConsole(deviceId: string): Promise<void> {\n    return new Promise<void>((resolve) => {\n      execFile('adb', ['-s', deviceId, 'emu', 'kill'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {\n        this.log(\n          error\n            ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}`\n            : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`\n        );\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.\n   *\n   * @param marker - The marker to judge.\n   * @param liveEmulatorPids - The emulator processes currently running on the host.\n   * @param scope - Whether an emulator another live harness process owns is spared.\n   */\n  private async reclaimLeftoverEmulator(marker: EmulatorMarker, liveEmulatorPids: readonly number[], scope: EmulatorReclaimerReclaimLeftoverEmulatorsParams['scope']): Promise<void> {\n    const verdict = resolveEmulatorMarkerVerdict({\n      currentPid: process.pid,\n      isOwnerAlive: checkIsProcessAlive(marker.ownerPid),\n      liveEmulatorPids,\n      marker\n    });\n\n    if (verdict === 'stale-marker') {\n      this.log(`Dropping the emulator marker for AVD \"${marker.avdName}\": none of its PIDs [${marker.ownedEmulatorPids.join(', ')}] is a running emulator any more.`);\n      clearEmulatorMarker(marker.avdName);\n      return;\n    }\n\n    /*\n     * A marker written at launch has no device yet: the emulator was still\n     * booting when whatever recorded it stopped looking. The stop below reads\n     * that absence correctly \u2014 no console to shut down, the owned PIDs are the\n     * whole of the evidence \u2014 so it is described rather than papered over.\n     */\n    const evidence = describeMarkedEmulator(marker);\n\n    if (verdict === 'in-use-by-live-run' && scope === 'preflight') {\n      this.log(`Leaving the emulator for ${evidence} alone: the harness process that owns it (PID ${String(marker.ownerPid)}) is still running.`);\n      return;\n    }\n\n    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    this.log(\n      `Stopping the emulator for ${evidence}: this harness started it ${String(ageInSeconds)}s ago, and no live run is left to stop it.`\n    );\n    await this.stopEmulator({\n      avdName: marker.avdName,\n      deviceId: marker.deviceId,\n      ownedEmulatorPids: selectLiveMarkedPids(marker, liveEmulatorPids)\n    });\n  }\n\n  /**\n   * Polls until this run's emulator is gone, or the budget elapses.\n   *\n   * @param params - The device, the PIDs this run owns, and the budget.\n   * @returns `true` when the emulator disappeared within the budget.\n   */\n  private async waitForEmulatorStopped(params: EmulatorReclaimerWaitForEmulatorStoppedParams): Promise<boolean> {\n    const deadline = Date.now() + params.timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      if (await this.checkIsEmulatorGone(params)) {\n        return true;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return false;\n  }\n}\n\n/**\n * Builds the platform's \"list every process\" query.\n *\n * @returns The command and arguments to run.\n */\nfunction buildHostProcessQuery(): HostCommandQuery {\n  return process.platform === 'win32'\n    ? { command: 'tasklist', commandArguments: ['/FO', 'CSV', '/NH'] }\n    : { command: 'ps', commandArguments: ['-eo', 'pid=,comm='] };\n}\n\n/**\n * Names the emulator a marker describes, for the log.\n *\n * @param marker - The marker.\n * @returns The AVD and its device, or the AVD alone for a launch that had not produced a device yet.\n */\nfunction describeMarkedEmulator(marker: EmulatorMarker): string {\n  return marker.deviceId === undefined\n    ? `AVD \"${marker.avdName}\" (no device: it was still booting when it was recorded)`\n    : `AVD \"${marker.avdName}\" on device ${marker.deviceId}`;\n}\n\n/**\n * Parses a host process listing with the platform's parser.\n *\n * @param output - Raw stdout of {@link buildHostProcessQuery}'s command.\n * @returns The listed processes.\n */\nfunction parseHostProcessList(output: string): ProcessListEntry[] {\n  return process.platform === 'win32' ? parseWindowsTaskList(output) : parsePosixProcessList(output);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-reclaim.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Stops the emulators this harness started, and **verifies** each stop \u2014 the\n * marker-driven half of emulator ownership (`emulator-marker.ts`, **L56**).\n *\n * It lives apart from `transport-factory.ts` so that a process with no business\n * loading the whole transport stack can still stop an emulator correctly. That\n * process is the emulator reaper (`emulator-reaper.ts`): it runs detached from\n * any test runner, and in this repo's own suites it runs straight from source\n * under Node's type stripping, where a module reading the build-time\n * `OBSIDIAN_METADATA` global \u2014 which the factory's import graph reaches \u2014\n * cannot load at all. So nothing this module imports may reach it either.\n */\n\n/* v8 ignore start -- Integration-time emulator management covered by the Android integration suite, not unit tests. */\n\nimport type {\n  ChildProcess,\n  ExecFileException\n} from 'node:child_process';\n\nimport { execFile } from 'node:child_process';\nimport process from 'node:process';\n\nimport type {\n  EmulatorProcessQuery,\n  ProcessListEntry\n} from './emulator-backend.mjs';\nimport type { EmulatorMarker } from './emulator-marker.mjs';\n\nimport { checkIsDeviceListed } from './adb-device-list.mjs';\nimport {\n  buildEmulatorProcessQueries,\n  checkIsNoMatchReported,\n  parseEmulatorProcessQueryOutput,\n  selectEmulatorBackendPids\n} from './emulator-backend.mjs';\nimport {\n  clearEmulatorMarker,\n  clearEmulatorMarkerIfStopped,\n  listEmulatorMarkers,\n  resolveEmulatorMarkerVerdict,\n  selectLiveMarkedPids\n} from './emulator-marker.mjs';\nimport {\n  buildHostProcessQueryMessage,\n  resolveHostProcessQueryOutcome\n} from './host-process-query-verdict.mjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.mjs';\nimport { checkIsProcessAlive } from './process-liveness.mjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.mjs';\n\n/**\n * Budget for one quick `adb` call \u2014 `adb devices`, a console command.\n */\nexport const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/*\n * `dumpsys connectivity` is far larger than the other probes' output, and Node's\n * default 1 MiB `maxBuffer` would fail the call rather than truncate it \u2014 which\n * would read as \"not ready\" forever and burn the whole network budget. A host\n * process listing shares the same ceiling.\n */\nexport const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8_388_608;\n\n/*\n * 120s, not the ~1s a whole-host `tasklist` costs on an idle host: this query\n * runs in the same post-boot contention window that inflates every `adb`\n * round-trip 25-50x (L45), and as a whole-host listing it was the most\n * contention-sensitive call the harness made \u2014 it walked every process on the\n * host, so it paid the host's slowdown ~540 times over.\n *\n * The two earlier numbers were both guesses, and both were too small. 10s was\n * overrun on the first end-to-end run. 30s then failed **every** Android run\n * from one host (measured 2026-09-20 across three runs and two AVDs), each time\n * killing the child at ~30s with nothing on stderr \u2014 the shape that reads as an\n * unexplained spawn failure and silently disarms the escalation.\n *\n * So this one is measured instead. Traced with no budget at all during an\n * emulator boot on that host (2026-09-23, n=40): p50 2.9s, p75 4.4s, p90 17.8s,\n * p95 29.1s, max **92.2s**. Every one of the 40 completed the full ~530-row\n * listing and exited within 55ms of its last row, so none of them was hung \u2014\n * the cost is spread across the rows, in 1.0-2.7s pauses on individual\n * processes. 30s therefore cut off the top 2.5% of a distribution whose tail\n * reaches 92s, and a real run \u2014 which boots the emulator, starts Appium,\n * installs the app and runs Vitest at once \u2014 is more contended than that trace.\n *\n * 120s is ~1.3x the worst observed call, and costs nothing at the median.\n *\n * **That tail belonged to the whole-host listing, which Windows no longer\n * makes.** The query is now filtered to the emulator image names\n * (`buildEmulatorProcessQueries`), and the filtered call skips the per-process\n * work the tail was made of: with every core saturated it never exceeded 505ms\n * where the whole-host call stalled for 120.9s. The budget stays at 120s as a\n * ceiling rather than a forecast \u2014 it costs nothing when the call is fast, and\n * POSIX still lists the whole host. If a filtered call ever overruns it, the\n * next step is not a fifth number but deriving ownership without a process\n * listing at all.\n */\nexport const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 120_000;\n\nconst EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 20_000;\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.\n */\nexport interface EmulatorReclaimerReclaimLeftoverEmulatorsParams {\n  /**\n  An AVD whose leftover is left alone \u2014 the one a preflight is about to adopt instead.\n   */\n  readonly exceptAvdName?: string | undefined;\n\n  /**\n   * `'preflight'` spares an emulator another live harness process still owns.\n   * `'end-of-run'` does not: the caller holds the `android` lock with no run in\n   * flight \u2014 the run's own global teardown, or the emulator reaper after the\n   * run is gone \u2014 so that owner can only be one of the finished run's\n   * processes, which no longer has a turn to stop it.\n   */\n  readonly scope: 'end-of-run' | 'preflight';\n}\n\n/**\n * Parameters for {@link EmulatorReclaimer.stopEmulator}.\n */\nexport interface EmulatorReclaimerStopEmulatorParams {\n  /**\n  The AVD name, named in the warning so the leftover is identifiable, and the key of its marker.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device the emulator is serving, shut down over its console and polled\n   * to decide whether it actually stopped. `undefined` when the emulator failed\n   * before any device appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n   * The emulator launcher process this run spawned. `undefined` for a leftover\n   * this run took over, whose launcher belonged to another process.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n  The emulator PIDs this run owns, escalated to when the console and the launcher's tree kill leave one behind.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\n/**\n * A host command and its arguments.\n */\nexport interface HostCommandQuery {\n  /**\n  The executable to run.\n   */\n  readonly command: string;\n\n  /**\n  The command's arguments.\n   */\n  readonly commandArguments: string[];\n}\n\n/**\n * Everything one host process listing left behind, kept together so the\n * classification sees the whole picture.\n *\n * `execFile`'s callback discards nothing here \u2014 not stderr, and not a *failed*\n * call's partial stdout. The old code kept only `error.message`, which for\n * `execFile` is `Command failed: <cmd>` plus stderr, so a killed child (empty\n * stderr) produced a line naming the command and nothing else.\n */\nexport interface HostProcessQueryResult {\n  /**\n  `execFile`'s error, or `null` when the listing succeeded.\n   */\n  readonly error: ExecFileException | null;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  Whatever the child wrote to stdout \u2014 a partial listing when the call failed part-way.\n   */\n  readonly standardOutput: string;\n}\n\ninterface EmulatorReclaimerCheckIsEmulatorGoneParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared \u2014 the PIDs are then the only proof.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface EmulatorReclaimerWaitForEmulatorStoppedParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  How long to wait for the emulator to disappear, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Finds, stops and verifies the harness's emulators, reporting through the\n * caller's log so each caller keeps its own prefix.\n */\nexport class EmulatorReclaimer {\n  private readonly log: (message: string) => void;\n\n  /**\n   * Creates a reclaimer that reports under the caller's own log prefix.\n   *\n   * @param log - Receives every progress and verdict line.\n   */\n  public constructor(log: (message: string) => void) {\n    this.log = log;\n  }\n\n  /**\n   * Runs `adb devices` and returns its raw stdout.\n   *\n   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only\n   * the `device` state, and an emulator on its way out answers `offline` while\n   * still holding the AVD \u2014 see `adb-device-list.ts`.\n   *\n   * @returns The raw `adb devices` output.\n   * @throws If adb could not be run at all.\n   */\n  public getDevicesOutput(): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n  }\n\n  /**\n   * Lists the host's emulator processes \u2014 every process whose image name could\n   * be the launcher or a QEMU backend, and on POSIX every process on the host.\n   *\n   * On Windows this is two **filtered** `tasklist` calls rather than one\n   * whole-host listing (`buildEmulatorProcessQueries` carries the measurement\n   * that made the switch), run in parallel. A filtered call may legitimately\n   * find nothing, but only when it says so: a clean exit with neither a row nor\n   * `tasklist`'s own no-match notice is still a failed query, and comes back as\n   * `undefined` exactly like one that did not run \u2014 never as an empty list a\n   * caller could read as \"no emulator is running\".\n   *\n   * Each failed call logs **one** line, from `host-process-query-verdict.ts`,\n   * naming which way it failed. The predecessor logged two contradictory ones\n   * for a single failure \u2014 `could not list host processes` immediately followed\n   * by `listed no processes` \u2014 because a failed call resolved `''`, which then\n   * parsed to zero rows and tripped the zero-row check as well.\n   *\n   * **If any call fails, the whole answer is `undefined`**, and a failed call's\n   * partial stdout is parsed but never returned: the owned PID set is the\n   * difference between two answers, so a half answer \u2014 one image name's\n   * processes without the other's, or a truncated listing \u2014 would both miss a\n   * process this run owns and claim one it does not, and killing a process the\n   * run does not own is the one thing **L46** forbids. The row count goes into\n   * the log instead, as the evidence that the command was working.\n   *\n   * @returns The host's emulator processes, or `undefined` when a query failed.\n   */\n  public async queryEmulatorProcesses(): Promise<ProcessListEntry[] | undefined> {\n    const answers = await Promise.all(buildEmulatorProcessQueries(process.platform).map((query) => this.runEmulatorProcessQuery(query)));\n    const processes: ProcessListEntry[] = [];\n    for (const answer of answers) {\n      if (answer === undefined) {\n        return undefined;\n      }\n      processes.push(...answer);\n    }\n\n    return processes;\n  }\n\n  /**\n   * Stops the emulators this harness started that no live run is responsible\n   * for, and drops the markers that no longer describe a running emulator.\n   *\n   * Only ever acts on a **marker-verified** emulator: one whose marker names a\n   * PID that is still a live emulator process. An emulator without a marker \u2014\n   * booted by hand, by CI, or by another tool \u2014 is never touched, which keeps\n   * the L46 line: never a `qemu*` sweep.\n   *\n   * Callers must hold the `android` setup lock (L7), which is what makes a\n   * leftover safe to stop: no other Android run can be mid-flight on it.\n   *\n   * @param params - Which AVD to leave alone, and whether this run is ending.\n   */\n  public async reclaimLeftoverEmulators(params: EmulatorReclaimerReclaimLeftoverEmulatorsParams): Promise<void> {\n    const markers = listEmulatorMarkers().filter((marker) => marker.avdName !== params.exceptAvdName);\n    if (markers.length === 0) {\n      return;\n    }\n\n    const processes = await this.queryEmulatorProcesses();\n    if (processes === undefined) {\n      // Without a listing every marker would read as stale, and deleting them would leave the leftovers impossible to convict.\n      this.log(`Cannot judge ${String(markers.length)} emulator marker(s) without a host process listing; leaving them for a later run.`);\n      return;\n    }\n\n    const liveEmulatorPids = selectEmulatorBackendPids({ knownPids: [], processes });\n    for (const marker of markers) {\n      await this.reclaimLeftoverEmulator(marker, liveEmulatorPids, params.scope);\n    }\n  }\n\n  /**\n   * Stops an emulator this harness owns, and **verifies** it stopped.\n   *\n   * The console shutdown goes first because it is the only path that releases\n   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a\n   * stale lock is what makes the next run fail with `Running multiple emulators\n   * with the same AVD` \u2014 a FATAL the emulator writes to its own stdout, where\n   * nobody sees it.\n   *\n   * Works without a launcher handle too: a leftover this run took over has only\n   * its PIDs, which is all the escalation below ever needed. The marker goes\n   * only with a **verified** stop, so an emulator that outlived this attempt\n   * stays convictable by the next one.\n   *\n   * @param params - The emulator process, the device it serves and the PIDs this run owns.\n   */\n  public async stopEmulator(params: EmulatorReclaimerStopEmulatorParams): Promise<void> {\n    if (params.deviceId !== undefined) {\n      await this.killEmulatorConsole(params.deviceId);\n    }\n    if (params.emulatorProcess) {\n      killProcessTree(params.emulatorProcess);\n    }\n\n    const waitParams: EmulatorReclaimerWaitForEmulatorStoppedParams = {\n      deviceId: params.deviceId,\n      ownedEmulatorPids: params.ownedEmulatorPids,\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    };\n\n    let hasEscalated = false;\n    let isStopped = await this.waitForEmulatorStopped(waitParams);\n\n    if (!isStopped) {\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      if (survivingPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started emulator outlived its console shutdown and the launcher's process tree; escalating to the emulator PID(s) this run owns: [${survivingPids.join(', ')}].`\n        );\n        for (const pid of survivingPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: params.deviceId === undefined ? `AVD \"${params.avdName}\"` : `AVD \"${params.avdName}\" on device ${params.deviceId}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started emulator',\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n\n    if (isStopped) {\n      clearEmulatorMarkerIfStopped(params.avdName);\n    }\n  }\n\n  /**\n   * Decides whether the emulator this run started is really gone.\n   *\n   * Two independent proofs, cheapest first: none of the PIDs this run owns is\n   * alive, and the device no longer appears in `adb devices` **in any state** (a\n   * dying emulator answers `offline` while it still holds the AVD).\n   *\n   * @param params - The device and the PIDs this run owns.\n   * @returns `true` when nothing of this run's emulator is left.\n   */\n  private async checkIsEmulatorGone(params: EmulatorReclaimerCheckIsEmulatorGoneParams): Promise<boolean> {\n    if (params.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid))) {\n      return false;\n    }\n\n    if (params.deviceId === undefined) {\n      return true;\n    }\n\n    try {\n      return !checkIsDeviceListed({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });\n    } catch (error: unknown) {\n      /*\n       * An adb that cannot run is not evidence about the emulator \u2014 and the PID\n       * probe above has already said this run's processes are gone, which is the\n       * stronger of the two proofs.\n       */\n      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);\n      return true;\n    }\n  }\n\n  /**\n   * Asks the emulator to shut itself down over its console.\n   *\n   * Preferred over killing the process outright because it is the path that\n   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does\n   * not answer is reported and the caller falls through to the kill.\n   *\n   * @param deviceId - The emulator's device ID.\n   */\n  private killEmulatorConsole(deviceId: string): Promise<void> {\n    return new Promise<void>((resolve) => {\n      execFile('adb', ['-s', deviceId, 'emu', 'kill'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {\n        this.log(\n          error\n            ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}`\n            : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`\n        );\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.\n   *\n   * @param marker - The marker to judge.\n   * @param liveEmulatorPids - The emulator processes currently running on the host.\n   * @param scope - Whether an emulator another live harness process owns is spared.\n   */\n  private async reclaimLeftoverEmulator(marker: EmulatorMarker, liveEmulatorPids: readonly number[], scope: EmulatorReclaimerReclaimLeftoverEmulatorsParams['scope']): Promise<void> {\n    const verdict = resolveEmulatorMarkerVerdict({\n      currentPid: process.pid,\n      isOwnerAlive: checkIsProcessAlive(marker.ownerPid),\n      liveEmulatorPids,\n      marker\n    });\n\n    if (verdict === 'stale-marker') {\n      this.log(`Dropping the emulator marker for AVD \"${marker.avdName}\": none of its PIDs [${marker.ownedEmulatorPids.join(', ')}] is a running emulator any more.`);\n      clearEmulatorMarker(marker.avdName);\n      return;\n    }\n\n    /*\n     * A marker written at launch has no device yet: the emulator was still\n     * booting when whatever recorded it stopped looking. The stop below reads\n     * that absence correctly \u2014 no console to shut down, the owned PIDs are the\n     * whole of the evidence \u2014 so it is described rather than papered over.\n     */\n    const evidence = describeMarkedEmulator(marker);\n\n    if (verdict === 'in-use-by-live-run' && scope === 'preflight') {\n      this.log(`Leaving the emulator for ${evidence} alone: the harness process that owns it (PID ${String(marker.ownerPid)}) is still running.`);\n      return;\n    }\n\n    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    this.log(\n      `Stopping the emulator for ${evidence}: this harness started it ${String(ageInSeconds)}s ago, and no live run is left to stop it.`\n    );\n    await this.stopEmulator({\n      avdName: marker.avdName,\n      deviceId: marker.deviceId,\n      ownedEmulatorPids: selectLiveMarkedPids(marker, liveEmulatorPids)\n    });\n  }\n\n  /**\n   * Runs one of the emulator process queries and classifies how it ended.\n   *\n   * @param query - The query.\n   * @returns Its parsed rows, or `undefined` when it failed.\n   */\n  private async runEmulatorProcessQuery(query: EmulatorProcessQuery): Promise<ProcessListEntry[] | undefined> {\n    const startedAtInMilliseconds = Date.now();\n    const result = await new Promise<HostProcessQueryResult>((resolve) => {\n      execFile(\n        query.command,\n        [...query.commandArguments],\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout, stderr) => {\n          resolve({ error, standardError: stderr, standardOutput: stdout });\n        }\n      );\n    });\n\n    const processes = parseEmulatorProcessQueryOutput({ output: result.standardOutput, query });\n    const outcome = resolveHostProcessQueryOutcome({\n      errorCode: result.error?.code ?? null,\n      hasFailed: result.error !== null,\n      hasReportedNoMatch: checkIsNoMatchReported({ output: result.standardOutput, query }),\n      isKilled: result.error?.killed ?? false,\n      rowCount: processes.length,\n      standardError: result.standardError\n    });\n\n    const message = buildHostProcessQueryMessage({\n      command: [query.command, ...query.commandArguments].join(' '),\n      elapsedInMilliseconds: Date.now() - startedAtInMilliseconds,\n      exitCode: typeof result.error?.code === 'number' ? result.error.code : null,\n      outcome,\n      partialRowCount: processes.length,\n      signal: result.error?.signal ?? null,\n      standardError: result.standardError,\n      timeoutInMilliseconds: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS\n    });\n    if (message !== undefined) {\n      this.log(message);\n    }\n\n    return outcome === 'listed' ? processes : undefined;\n  }\n\n  /**\n   * Polls until this run's emulator is gone, or the budget elapses.\n   *\n   * @param params - The device, the PIDs this run owns, and the budget.\n   * @returns `true` when the emulator disappeared within the budget.\n   */\n  private async waitForEmulatorStopped(params: EmulatorReclaimerWaitForEmulatorStoppedParams): Promise<boolean> {\n    const deadline = Date.now() + params.timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      if (await this.checkIsEmulatorGone(params)) {\n        return true;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return false;\n  }\n}\n\n/**\n * Names the emulator a marker describes, for the log.\n *\n * @param marker - The marker.\n * @returns The AVD and its device, or the AVD alone for a launch that had not produced a device yet.\n */\nfunction describeMarkedEmulator(marker: EmulatorMarker): string {\n  return marker.deviceId === undefined\n    ? `AVD \"${marker.avdName}\" (no device: it was still booting when it was recorded)`\n    : `AVD \"${marker.avdName}\" on device ${marker.deviceId}`;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/enable-plugin.d.mts

@@ -49,7 +49,9 @@ export interface EnablePluginResult {
  *
  * Monkey-patches `app.plugins.loadPlugin` to intercept errors before
  * Obsidian's `enablePlugin` try-catch swallows them. The original method
- * is always restored in a `finally` block.
+ * is restored in a `finally` block — but only while the patch this function
+ * installed is still the one in place, so a plugin that patched the same slot
+ * during its own load keeps its patch.
  *
  * Designed to be passed as the `callback` argument to {@link evalInObsidian}.
  *

package/dist/lib/esm/enable-plugin.mjs

@@ -18,6 +18,7 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
       throw error;
     }
   };
+  const ourLoadPlugin = app.plugins.loadPlugin;
   const capturedConsole = [];
   const formatHolder = globalThis;
   function formatArgument(argument) {
@@ -38,14 +39,16 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
   }
   const origConsoleError = console.error;
   const origConsoleWarn = console.warn;
-  console.error = (...input) => {
+  function ourConsoleError(...input) {
     recordConsole(...input);
     origConsoleError.apply(console, input);
-  };
-  console.warn = (...input) => {
+  }
+  function ourConsoleWarn(...input) {
     recordConsole(...input);
     origConsoleWarn.apply(console, input);
-  };
+  }
+  console.error = ourConsoleError;
+  console.warn = ourConsoleWarn;
   function onWindowError(event) {
     capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);
   }
@@ -57,9 +60,15 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
   try {
     await app.plugins.enablePluginAndSave(pluginId);
   } finally {
-    app.plugins.loadPlugin = origLoadPlugin;
-    console.error = origConsoleError;
-    console.warn = origConsoleWarn;
+    if (app.plugins.loadPlugin === ourLoadPlugin) {
+      app.plugins.loadPlugin = origLoadPlugin;
+    }
+    if (console.error === ourConsoleError) {
+      console.error = origConsoleError;
+    }
+    if (console.warn === ourConsoleWarn) {
+      console.warn = origConsoleWarn;
+    }
     globalThis.removeEventListener("error", onWindowError);
     globalThis.removeEventListener("unhandledrejection", onUnhandledRejection);
   }
@@ -83,4 +92,4 @@ export {
   enablePluginWithErrorCapture,
   getGenericPluginLoadFailureMessage
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArguments } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString: (error: unknown) => string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is always restored in a `finally` block.\n *\n * Designed to be passed as the `callback` argument to {@link evalInObsidian}.\n *\n * @param input - The common input plus the plugin ID.\n * @param input.app - The Obsidian app instance.\n * @param input.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArguments & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n      const holder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n  function formatArgument(argument: unknown): string {\n    if (argument instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);\n    }\n    if (typeof argument === 'string') {\n      return argument;\n    }\n    if (argument === undefined || argument === null) {\n      return String(argument);\n    }\n    const json = JSON.stringify(argument);\n    return json ?? Object.prototype.toString.call(argument);\n  }\n  function recordConsole(...input: unknown[]): void {\n    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  console.error = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleError.apply(console, input);\n  };\n  console.warn = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleWarn.apply(console, input);\n  };\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArgument(event.reason));\n  }\n  globalThis.addEventListener('error', onWindowError);\n  globalThis.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Intentional restore of monkey-patch.\n    app.plugins.loadPlugin = origLoadPlugin;\n    console.error = origConsoleError;\n    console.warn = origConsoleWarn;\n    globalThis.removeEventListener('error', onWindowError);\n    globalThis.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined || undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA+EA,eAAsB,6BAA6B,EAAE,KAAK,SAAS,GAAsE;AACvI,MAAI,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5B,UAAM,IAAI,QAAQ,UAAU,IAAI;AAAA,EAClC;AASA,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,KAAK,CAAC,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ,GAAG;AAC7F,UAAM,IAAI,QAAQ,qBAAqB,QAAQ;AAAA,EACjD;AAEA,MAAI;AAEJ,QAAM,iBAAiB,IAAI,QAAQ;AACnC,MAAI,QAAQ,aAAa,eAAe,WAAW,IAAY,eAA0C;AACvG,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,KAAK,MAAM,IAAI,aAAa;AAChE,qBAAe;AACf,aAAO;AAAA,IACT,SAAS,OAAO;AAEd,YAAM,SAAS;AACf,qBAAe,OAAO,8BAA8B,cAAc,KAAK,KAAK,OAAO,KAAK;AACxF,YAAM;AAAA,IACR;AAAA,EACF;AAUA,QAAM,kBAA4B,CAAC;AAEnC,QAAM,eAAe;AACrB,WAAS,eAAe,UAA2B;AACjD,QAAI,oBAAoB,OAAO;AAC7B,aAAO,aAAa,8BAA8B,cAAc,QAAQ,KAAK,OAAO,QAAQ;AAAA,IAC9F;AACA,QAAI,OAAO,aAAa,UAAU;AAChC,aAAO;AAAA,IACT;AACA,QAAI,aAAa,UAAa,aAAa,MAAM;AAC/C,aAAO,OAAO,QAAQ;AAAA,IACxB;AACA,UAAM,OAAO,KAAK,UAAU,QAAQ;AACpC,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,QAAQ;AAAA,EACxD;AACA,WAAS,iBAAiB,OAAwB;AAChD,oBAAgB,KAAK,MAAM,IAAI,CAAC,aAAa,eAAe,QAAQ,CAAC,EAAE,KAAK,GAAG,CAAC;AAAA,EAClF;AACA,QAAM,mBAAmB,QAAQ;AACjC,QAAM,kBAAkB,QAAQ;AAChC,UAAQ,QAAQ,IAAI,UAA2B;AAC7C,kBAAc,GAAG,KAAK;AACtB,qBAAiB,MAAM,SAAS,KAAK;AAAA,EACvC;AACA,UAAQ,OAAO,IAAI,UAA2B;AAC5C,kBAAc,GAAG,KAAK;AACtB,oBAAgB,MAAM,SAAS,KAAK;AAAA,EACtC;AACA,WAAS,cAAc,OAAyB;AAC9C,oBAAgB,KAAK,MAAM,iBAAiB,QAAQ,eAAe,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACjG;AACA,WAAS,qBAAqB,OAAoC;AAChE,oBAAgB,KAAK,eAAe,MAAM,MAAM,CAAC;AAAA,EACnD;AACA,aAAW,iBAAiB,SAAS,aAAa;AAClD,aAAW,iBAAiB,sBAAsB,oBAAoB;AAEtE,MAAI;AACF,UAAM,IAAI,QAAQ,oBAAoB,QAAQ;AAAA,EAChD,UAAE;AAEA,QAAI,QAAQ,aAAa;AACzB,YAAQ,QAAQ;AAChB,YAAQ,OAAO;AACf,eAAW,oBAAoB,SAAS,aAAa;AACrD,eAAW,oBAAoB,sBAAsB,oBAAoB;AAAA,EAC3E;AAEA,QAAM,WAAW,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ;AAE5D,MAAI;AACJ,MAAI,CAAC,gBAAgB,CAAC,UAAU;AAC9B,UAAM,SAAS,gBAAgB,KAAK,IAAI,EAAE,KAAK;AAC/C,4BAAwB,UAAU;AAAA,EACpC;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAW,IAAI,QAAQ,eAAe,IAAI,QAAQ;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAeO,SAAS,mCAAmC,UAA0B;AAC3E,SAAO,WAAW,QAAQ;AAG5B;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArguments } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString: (error: unknown) => string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is restored in a `finally` block \u2014 but only while the patch this function\n * installed is still the one in place, so a plugin that patched the same slot\n * during its own load keeps its patch.\n *\n * Designed to be passed as the `callback` argument to {@link evalInObsidian}.\n *\n * @param input - The common input plus the plugin ID.\n * @param input.app - The Obsidian app instance.\n * @param input.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArguments & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n      const holder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n  /*\n   * Read the wrapper back so the `finally` can tell \"still ours\" from \"someone patched over us\". Assigning\n   * it through `app.plugins.loadPlugin` rather than declaring it standalone is what types its `this`.\n   */\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Reading back the patch just installed, to restore it conditionally.\n  const ourLoadPlugin = app.plugins.loadPlugin;\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n  function formatArgument(argument: unknown): string {\n    if (argument instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);\n    }\n    if (typeof argument === 'string') {\n      return argument;\n    }\n    if (argument === undefined || argument === null) {\n      return String(argument);\n    }\n    const json = JSON.stringify(argument);\n    return json ?? Object.prototype.toString.call(argument);\n  }\n  function recordConsole(...input: unknown[]): void {\n    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  function ourConsoleError(...input: unknown[]): void {\n    recordConsole(...input);\n    origConsoleError.apply(console, input);\n  }\n  function ourConsoleWarn(...input: unknown[]): void {\n    recordConsole(...input);\n    origConsoleWarn.apply(console, input);\n  }\n  console.error = ourConsoleError;\n  console.warn = ourConsoleWarn;\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArgument(event.reason));\n  }\n  globalThis.addEventListener('error', onWindowError);\n  globalThis.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    /*\n     * Restore ONLY what this function installed. The plugin under test loads INSIDE the `try` above, so its\n     * `onload` runs before this line \u2014 and a plugin that monkey-patches any of these three slots there writes\n     * an own property over ours (the shape `monkey-around` produces). An unconditional restore puts back the\n     * value read before that plugin existed, deleting its patch with no error and no warning; `loadPlugin` is\n     * the only complete seam for observing `app.plugins.plugins` move, so a plugin reaching for it is ordinary\n     * rather than exotic. The guard is `monkey-around`'s own uninstaller discipline (`if (obj[method] ===\n     * wrapper)`): when someone patched over us, leaving the chain alone is the correct no-op \u2014 our wrapper is\n     * still in it, one level down, and unwinds when that plugin unpatches.\n     */\n    if (app.plugins.loadPlugin === ourLoadPlugin) {\n      app.plugins.loadPlugin = origLoadPlugin;\n    }\n    if (console.error === ourConsoleError) {\n      console.error = origConsoleError;\n    }\n    if (console.warn === ourConsoleWarn) {\n      console.warn = origConsoleWarn;\n    }\n    globalThis.removeEventListener('error', onWindowError);\n    globalThis.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined || undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -187,6 +187,18 @@ export interface Lib {
      * the renderer cannot produce a trusted event itself — so a missing `await`
      * would let the assertion run before the click landed.
      *
+     * **On mobile it waits for the element to stop moving, and refuses a covered
+     * one.** The tap reaches the page about a second after its point is read,
+     * and Obsidian Mobile slides a modal in with a `transform` transition that
+     * can hold for over a second, so a point read too early is where the
+     * control *used to be*. So the mobile path first waits (up to 5 s) until no finite
+     * animation or transition runs on the element or any ancestor and its box
+     * has held across two reads, then checks with `elementFromPoint` that the
+     * center belongs to the element. It throws a named error in either case
+     * rather than tapping, because a trusted tap goes to whatever is on top and
+     * would otherwise land on it silently. Use {@link Lib.clickMouse} to tap a
+     * point deliberately, covered or not. Desktop is unchanged.
+     *
      * @param params - The element to click, the button to press and any modifiers
      *   to hold.
      * @returns A {@link Promise} that resolves once the click has been injected.