obsidian-integration-testing 12.1.1 → 12.2.0

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

@@ -20,7 +20,25 @@
  * default is a full cold boot, and snapshot reuse is an explicit opt-in that
  * takes **both** halves: load and save together, so the snapshot the next run
  * resumes is one this run wrote.
+ *
+ * **The environment quiets `netsimd`, because nothing else can.** The emulator
+ * starts `netsimd`, its network simulator, and netsimd has a loop that never
+ * checks its hostapd socket for end-of-file: once that socket closes, every
+ * pass decodes an empty Wi-Fi frame and logs the failure, with no rate limit.
+ * On 2026-09-10 an idle emulator's netsimd wrote 278 GB of that one warning to
+ * `%TEMP%\netsimd\netsim_stderr.log` in six hours, filling the drive. netsimd
+ * has no flag to quiet it; its log level is `RUST_LOG`, read from the
+ * environment it inherits. See **L56**.
+ */
+/**
+ * The `RUST_LOG` filter the harness hands the emulator, and through it `netsimd`.
+ *
+ * `error` rather than a directive aimed at the one noisy module: nothing reads
+ * netsimd's log, real failures are still recorded, and a level can be verified
+ * by the absence of `netsimd I` lines where a module directive could only be
+ * verified by reproducing the flood.
  */
+export declare const NETSIM_LOG_FILTER = "error";
 /**
  * Parameters for {@link buildEmulatorArguments}.
  */
@@ -43,6 +61,21 @@ export interface BuildEmulatorArgumentsParams {
      */
     readonly shouldReuseSnapshot: boolean;
 }
+/**
+ * Result of {@link buildEmulatorEnvironment}.
+ */
+export interface EmulatorEnvironment {
+    /**
+    The environment to spawn the emulator with.
+     */
+    readonly environment: NodeJS.ProcessEnv;
+    /**
+     * Whether the harness set `RUST_LOG` itself. `false` means the caller's
+     * environment already carried one, which wins — and which leaves netsimd's
+     * log unbounded if it is `warn` or chattier.
+     */
+    readonly isNetsimLogGuarded: boolean;
+}
 /**
  * Builds the argument list for spawning the Android emulator.
  *
@@ -50,3 +83,14 @@ export interface BuildEmulatorArgumentsParams {
  * @returns The argument array to pass to the emulator binary.
  */
 export declare function buildEmulatorArguments(params: BuildEmulatorArgumentsParams): string[];
+/**
+ * Builds the environment for spawning the Android emulator: the caller's own,
+ * plus a `RUST_LOG` that keeps `netsimd`'s log bounded.
+ *
+ * An explicit `RUST_LOG` is left alone — someone who set it asked for that
+ * level — and reported back so the caller can say the guard is off.
+ *
+ * @param baseEnvironment - The environment to extend, normally `process.env`.
+ * @returns The environment, and whether the harness supplied the log filter.
+ */
+export declare function buildEmulatorEnvironment(baseEnvironment: NodeJS.ProcessEnv): EmulatorEnvironment;

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

@@ -0,0 +1,169 @@
+"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_marker_exports = {};
+__export(emulator_marker_exports, {
+  checkIsMarkedEmulatorRunning: () => checkIsMarkedEmulatorRunning,
+  clearEmulatorMarker: () => clearEmulatorMarker,
+  clearEmulatorMarkerIfStopped: () => clearEmulatorMarkerIfStopped,
+  listEmulatorMarkers: () => listEmulatorMarkers,
+  readEmulatorMarker: () => readEmulatorMarker,
+  resolveEmulatorMarkerVerdict: () => resolveEmulatorMarkerVerdict,
+  selectLiveMarkedPids: () => selectLiveMarkedPids,
+  writeEmulatorMarker: () => writeEmulatorMarker
+});
+module.exports = __toCommonJS(emulator_marker_exports);
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_leftover_cleanup = require("./leftover-cleanup.cjs");
+var import_log = require("./log.cjs");
+var import_process_liveness = require("./process-liveness.cjs");
+const MARKER_FILE_SUFFIX = ".emulator.json";
+function checkIsMarkedEmulatorRunning(marker) {
+  return marker?.ownedEmulatorPids.some((pid) => (0, import_process_liveness.checkIsProcessAlive)(pid)) ?? false;
+}
+function clearEmulatorMarker(avdName) {
+  try {
+    (0, import_node_fs.rmSync)(getMarkerFilePath(avdName), { force: true });
+  } catch (error) {
+    (0, import_log.log)(`[emulator-marker] Could not remove the marker for AVD "${avdName}": ${getErrorMessage(error)}`);
+  }
+}
+function clearEmulatorMarkerIfStopped(avdName) {
+  if (checkIsMarkedEmulatorRunning(readEmulatorMarker(avdName))) {
+    return;
+  }
+  clearEmulatorMarker(avdName);
+}
+function listEmulatorMarkers() {
+  let fileNames;
+  try {
+    fileNames = (0, import_node_fs.readdirSync)(getMarkerDirectory());
+  } catch {
+    return [];
+  }
+  const markers = [];
+  for (const fileName of fileNames) {
+    if (!fileName.endsWith(MARKER_FILE_SUFFIX)) {
+      continue;
+    }
+    const marker = readEmulatorMarker(fileName.slice(0, -MARKER_FILE_SUFFIX.length));
+    if (marker) {
+      markers.push(marker);
+    }
+  }
+  return markers;
+}
+function readEmulatorMarker(avdName) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs.readFileSync)(getMarkerFilePath(avdName), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  return parseMarker(parsed, avdName);
+}
+function resolveEmulatorMarkerVerdict(params) {
+  if (selectLiveMarkedPids(params.marker, params.liveEmulatorPids).length === 0) {
+    return "stale-marker";
+  }
+  if (params.marker.ownerPid !== params.currentPid && params.isOwnerAlive) {
+    return "in-use-by-live-run";
+  }
+  return "harness-leftover";
+}
+function selectLiveMarkedPids(marker, liveEmulatorPids) {
+  const livePids = marker.ownedEmulatorPids.filter((pid) => liveEmulatorPids.includes(pid));
+  const { preLaunchEmulatorPids } = marker;
+  if (preLaunchEmulatorPids === void 0) {
+    return livePids;
+  }
+  return [...livePids, ...liveEmulatorPids.filter((pid) => !preLaunchEmulatorPids.includes(pid) && !livePids.includes(pid))];
+}
+function writeEmulatorMarker(params) {
+  const marker = {
+    avdName: params.avdName,
+    // Omitted rather than written empty while the emulator is still booting: the stop reads its absence as "no console to shut down".
+    ...params.deviceId !== void 0 && { deviceId: params.deviceId },
+    ownedEmulatorPids: [...params.ownedEmulatorPids],
+    ownerPid: import_node_process.default.pid,
+    // Dropped by the write that learns the backend's PID: from then on the owned set is exact and a diff would only widen it.
+    ...params.preLaunchEmulatorPids !== void 0 && { preLaunchEmulatorPids: [...params.preLaunchEmulatorPids] },
+    startedAtInMilliseconds: params.startedAtInMilliseconds ?? Date.now()
+  };
+  try {
+    (0, import_node_fs.mkdirSync)(getMarkerDirectory(), { recursive: true });
+    (0, import_node_fs.writeFileSync)(getMarkerFilePath(marker.avdName), JSON.stringify(marker));
+  } catch (error) {
+    (0, import_log.log)(`[emulator-marker] Could not record the emulator for AVD "${marker.avdName}": ${getErrorMessage(error)}`);
+  }
+}
+function checkIsNumberArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "number");
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getMarkerDirectory() {
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), import_leftover_cleanup.HARNESS_TEMP_DIR_NAME);
+}
+function getMarkerFilePath(avdName) {
+  return (0, import_node_path.join)(getMarkerDirectory(), `${avdName}${MARKER_FILE_SUFFIX}`);
+}
+function parseMarker(parsed, avdName) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const { avdName: markedAvdName, deviceId, ownedEmulatorPids, ownerPid, preLaunchEmulatorPids, startedAtInMilliseconds } = record;
+  if (markedAvdName !== avdName || deviceId !== void 0 && typeof deviceId !== "string" || typeof ownerPid !== "number" || typeof startedAtInMilliseconds !== "number" || !checkIsNumberArray(ownedEmulatorPids) || preLaunchEmulatorPids !== void 0 && !checkIsNumberArray(preLaunchEmulatorPids)) {
+    return void 0;
+  }
+  return {
+    avdName,
+    ...deviceId !== void 0 && { deviceId },
+    ownedEmulatorPids,
+    ownerPid,
+    ...preLaunchEmulatorPids !== void 0 && { preLaunchEmulatorPids },
+    startedAtInMilliseconds
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsMarkedEmulatorRunning,
+  clearEmulatorMarker,
+  clearEmulatorMarkerIfStopped,
+  listEmulatorMarkers,
+  readEmulatorMarker,
+  resolveEmulatorMarkerVerdict,
+  selectLiveMarkedPids,
+  writeEmulatorMarker
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records which emulator this harness started for an AVD, so the emulator\n * stays **the harness's** until a stop of it has been verified \u2014 whichever run,\n * or whichever process of a run, gets to that stop.\n *\n * Ownership used to live only in the memory of the run that launched the\n * emulator, and three ordinary things lose that memory:\n *\n * - **The launching process is a test worker.** A project with no transport\n *   global setup creates its transport \u2014 and auto-starts its emulator \u2014 inside a\n *   Vitest worker, and Vitest ends workers abruptly, so the worker's teardown\n *   never gets a turn. The project's own global teardown runs, but held no\n *   handle to the emulator. This repo's `integration-tests:android`\n *   project is exactly this, and on 2026-09-10 the emulator it left idle kept\n *   `netsimd` writing until a 278 GB log filled the drive (**L56**).\n * - **The runner is killed** \u2014 SIGKILL, Task Manager, an IDE stop button \u2014 and\n *   neither teardown path runs at all.\n * - **A later run adopts the leftover.** A device this run did not start is\n *   correctly not this run's to stop \u2014 which, without a record, made every\n *   leftover nobody's to stop, for ever.\n *\n * The marker is the record: a small JSON sentinel per AVD next to the setup lock,\n * written from the moment the emulator is launched and removed only by a verified\n * stop. It is deliberately tolerant \u2014 a missing, unreadable or mismatched marker\n * reads as \"not ours\", the same answer the harness gave before markers existed.\n *\n * **It records a launch, not a booted emulator**, and that is the difference\n * between covering the third case above and covering it only after the ~45s a\n * cold boot takes. A launch-time marker names the `emulator` launcher alone and\n * no device yet; the device id arrives when one appears, and the QEMU backend's\n * PID once the boot completes. Each write keeps the original launch time, so the\n * reaper armed by the first still recognizes the last as the same emulator.\n *\n * What makes a marker's emulator ours is evidence, not the file: at least one\n * PID it records must still be a **live emulator process** on the host (the\n * caller intersects with the process listing, not a bare signal-0 probe), so a\n * recycled PID or an emulator somebody booted by hand is never mistaken for one\n * this harness started. A launch-time marker satisfies that as written, because\n * `emulator-backend.ts` counts the `emulator` launcher as one of the emulator\n * processes \u2014 which is why phasing the marker needed no change to the verdict.\n */\n\nimport {\n  mkdirSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { HARNESS_TEMP_DIR_NAME } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { checkIsProcessAlive } from './process-liveness.cjs';\n\nconst MARKER_FILE_SUFFIX = '.emulator.json';\n\n/**\n * Identifies the emulator this harness started for an AVD.\n */\nexport interface EmulatorMarker {\n  /**\n  The AVD the emulator is running.\n   */\n  readonly avdName: string;\n\n  /**\n   * The adb serial of the device it serves, e.g. `emulator-5554`. Absent while\n   * the emulator is still booting and no device has appeared yet \u2014 a marker is\n   * written from the launch, before there is anything to name.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n   * The emulator processes the harness owns: the launcher plus the QEMU backend\n   * it forked \u2014 or, until the device appears, the launcher alone.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n   * PID of the harness process responsible for stopping the emulator \u2014 the one\n   * that started it, or the one that later took it over as a leftover.\n   */\n  readonly ownerPid: number;\n\n  /**\n   * The emulator processes that were already running when this launch spawned\n   * its own \u2014 present only while the record is still provisional, i.e. before\n   * the backend's own PID is known.\n   *\n   * It is what makes a launch-time marker convictable at all. Killing the\n   * launcher does **not** kill the `qemu-system-*-headless` backend it forked\n   * (**L46**), so a record naming the launcher alone goes stale over an\n   * emulator that is still running \u2014 the leak this marker exists to prevent.\n   * With the snapshot, anything in the host's emulator listing that is not in\n   * it was forked by this launch, which is the same pre-launch diff the\n   * successful path uses (`emulator-backend.ts`) and the same one **L46**\n   * requires instead of a `qemu*` sweep.\n   */\n  readonly preLaunchEmulatorPids?: readonly number[] | undefined;\n\n  /**\n  When the emulator was started (`Date.now()` epoch milliseconds).\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * What a marker says about the emulator it describes.\n *\n * - `harness-leftover` \u2014 ours, and no live harness process is responsible for\n *   it: the caller may take it over or stop it.\n * - `in-use-by-live-run` \u2014 ours, but another live harness process owns it.\n * - `stale-marker` \u2014 none of its PIDs is a live emulator any more; the marker\n *   outlived its emulator and proves nothing.\n */\nexport type EmulatorMarkerVerdict = 'harness-leftover' | 'in-use-by-live-run' | 'stale-marker';\n\n/**\n * Parameters for {@link resolveEmulatorMarkerVerdict}.\n */\nexport interface ResolveEmulatorMarkerVerdictParams {\n  /**\n  PID of the process asking.\n   */\n  readonly currentPid: number;\n\n  /**\n  Whether the marker's owner process is still running.\n   */\n  readonly isOwnerAlive: boolean;\n\n  /**\n  The emulator processes currently running on the host.\n   */\n  readonly liveEmulatorPids: readonly number[];\n\n  /**\n  The marker to judge.\n   */\n  readonly marker: EmulatorMarker;\n}\n\n/**\n * Parameters for {@link writeEmulatorMarker}.\n */\nexport interface WriteEmulatorMarkerParams {\n  /**\n  The AVD the emulator is running.\n   */\n  readonly avdName: string;\n\n  /**\n  The adb serial of the device it serves; omitted while the emulator is still booting.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator processes the harness owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  The emulator processes that predate this launch. Written only while the backend's own PID is not known yet.\n   */\n  readonly preLaunchEmulatorPids?: readonly number[] | undefined;\n\n  /**\n  When the emulator was launched; omitted \u2192 now. A takeover keeps the original launch time.\n   */\n  readonly startedAtInMilliseconds?: number | undefined;\n}\n\n/**\n * Says whether a marker still names a process that is running.\n *\n * A signal-0 probe, not the emulator listing `resolveEmulatorMarkerVerdict`\n * intersects with: this answers the cheap question \"is there anything left of\n * what this marker recorded\", which is what deciding whether a marker may be\n * overwritten or removed needs. Convicting one as another run's leftover is the\n * stronger question, and costs a host process listing.\n *\n * @param marker - The marker, or `undefined` when there is none.\n * @returns `true` when the marker records a PID that is still alive.\n */\nexport function checkIsMarkedEmulatorRunning(marker: EmulatorMarker | undefined): boolean {\n  return marker?.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid)) ?? false;\n}\n\n/**\n * Removes the marker for an AVD. Called once its emulator is verifiably gone, so\n * a later run cannot mistake a recycled PID for ours.\n *\n * @param avdName - The AVD name.\n */\nexport function clearEmulatorMarker(avdName: string): void {\n  try {\n    rmSync(getMarkerFilePath(avdName), { force: true });\n  } catch (error: unknown) {\n    log(`[emulator-marker] Could not remove the marker for AVD \"${avdName}\": ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Removes the marker for an AVD once none of the processes it records is still\n * running \u2014 the form a stop uses.\n *\n * A stop is verified against the PIDs **it** owned, which is not always the\n * emulator the marker describes: a launch that died at once (the emulator's own\n * `Running multiple emulators with the same AVD` FATAL) owns nothing, verifies\n * trivially, and must not erase the record of an emulator that is still up.\n *\n * @param avdName - The AVD name.\n */\nexport function clearEmulatorMarkerIfStopped(avdName: string): void {\n  if (checkIsMarkedEmulatorRunning(readEmulatorMarker(avdName))) {\n    return;\n  }\n\n  clearEmulatorMarker(avdName);\n}\n\n/**\n * Lists every emulator marker on this host.\n *\n * @returns The readable markers, in directory order.\n */\nexport function listEmulatorMarkers(): EmulatorMarker[] {\n  let fileNames: string[];\n  try {\n    fileNames = readdirSync(getMarkerDirectory());\n  } catch {\n    return [];\n  }\n\n  const markers: EmulatorMarker[] = [];\n  for (const fileName of fileNames) {\n    if (!fileName.endsWith(MARKER_FILE_SUFFIX)) {\n      continue;\n    }\n\n    const marker = readEmulatorMarker(fileName.slice(0, -MARKER_FILE_SUFFIX.length));\n    if (marker) {\n      markers.push(marker);\n    }\n  }\n\n  return markers;\n}\n\n/**\n * Reads the marker for an AVD.\n *\n * @param avdName - The AVD name.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it describes another AVD.\n */\nexport function readEmulatorMarker(avdName: string): EmulatorMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(avdName), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, avdName);\n}\n\n/**\n * Decides what a marker says about the emulator it describes.\n *\n * Evidence first: a marker none of whose PIDs is a live emulator is stale,\n * whoever owns it. Only then does ownership matter \u2014 and a live owner that is\n * not the caller keeps it, because that run will stop it itself.\n *\n * @param params - The marker, the host's live emulator PIDs, and who is asking.\n * @returns The verdict.\n */\nexport function resolveEmulatorMarkerVerdict(params: ResolveEmulatorMarkerVerdictParams): EmulatorMarkerVerdict {\n  if (selectLiveMarkedPids(params.marker, params.liveEmulatorPids).length === 0) {\n    return 'stale-marker';\n  }\n\n  if (params.marker.ownerPid !== params.currentPid && params.isOwnerAlive) {\n    return 'in-use-by-live-run';\n  }\n\n  return 'harness-leftover';\n}\n\n/**\n * Selects the emulator processes a marker convicts: the PIDs it records that\n * are still running, plus \u2014 while the record is still provisional \u2014 whatever\n * the launch it describes has forked since.\n *\n * The second half is what makes a launch-time marker usable. It names the\n * launcher, and killing the launcher leaves the QEMU backend running\n * (**L46**), so without the `preLaunchEmulatorPids` diff a stop would kill the\n * one process that does not hold the AVD and the marker would then read as\n * stale over a live emulator. The diff claims exactly what the successful path\n * claims \u2014 the emulator processes that appeared across this launch \u2014 and never\n * one that predates it.\n *\n * @param marker - The marker.\n * @param liveEmulatorPids - The emulator processes currently running on the host.\n * @returns The marked PIDs still running, in marker order, then any this launch forked, in listed order.\n */\nexport function selectLiveMarkedPids(marker: EmulatorMarker, liveEmulatorPids: readonly number[]): number[] {\n  const livePids = marker.ownedEmulatorPids.filter((pid) => liveEmulatorPids.includes(pid));\n  const { preLaunchEmulatorPids } = marker;\n  if (preLaunchEmulatorPids === undefined) {\n    return livePids;\n  }\n\n  return [...livePids, ...liveEmulatorPids.filter((pid) => !preLaunchEmulatorPids.includes(pid) && !livePids.includes(pid))];\n}\n\n/**\n * Records that the current process is responsible for stopping an AVD's\n * emulator \u2014 one it just started, or a leftover it is taking over.\n *\n * @param params - The emulator's AVD, device and PIDs.\n */\nexport function writeEmulatorMarker(params: WriteEmulatorMarkerParams): void {\n  const marker: EmulatorMarker = {\n    avdName: params.avdName,\n    // Omitted rather than written empty while the emulator is still booting: the stop reads its absence as \"no console to shut down\".\n    ...(params.deviceId !== undefined && { deviceId: params.deviceId }),\n    ownedEmulatorPids: [...params.ownedEmulatorPids],\n    ownerPid: process.pid,\n    // Dropped by the write that learns the backend's PID: from then on the owned set is exact and a diff would only widen it.\n    ...(params.preLaunchEmulatorPids !== undefined && { preLaunchEmulatorPids: [...params.preLaunchEmulatorPids] }),\n    startedAtInMilliseconds: params.startedAtInMilliseconds ?? Date.now()\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(marker.avdName), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[emulator-marker] Could not record the emulator for AVD \"${marker.avdName}\": ${getErrorMessage(error)}`);\n  }\n}\n\nfunction checkIsNumberArray(value: unknown): value is number[] {\n  return Array.isArray(value) && value.every((item) => typeof item === 'number');\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), HARNESS_TEMP_DIR_NAME);\n}\n\nfunction getMarkerFilePath(avdName: string): string {\n  return join(getMarkerDirectory(), `${avdName}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, avdName: string): EmulatorMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { avdName: markedAvdName, deviceId, ownedEmulatorPids, ownerPid, preLaunchEmulatorPids, startedAtInMilliseconds } = record;\n\n  if (\n    markedAvdName !== avdName\n    || (deviceId !== undefined && typeof deviceId !== 'string')\n    || typeof ownerPid !== 'number'\n    || typeof startedAtInMilliseconds !== 'number'\n    || !checkIsNumberArray(ownedEmulatorPids)\n    || (preLaunchEmulatorPids !== undefined && !checkIsNumberArray(preLaunchEmulatorPids))\n  ) {\n    return undefined;\n  }\n\n  return {\n    avdName,\n    ...(deviceId !== undefined && { deviceId }),\n    ownedEmulatorPids,\n    ownerPid,\n    ...(preLaunchEmulatorPids !== undefined && { preLaunchEmulatorPids }),\n    startedAtInMilliseconds\n  };\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -0,0 +1,224 @@
+/**
+ * @file
+ *
+ * Records which emulator this harness started for an AVD, so the emulator
+ * stays **the harness's** until a stop of it has been verified — whichever run,
+ * or whichever process of a run, gets to that stop.
+ *
+ * Ownership used to live only in the memory of the run that launched the
+ * emulator, and three ordinary things lose that memory:
+ *
+ * - **The launching process is a test worker.** A project with no transport
+ *   global setup creates its transport — and auto-starts its emulator — inside a
+ *   Vitest worker, and Vitest ends workers abruptly, so the worker's teardown
+ *   never gets a turn. The project's own global teardown runs, but held no
+ *   handle to the emulator. This repo's `integration-tests:android`
+ *   project is exactly this, and on 2026-09-10 the emulator it left idle kept
+ *   `netsimd` writing until a 278 GB log filled the drive (**L56**).
+ * - **The runner is killed** — SIGKILL, Task Manager, an IDE stop button — and
+ *   neither teardown path runs at all.
+ * - **A later run adopts the leftover.** A device this run did not start is
+ *   correctly not this run's to stop — which, without a record, made every
+ *   leftover nobody's to stop, for ever.
+ *
+ * The marker is the record: a small JSON sentinel per AVD next to the setup lock,
+ * written from the moment the emulator is launched and removed only by a verified
+ * stop. It is deliberately tolerant — a missing, unreadable or mismatched marker
+ * reads as "not ours", the same answer the harness gave before markers existed.
+ *
+ * **It records a launch, not a booted emulator**, and that is the difference
+ * between covering the third case above and covering it only after the ~45s a
+ * cold boot takes. A launch-time marker names the `emulator` launcher alone and
+ * no device yet; the device id arrives when one appears, and the QEMU backend's
+ * PID once the boot completes. Each write keeps the original launch time, so the
+ * reaper armed by the first still recognizes the last as the same emulator.
+ *
+ * What makes a marker's emulator ours is evidence, not the file: at least one
+ * PID it records must still be a **live emulator process** on the host (the
+ * caller intersects with the process listing, not a bare signal-0 probe), so a
+ * recycled PID or an emulator somebody booted by hand is never mistaken for one
+ * this harness started. A launch-time marker satisfies that as written, because
+ * `emulator-backend.ts` counts the `emulator` launcher as one of the emulator
+ * processes — which is why phasing the marker needed no change to the verdict.
+ */
+/**
+ * Identifies the emulator this harness started for an AVD.
+ */
+export interface EmulatorMarker {
+    /**
+    The AVD the emulator is running.
+     */
+    readonly avdName: string;
+    /**
+     * The adb serial of the device it serves, e.g. `emulator-5554`. Absent while
+     * the emulator is still booting and no device has appeared yet — a marker is
+     * written from the launch, before there is anything to name.
+     */
+    readonly deviceId?: string | undefined;
+    /**
+     * The emulator processes the harness owns: the launcher plus the QEMU backend
+     * it forked — or, until the device appears, the launcher alone.
+     */
+    readonly ownedEmulatorPids: readonly number[];
+    /**
+     * PID of the harness process responsible for stopping the emulator — the one
+     * that started it, or the one that later took it over as a leftover.
+     */
+    readonly ownerPid: number;
+    /**
+     * The emulator processes that were already running when this launch spawned
+     * its own — present only while the record is still provisional, i.e. before
+     * the backend's own PID is known.
+     *
+     * It is what makes a launch-time marker convictable at all. Killing the
+     * launcher does **not** kill the `qemu-system-*-headless` backend it forked
+     * (**L46**), so a record naming the launcher alone goes stale over an
+     * emulator that is still running — the leak this marker exists to prevent.
+     * With the snapshot, anything in the host's emulator listing that is not in
+     * it was forked by this launch, which is the same pre-launch diff the
+     * successful path uses (`emulator-backend.ts`) and the same one **L46**
+     * requires instead of a `qemu*` sweep.
+     */
+    readonly preLaunchEmulatorPids?: readonly number[] | undefined;
+    /**
+    When the emulator was started (`Date.now()` epoch milliseconds).
+     */
+    readonly startedAtInMilliseconds: number;
+}
+/**
+ * What a marker says about the emulator it describes.
+ *
+ * - `harness-leftover` — ours, and no live harness process is responsible for
+ *   it: the caller may take it over or stop it.
+ * - `in-use-by-live-run` — ours, but another live harness process owns it.
+ * - `stale-marker` — none of its PIDs is a live emulator any more; the marker
+ *   outlived its emulator and proves nothing.
+ */
+export type EmulatorMarkerVerdict = 'harness-leftover' | 'in-use-by-live-run' | 'stale-marker';
+/**
+ * Parameters for {@link resolveEmulatorMarkerVerdict}.
+ */
+export interface ResolveEmulatorMarkerVerdictParams {
+    /**
+    PID of the process asking.
+     */
+    readonly currentPid: number;
+    /**
+    Whether the marker's owner process is still running.
+     */
+    readonly isOwnerAlive: boolean;
+    /**
+    The emulator processes currently running on the host.
+     */
+    readonly liveEmulatorPids: readonly number[];
+    /**
+    The marker to judge.
+     */
+    readonly marker: EmulatorMarker;
+}
+/**
+ * Parameters for {@link writeEmulatorMarker}.
+ */
+export interface WriteEmulatorMarkerParams {
+    /**
+    The AVD the emulator is running.
+     */
+    readonly avdName: string;
+    /**
+    The adb serial of the device it serves; omitted while the emulator is still booting.
+     */
+    readonly deviceId?: string | undefined;
+    /**
+    The emulator processes the harness owns.
+     */
+    readonly ownedEmulatorPids: readonly number[];
+    /**
+    The emulator processes that predate this launch. Written only while the backend's own PID is not known yet.
+     */
+    readonly preLaunchEmulatorPids?: readonly number[] | undefined;
+    /**
+    When the emulator was launched; omitted → now. A takeover keeps the original launch time.
+     */
+    readonly startedAtInMilliseconds?: number | undefined;
+}
+/**
+ * Says whether a marker still names a process that is running.
+ *
+ * A signal-0 probe, not the emulator listing `resolveEmulatorMarkerVerdict`
+ * intersects with: this answers the cheap question "is there anything left of
+ * what this marker recorded", which is what deciding whether a marker may be
+ * overwritten or removed needs. Convicting one as another run's leftover is the
+ * stronger question, and costs a host process listing.
+ *
+ * @param marker - The marker, or `undefined` when there is none.
+ * @returns `true` when the marker records a PID that is still alive.
+ */
+export declare function checkIsMarkedEmulatorRunning(marker: EmulatorMarker | undefined): boolean;
+/**
+ * Removes the marker for an AVD. Called once its emulator is verifiably gone, so
+ * a later run cannot mistake a recycled PID for ours.
+ *
+ * @param avdName - The AVD name.
+ */
+export declare function clearEmulatorMarker(avdName: string): void;
+/**
+ * Removes the marker for an AVD once none of the processes it records is still
+ * running — the form a stop uses.
+ *
+ * A stop is verified against the PIDs **it** owned, which is not always the
+ * emulator the marker describes: a launch that died at once (the emulator's own
+ * `Running multiple emulators with the same AVD` FATAL) owns nothing, verifies
+ * trivially, and must not erase the record of an emulator that is still up.
+ *
+ * @param avdName - The AVD name.
+ */
+export declare function clearEmulatorMarkerIfStopped(avdName: string): void;
+/**
+ * Lists every emulator marker on this host.
+ *
+ * @returns The readable markers, in directory order.
+ */
+export declare function listEmulatorMarkers(): EmulatorMarker[];
+/**
+ * Reads the marker for an AVD.
+ *
+ * @param avdName - The AVD name.
+ * @returns The marker, or `undefined` when there is none, it is unreadable, or it describes another AVD.
+ */
+export declare function readEmulatorMarker(avdName: string): EmulatorMarker | undefined;
+/**
+ * Decides what a marker says about the emulator it describes.
+ *
+ * Evidence first: a marker none of whose PIDs is a live emulator is stale,
+ * whoever owns it. Only then does ownership matter — and a live owner that is
+ * not the caller keeps it, because that run will stop it itself.
+ *
+ * @param params - The marker, the host's live emulator PIDs, and who is asking.
+ * @returns The verdict.
+ */
+export declare function resolveEmulatorMarkerVerdict(params: ResolveEmulatorMarkerVerdictParams): EmulatorMarkerVerdict;
+/**
+ * Selects the emulator processes a marker convicts: the PIDs it records that
+ * are still running, plus — while the record is still provisional — whatever
+ * the launch it describes has forked since.
+ *
+ * The second half is what makes a launch-time marker usable. It names the
+ * launcher, and killing the launcher leaves the QEMU backend running
+ * (**L46**), so without the `preLaunchEmulatorPids` diff a stop would kill the
+ * one process that does not hold the AVD and the marker would then read as
+ * stale over a live emulator. The diff claims exactly what the successful path
+ * claims — the emulator processes that appeared across this launch — and never
+ * one that predates it.
+ *
+ * @param marker - The marker.
+ * @param liveEmulatorPids - The emulator processes currently running on the host.
+ * @returns The marked PIDs still running, in marker order, then any this launch forked, in listed order.
+ */
+export declare function selectLiveMarkedPids(marker: EmulatorMarker, liveEmulatorPids: readonly number[]): number[];
+/**
+ * Records that the current process is responsible for stopping an AVD's
+ * emulator — one it just started, or a leftover it is taking over.
+ *
+ * @param params - The emulator's AVD, device and PIDs.
+ */
+export declare function writeEmulatorMarker(params: WriteEmulatorMarkerParams): void;