obsidian-integration-testing 12.1.2 → 12.3.0

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;

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

@@ -0,0 +1,248 @@
+"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_reaper_exports = {};
+__export(emulator_reaper_exports, {
+  EMULATOR_REAPER_ENTRY_NAME: () => EMULATOR_REAPER_ENTRY_NAME,
+  EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS: () => EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS,
+  EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES: () => EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES,
+  EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS: () => EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS,
+  buildEmulatorReaperArguments: () => buildEmulatorReaperArguments,
+  buildEmulatorReaperBootstrap: () => buildEmulatorReaperBootstrap,
+  buildEmulatorReaperRelayBootstrap: () => buildEmulatorReaperRelayBootstrap,
+  parseEmulatorReaperArguments: () => parseEmulatorReaperArguments,
+  resolveEmulatorReaperLogOpenFlag: () => resolveEmulatorReaperLogOpenFlag,
+  resolveEmulatorReaperWatch: () => resolveEmulatorReaperWatch,
+  runEmulatorReaper: () => runEmulatorReaper,
+  spawnEmulatorReaper: () => spawnEmulatorReaper
+});
+module.exports = __toCommonJS(emulator_reaper_exports);
+var import_node_child_process = require("node:child_process");
+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_node_url = require("node:url");
+var import_emulator_marker = require("./emulator-marker.cjs");
+var import_emulator_reclaim = require("./emulator-reclaim.cjs");
+var import_leftover_cleanup = require("./leftover-cleanup.cjs");
+var import_log = require("./log.cjs");
+var import_process_liveness = require("./process-liveness.cjs");
+var import_setup_lock = require("./setup-lock.cjs");
+const import_meta = {};
+const EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS = 5e3;
+const EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS = 18e5;
+const EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES = 1048576;
+const EMULATOR_REAPER_ENTRY_NAME = "runEmulatorReaper";
+const LOCK_LABEL = "emulator-reaper";
+const REAPER_LOG_FILE_SUFFIX = ".emulator-reaper.log";
+function buildEmulatorReaperArguments(reaperArguments) {
+  return [reaperArguments.avdName, String(reaperArguments.startedAtInMilliseconds)];
+}
+function buildEmulatorReaperBootstrap() {
+  return [
+    "import(process.argv[1]).then((reaperModule) => {",
+    `  const run = reaperModule.${EMULATOR_REAPER_ENTRY_NAME} ?? reaperModule.default.${EMULATOR_REAPER_ENTRY_NAME};`,
+    "  return run(process.argv.slice(2));",
+    "}).catch((error) => {",
+    "  console.error(error);",
+    "  process.exitCode = 1;",
+    "});"
+  ].join("\n");
+}
+function buildEmulatorReaperRelayBootstrap() {
+  return [
+    'const { spawn } = require("node:child_process");',
+    "try {",
+    '  const child = spawn(process.execPath, ["-e", process.argv[1], ...process.argv.slice(2)], {',
+    "    detached: true,",
+    '    stdio: ["ignore", 1, 2],',
+    "    windowsHide: true",
+    "  });",
+    '  child.once("error", (error) => { console.error(error); });',
+    "  child.unref();",
+    "} catch (error) {",
+    "  console.error(error);",
+    "  process.exitCode = 1;",
+    "}"
+  ].join("\n");
+}
+function parseEmulatorReaperArguments(argv) {
+  const [avdName, startedAtText, ...rest] = argv;
+  if (!avdName || startedAtText === void 0 || rest.length > 0) {
+    return void 0;
+  }
+  const startedAtInMilliseconds = Number(startedAtText);
+  if (!Number.isSafeInteger(startedAtInMilliseconds) || startedAtInMilliseconds <= 0) {
+    return void 0;
+  }
+  return { avdName, startedAtInMilliseconds };
+}
+function resolveEmulatorReaperLogOpenFlag(sizeInBytes) {
+  return sizeInBytes !== void 0 && sizeInBytes > EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES ? "w" : "a";
+}
+function resolveEmulatorReaperWatch(params) {
+  const { marker } = params;
+  if (marker === void 0) {
+    return "emulator-stopped";
+  }
+  if (marker.startedAtInMilliseconds !== params.armedStartedAtInMilliseconds) {
+    return "superseded";
+  }
+  if (marker.preLaunchEmulatorPids !== void 0) {
+    return "watch";
+  }
+  return marker.ownedEmulatorPids.some((pid) => params.checkIsPidAlive(pid)) ? "watch" : "emulator-stopped";
+}
+async function runEmulatorReaper(argv) {
+  const reaperArguments = parseEmulatorReaperArguments(argv);
+  if (!reaperArguments) {
+    (0, import_log.log)(`[emulator-reaper] Refusing to run: expected <avdName> <startedAtInMilliseconds>, got ${JSON.stringify(argv)}.`);
+    import_node_process.default.exitCode = 1;
+    return;
+  }
+  const { avdName, startedAtInMilliseconds } = reaperArguments;
+  reaperLog(
+    `Watching the emulator started at ${new Date(startedAtInMilliseconds).toISOString()} (reaper PID ${String(import_node_process.default.pid)}); it is stopped once no Android run holds the '${import_setup_lock.ANDROID_SETUP_LOCK_SCOPE}' setup lock.`
+  );
+  for (; ; ) {
+    const verdict = readWatchVerdict(reaperArguments);
+    if (verdict !== "watch") {
+      reaperLog(describeExit(verdict));
+      return;
+    }
+    let lock;
+    try {
+      lock = (0, import_setup_lock.tryAcquireSetupLock)({
+        label: LOCK_LABEL,
+        scope: import_setup_lock.ANDROID_SETUP_LOCK_SCOPE,
+        staleAfterSilenceInMilliseconds: EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS
+      });
+    } catch (error) {
+      reaperLog(`Giving up: the setup lock could not be read (${error instanceof Error ? error.message : String(error)}). The next Android run reclaims the emulator instead.`);
+      return;
+    }
+    if (lock) {
+      try {
+        const lockedVerdict = readWatchVerdict(reaperArguments);
+        if (lockedVerdict !== "watch") {
+          reaperLog(describeExit(lockedVerdict));
+          return;
+        }
+        reaperLog("No Android run holds the setup lock any more, so nothing is left to stop the emulator. Stopping the leftovers this harness started...");
+        await new import_emulator_reclaim.EmulatorReclaimer(reaperLog).reclaimLeftoverEmulators({ scope: "end-of-run" });
+      } finally {
+        lock.release();
+      }
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS);
+    });
+  }
+  function reaperLog(message) {
+    (0, import_log.log)(`[emulator-reaper:${avdName}] ${message}`);
+  }
+}
+function spawnEmulatorReaper(params) {
+  const { avdName } = params;
+  if (!(0, import_setup_lock.checkIsSetupLockHeld)(import_setup_lock.ANDROID_SETUP_LOCK_SCOPE)) {
+    params.log(
+      `No emulator reaper armed for AVD "${avdName}": no run holds the '${import_setup_lock.ANDROID_SETUP_LOCK_SCOPE}' setup lock, so a reaper could not tell this run ending from it being killed. If this process is killed, only the next Android run on this host stops the emulator.`
+    );
+    return;
+  }
+  const logFilePath = (0, import_node_path.join)(getReaperLogDirectory(), `${avdName}${REAPER_LOG_FILE_SUFFIX}`);
+  try {
+    (0, import_node_fs.mkdirSync)(getReaperLogDirectory(), { recursive: true });
+    const logFileDescriptor = (0, import_node_fs.openSync)(logFilePath, resolveEmulatorReaperLogOpenFlag(readFileSize(logFilePath)));
+    try {
+      const relay = (0, import_node_child_process.spawn)(
+        import_node_process.default.execPath,
+        [
+          "-e",
+          buildEmulatorReaperRelayBootstrap(),
+          buildEmulatorReaperBootstrap(),
+          resolveOwnModuleUrl(),
+          ...buildEmulatorReaperArguments({ avdName, startedAtInMilliseconds: params.startedAtInMilliseconds })
+        ],
+        { detached: true, stdio: ["ignore", logFileDescriptor, logFileDescriptor], windowsHide: true }
+      );
+      relay.once("error", (error) => {
+        params.log(`The emulator reaper relay for AVD "${avdName}" failed to start: ${error.message}`);
+      });
+      relay.unref();
+      params.log(
+        `Emulator reaper armed for AVD "${avdName}": if this run is killed \u2014 a process-tree kill included, since the reaper is started through a relay that exits at once \u2014 it stops the emulator once no Android run holds the '${import_setup_lock.ANDROID_SETUP_LOCK_SCOPE}' setup lock. Its PID is the first line of its log: ${logFilePath}`
+      );
+    } finally {
+      (0, import_node_fs.closeSync)(logFileDescriptor);
+    }
+  } catch (error) {
+    params.log(`Could not arm the emulator reaper for AVD "${avdName}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function describeExit(verdict) {
+  return verdict === "superseded" ? "The marker now records a later emulator of this AVD, which has its own reaper; nothing left to watch." : "The emulator was stopped; nothing left to watch.";
+}
+function getReaperLogDirectory() {
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), import_leftover_cleanup.HARNESS_TEMP_DIR_NAME);
+}
+function readFileSize(path) {
+  try {
+    return (0, import_node_fs.statSync)(path).size;
+  } catch {
+    return void 0;
+  }
+}
+function readWatchVerdict(reaperArguments) {
+  return resolveEmulatorReaperWatch({
+    armedStartedAtInMilliseconds: reaperArguments.startedAtInMilliseconds,
+    checkIsPidAlive: import_process_liveness.checkIsProcessAlive,
+    marker: (0, import_emulator_marker.readEmulatorMarker)(reaperArguments.avdName)
+  });
+}
+function resolveOwnModuleUrl() {
+  return typeof __filename === "string" ? (0, import_node_url.pathToFileURL)(__filename).href : import_meta.url;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMULATOR_REAPER_ENTRY_NAME,
+  EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS,
+  EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES,
+  EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS,
+  buildEmulatorReaperArguments,
+  buildEmulatorReaperBootstrap,
+  buildEmulatorReaperRelayBootstrap,
+  parseEmulatorReaperArguments,
+  resolveEmulatorReaperLogOpenFlag,
+  resolveEmulatorReaperWatch,
+  runEmulatorReaper,
+  spawnEmulatorReaper
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-reaper.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Stops an emulator this harness started once its run is gone for good \u2014 the\n * case nothing else covers, **L56**'s path B with no later run: the runner is\n * killed (SIGKILL, Task Manager, an IDE stop button), no teardown runs, and no\n * other Android run ever comes along to reclaim the leftover from its marker.\n * On 2026-09-10 an emulator left like that kept `netsimd` spinning for six hours.\n *\n * The reaper is a small detached Node process spawned beside every emulator the\n * harness starts or takes over. It holds no handle to the emulator and needs\n * none: the marker (`emulator-marker.ts`) says what to stop, and the verified\n * stop (`emulator-reclaim.ts`) is the one the run's own teardown uses.\n *\n * ## It watches the `android` setup lock, not the process that started it\n *\n * The process that starts the emulator is not always the run. A project with no\n * transport global setup boots it from a **test worker** (**L56** path A), and\n * Vitest ends workers during a perfectly healthy run \u2014 so a reaper tied to its\n * spawner's lifetime (the **L33** liveness socket, the first idea) would stop\n * the emulator mid-run, or race the next worker taking it over. The `android`\n * setup lock (**L7**) is held by the run's main process for the whole run, and\n * its holder being alive is exactly what \"an Android run is in flight\" means.\n *\n * So the reaper polls that lock, and once it can **take** it \u2014 no live run\n * holds it \u2014 it stops the harness's leftovers while holding it, which is the\n * precondition every leftover stop documents: no run can adopt an emulator that\n * is mid-shutdown. That is precisely what the next run's preflight would do,\n * done at the first moment that run could have done it.\n *\n * A dead same-host holder is abandoned at once. A live-PID holder that has gone\n * silent is only abandoned after\n * {@link EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS}, far wider than the\n * two minutes a waiting run steals on: a reaper is always waiting, so at two\n * minutes a live run that blocked its event loop would lose its emulator.\n *\n * ## Fail-open, like the renderer watchdog\n *\n * A reaper is armed only when a live run holds the lock at the moment the\n * emulator is recorded. A run that takes no lock \u2014 a hand-wired\n * `createTransportFromOptions` \u2014 gets none, and says so, rather than a reaper\n * that would read its missing lock as \"the run is over\" and stop an emulator\n * somebody is using. A spawn that fails is logged and never fails the launch.\n *\n * ## How it runs\n *\n * `process.execPath -e <bootstrap> <this module's URL> <avdName> <startedAt>`:\n * the bootstrap `import()`s this very module and calls {@link runEmulatorReaper}.\n * The URL is the built `.mjs` / `.cjs` in a consumer's install, and the `.ts`\n * source in this repo's own suites, which Node's type stripping runs as-is \u2014 so\n * nothing this module imports may reach a module that reads the build-time\n * `OBSIDIAN_METADATA` global. Its stdout/stderr go to a per-AVD log file, capped\n * at {@link EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES}, so the verdict lines the stop\n * prints are on record even though no terminal is left to show them.\n *\n * ## It is started through a relay, so a process-tree kill cannot take it\n *\n * `detached` does not reparent on Windows: a child spawned straight from the run\n * stays in the run's process tree, so the kill shapes that walk that tree take\n * the safety net along with the thing it was guarding \u2014 Task Manager's *End\n * task*, `taskkill /T`, an IDE stop button, a `ParentProcessId` descendant\n * sweep. Measured on 2026-09-11: a reaper died with the run it was watching, and\n * the emulator it would have stopped idled on for ten minutes.\n *\n * So the spawn goes through a relay \u2014 {@link buildEmulatorReaperRelayBootstrap} \u2014\n * which starts the reaper and exits at once. By the time any tree-walker takes\n * its snapshot the relay is gone, so there is no edge from the run to the reaper\n * left to follow. This is the double-fork idiom, and it holds on POSIX for the\n * same reason: once the relay exits, the reaper belongs to `init`.\n */\n\nimport { spawn } from 'node:child_process';\nimport {\n  closeSync,\n  mkdirSync,\n  openSync,\n  statSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { pathToFileURL } from 'node:url';\n\nimport type { EmulatorMarker } from './emulator-marker.cjs';\nimport type { SetupLock } from './setup-lock.cjs';\n\nimport { readEmulatorMarker } from './emulator-marker.cjs';\nimport { EmulatorReclaimer } from './emulator-reclaim.cjs';\nimport { HARNESS_TEMP_DIR_NAME } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { checkIsProcessAlive } from './process-liveness.cjs';\nimport {\n  ANDROID_SETUP_LOCK_SCOPE,\n  checkIsSetupLockHeld,\n  tryAcquireSetupLock\n} from './setup-lock.cjs';\n\n/**\n * How often the reaper looks at the marker and the lock \u2014 the lock's own\n * heartbeat interval, so a killed run is noticed within one beat.\n */\nexport const EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS = 5000;\n\n/**\n * How long a same-host lock holder whose PID is still alive may stay silent\n * before the reaper treats its run as gone: 30 minutes, the threshold the lock\n * already uses across hosts. Only a recycled PID should ever reach it.\n */\nexport const EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS = 1_800_000;\n\n/**\n * The size past which the reaper log is started afresh rather than appended to.\n */\nexport const EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES = 1_048_576;\n\n/**\n * The export the bootstrap calls. Named here so the bootstrap and the export\n * cannot drift apart.\n */\nexport const EMULATOR_REAPER_ENTRY_NAME = 'runEmulatorReaper';\n\nconst LOCK_LABEL = 'emulator-reaper';\nconst REAPER_LOG_FILE_SUFFIX = '.emulator-reaper.log';\n\n/**\n * What the reaper watches for: the emulator a marker recorded when it was armed.\n */\nexport interface EmulatorReaperArguments {\n  /**\n  The AVD whose marker it watches.\n   */\n  readonly avdName: string;\n\n  /**\n   * When the watched emulator was launched. A takeover keeps it, so it names one\n   * emulator across every run that owns it, and tells a later emulator of the\n   * same AVD apart.\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * What the marker says the reaper should do next.\n *\n * - `emulator-stopped` \u2014 the marker is gone, or none of its PIDs is alive: the\n *   emulator was stopped, so there is nothing left to watch.\n * - `superseded` \u2014 the marker now records a different emulator of the same AVD,\n *   which has its own reaper.\n * - `watch` \u2014 the emulator is still up.\n */\nexport type EmulatorReaperWatchVerdict = 'emulator-stopped' | 'superseded' | 'watch';\n\n/**\n * Parameters for {@link resolveEmulatorReaperWatch}.\n */\nexport interface ResolveEmulatorReaperWatchParams {\n  /**\n  The launch time of the emulator this reaper was armed for.\n   */\n  readonly armedStartedAtInMilliseconds: number;\n\n  /**\n  Whether a PID is still running.\n   */\n  readonly checkIsPidAlive: (pid: number) => boolean;\n\n  /**\n  The AVD's marker as it reads now, if any.\n   */\n  readonly marker: EmulatorMarker | undefined;\n}\n\n/**\n * Parameters for {@link spawnEmulatorReaper}.\n */\nexport interface SpawnEmulatorReaperParams {\n  /**\n  The AVD whose emulator was just recorded.\n   */\n  readonly avdName: string;\n\n  /**\n  Receives the armed / not-armed line.\n   */\n  readonly log: (message: string) => void;\n\n  /**\n  The recorded emulator's launch time, as written into its marker.\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * Encodes the reaper's arguments for its command line.\n *\n * @param reaperArguments - What the reaper watches for.\n * @returns The command-line arguments, in the order {@link parseEmulatorReaperArguments} reads them.\n */\nexport function buildEmulatorReaperArguments(reaperArguments: EmulatorReaperArguments): string[] {\n  return [reaperArguments.avdName, String(reaperArguments.startedAtInMilliseconds)];\n}\n\n/**\n * Builds the script `node -e` runs to start the reaper.\n *\n * It `import()`s the module whose URL is its first argument and hands the rest\n * to {@link runEmulatorReaper}. `import()` rather than `require`, because it\n * loads all three forms the module ships as \u2014 ESM, CJS, and this repo's own\n * `.ts` source under Node's type stripping. A CJS module's named exports are\n * found by Node's static analysis; `default` is the fallback when they are not.\n *\n * @returns The script.\n */\nexport function buildEmulatorReaperBootstrap(): string {\n  return [\n    'import(process.argv[1]).then((reaperModule) => {',\n    `  const run = reaperModule.${EMULATOR_REAPER_ENTRY_NAME} ?? reaperModule.default.${EMULATOR_REAPER_ENTRY_NAME};`,\n    '  return run(process.argv.slice(2));',\n    '}).catch((error) => {',\n    '  console.error(error);',\n    '  process.exitCode = 1;',\n    '});'\n  ].join('\\n');\n}\n\n/**\n * Builds the script `node -e` runs as the **relay**: it starts the reaper and\n * exits at once, so the reaper is left with a dead parent and no tree-walking\n * kill of the run can reach it. See the relay section in this module's header\n * for why that indirection exists at all.\n *\n * Its own arguments are the reaper's whole command line \u2014 the bootstrap script\n * first, then everything that bootstrap reads \u2014 so the relay never has to know\n * what any of them mean. It hands the reaper its own stdout and stderr, which\n * are the capped log file the spawner opened, so the log is unaffected by the\n * extra hop.\n *\n * @returns The script.\n */\nexport function buildEmulatorReaperRelayBootstrap(): string {\n  return [\n    'const { spawn } = require(\"node:child_process\");',\n    'try {',\n    '  const child = spawn(process.execPath, [\"-e\", process.argv[1], ...process.argv.slice(2)], {',\n    '    detached: true,',\n    '    stdio: [\"ignore\", 1, 2],',\n    '    windowsHide: true',\n    '  });',\n    '  child.once(\"error\", (error) => { console.error(error); });',\n    '  child.unref();',\n    '} catch (error) {',\n    '  console.error(error);',\n    '  process.exitCode = 1;',\n    '}'\n  ].join('\\n');\n}\n\n/**\n * Decodes the reaper's command-line arguments.\n *\n * @param argv - The arguments after the module URL.\n * @returns The arguments, or `undefined` when they are not the two {@link buildEmulatorReaperArguments} writes.\n */\nexport function parseEmulatorReaperArguments(argv: readonly string[]): EmulatorReaperArguments | undefined {\n  const [avdName, startedAtText, ...rest] = argv;\n  if (!avdName || startedAtText === undefined || rest.length > 0) {\n    return undefined;\n  }\n\n  const startedAtInMilliseconds = Number(startedAtText);\n  if (!Number.isSafeInteger(startedAtInMilliseconds) || startedAtInMilliseconds <= 0) {\n    return undefined;\n  }\n\n  return { avdName, startedAtInMilliseconds };\n}\n\n/**\n * Decides how the reaper log is opened, so it can never grow without bound.\n *\n * @param sizeInBytes - The log's current size, or `undefined` when there is none.\n * @returns `'a'` to append, or `'w'` to start it afresh once it has passed the cap.\n */\nexport function resolveEmulatorReaperLogOpenFlag(sizeInBytes: number | undefined): 'a' | 'w' {\n  return sizeInBytes !== undefined && sizeInBytes > EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES ? 'w' : 'a';\n}\n\n/**\n * Decides what the marker says the reaper should do next.\n *\n * @param params - The marker as it reads now, and the emulator the reaper was armed for.\n * @returns The verdict.\n */\nexport function resolveEmulatorReaperWatch(params: ResolveEmulatorReaperWatchParams): EmulatorReaperWatchVerdict {\n  const { marker } = params;\n  if (marker === undefined) {\n    return 'emulator-stopped';\n  }\n\n  if (marker.startedAtInMilliseconds !== params.armedStartedAtInMilliseconds) {\n    return 'superseded';\n  }\n\n  /*\n   * A launch-time marker's PID list is deliberately incomplete \u2014 it names the\n   * launcher, and the backend it forks is identified by the pre-launch diff,\n   * which costs a host process listing this poll deliberately does not make.\n   * So it is never read as stopped from PIDs alone: the reclaim, which does\n   * make that listing, is what judges it.\n   */\n  if (marker.preLaunchEmulatorPids !== undefined) {\n    return 'watch';\n  }\n\n  return marker.ownedEmulatorPids.some((pid) => params.checkIsPidAlive(pid)) ? 'watch' : 'emulator-stopped';\n}\n\n/* v8 ignore start -- Detached-process glue covered by the Android integration suite, not unit tests. */\n\n/**\n * The reaper process's body: watches the marker and the lock until either the\n * emulator is gone or no run holds the lock, and in the second case stops the\n * harness's leftovers while holding it.\n *\n * Exported for the bootstrap, which is its only caller.\n *\n * @param argv - The reaper's arguments, as {@link buildEmulatorReaperArguments} wrote them.\n */\nexport async function runEmulatorReaper(argv: readonly string[]): Promise<void> {\n  const reaperArguments = parseEmulatorReaperArguments(argv);\n  if (!reaperArguments) {\n    log(`[emulator-reaper] Refusing to run: expected <avdName> <startedAtInMilliseconds>, got ${JSON.stringify(argv)}.`);\n    process.exitCode = 1;\n    return;\n  }\n\n  const { avdName, startedAtInMilliseconds } = reaperArguments;\n  reaperLog(\n    `Watching the emulator started at ${new Date(startedAtInMilliseconds).toISOString()} (reaper PID ${String(process.pid)}); it is stopped once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock.`\n  );\n\n  for (;;) {\n    const verdict = readWatchVerdict(reaperArguments);\n    if (verdict !== 'watch') {\n      reaperLog(describeExit(verdict));\n      return;\n    }\n\n    let lock: SetupLock | undefined;\n    try {\n      lock = tryAcquireSetupLock({\n        label: LOCK_LABEL,\n        scope: ANDROID_SETUP_LOCK_SCOPE,\n        staleAfterSilenceInMilliseconds: EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS\n      });\n    } catch (error: unknown) {\n      // Fail open: a lock this process cannot even look at is no evidence the run is over.\n      reaperLog(`Giving up: the setup lock could not be read (${error instanceof Error ? error.message : String(error)}). The next Android run reclaims the emulator instead.`);\n      return;\n    }\n\n    if (lock) {\n      try {\n        // The run may have ended normally between the look above and the lock: its teardown then stopped the emulator.\n        const lockedVerdict = readWatchVerdict(reaperArguments);\n        if (lockedVerdict !== 'watch') {\n          reaperLog(describeExit(lockedVerdict));\n          return;\n        }\n\n        reaperLog('No Android run holds the setup lock any more, so nothing is left to stop the emulator. Stopping the leftovers this harness started...');\n        await new EmulatorReclaimer(reaperLog).reclaimLeftoverEmulators({ scope: 'end-of-run' });\n      } finally {\n        lock.release();\n      }\n      return;\n    }\n\n    await new Promise((resolve) => {\n      setTimeout(resolve, EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS);\n    });\n  }\n\n  function reaperLog(message: string): void {\n    log(`[emulator-reaper:${avdName}] ${message}`);\n  }\n}\n\n/**\n * Starts the reaper for an emulator the harness just recorded as its own, when\n * a live run holds the `android` setup lock \u2014 and says which it did.\n *\n * Never throws: a reaper that cannot be spawned is a lost safety net, not a\n * reason to fail the launch it would have guarded.\n *\n * @param params - The recorded emulator, and where to report.\n */\nexport function spawnEmulatorReaper(params: SpawnEmulatorReaperParams): void {\n  const { avdName } = params;\n  if (!checkIsSetupLockHeld(ANDROID_SETUP_LOCK_SCOPE)) {\n    params.log(\n      `No emulator reaper armed for AVD \"${avdName}\": no run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock, so a reaper could not tell this run ending from it being killed. If this process is killed, only the next Android run on this host stops the emulator.`\n    );\n    return;\n  }\n\n  const logFilePath = join(getReaperLogDirectory(), `${avdName}${REAPER_LOG_FILE_SUFFIX}`);\n  try {\n    mkdirSync(getReaperLogDirectory(), { recursive: true });\n    const logFileDescriptor = openSync(logFilePath, resolveEmulatorReaperLogOpenFlag(readFileSize(logFilePath)));\n    try {\n      /*\n       * Through the relay, never straight at the reaper: a reaper spawned here\n       * would be a child of this run and would die with it under any kill that\n       * walks the process tree. The relay exits at once, leaving the reaper with\n       * a dead parent and no edge back to this run.\n       */\n      const relay = spawn(\n        process.execPath,\n        [\n          '-e',\n          buildEmulatorReaperRelayBootstrap(),\n          buildEmulatorReaperBootstrap(),\n          resolveOwnModuleUrl(),\n          ...buildEmulatorReaperArguments({ avdName, startedAtInMilliseconds: params.startedAtInMilliseconds })\n        ],\n        { detached: true, stdio: ['ignore', logFileDescriptor, logFileDescriptor], windowsHide: true }\n      );\n      relay.once('error', (error) => {\n        params.log(`The emulator reaper relay for AVD \"${avdName}\" failed to start: ${error.message}`);\n      });\n      relay.unref();\n      params.log(\n        `Emulator reaper armed for AVD \"${avdName}\": if this run is killed \u2014 a process-tree kill included, since the reaper is started through a relay that exits at once \u2014 it stops the emulator once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock. Its PID is the first line of its log: ${logFilePath}`\n      );\n    } finally {\n      closeSync(logFileDescriptor);\n    }\n  } catch (error: unknown) {\n    params.log(`Could not arm the emulator reaper for AVD \"${avdName}\": ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\nfunction describeExit(verdict: Exclude<EmulatorReaperWatchVerdict, 'watch'>): string {\n  return verdict === 'superseded'\n    ? 'The marker now records a later emulator of this AVD, which has its own reaper; nothing left to watch.'\n    : 'The emulator was stopped; nothing left to watch.';\n}\n\nfunction getReaperLogDirectory(): string {\n  return join(tmpdir(), HARNESS_TEMP_DIR_NAME);\n}\n\nfunction readFileSize(path: string): number | undefined {\n  try {\n    return statSync(path).size;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction readWatchVerdict(reaperArguments: EmulatorReaperArguments): EmulatorReaperWatchVerdict {\n  return resolveEmulatorReaperWatch({\n    armedStartedAtInMilliseconds: reaperArguments.startedAtInMilliseconds,\n    checkIsPidAlive: checkIsProcessAlive,\n    marker: readEmulatorMarker(reaperArguments.avdName)\n  });\n}\n\n/**\n * Finds this module's own URL \u2014 the one the bootstrap imports.\n *\n * The CJS build has no `import.meta` (esbuild empties it), but it has\n * `__filename`; the ESM build and the `.ts` source have `import.meta.url`.\n *\n * @returns The URL of this module as it is running.\n */\nfunction resolveOwnModuleUrl(): string {\n  return typeof __filename === 'string' ? pathToFileURL(__filename).href : import.meta.url;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuEA,gCAAsB;AACtB,qBAKO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,0BAAoB;AACpB,sBAA8B;AAK9B,6BAAmC;AACnC,8BAAkC;AAClC,8BAAsC;AACtC,iBAAoB;AACpB,8BAAoC;AACpC,wBAIO;AA/FP;AAqGO,MAAM,gDAAgD;AAOtD,MAAM,+CAA+C;AAKrD,MAAM,wCAAwC;AAM9C,MAAM,6BAA6B;AAE1C,MAAM,aAAa;AACnB,MAAM,yBAAyB;AA4ExB,SAAS,6BAA6B,iBAAoD;AAC/F,SAAO,CAAC,gBAAgB,SAAS,OAAO,gBAAgB,uBAAuB,CAAC;AAClF;AAaO,SAAS,+BAAuC;AACrD,SAAO;AAAA,IACL;AAAA,IACA,8BAA8B,0BAA0B,4BAA4B,0BAA0B;AAAA,IAC9G;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,EAAE,KAAK,IAAI;AACb;AAgBO,SAAS,oCAA4C;AAC1D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,EAAE,KAAK,IAAI;AACb;AAQO,SAAS,6BAA6B,MAA8D;AACzG,QAAM,CAAC,SAAS,eAAe,GAAG,IAAI,IAAI;AAC1C,MAAI,CAAC,WAAW,kBAAkB,UAAa,KAAK,SAAS,GAAG;AAC9D,WAAO;AAAA,EACT;AAEA,QAAM,0BAA0B,OAAO,aAAa;AACpD,MAAI,CAAC,OAAO,cAAc,uBAAuB,KAAK,2BAA2B,GAAG;AAClF,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,SAAS,wBAAwB;AAC5C;AAQO,SAAS,iCAAiC,aAA4C;AAC3F,SAAO,gBAAgB,UAAa,cAAc,wCAAwC,MAAM;AAClG;AAQO,SAAS,2BAA2B,QAAsE;AAC/G,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,WAAW,QAAW;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,4BAA4B,OAAO,8BAA8B;AAC1E,WAAO;AAAA,EACT;AASA,MAAI,OAAO,0BAA0B,QAAW;AAC9C,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,kBAAkB,KAAK,CAAC,QAAQ,OAAO,gBAAgB,GAAG,CAAC,IAAI,UAAU;AACzF;AAaA,eAAsB,kBAAkB,MAAwC;AAC9E,QAAM,kBAAkB,6BAA6B,IAAI;AACzD,MAAI,CAAC,iBAAiB;AACpB,wBAAI,wFAAwF,KAAK,UAAU,IAAI,CAAC,GAAG;AACnH,wBAAAA,QAAQ,WAAW;AACnB;AAAA,EACF;AAEA,QAAM,EAAE,SAAS,wBAAwB,IAAI;AAC7C;AAAA,IACE,oCAAoC,IAAI,KAAK,uBAAuB,EAAE,YAAY,CAAC,gBAAgB,OAAO,oBAAAA,QAAQ,GAAG,CAAC,mDAAmD,0CAAwB;AAAA,EACnM;AAEA,aAAS;AACP,UAAM,UAAU,iBAAiB,eAAe;AAChD,QAAI,YAAY,SAAS;AACvB,gBAAU,aAAa,OAAO,CAAC;AAC/B;AAAA,IACF;AAEA,QAAI;AACJ,QAAI;AACF,iBAAO,uCAAoB;AAAA,QACzB,OAAO;AAAA,QACP,OAAO;AAAA,QACP,iCAAiC;AAAA,MACnC,CAAC;AAAA,IACH,SAAS,OAAgB;AAEvB,gBAAU,gDAAgD,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC,wDAAwD;AACxK;AAAA,IACF;AAEA,QAAI,MAAM;AACR,UAAI;AAEF,cAAM,gBAAgB,iBAAiB,eAAe;AACtD,YAAI,kBAAkB,SAAS;AAC7B,oBAAU,aAAa,aAAa,CAAC;AACrC;AAAA,QACF;AAEA,kBAAU,uIAAuI;AACjJ,cAAM,IAAI,0CAAkB,SAAS,EAAE,yBAAyB,EAAE,OAAO,aAAa,CAAC;AAAA,MACzF,UAAE;AACA,aAAK,QAAQ;AAAA,MACf;AACA;AAAA,IACF;AAEA,UAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,iBAAW,SAAS,6CAA6C;AAAA,IACnE,CAAC;AAAA,EACH;AAEA,WAAS,UAAU,SAAuB;AACxC,wBAAI,oBAAoB,OAAO,KAAK,OAAO,EAAE;AAAA,EAC/C;AACF;AAWO,SAAS,oBAAoB,QAAyC;AAC3E,QAAM,EAAE,QAAQ,IAAI;AACpB,MAAI,KAAC,wCAAqB,0CAAwB,GAAG;AACnD,WAAO;AAAA,MACL,qCAAqC,OAAO,wBAAwB,0CAAwB;AAAA,IAC9F;AACA;AAAA,EACF;AAEA,QAAM,kBAAc,uBAAK,sBAAsB,GAAG,GAAG,OAAO,GAAG,sBAAsB,EAAE;AACvF,MAAI;AACF,kCAAU,sBAAsB,GAAG,EAAE,WAAW,KAAK,CAAC;AACtD,UAAM,wBAAoB,yBAAS,aAAa,iCAAiC,aAAa,WAAW,CAAC,CAAC;AAC3G,QAAI;AAOF,YAAM,YAAQ;AAAA,QACZ,oBAAAA,QAAQ;AAAA,QACR;AAAA,UACE;AAAA,UACA,kCAAkC;AAAA,UAClC,6BAA6B;AAAA,UAC7B,oBAAoB;AAAA,UACpB,GAAG,6BAA6B,EAAE,SAAS,yBAAyB,OAAO,wBAAwB,CAAC;AAAA,QACtG;AAAA,QACA,EAAE,UAAU,MAAM,OAAO,CAAC,UAAU,mBAAmB,iBAAiB,GAAG,aAAa,KAAK;AAAA,MAC/F;AACA,YAAM,KAAK,SAAS,CAAC,UAAU;AAC7B,eAAO,IAAI,sCAAsC,OAAO,sBAAsB,MAAM,OAAO,EAAE;AAAA,MAC/F,CAAC;AACD,YAAM,MAAM;AACZ,aAAO;AAAA,QACL,kCAAkC,OAAO,4LAAkL,0CAAwB,uDAAuD,WAAW;AAAA,MACvT;AAAA,IACF,UAAE;AACA,oCAAU,iBAAiB;AAAA,IAC7B;AAAA,EACF,SAAS,OAAgB;AACvB,WAAO,IAAI,8CAA8C,OAAO,MAAM,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC,EAAE;AAAA,EAChI;AACF;AAEA,SAAS,aAAa,SAA+D;AACnF,SAAO,YAAY,eACf,0GACA;AACN;AAEA,SAAS,wBAAgC;AACvC,aAAO,2BAAK,uBAAO,GAAG,6CAAqB;AAC7C;AAEA,SAAS,aAAa,MAAkC;AACtD,MAAI;AACF,eAAO,yBAAS,IAAI,EAAE;AAAA,EACxB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,iBAAiB,iBAAsE;AAC9F,SAAO,2BAA2B;AAAA,IAChC,8BAA8B,gBAAgB;AAAA,IAC9C,iBAAiB;AAAA,IACjB,YAAQ,2CAAmB,gBAAgB,OAAO;AAAA,EACpD,CAAC;AACH;AAUA,SAAS,sBAA8B;AACrC,SAAO,OAAO,eAAe,eAAW,+BAAc,UAAU,EAAE,OAAO,YAAY;AACvF;",
  "names": ["process"]
}
