obsidian-integration-testing 12.1.2 → 12.2.0

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

@@ -0,0 +1,312 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var emulator_reclaim_exports = {};
+__export(emulator_reclaim_exports, {
+  ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS: () => ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,
+  ADB_DUMPSYS_MAX_BUFFER_IN_BYTES: () => ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,
+  EmulatorReclaimer: () => EmulatorReclaimer,
+  HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS: () => HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
+});
+module.exports = __toCommonJS(emulator_reclaim_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_adb_device_list = require("./adb-device-list.cjs");
+var import_emulator_backend = require("./emulator-backend.cjs");
+var import_emulator_marker = require("./emulator-marker.cjs");
+var import_kill_process_tree = require("./kill-process-tree.cjs");
+var import_process_liveness = require("./process-liveness.cjs");
+var import_teardown_verdict = require("./teardown-verdict.cjs");
+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 EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5e3;
+const EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;
+const EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 2e4;
+const MILLISECONDS_PER_SECOND = 1e3;
+class EmulatorReclaimer {
+  log;
+  /**
+   * Creates a reclaimer that reports under the caller's own log prefix.
+   *
+   * @param log - Receives every progress and verdict line.
+   */
+  constructor(log) {
+    this.log = log;
+  }
+  /**
+   * Runs `adb devices` and returns its raw stdout.
+   *
+   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only
+   * the `device` state, and an emulator on its way out answers `offline` while
+   * still holding the AVD — see `adb-device-list.ts`.
+   *
+   * @returns The raw `adb devices` output.
+   * @throws If adb could not be run at all.
+   */
+  getDevicesOutput() {
+    return new Promise((resolve, reject) => {
+      (0, import_node_child_process.execFile)("adb", ["devices"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));
+          return;
+        }
+        if (stderr) {
+          this.log(`ADB stderr: ${stderr.trim()}`);
+        }
+        resolve(stdout);
+      });
+    });
+  }
+  /**
+   * Lists every process on the host.
+   *
+   * 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".
+   *
+   * @returns The host's processes, or `undefined` when the listing failed.
+   */
+  async queryHostProcesses() {
+    const query = buildHostProcessQuery();
+    const output = await new Promise((resolve) => {
+      (0, import_node_child_process.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;
+    }
+    return processes;
+  }
+  /**
+   * Stops the emulators this harness started that no live run is responsible
+   * for, and drops the markers that no longer describe a running emulator.
+   *
+   * Only ever acts on a **marker-verified** emulator: one whose marker names a
+   * PID that is still a live emulator process. An emulator without a marker —
+   * booted by hand, by CI, or by another tool — is never touched, which keeps
+   * the L46 line: never a `qemu*` sweep.
+   *
+   * Callers must hold the `android` setup lock (L7), which is what makes a
+   * leftover safe to stop: no other Android run can be mid-flight on it.
+   *
+   * @param params - Which AVD to leave alone, and whether this run is ending.
+   */
+  async reclaimLeftoverEmulators(params) {
+    const markers = (0, import_emulator_marker.listEmulatorMarkers)().filter((marker) => marker.avdName !== params.exceptAvdName);
+    if (markers.length === 0) {
+      return;
+    }
+    const processes = await this.queryHostProcesses();
+    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;
+    }
+    const liveEmulatorPids = (0, import_emulator_backend.selectEmulatorBackendPids)({ knownPids: [], processes });
+    for (const marker of markers) {
+      await this.reclaimLeftoverEmulator(marker, liveEmulatorPids, params.scope);
+    }
+  }
+  /**
+   * Stops an emulator this harness owns, and **verifies** it stopped.
+   *
+   * The console shutdown goes first because it is the only path that releases
+   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a
+   * stale lock is what makes the next run fail with `Running multiple emulators
+   * with the same AVD` — a FATAL the emulator writes to its own stdout, where
+   * nobody sees it.
+   *
+   * Works without a launcher handle too: a leftover this run took over has only
+   * its PIDs, which is all the escalation below ever needed. The marker goes
+   * only with a **verified** stop, so an emulator that outlived this attempt
+   * stays convictable by the next one.
+   *
+   * @param params - The emulator process, the device it serves and the PIDs this run owns.
+   */
+  async stopEmulator(params) {
+    if (params.deviceId !== void 0) {
+      await this.killEmulatorConsole(params.deviceId);
+    }
+    if (params.emulatorProcess) {
+      (0, import_kill_process_tree.killProcessTree)(params.emulatorProcess);
+    }
+    const waitParams = {
+      deviceId: params.deviceId,
+      ownedEmulatorPids: params.ownedEmulatorPids,
+      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
+    };
+    let hasEscalated = false;
+    let isStopped = await this.waitForEmulatorStopped(waitParams);
+    if (!isStopped) {
+      const survivingPids = params.ownedEmulatorPids.filter((pid) => (0, import_process_liveness.checkIsProcessAlive)(pid));
+      if (survivingPids.length > 0) {
+        hasEscalated = true;
+        this.log(
+          `Auto-started emulator outlived its console shutdown and the launcher's process tree; escalating to the emulator PID(s) this run owns: [${survivingPids.join(", ")}].`
+        );
+        for (const pid of survivingPids) {
+          (0, import_kill_process_tree.killProcessTreeByPid)(pid);
+        }
+        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });
+      }
+    }
+    this.log((0, import_teardown_verdict.buildTeardownMessage)({
+      evidence: params.deviceId === void 0 ? `AVD "${params.avdName}"` : `AVD "${params.avdName}" on device ${params.deviceId}`,
+      outcome: (0, import_teardown_verdict.resolveTeardownOutcome)({ hasEscalated, isStopped }),
+      subject: "Auto-started emulator",
+      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
+    }));
+    if (isStopped) {
+      (0, import_emulator_marker.clearEmulatorMarkerIfStopped)(params.avdName);
+    }
+  }
+  /**
+   * Decides whether the emulator this run started is really gone.
+   *
+   * Two independent proofs, cheapest first: none of the PIDs this run owns is
+   * alive, and the device no longer appears in `adb devices` **in any state** (a
+   * dying emulator answers `offline` while it still holds the AVD).
+   *
+   * @param params - The device and the PIDs this run owns.
+   * @returns `true` when nothing of this run's emulator is left.
+   */
+  async checkIsEmulatorGone(params) {
+    if (params.ownedEmulatorPids.some((pid) => (0, import_process_liveness.checkIsProcessAlive)(pid))) {
+      return false;
+    }
+    if (params.deviceId === void 0) {
+      return true;
+    }
+    try {
+      return !(0, import_adb_device_list.checkIsDeviceListed)({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });
+    } catch (error) {
+      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);
+      return true;
+    }
+  }
+  /**
+   * Asks the emulator to shut itself down over its console.
+   *
+   * Preferred over killing the process outright because it is the path that
+   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does
+   * not answer is reported and the caller falls through to the kill.
+   *
+   * @param deviceId - The emulator's device ID.
+   */
+  killEmulatorConsole(deviceId) {
+    return new Promise((resolve) => {
+      (0, import_node_child_process.execFile)("adb", ["-s", deviceId, "emu", "kill"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {
+        this.log(
+          error ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}` : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`
+        );
+        resolve();
+      });
+    });
+  }
+  /**
+   * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.
+   *
+   * @param marker - The marker to judge.
+   * @param liveEmulatorPids - The emulator processes currently running on the host.
+   * @param scope - Whether an emulator another live harness process owns is spared.
+   */
+  async reclaimLeftoverEmulator(marker, liveEmulatorPids, scope) {
+    const verdict = (0, import_emulator_marker.resolveEmulatorMarkerVerdict)({
+      currentPid: import_node_process.default.pid,
+      isOwnerAlive: (0, import_process_liveness.checkIsProcessAlive)(marker.ownerPid),
+      liveEmulatorPids,
+      marker
+    });
+    if (verdict === "stale-marker") {
+      this.log(`Dropping the emulator marker for AVD "${marker.avdName}": none of its PIDs [${marker.ownedEmulatorPids.join(", ")}] is a running emulator any more.`);
+      (0, import_emulator_marker.clearEmulatorMarker)(marker.avdName);
+      return;
+    }
+    const evidence = describeMarkedEmulator(marker);
+    if (verdict === "in-use-by-live-run" && scope === "preflight") {
+      this.log(`Leaving the emulator for ${evidence} alone: the harness process that owns it (PID ${String(marker.ownerPid)}) is still running.`);
+      return;
+    }
+    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);
+    this.log(
+      `Stopping the emulator for ${evidence}: this harness started it ${String(ageInSeconds)}s ago, and no live run is left to stop it.`
+    );
+    await this.stopEmulator({
+      avdName: marker.avdName,
+      deviceId: marker.deviceId,
+      ownedEmulatorPids: (0, import_emulator_marker.selectLiveMarkedPids)(marker, liveEmulatorPids)
+    });
+  }
+  /**
+   * Polls until this run's emulator is gone, or the budget elapses.
+   *
+   * @param params - The device, the PIDs this run owns, and the budget.
+   * @returns `true` when the emulator disappeared within the budget.
+   */
+  async waitForEmulatorStopped(params) {
+    const deadline = Date.now() + params.timeoutInMilliseconds;
+    while (Date.now() < deadline) {
+      if (await this.checkIsEmulatorGone(params)) {
+        return true;
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);
+      });
+    }
+    return false;
+  }
+}
+function buildHostProcessQuery() {
+  return import_node_process.default.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 import_node_process.default.platform === "win32" ? (0, import_emulator_backend.parseWindowsTaskList)(output) : (0, import_emulator_backend.parsePosixProcessList)(output);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\nimport type { EmulatorMarker } from './emulator-marker.cjs';\n\nimport { checkIsDeviceListed } from './adb-device-list.cjs';\nimport {\n  parsePosixProcessList,\n  parseWindowsTaskList,\n  selectEmulatorBackendPids\n} from './emulator-backend.cjs';\nimport {\n  clearEmulatorMarker,\n  clearEmulatorMarkerIfStopped,\n  listEmulatorMarkers,\n  resolveEmulatorMarkerVerdict,\n  selectLiveMarkedPids\n} from './emulator-marker.cjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.cjs';\nimport { checkIsProcessAlive } from './process-liveness.cjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.cjs';\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 * 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 * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.\n */\nexport interface ReclaimLeftoverEmulatorsParams {\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 StopEmulatorParams {\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\ninterface CheckIsEmulatorGoneParams {\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 WaitForEmulatorStoppedParams {\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: ReclaimLeftoverEmulatorsParams): 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: StopEmulatorParams): 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: WaitForEmulatorStoppedParams = {\n      deviceId: params.deviceId,\n      ownedEmulatorPids: params.ownedEmulatorPids,\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    };\n\n    let hasEscalated = false;\n    let isStopped = await this.waitForEmulatorStopped(waitParams);\n\n    if (!isStopped) {\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      if (survivingPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started emulator outlived 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: CheckIsEmulatorGoneParams): 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: ReclaimLeftoverEmulatorsParams['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: WaitForEmulatorStoppedParams): Promise<boolean> {\n    const deadline = Date.now() + params.timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      if (await this.checkIsEmulatorGone(params)) {\n        return true;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return false;\n  }\n}\n\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": ["process"]
}


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

@@ -0,0 +1,179 @@
+/**
+ * @file
+ *
+ * Stops the emulators this harness started, and **verifies** each stop — the
+ * marker-driven half of emulator ownership (`emulator-marker.ts`, **L56**).
+ *
+ * It lives apart from `transport-factory.ts` so that a process with no business
+ * loading the whole transport stack can still stop an emulator correctly. That
+ * process is the emulator reaper (`emulator-reaper.ts`): it runs detached from
+ * any test runner, and in this repo's own suites it runs straight from source
+ * under Node's type stripping, where a module reading the build-time
+ * `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 { ProcessListEntry } from './emulator-backend.cjs';
+/**
+ * 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;
+/**
+ * A host command and its arguments.
+ */
+export interface HostCommandQuery {
+    /**
+    The executable to run.
+     */
+    readonly command: string;
+    /**
+    The command's arguments.
+     */
+    readonly commandArguments: string[];
+}
+/**
+ * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.
+ */
+export interface ReclaimLeftoverEmulatorsParams {
+    /**
+    An AVD whose leftover is left alone — the one a preflight is about to adopt instead.
+     */
+    readonly exceptAvdName?: string | undefined;
+    /**
+     * `'preflight'` spares an emulator another live harness process still owns.
+     * `'end-of-run'` does not: the caller holds the `android` lock with no run in
+     * flight — the run's own global teardown, or the emulator reaper after the
+     * run is gone — so that owner can only be one of the finished run's
+     * processes, which no longer has a turn to stop it.
+     */
+    readonly scope: 'end-of-run' | 'preflight';
+}
+/**
+ * Parameters for {@link EmulatorReclaimer.stopEmulator}.
+ */
+export interface StopEmulatorParams {
+    /**
+    The AVD name, named in the warning so the leftover is identifiable, and the key of its marker.
+     */
+    readonly avdName: string;
+    /**
+     * The device the emulator is serving, shut down over its console and polled
+     * to decide whether it actually stopped. `undefined` when the emulator failed
+     * before any device appeared.
+     */
+    readonly deviceId?: string | undefined;
+    /**
+     * The emulator launcher process this run spawned. `undefined` for a leftover
+     * this run took over, whose launcher belonged to another process.
+     */
+    readonly emulatorProcess?: ChildProcess | undefined;
+    /**
+    The emulator PIDs this run owns, escalated to when the console and the launcher's tree kill leave one behind.
+     */
+    readonly ownedEmulatorPids: readonly number[];
+}
+/**
+ * Finds, stops and verifies the harness's emulators, reporting through the
+ * caller's log so each caller keeps its own prefix.
+ */
+export declare class EmulatorReclaimer {
+    private readonly log;
+    /**
+     * Creates a reclaimer that reports under the caller's own log prefix.
+     *
+     * @param log - Receives every progress and verdict line.
+     */
+    constructor(log: (message: string) => void);
+    /**
+     * Runs `adb devices` and returns its raw stdout.
+     *
+     * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only
+     * the `device` state, and an emulator on its way out answers `offline` while
+     * still holding the AVD — see `adb-device-list.ts`.
+     *
+     * @returns The raw `adb devices` output.
+     * @throws If adb could not be run at all.
+     */
+    getDevicesOutput(): Promise<string>;
+    /**
+     * Lists every process on the host.
+     *
+     * 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".
+     *
+     * @returns The host's processes, or `undefined` when the listing failed.
+     */
+    queryHostProcesses(): 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.
+     *
+     * Only ever acts on a **marker-verified** emulator: one whose marker names a
+     * PID that is still a live emulator process. An emulator without a marker —
+     * booted by hand, by CI, or by another tool — is never touched, which keeps
+     * the L46 line: never a `qemu*` sweep.
+     *
+     * Callers must hold the `android` setup lock (L7), which is what makes a
+     * leftover safe to stop: no other Android run can be mid-flight on it.
+     *
+     * @param params - Which AVD to leave alone, and whether this run is ending.
+     */
+    reclaimLeftoverEmulators(params: ReclaimLeftoverEmulatorsParams): Promise<void>;
+    /**
+     * Stops an emulator this harness owns, and **verifies** it stopped.
+     *
+     * The console shutdown goes first because it is the only path that releases
+     * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a
+     * stale lock is what makes the next run fail with `Running multiple emulators
+     * with the same AVD` — a FATAL the emulator writes to its own stdout, where
+     * nobody sees it.
+     *
+     * Works without a launcher handle too: a leftover this run took over has only
+     * its PIDs, which is all the escalation below ever needed. The marker goes
+     * only with a **verified** stop, so an emulator that outlived this attempt
+     * stays convictable by the next one.
+     *
+     * @param params - The emulator process, the device it serves and the PIDs this run owns.
+     */
+    stopEmulator(params: StopEmulatorParams): Promise<void>;
+    /**
+     * Decides whether the emulator this run started is really gone.
+     *
+     * Two independent proofs, cheapest first: none of the PIDs this run owns is
+     * alive, and the device no longer appears in `adb devices` **in any state** (a
+     * dying emulator answers `offline` while it still holds the AVD).
+     *
+     * @param params - The device and the PIDs this run owns.
+     * @returns `true` when nothing of this run's emulator is left.
+     */
+    private checkIsEmulatorGone;
+    /**
+     * Asks the emulator to shut itself down over its console.
+     *
+     * Preferred over killing the process outright because it is the path that
+     * releases the AVD's `multiinstance.lock`. Best-effort: a console that does
+     * not answer is reported and the caller falls through to the kill.
+     *
+     * @param deviceId - The emulator's device ID.
+     */
+    private killEmulatorConsole;
+    /**
+     * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.
+     *
+     * @param marker - The marker to judge.
+     * @param liveEmulatorPids - The emulator processes currently running on the host.
+     * @param scope - Whether an emulator another live harness process owns is spared.
+     */
+    private reclaimLeftoverEmulator;
+    /**
+     * Polls until this run's emulator is gone, or the budget elapses.
+     *
+     * @param params - The device, the PIDs this run owns, and the budget.
+     * @returns `true` when the emulator disappeared within the budget.
+     */
+    private waitForEmulatorStopped;
+}

package/dist/lib/cjs/eval-cap-exceeded-error.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eval_cap_exceeded_error_exports = {};
+__export(eval_cap_exceeded_error_exports, {
+  EvalCapExceededError: () => EvalCapExceededError,
+  isScriptTimeoutError: () => isScriptTimeoutError
+});
+module.exports = __toCommonJS(eval_cap_exceeded_error_exports);
+const SCRIPT_TIMEOUT_PATTERN = /script\s*timeout/i;
+class EvalCapExceededError extends Error {
+  /**
+  The per-eval cap the closure outran, in milliseconds.
+   */
+  capInMilliseconds;
+  /**
+  How the transport that enforced the cap was named in the message.
+   */
+  transportName;
+  /**
+   * Creates the error from the cap, the transport, and the raw error it replaces.
+   *
+   * @param params - The cap, the transport, the option that sets the cap, and the underlying error.
+   */
+  constructor(params) {
+    super(buildMessage(params), { cause: params.cause });
+    this.name = "EvalCapExceededError";
+    this.capInMilliseconds = params.capInMilliseconds;
+    this.transportName = params.transportName;
+  }
+}
+function isScriptTimeoutError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return SCRIPT_TIMEOUT_PATTERN.test(error.message) || SCRIPT_TIMEOUT_PATTERN.test(error.name);
+}
+function buildMessage(params) {
+  return `A single evalInObsidian closure ran longer than the ${params.transportName} per-eval cap of ${String(params.capInMilliseconds)}ms, so it was killed mid-flight. This is a property of the closure, not of the device or the app: everything awaited inside one closure shares that one budget, including every \`lib.waitUntil\` timeout and every settle \`sleep\`. Do the waiting from Node instead \u2014 \`pollInObsidian\` runs a short \`poll\` closure repeatedly until a Node-side \`until\` accepts, so no single eval is ever long. Raise \`${params.optionName}\` only for a closure that genuinely cannot be split.`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvalCapExceededError,
+  isScriptTimeoutError
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-cap-exceeded-error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The one error both transports raise when a single `evalInObsidian` closure\n * outruns the per-eval cap, and the predicate that recognizes the raw transport\n * error it replaces.\n *\n * The cap itself is not the problem this module solves \u2014 the diagnosis is.\n * Desktop surfaces the overrun as a generic\n * `CDP command timed out ... : Runtime.evaluate`, which never names the test's\n * own wait and so reads as a broken device or a wedged app \u2014 a plugin release was\n * once held for two days by that reading, with a healthy emulator blamed for\n * having no network.\n *\n * Android is worse, because it surfaces NOTHING. On a live emulator the closure\n * was measured completing in the guest on schedule \u2014 timers armed at 30s and 40s fired within\n * ~13ms of nominal on a visible, focused page \u2014 while its Execute Script response\n * never reached the client, so the call hung until whichever outer budget gave up\n * first. A hang names nothing at all, which is why the Android cap is enforced by\n * the transport on the Node side rather than by the `timeouts.script` capability\n * it also declares and that nothing acts on.\n *\n * Both transports therefore funnel into the message below, which says what the cap\n * is, which transport enforced it, and what to do instead.\n *\n * A closure that needs to wait longer than the cap should not be waiting inside\n * Obsidian at all. `pollInObsidian` is the sanctioned shape: short closures, and\n * the waiting done from Node.\n */\n\n/*\n * The W3C error code is the spaced `script timeout`, while a client that turns it into a type spells the\n * Same thing as `ScriptTimeoutError` \u2014 hence the optional whitespace, which lets one pattern read both.\n */\nconst SCRIPT_TIMEOUT_PATTERN = /script\\s*timeout/i;\n\n/**\n * Parameters for {@link EvalCapExceededError}'s constructor.\n */\nexport interface EvalCapExceededErrorConstructorParams {\n  /**\n  The per-eval cap the closure outran, in milliseconds.\n   */\n  readonly capInMilliseconds: number;\n\n  /**\n  The underlying transport error, kept as the `cause` so the raw diagnosis is not lost.\n   */\n  readonly cause: unknown;\n\n  /**\n  The name of the option that sets the cap on this transport, so the message can name the real knob.\n   */\n  readonly optionName: string;\n\n  /**\n  How to refer to the transport that enforced the cap, e.g. `'Android (Appium)'`.\n   */\n  readonly transportName: string;\n}\n\n/**\n * Thrown when one `evalInObsidian` closure ran longer than the transport's\n * per-eval cap.\n *\n * Carries the cap and the transport so a caller can `instanceof`-match, and the\n * original transport error as `cause`.\n */\nexport class EvalCapExceededError extends Error {\n  /**\n  The per-eval cap the closure outran, in milliseconds.\n   */\n  public readonly capInMilliseconds: number;\n\n  /**\n  How the transport that enforced the cap was named in the message.\n   */\n  public readonly transportName: string;\n\n  /**\n   * Creates the error from the cap, the transport, and the raw error it replaces.\n   *\n   * @param params - The cap, the transport, the option that sets the cap, and the underlying error.\n   */\n  public constructor(params: EvalCapExceededErrorConstructorParams) {\n    super(buildMessage(params), { cause: params.cause });\n    this.name = 'EvalCapExceededError';\n    this.capInMilliseconds = params.capInMilliseconds;\n    this.transportName = params.transportName;\n  }\n}\n\n/**\n * Whether an error is a WebDriver script timeout \u2014 the W3C error a driver would\n * raise if it enforced `timeouts.script`.\n *\n * Matched on the message rather than on a type, because the error arrives as a\n * generic `WebDriverError` whose only distinguishing mark is the W3C error code\n * in its text.\n *\n * **This driver never raises it.** UiAutomator2 was measured accepting the\n * capability, reporting it back, and enforcing nothing. The predicate is kept\n * because it costs nothing, it is the right translation if a future driver does\n * enforce the capability, and it keeps one error covering one condition on both\n * transports \u2014 but the Android cap is enforced Node-side, and this is not what\n * enforces it.\n *\n * @param error - The error thrown by the transport.\n * @returns `true` when the error is a script timeout.\n */\nexport function isScriptTimeoutError(error: unknown): boolean {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  return SCRIPT_TIMEOUT_PATTERN.test(error.message) || SCRIPT_TIMEOUT_PATTERN.test(error.name);\n}\n\n/**\n * Builds the shared message both transports report.\n *\n * @param params - The cap, the transport, and the option that sets the cap.\n * @returns The message.\n */\nfunction buildMessage(params: EvalCapExceededErrorConstructorParams): string {\n  return `A single evalInObsidian closure ran longer than the ${params.transportName} per-eval cap of ${String(params.capInMilliseconds)}ms, so it was killed mid-flight. This is a property of the closure, not of the device or the app: `\n    + 'everything awaited inside one closure shares that one budget, including every `lib.waitUntil` timeout '\n    + 'and every settle `sleep`. Do the waiting from Node instead \u2014 `pollInObsidian` runs a short `poll` '\n    + 'closure repeatedly until a Node-side `until` accepts, so no single eval is ever long. Raise '\n    + `\\`${params.optionName}\\` only for a closure that genuinely cannot be split.`;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkCA,MAAM,yBAAyB;AAkCxB,MAAM,6BAA6B,MAAM;AAAA;AAAA;AAAA;AAAA,EAI9B;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,QAA+C;AAChE,UAAM,aAAa,MAAM,GAAG,EAAE,OAAO,OAAO,MAAM,CAAC;AACnD,SAAK,OAAO;AACZ,SAAK,oBAAoB,OAAO;AAChC,SAAK,gBAAgB,OAAO;AAAA,EAC9B;AACF;AAoBO,SAAS,qBAAqB,OAAyB;AAC5D,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO,uBAAuB,KAAK,MAAM,OAAO,KAAK,uBAAuB,KAAK,MAAM,IAAI;AAC7F;AAQA,SAAS,aAAa,QAAuD;AAC3E,SAAO,uDAAuD,OAAO,aAAa,oBAAoB,OAAO,OAAO,iBAAiB,CAAC,0ZAI7H,OAAO,UAAU;AAC5B;",
  "names": []
}
