obsidian-integration-testing 12.0.0 → 12.1.1

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

@@ -0,0 +1,158 @@
+/**
+ * @file
+ *
+ * Pure classification of whether the device a run is about to drive is still
+ * **there** — and, when it is not, which of the two very different things went
+ * wrong: the guest froze, or the emulator process itself did.
+ *
+ * The readiness gates in `device-readiness.ts` answer *"is the guest ready
+ * yet?"*, and both are deliberately best-effort: they warn and proceed. Nothing
+ * asked *"is it still answering?"* at the moment the session is created, so a
+ * guest that stopped answering between the last gate and `remote()` was handed
+ * to Appium anyway. What the operator then saw was Appium's own report:
+ *
+ * ```text
+ * WebDriverError: Device emulator-5554 was not in the list of connected devices
+ *   when running "http://localhost:4723/session" with method "POST"
+ * ```
+ *
+ * — measured on this host 2026-09-05, after 515s. That names the device, and
+ * `adb devices` then lists the device happily, so it sends the reader to the one
+ * diagnostic that cannot help. The same trap `wedged-appium-server.ts` exists to
+ * escape, one layer further down.
+ *
+ * ## The console is what tells the two apart
+ *
+ * `adb -s <device> emu <command>` is served by the **emulator's own console**,
+ * not by the guest's `adbd`. So the two probes answer different questions, and
+ * the pair is a diagnosis where either alone is a guess:
+ *
+ * | `adb shell` | `adb emu` | What it means |
+ * | --- | --- | --- |
+ * | succeeds | — | Alive. Proceed. |
+ * | fails | succeeds | The **guest** is frozen or too busy to schedule `adbd`. |
+ * | fails | fails | The **emulator process** is unreachable. Nothing will recover it. |
+ *
+ * Only a *successful* console probe clears the emulator — see
+ * {@link EmulatorLivenessProbeOutcome} for why a failed one cannot be read as
+ * the emulator answering.
+ *
+ * Measured 2026-09-05 across six hand-boots on this host — two AVDs and five
+ * argument sets — every one of which reached the bottom row 64–92s after boot:
+ *
+ * ```text
+ * 80s  emulator console (QEMU, not the guest): HUNG
+ * 80s  qemu-system-x86_64-headless (pid 10004): cpu=0% rss=5.82GB
+ * ```
+ *
+ * **0% CPU** — blocked, not spinning — and a console that cannot answer. That is
+ * the QEMU main loop, below anything the guest, the GPU stack, the network
+ * simulator or the AVD's size can explain (each was eliminated by measurement,
+ * not by argument). It also explains the two downstream symptoms that had always
+ * looked like separate faults: `adb devices` keeps reporting `device` because
+ * nothing is left running to update that state, and the teardown's
+ * `adb emu kill` hangs for its full budget because it is asking the wedged
+ * console to shut itself down.
+ *
+ * The harness already *observed* the second half of this — teardown logs
+ * `Emulator console shutdown for emulator-5554 did not answer` — but only after
+ * the run had already failed with an error blaming the device. This module moves
+ * that observation to where it changes the verdict instead of annotating it.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the classification and the message stay unit-testable — the
+ * factory itself shells out to `adb`.
+ */
+/**
+ * Parameters for {@link buildEmulatorLivenessMessage}.
+ */
+export interface BuildEmulatorLivenessMessageParams {
+    /**
+    The device the run was about to drive.
+     */
+    readonly deviceId: string;
+    /**
+    The emulator's captured stdout+stderr tail, when this run started it (empty when none).
+     */
+    readonly emulatorOutput: string;
+    /**
+    The per-probe budget, so the message states what "did not answer" was measured against.
+     */
+    readonly probeTimeoutInMilliseconds: number;
+    /**
+    Which failure this is. `'alive'` is not a failure and has no message.
+     */
+    readonly verdict: Exclude<EmulatorLivenessVerdict, 'alive'>;
+}
+/**
+ * Whether a probe got an answer from the thing it was asking.
+ *
+ * Two-valued on purpose. An earlier draft split failures into "errored" and
+ * "timed out" and read an errored console as *the emulator speaking, with a
+ * refusal* — which is wrong, and wrong in the exact way this module exists to
+ * avoid. `adb -s <device> emu <command>` is routed by the **adb server**: when
+ * the device is `offline` adb refuses on the spot and never reaches the console,
+ * so the error is adb's, not the emulator's. Measured 2026-09-05, where that
+ * draft logged `shell=errored, console=errored -> guest-unresponsive` for a
+ * device whose emulator then had to be killed by PID because `adb emu kill`
+ * could not reach it either. Only a **successful** probe is an answer.
+ */
+export type EmulatorLivenessProbeOutcome = 'answered' | 'no-answer';
+/**
+ * Whether the device is still usable, and if not, which layer failed.
+ *
+ * - `'alive'` — the guest answered. Proceed.
+ * - `'device-gone'` — the host's adb no longer lists it at all.
+ * - `'emulator-wedged'` — neither the guest nor the emulator's own console
+ *   answers. The emulator process is stuck; retrying anything against this
+ *   device cannot succeed.
+ * - `'guest-unresponsive'` — the console answers but the guest does not, so the
+ *   emulator is alive and the guest is frozen or starved.
+ */
+export type EmulatorLivenessVerdict = 'alive' | 'device-gone' | 'emulator-wedged' | 'guest-unresponsive';
+/**
+ * Parameters for {@link resolveEmulatorLivenessVerdict}.
+ */
+export interface ResolveEmulatorLivenessVerdictParams {
+    /**
+     * Whether `adb -s <device> emu avd status` succeeded — reaching the
+     * **emulator console**, served by the emulator process rather than by the
+     * guest.
+     *
+     * Meaningful only for an `emulator-<port>` device: the console fails against a
+     * physical handset however healthy it is, which is why a non-emulator is never
+     * convicted on it (the trap `avd-probe-verdict.ts` documents).
+     */
+    readonly consoleProbe: EmulatorLivenessProbeOutcome;
+    /**
+    The device the run is about to drive.
+     */
+    readonly deviceId: string;
+    /**
+    Whether the host's `adb devices` still lists the device in any state.
+     */
+    readonly isListedByAdb: boolean;
+    /**
+    What `adb -s <device> shell true` answered — the **guest**, via `adbd`.
+     */
+    readonly shellProbe: EmulatorLivenessProbeOutcome;
+}
+/**
+ * Builds the message for a device that stopped answering, naming the layer that
+ * failed and the evidence for it.
+ *
+ * @param params - The verdict, the device, the probe budget and the emulator's output.
+ * @returns The message.
+ */
+export declare function buildEmulatorLivenessMessage(params: BuildEmulatorLivenessMessageParams): string;
+/**
+ * Decides whether the device is still usable, and which layer failed when it is
+ * not.
+ *
+ * A guest that answers settles it on its own — a console probe is only consulted
+ * when the guest has already gone quiet, so a healthy run never pays for it.
+ *
+ * @param params - What each probe answered, and whether adb still lists the device.
+ * @returns The verdict.
+ */
+export declare function resolveEmulatorLivenessVerdict(params: ResolveEmulatorLivenessVerdictParams): EmulatorLivenessVerdict;

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

@@ -0,0 +1,57 @@
+"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 emulator_snapshot_exports = {};
+__export(emulator_snapshot_exports, {
+  buildAvdSnapshotDirectoryCandidates: () => buildAvdSnapshotDirectoryCandidates,
+  buildSnapshotAgeMessage: () => buildSnapshotAgeMessage
+});
+module.exports = __toCommonJS(emulator_snapshot_exports);
+const DEFAULT_SNAPSHOT_NAME = "default_boot";
+const AVD_HOME_SEGMENTS = [".android", "avd"];
+const TRAILING_SEPARATOR_PATTERN = /[/\\]+$/;
+function buildAvdSnapshotDirectoryCandidates(params) {
+  const { avdName, environment, homeDirectory } = params;
+  const avdHomes = [
+    environment["ANDROID_AVD_HOME"],
+    resolveAvdHomeUnder(environment["ANDROID_SDK_HOME"]),
+    resolveAvdHomeUnder(homeDirectory)
+  ];
+  return avdHomes.filter((avdHome) => avdHome !== void 0 && avdHome.length > 0).map((avdHome) => joinPath(avdHome, `${avdName}.avd`, "snapshots", DEFAULT_SNAPSHOT_NAME));
+}
+function buildSnapshotAgeMessage(params) {
+  if (params.savedAt === void 0) {
+    return `Snapshot reuse is enabled for AVD "${params.avdName}", but no \`${DEFAULT_SNAPSHOT_NAME}\` snapshot was found \u2014 this run cold-boots and saves one for the next.`;
+  }
+  return `Snapshot reuse is enabled for AVD "${params.avdName}": resuming \`${DEFAULT_SNAPSHOT_NAME}\` saved ${params.savedAt.toISOString()}.`;
+}
+function joinPath(base, ...segments) {
+  return [base.replace(TRAILING_SEPARATOR_PATTERN, ""), ...segments].join("/");
+}
+function resolveAvdHomeUnder(base) {
+  if (base === void 0 || base.length === 0) {
+    return void 0;
+  }
+  return joinPath(base, ...AVD_HOME_SEGMENTS);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAvdSnapshotDirectoryCandidates,
+  buildSnapshotAgeMessage
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLXNuYXBzaG90LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHVyZSBoZWxwZXJzIGZvciBsb2NhdGluZyBhbmQgZGVzY3JpYmluZyBhbiBBVkQncyBzYXZlZCBib290IHNuYXBzaG90LlxuICpcbiAqIE9ubHkgdGhlIG9wdC1pbiBgc2hvdWxkUmV1c2VFbXVsYXRvclNuYXBzaG90YCBwYXRoIHJlc3VtZXMgb25lLCBhbmQgZXZlbiB0aGVuXG4gKiBpdHMgYWdlIGlzIHdvcnRoIGEgbG9nIGxpbmU6IGEgc25hcHNob3QgaXMgdGhlIG9uZSBpbnB1dCB0byBhIHJ1biB0aGF0IG5vIGdhdGVcbiAqIGluc3BlY3RzLCBhbmQgdGhlIGZhaWx1cmUgYSByb3R0ZW4gb25lIHByb2R1Y2VzIFx1MjAxNCBhIGd1ZXN0IHRoYXQgc2VydmVzIGFkYixcbiAqIGFjY2VwdHMgYSB1aWF1dG9tYXRvcjIgc2Vzc2lvbiBhbmQgdGhlbiBkcm9wcyBgb2ZmbGluZWAgYWJvdXQgaGFsZiBhIG1pbnV0ZVxuICogbGF0ZXIgXHUyMDE0IHJlYWRzIGFzIGEgY29kZSByZWdyZXNzaW9uIHJhdGhlciB0aGFuIGFzIHN0YWxlIHN0YXRlLiBgZW11bGF0b3JcbiAqIC1hdmQgXHUyMDI2IC1uby1zbmFwc2hvdC1sb2FkYCAodGhlIGRlZmF1bHQpIG1ha2VzIHRoZSBxdWVzdGlvbiBtb290OyB3aGVuIHRoZVxuICogY2FsbGVyIGhhcyBkZWxpYmVyYXRlbHkgdHJhZGVkIHRoYXQgYXdheSwgKlwicmVzdW1pbmcgc25hcHNob3Qgc2F2ZWQgPGRhdGU+XCIqXG4gKiBpcyB3aGF0IGtlZXBzIHRoZSB0cmFkZSB2aXNpYmxlIGluIHRoZSB0cmFuc2NyaXB0LlxuICpcbiAqIEtlcHQgc2VwYXJhdGUgZnJvbSB0aGUgaW50ZWdyYXRpb24tb25seSBgdHJhbnNwb3J0LWZhY3RvcnlgIHNvIHRoZSBwYXRoXG4gKiBkZXJpdmF0aW9uIGFuZCB0aGUgd29yZGluZyBzdGF5IHVuaXQtdGVzdGFibGUgXHUyMDE0IHRoZSBmYWN0b3J5IGl0c2VsZiBkb2VzIHRoZVxuICogYHN0YXRgLlxuICovXG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGJ1aWxkQXZkU25hcHNob3REaXJlY3RvcnlDYW5kaWRhdGVzfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZEF2ZFNuYXBzaG90RGlyZWN0b3J5Q2FuZGlkYXRlc1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICBUaGUgcHJvY2VzcyBlbnZpcm9ubWVudCwgcmVhZCBmb3IgdGhlIEFuZHJvaWQgU0RLJ3MgQVZELWhvbWUgb3ZlcnJpZGVzLlxuICAgKi9cbiAgcmVhZG9ubHkgZW52aXJvbm1lbnQ6IFJlYWRvbmx5PFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IHVuZGVmaW5lZD4+O1xuXG4gIC8qKlxuICBUaGUgdXNlcidzIGhvbWUgZGlyZWN0b3J5LCB0aGUgYmFzZSBvZiB0aGUgZGVmYXVsdCBBVkQgaG9tZS5cbiAgICovXG4gIHJlYWRvbmx5IGhvbWVEaXJlY3Rvcnk6IHN0cmluZztcbn1cblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRTbmFwc2hvdEFnZU1lc3NhZ2V9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEJ1aWxkU25hcHNob3RBZ2VNZXNzYWdlUGFyYW1zIHtcbiAgLyoqXG4gIFRoZSBBbmRyb2lkIFZpcnR1YWwgRGV2aWNlIG5hbWUuXG4gICAqL1xuICByZWFkb25seSBhdmROYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gIFdoZW4gdGhlIHNuYXBzaG90IHdhcyBsYXN0IHdyaXR0ZW4sIG9yIGB1bmRlZmluZWRgIHdoZW4gbm9uZSB3YXMgZm91bmQuXG4gICAqL1xuICByZWFkb25seSBzYXZlZEF0PzogRGF0ZSB8IHVuZGVmaW5lZDtcbn1cblxuLyoqXG4gKiBUaGUgc25hcHNob3QgdGhlIGVtdWxhdG9yIGxvYWRzIGFuZCBzYXZlcyBieSBkZWZhdWx0LlxuICovXG5jb25zdCBERUZBVUxUX1NOQVBTSE9UX05BTUUgPSAnZGVmYXVsdF9ib290JztcblxuLyoqXG4gKiBUaGUgZGlyZWN0b3J5IHRoZSBBbmRyb2lkIFNESyBrZWVwcyBBVkRzIGluLCB1bmRlciB3aGljaGV2ZXIgaG9tZSBhcHBsaWVzLlxuICovXG5jb25zdCBBVkRfSE9NRV9TRUdNRU5UUyA9IFsnLmFuZHJvaWQnLCAnYXZkJ107XG5jb25zdCBUUkFJTElOR19TRVBBUkFUT1JfUEFUVEVSTiA9IC9bL1xcXFxdKyQvO1xuXG4vKipcbiAqIEJ1aWxkcyB0aGUgZGlyZWN0b3JpZXMgdGhlIEFWRCdzIGJvb3Qgc25hcHNob3QgY291bGQgbGl2ZSBpbiwgbW9zdCBzcGVjaWZpY1xuICogZmlyc3QuXG4gKlxuICogVGhlIGxvb2t1cCBtaXJyb3JzIHRoZSBlbXVsYXRvcidzIG93bjogYEFORFJPSURfQVZEX0hPTUVgIHdpbnMgb3V0cmlnaHQsIHRoZW5cbiAqIGAuYW5kcm9pZC9hdmRgIHVuZGVyIGBBTkRST0lEX1NES19IT01FYCwgdGhlbiB1bmRlciB0aGUgdXNlcidzIGhvbWUuIFJldHVybmluZ1xuICogY2FuZGlkYXRlcyByYXRoZXIgdGhhbiBvbmUgcGF0aCBrZWVwcyB0aGUgYHN0YXRgIFx1MjAxNCBhbmQgdGhlIGRlY2lzaW9uIHRoYXQgYVxuICogbWlzcyBpcyBub3QgYW4gZXJyb3IgXHUyMDE0IGluIHRoZSBjYWxsZXIuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBBVkQgbmFtZSwgdGhlIGVudmlyb25tZW50LCBhbmQgdGhlIGhvbWUgZGlyZWN0b3J5LlxuICogQHJldHVybnMgVGhlIGNhbmRpZGF0ZSBzbmFwc2hvdCBkaXJlY3RvcmllcywgbW9zdCBzcGVjaWZpYyBmaXJzdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkQXZkU25hcHNob3REaXJlY3RvcnlDYW5kaWRhdGVzKHBhcmFtczogQnVpbGRBdmRTbmFwc2hvdERpcmVjdG9yeUNhbmRpZGF0ZXNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IHsgYXZkTmFtZSwgZW52aXJvbm1lbnQsIGhvbWVEaXJlY3RvcnkgfSA9IHBhcmFtcztcblxuICBjb25zdCBhdmRIb21lcyA9IFtcbiAgICBlbnZpcm9ubWVudFsnQU5EUk9JRF9BVkRfSE9NRSddLFxuICAgIHJlc29sdmVBdmRIb21lVW5kZXIoZW52aXJvbm1lbnRbJ0FORFJPSURfU0RLX0hPTUUnXSksXG4gICAgcmVzb2x2ZUF2ZEhvbWVVbmRlcihob21lRGlyZWN0b3J5KVxuICBdO1xuXG4gIHJldHVybiBhdmRIb21lc1xuICAgIC5maWx0ZXIoKGF2ZEhvbWUpOiBhdmRIb21lIGlzIHN0cmluZyA9PiBhdmRIb21lICE9PSB1bmRlZmluZWQgJiYgYXZkSG9tZS5sZW5ndGggPiAwKVxuICAgIC5tYXAoKGF2ZEhvbWUpID0+IGpvaW5QYXRoKGF2ZEhvbWUsIGAke2F2ZE5hbWV9LmF2ZGAsICdzbmFwc2hvdHMnLCBERUZBVUxUX1NOQVBTSE9UX05BTUUpKTtcbn1cblxuLyoqXG4gKiBCdWlsZHMgdGhlIGxpbmUgbG9nZ2VkIHdoZW4gYSBydW4gaGFzIG9wdGVkIGludG8gcmVzdW1pbmcgYSBzbmFwc2hvdC5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIEFWRCBuYW1lIGFuZCB0aGUgc25hcHNob3QncyBzYXZlIHRpbWUsIGlmIGl0IHdhcyBmb3VuZC5cbiAqIEByZXR1cm5zIFRoZSBsb2cgbGluZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkU25hcHNob3RBZ2VNZXNzYWdlKHBhcmFtczogQnVpbGRTbmFwc2hvdEFnZU1lc3NhZ2VQYXJhbXMpOiBzdHJpbmcge1xuICBpZiAocGFyYW1zLnNhdmVkQXQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBgU25hcHNob3QgcmV1c2UgaXMgZW5hYmxlZCBmb3IgQVZEIFwiJHtwYXJhbXMuYXZkTmFtZX1cIiwgYnV0IG5vIFxcYCR7REVGQVVMVF9TTkFQU0hPVF9OQU1FfVxcYCBzbmFwc2hvdCB3YXMgZm91bmQgXHUyMDE0IHRoaXMgcnVuIGNvbGQtYm9vdHMgYW5kIHNhdmVzIG9uZSBmb3IgdGhlIG5leHQuYDtcbiAgfVxuXG4gIHJldHVybiBgU25hcHNob3QgcmV1c2UgaXMgZW5hYmxlZCBmb3IgQVZEIFwiJHtwYXJhbXMuYXZkTmFtZX1cIjogcmVzdW1pbmcgXFxgJHtERUZBVUxUX1NOQVBTSE9UX05BTUV9XFxgIHNhdmVkICR7cGFyYW1zLnNhdmVkQXQudG9JU09TdHJpbmcoKX0uYDtcbn1cblxuLyoqXG4gKiBKb2lucyBwYXRoIHNlZ21lbnRzIHdpdGggYC9gLCB3aGljaCBldmVyeSBwbGF0Zm9ybSdzIHBhdGggQVBJcyBhY2NlcHQuXG4gKlxuICogQHBhcmFtIGJhc2UgLSBUaGUgbGVhZGluZyBzZWdtZW50LCB3aG9zZSB0cmFpbGluZyBzZXBhcmF0b3JzIGFyZSBkcm9wcGVkLlxuICogQHBhcmFtIHNlZ21lbnRzIC0gVGhlIHNlZ21lbnRzIHRvIGFwcGVuZC5cbiAqIEByZXR1cm5zIFRoZSBqb2luZWQgcGF0aC5cbiAqL1xuZnVuY3Rpb24gam9pblBhdGgoYmFzZTogc3RyaW5nLCAuLi5zZWdtZW50czogc3RyaW5nW10pOiBzdHJpbmcge1xuICByZXR1cm4gW2Jhc2UucmVwbGFjZShUUkFJTElOR19TRVBBUkFUT1JfUEFUVEVSTiwgJycpLCAuLi5zZWdtZW50c10uam9pbignLycpO1xufVxuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBBVkQgaG9tZSB1bmRlciBhIGJhc2UgZGlyZWN0b3J5LCB3aGVuIHRoZXJlIGlzIG9uZS5cbiAqXG4gKiBAcGFyYW0gYmFzZSAtIGBBTkRST0lEX1NES19IT01FYCBvciB0aGUgdXNlcidzIGhvbWUgZGlyZWN0b3J5LlxuICogQHJldHVybnMgVGhlIEFWRCBob21lLCBvciBgdW5kZWZpbmVkYCB3aGVuIGBiYXNlYCBpcyB1bnNldC5cbiAqL1xuZnVuY3Rpb24gcmVzb2x2ZUF2ZEhvbWVVbmRlcihiYXNlOiBzdHJpbmcgfCB1bmRlZmluZWQpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICBpZiAoYmFzZSA9PT0gdW5kZWZpbmVkIHx8IGJhc2UubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIHJldHVybiBqb2luUGF0aChiYXNlLCAuLi5BVkRfSE9NRV9TRUdNRU5UUyk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUF5REEsTUFBTSx3QkFBd0I7QUFLOUIsTUFBTSxvQkFBb0IsQ0FBQyxZQUFZLEtBQUs7QUFDNUMsTUFBTSw2QkFBNkI7QUFjNUIsU0FBUyxvQ0FBb0MsUUFBNkQ7QUFDL0csUUFBTSxFQUFFLFNBQVMsYUFBYSxjQUFjLElBQUk7QUFFaEQsUUFBTSxXQUFXO0FBQUEsSUFDZixZQUFZLGtCQUFrQjtBQUFBLElBQzlCLG9CQUFvQixZQUFZLGtCQUFrQixDQUFDO0FBQUEsSUFDbkQsb0JBQW9CLGFBQWE7QUFBQSxFQUNuQztBQUVBLFNBQU8sU0FDSixPQUFPLENBQUMsWUFBK0IsWUFBWSxVQUFhLFFBQVEsU0FBUyxDQUFDLEVBQ2xGLElBQUksQ0FBQyxZQUFZLFNBQVMsU0FBUyxHQUFHLE9BQU8sUUFBUSxhQUFhLHFCQUFxQixDQUFDO0FBQzdGO0FBUU8sU0FBUyx3QkFBd0IsUUFBK0M7QUFDckYsTUFBSSxPQUFPLFlBQVksUUFBVztBQUNoQyxXQUFPLHNDQUFzQyxPQUFPLE9BQU8sZUFBZSxxQkFBcUI7QUFBQSxFQUNqRztBQUVBLFNBQU8sc0NBQXNDLE9BQU8sT0FBTyxpQkFBaUIscUJBQXFCLFlBQVksT0FBTyxRQUFRLFlBQVksQ0FBQztBQUMzSTtBQVNBLFNBQVMsU0FBUyxTQUFpQixVQUE0QjtBQUM3RCxTQUFPLENBQUMsS0FBSyxRQUFRLDRCQUE0QixFQUFFLEdBQUcsR0FBRyxRQUFRLEVBQUUsS0FBSyxHQUFHO0FBQzdFO0FBUUEsU0FBUyxvQkFBb0IsTUFBOEM7QUFDekUsTUFBSSxTQUFTLFVBQWEsS0FBSyxXQUFXLEdBQUc7QUFDM0MsV0FBTztBQUFBLEVBQ1Q7QUFFQSxTQUFPLFNBQVMsTUFBTSxHQUFHLGlCQUFpQjtBQUM1QzsiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,68 @@
+/**
+ * @file
+ *
+ * Pure helpers for locating and describing an AVD's saved boot snapshot.
+ *
+ * Only the opt-in `shouldReuseEmulatorSnapshot` path resumes one, and even then
+ * its age is worth a log line: a snapshot is the one input to a run that no gate
+ * inspects, and the failure a rotten one produces — a guest that serves adb,
+ * accepts a uiautomator2 session and then drops `offline` about half a minute
+ * later — reads as a code regression rather than as stale state. `emulator
+ * -avd … -no-snapshot-load` (the default) makes the question moot; when the
+ * caller has deliberately traded that away, *"resuming snapshot saved <date>"*
+ * is what keeps the trade visible in the transcript.
+ *
+ * Kept separate from the integration-only `transport-factory` so the path
+ * derivation and the wording stay unit-testable — the factory itself does the
+ * `stat`.
+ */
+/**
+ * Parameters for {@link buildAvdSnapshotDirectoryCandidates}.
+ */
+export interface BuildAvdSnapshotDirectoryCandidatesParams {
+    /**
+    The Android Virtual Device name.
+     */
+    readonly avdName: string;
+    /**
+    The process environment, read for the Android SDK's AVD-home overrides.
+     */
+    readonly environment: Readonly<Record<string, string | undefined>>;
+    /**
+    The user's home directory, the base of the default AVD home.
+     */
+    readonly homeDirectory: string;
+}
+/**
+ * Parameters for {@link buildSnapshotAgeMessage}.
+ */
+export interface BuildSnapshotAgeMessageParams {
+    /**
+    The Android Virtual Device name.
+     */
+    readonly avdName: string;
+    /**
+    When the snapshot was last written, or `undefined` when none was found.
+     */
+    readonly savedAt?: Date | undefined;
+}
+/**
+ * Builds the directories the AVD's boot snapshot could live in, most specific
+ * first.
+ *
+ * The lookup mirrors the emulator's own: `ANDROID_AVD_HOME` wins outright, then
+ * `.android/avd` under `ANDROID_SDK_HOME`, then under the user's home. Returning
+ * candidates rather than one path keeps the `stat` — and the decision that a
+ * miss is not an error — in the caller.
+ *
+ * @param params - The AVD name, the environment, and the home directory.
+ * @returns The candidate snapshot directories, most specific first.
+ */
+export declare function buildAvdSnapshotDirectoryCandidates(params: BuildAvdSnapshotDirectoryCandidatesParams): string[];
+/**
+ * Builds the line logged when a run has opted into resuming a snapshot.
+ *
+ * @param params - The AVD name and the snapshot's save time, if it was found.
+ * @returns The log line.
+ */
+export declare function buildSnapshotAgeMessage(params: BuildSnapshotAgeMessageParams): string;