obsidian-integration-testing 12.0.0 → 12.1.0

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

@@ -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/esm/emulator-liveness.mjs

@@ -0,0 +1,47 @@
+import { checkIsEmulatorDeviceId } from "./avd-probe-verdict.mjs";
+import { appendProcessOutputTail } from "./process-exit-message.mjs";
+function buildEmulatorLivenessMessage(params) {
+  const budget = `${String(params.probeTimeoutInMilliseconds)}ms`;
+  const diagnosis = {
+    "device-gone": [
+      "The host's `adb devices` no longer lists it, so it is no longer serving adb at all.",
+      "Either the emulator exited, or it wedged badly enough to drop off adb \u2014 the emulator output below is the best evidence for which.",
+      "An emulator this run started is replaced automatically once, so seeing this means the replacement did not survive either. Check that nothing else on this host stops emulators, and that the emulator build and system image are sound."
+    ],
+    "emulator-wedged": [
+      `Neither the guest (\`adb -s ${params.deviceId} shell\`) nor the emulator's own console (\`adb -s ${params.deviceId} emu avd status\`) answered within ${budget}.`,
+      "The console is served by the emulator process, not by the guest, so its silence means the EMULATOR is wedged \u2014 not the guest, not the Appium server, and not the device being absent.",
+      "`adb devices` will still list this device and will mislead you: nothing is left running to update that state.",
+      "A wedged emulator does not come back, so retrying the session against it cannot succeed. One this run started is replaced with a fresh boot automatically, which means seeing this message is the replacement failing too.",
+      "If it recurs at the same point in every run, the fault is below the harness \u2014 and the first thing to check is what filters this host's sockets. Endpoint-security, content-blocking and VPN products install socket filter drivers in the path of every socket call the emulator makes, the console's localhost connection included; stopping that service has fixed exactly this signature. After that, the emulator build, the system image and the host hypervisor."
+    ],
+    "guest-unresponsive": [
+      `The guest (\`adb -s ${params.deviceId} shell\`) did not answer within ${budget}, but the emulator's own console did.`,
+      "So the emulator process is healthy and the guest is frozen or too starved to schedule `adbd`.",
+      "A contended host is the usual cause; `deviceIdleTimeoutInMilliseconds` is the budget that governs waiting one out.",
+      "But if it recurs at the same point in every run, no timeout will fix it, and the host is not merely busy. Check what filters this host's sockets first \u2014 a content-blocking, endpoint-security or VPN socket filter driver produces this verdict as readily as it produces a fully wedged emulator \u2014 then the emulator build, the system image and the host hypervisor."
+    ]
+  };
+  const lines = [
+    `Device ${params.deviceId} stopped answering before the Appium session could be established.`,
+    ...diagnosis[params.verdict]
+  ];
+  return appendProcessOutputTail(lines.join("\n"), { output: params.emulatorOutput, outputLabel: "Emulator output" });
+}
+function resolveEmulatorLivenessVerdict(params) {
+  if (params.shellProbe === "answered") {
+    return "alive";
+  }
+  if (!params.isListedByAdb) {
+    return "device-gone";
+  }
+  if (!checkIsEmulatorDeviceId(params.deviceId)) {
+    return "guest-unresponsive";
+  }
+  return params.consoleProbe === "answered" ? "guest-unresponsive" : "emulator-wedged";
+}
+export {
+  buildEmulatorLivenessMessage,
+  resolveEmulatorLivenessVerdict
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of whether the device a run is about to drive is still\n * **there** \u2014 and, when it is not, which of the two very different things went\n * wrong: the guest froze, or the emulator process itself did.\n *\n * The readiness gates in `device-readiness.ts` answer *\"is the guest ready\n * yet?\"*, and both are deliberately best-effort: they warn and proceed. Nothing\n * asked *\"is it still answering?\"* at the moment the session is created, so a\n * guest that stopped answering between the last gate and `remote()` was handed\n * to Appium anyway. What the operator then saw was Appium's own report:\n *\n * ```text\n * WebDriverError: Device emulator-5554 was not in the list of connected devices\n *   when running \"http://localhost:4723/session\" with method \"POST\"\n * ```\n *\n * \u2014 measured on this host 2026-09-05, after 515s. That names the device, and\n * `adb devices` then lists the device happily, so it sends the reader to the one\n * diagnostic that cannot help. The same trap `wedged-appium-server.ts` exists to\n * escape, one layer further down.\n *\n * ## The console is what tells the two apart\n *\n * `adb -s <device> emu <command>` is served by the **emulator's own console**,\n * not by the guest's `adbd`. So the two probes answer different questions, and\n * the pair is a diagnosis where either alone is a guess:\n *\n * | `adb shell` | `adb emu` | What it means |\n * | --- | --- | --- |\n * | succeeds | \u2014 | Alive. Proceed. |\n * | fails | succeeds | The **guest** is frozen or too busy to schedule `adbd`. |\n * | fails | fails | The **emulator process** is unreachable. Nothing will recover it. |\n *\n * Only a *successful* console probe clears the emulator \u2014 see\n * {@link EmulatorLivenessProbeOutcome} for why a failed one cannot be read as\n * the emulator answering.\n *\n * Measured 2026-09-05 across six hand-boots on this host \u2014 two AVDs and five\n * argument sets \u2014 every one of which reached the bottom row 64\u201392s after boot:\n *\n * ```text\n * 80s  emulator console (QEMU, not the guest): HUNG\n * 80s  qemu-system-x86_64-headless (pid 10004): cpu=0% rss=5.82GB\n * ```\n *\n * **0% CPU** \u2014 blocked, not spinning \u2014 and a console that cannot answer. That is\n * the QEMU main loop, below anything the guest, the GPU stack, the network\n * simulator or the AVD's size can explain (each was eliminated by measurement,\n * not by argument). It also explains the two downstream symptoms that had always\n * looked like separate faults: `adb devices` keeps reporting `device` because\n * nothing is left running to update that state, and the teardown's\n * `adb emu kill` hangs for its full budget because it is asking the wedged\n * console to shut itself down.\n *\n * The harness already *observed* the second half of this \u2014 teardown logs\n * `Emulator console shutdown for emulator-5554 did not answer` \u2014 but only after\n * the run had already failed with an error blaming the device. This module moves\n * that observation to where it changes the verdict instead of annotating it.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification and the message stay unit-testable \u2014 the\n * factory itself shells out to `adb`.\n */\n\nimport { checkIsEmulatorDeviceId } from './avd-probe-verdict.mjs';\nimport { appendProcessOutputTail } from './process-exit-message.mjs';\n\n/**\n * Parameters for {@link buildEmulatorLivenessMessage}.\n */\nexport interface BuildEmulatorLivenessMessageParams {\n  /**\n  The device the run was about to drive.\n   */\n  readonly deviceId: string;\n\n  /**\n  The emulator's captured stdout+stderr tail, when this run started it (empty when none).\n   */\n  readonly emulatorOutput: string;\n\n  /**\n  The per-probe budget, so the message states what \"did not answer\" was measured against.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  Which failure this is. `'alive'` is not a failure and has no message.\n   */\n  readonly verdict: Exclude<EmulatorLivenessVerdict, 'alive'>;\n}\n\n/**\n * Whether a probe got an answer from the thing it was asking.\n *\n * Two-valued on purpose. An earlier draft split failures into \"errored\" and\n * \"timed out\" and read an errored console as *the emulator speaking, with a\n * refusal* \u2014 which is wrong, and wrong in the exact way this module exists to\n * avoid. `adb -s <device> emu <command>` is routed by the **adb server**: when\n * the device is `offline` adb refuses on the spot and never reaches the console,\n * so the error is adb's, not the emulator's. Measured 2026-09-05, where that\n * draft logged `shell=errored, console=errored -> guest-unresponsive` for a\n * device whose emulator then had to be killed by PID because `adb emu kill`\n * could not reach it either. Only a **successful** probe is an answer.\n */\nexport type EmulatorLivenessProbeOutcome = 'answered' | 'no-answer';\n\n/**\n * Whether the device is still usable, and if not, which layer failed.\n *\n * - `'alive'` \u2014 the guest answered. Proceed.\n * - `'device-gone'` \u2014 the host's adb no longer lists it at all.\n * - `'emulator-wedged'` \u2014 neither the guest nor the emulator's own console\n *   answers. The emulator process is stuck; retrying anything against this\n *   device cannot succeed.\n * - `'guest-unresponsive'` \u2014 the console answers but the guest does not, so the\n *   emulator is alive and the guest is frozen or starved.\n */\nexport type EmulatorLivenessVerdict = 'alive' | 'device-gone' | 'emulator-wedged' | 'guest-unresponsive';\n\n/**\n * Parameters for {@link resolveEmulatorLivenessVerdict}.\n */\nexport interface ResolveEmulatorLivenessVerdictParams {\n  /**\n   * Whether `adb -s <device> emu avd status` succeeded \u2014 reaching the\n   * **emulator console**, served by the emulator process rather than by the\n   * guest.\n   *\n   * Meaningful only for an `emulator-<port>` device: the console fails against a\n   * physical handset however healthy it is, which is why a non-emulator is never\n   * convicted on it (the trap `avd-probe-verdict.ts` documents).\n   */\n  readonly consoleProbe: EmulatorLivenessProbeOutcome;\n\n  /**\n  The device the run is about to drive.\n   */\n  readonly deviceId: string;\n\n  /**\n  Whether the host's `adb devices` still lists the device in any state.\n   */\n  readonly isListedByAdb: boolean;\n\n  /**\n  What `adb -s <device> shell true` answered \u2014 the **guest**, via `adbd`.\n   */\n  readonly shellProbe: EmulatorLivenessProbeOutcome;\n}\n\n/**\n * Builds the message for a device that stopped answering, naming the layer that\n * failed and the evidence for it.\n *\n * @param params - The verdict, the device, the probe budget and the emulator's output.\n * @returns The message.\n */\nexport function buildEmulatorLivenessMessage(params: BuildEmulatorLivenessMessageParams): string {\n  const budget = `${String(params.probeTimeoutInMilliseconds)}ms`;\n\n  /*\n   * A `Record` keyed by the verdict rather than a `switch`: exhaustiveness comes\n   * from the type, with no unreachable `default` arm to explain or to cover.\n   * Same shape as `resolveRemedyAdvice` in `wedged-appium-server.ts`.\n   */\n  const diagnosis: Record<Exclude<EmulatorLivenessVerdict, 'alive'>, string[]> = {\n    'device-gone': [\n      'The host\\'s `adb devices` no longer lists it, so it is no longer serving adb at all.',\n      'Either the emulator exited, or it wedged badly enough to drop off adb \u2014 the emulator output below is the best evidence for which.',\n      'An emulator this run started is replaced automatically once, so seeing this means the replacement did not survive either. Check that nothing else on this host stops emulators, and that the emulator build and system image are sound.'\n    ],\n    'emulator-wedged': [\n      `Neither the guest (\\`adb -s ${params.deviceId} shell\\`) nor the emulator's own console (\\`adb -s ${params.deviceId} emu avd status\\`) answered within ${budget}.`,\n      'The console is served by the emulator process, not by the guest, so its silence means the EMULATOR is wedged \u2014 not the guest, not the Appium server, and not the device being absent.',\n      '`adb devices` will still list this device and will mislead you: nothing is left running to update that state.',\n      'A wedged emulator does not come back, so retrying the session against it cannot succeed. One this run started is replaced with a fresh boot automatically, which means seeing this message is the replacement failing too.',\n      'If it recurs at the same point in every run, the fault is below the harness \u2014 and the first thing to check is what filters this host\\'s sockets. Endpoint-security, content-blocking and VPN products install socket filter drivers in the path of every socket call the emulator makes, the console\\'s localhost connection included; stopping that service has fixed exactly this signature. After that, the emulator build, the system image and the host hypervisor.'\n    ],\n    'guest-unresponsive': [\n      `The guest (\\`adb -s ${params.deviceId} shell\\`) did not answer within ${budget}, but the emulator's own console did.`,\n      'So the emulator process is healthy and the guest is frozen or too starved to schedule `adbd`.',\n      'A contended host is the usual cause; `deviceIdleTimeoutInMilliseconds` is the budget that governs waiting one out.',\n      'But if it recurs at the same point in every run, no timeout will fix it, and the host is not merely busy. Check what filters this host\\'s sockets first \u2014 a content-blocking, endpoint-security or VPN socket filter driver produces this verdict as readily as it produces a fully wedged emulator \u2014 then the emulator build, the system image and the host hypervisor.'\n    ]\n  };\n\n  const lines = [\n    `Device ${params.deviceId} stopped answering before the Appium session could be established.`,\n    ...diagnosis[params.verdict]\n  ];\n\n  return appendProcessOutputTail(lines.join('\\n'), { output: params.emulatorOutput, outputLabel: 'Emulator output' });\n}\n\n/**\n * Decides whether the device is still usable, and which layer failed when it is\n * not.\n *\n * A guest that answers settles it on its own \u2014 a console probe is only consulted\n * when the guest has already gone quiet, so a healthy run never pays for it.\n *\n * @param params - What each probe answered, and whether adb still lists the device.\n * @returns The verdict.\n */\nexport function resolveEmulatorLivenessVerdict(params: ResolveEmulatorLivenessVerdictParams): EmulatorLivenessVerdict {\n  if (params.shellProbe === 'answered') {\n    return 'alive';\n  }\n\n  if (!params.isListedByAdb) {\n    return 'device-gone';\n  }\n\n  /*\n   * `adb \u2026 emu` errors against a physical handset however healthy it is, so its\n   * silence is not evidence there. Only an `emulator-<port>` device has a\n   * console whose silence can convict it \u2014 the same restraint `classifyAvdProbe`\n   * shows in never probing a non-emulator at all.\n   */\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'guest-unresponsive';\n  }\n\n  return params.consoleProbe === 'answered' ? 'guest-unresponsive' : 'emulator-wedged';\n}\n"],
  "mappings": "AAkEA,SAAS,+BAA+B;AACxC,SAAS,+BAA+B;AA6FjC,SAAS,6BAA6B,QAAoD;AAC/F,QAAM,SAAS,GAAG,OAAO,OAAO,0BAA0B,CAAC;AAO3D,QAAM,YAAyE;AAAA,IAC7E,eAAe;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,mBAAmB;AAAA,MACjB,+BAA+B,OAAO,QAAQ,sDAAsD,OAAO,QAAQ,sCAAsC,MAAM;AAAA,MAC/J;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,sBAAsB;AAAA,MACpB,uBAAuB,OAAO,QAAQ,mCAAmC,MAAM;AAAA,MAC/E;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ;AAAA,IACZ,UAAU,OAAO,QAAQ;AAAA,IACzB,GAAG,UAAU,OAAO,OAAO;AAAA,EAC7B;AAEA,SAAO,wBAAwB,MAAM,KAAK,IAAI,GAAG,EAAE,QAAQ,OAAO,gBAAgB,aAAa,kBAAkB,CAAC;AACpH;AAYO,SAAS,+BAA+B,QAAuE;AACpH,MAAI,OAAO,eAAe,YAAY;AACpC,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,OAAO,eAAe;AACzB,WAAO;AAAA,EACT;AAQA,MAAI,CAAC,wBAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,iBAAiB,aAAa,uBAAuB;AACrE;",
  "names": []
}


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

@@ -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;

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

@@ -0,0 +1,32 @@
+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);
+}
+export {
+  buildAvdSnapshotDirectoryCandidates,
+  buildSnapshotAgeMessage
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLXNuYXBzaG90LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHVyZSBoZWxwZXJzIGZvciBsb2NhdGluZyBhbmQgZGVzY3JpYmluZyBhbiBBVkQncyBzYXZlZCBib290IHNuYXBzaG90LlxuICpcbiAqIE9ubHkgdGhlIG9wdC1pbiBgc2hvdWxkUmV1c2VFbXVsYXRvclNuYXBzaG90YCBwYXRoIHJlc3VtZXMgb25lLCBhbmQgZXZlbiB0aGVuXG4gKiBpdHMgYWdlIGlzIHdvcnRoIGEgbG9nIGxpbmU6IGEgc25hcHNob3QgaXMgdGhlIG9uZSBpbnB1dCB0byBhIHJ1biB0aGF0IG5vIGdhdGVcbiAqIGluc3BlY3RzLCBhbmQgdGhlIGZhaWx1cmUgYSByb3R0ZW4gb25lIHByb2R1Y2VzIFx1MjAxNCBhIGd1ZXN0IHRoYXQgc2VydmVzIGFkYixcbiAqIGFjY2VwdHMgYSB1aWF1dG9tYXRvcjIgc2Vzc2lvbiBhbmQgdGhlbiBkcm9wcyBgb2ZmbGluZWAgYWJvdXQgaGFsZiBhIG1pbnV0ZVxuICogbGF0ZXIgXHUyMDE0IHJlYWRzIGFzIGEgY29kZSByZWdyZXNzaW9uIHJhdGhlciB0aGFuIGFzIHN0YWxlIHN0YXRlLiBgZW11bGF0b3JcbiAqIC1hdmQgXHUyMDI2IC1uby1zbmFwc2hvdC1sb2FkYCAodGhlIGRlZmF1bHQpIG1ha2VzIHRoZSBxdWVzdGlvbiBtb290OyB3aGVuIHRoZVxuICogY2FsbGVyIGhhcyBkZWxpYmVyYXRlbHkgdHJhZGVkIHRoYXQgYXdheSwgKlwicmVzdW1pbmcgc25hcHNob3Qgc2F2ZWQgPGRhdGU+XCIqXG4gKiBpcyB3aGF0IGtlZXBzIHRoZSB0cmFkZSB2aXNpYmxlIGluIHRoZSB0cmFuc2NyaXB0LlxuICpcbiAqIEtlcHQgc2VwYXJhdGUgZnJvbSB0aGUgaW50ZWdyYXRpb24tb25seSBgdHJhbnNwb3J0LWZhY3RvcnlgIHNvIHRoZSBwYXRoXG4gKiBkZXJpdmF0aW9uIGFuZCB0aGUgd29yZGluZyBzdGF5IHVuaXQtdGVzdGFibGUgXHUyMDE0IHRoZSBmYWN0b3J5IGl0c2VsZiBkb2VzIHRoZVxuICogYHN0YXRgLlxuICovXG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGJ1aWxkQXZkU25hcHNob3REaXJlY3RvcnlDYW5kaWRhdGVzfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZEF2ZFNuYXBzaG90RGlyZWN0b3J5Q2FuZGlkYXRlc1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICBUaGUgcHJvY2VzcyBlbnZpcm9ubWVudCwgcmVhZCBmb3IgdGhlIEFuZHJvaWQgU0RLJ3MgQVZELWhvbWUgb3ZlcnJpZGVzLlxuICAgKi9cbiAgcmVhZG9ubHkgZW52aXJvbm1lbnQ6IFJlYWRvbmx5PFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IHVuZGVmaW5lZD4+O1xuXG4gIC8qKlxuICBUaGUgdXNlcidzIGhvbWUgZGlyZWN0b3J5LCB0aGUgYmFzZSBvZiB0aGUgZGVmYXVsdCBBVkQgaG9tZS5cbiAgICovXG4gIHJlYWRvbmx5IGhvbWVEaXJlY3Rvcnk6IHN0cmluZztcbn1cblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRTbmFwc2hvdEFnZU1lc3NhZ2V9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEJ1aWxkU25hcHNob3RBZ2VNZXNzYWdlUGFyYW1zIHtcbiAgLyoqXG4gIFRoZSBBbmRyb2lkIFZpcnR1YWwgRGV2aWNlIG5hbWUuXG4gICAqL1xuICByZWFkb25seSBhdmROYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gIFdoZW4gdGhlIHNuYXBzaG90IHdhcyBsYXN0IHdyaXR0ZW4sIG9yIGB1bmRlZmluZWRgIHdoZW4gbm9uZSB3YXMgZm91bmQuXG4gICAqL1xuICByZWFkb25seSBzYXZlZEF0PzogRGF0ZSB8IHVuZGVmaW5lZDtcbn1cblxuLyoqXG4gKiBUaGUgc25hcHNob3QgdGhlIGVtdWxhdG9yIGxvYWRzIGFuZCBzYXZlcyBieSBkZWZhdWx0LlxuICovXG5jb25zdCBERUZBVUxUX1NOQVBTSE9UX05BTUUgPSAnZGVmYXVsdF9ib290JztcblxuLyoqXG4gKiBUaGUgZGlyZWN0b3J5IHRoZSBBbmRyb2lkIFNESyBrZWVwcyBBVkRzIGluLCB1bmRlciB3aGljaGV2ZXIgaG9tZSBhcHBsaWVzLlxuICovXG5jb25zdCBBVkRfSE9NRV9TRUdNRU5UUyA9IFsnLmFuZHJvaWQnLCAnYXZkJ107XG5jb25zdCBUUkFJTElOR19TRVBBUkFUT1JfUEFUVEVSTiA9IC9bL1xcXFxdKyQvO1xuXG4vKipcbiAqIEJ1aWxkcyB0aGUgZGlyZWN0b3JpZXMgdGhlIEFWRCdzIGJvb3Qgc25hcHNob3QgY291bGQgbGl2ZSBpbiwgbW9zdCBzcGVjaWZpY1xuICogZmlyc3QuXG4gKlxuICogVGhlIGxvb2t1cCBtaXJyb3JzIHRoZSBlbXVsYXRvcidzIG93bjogYEFORFJPSURfQVZEX0hPTUVgIHdpbnMgb3V0cmlnaHQsIHRoZW5cbiAqIGAuYW5kcm9pZC9hdmRgIHVuZGVyIGBBTkRST0lEX1NES19IT01FYCwgdGhlbiB1bmRlciB0aGUgdXNlcidzIGhvbWUuIFJldHVybmluZ1xuICogY2FuZGlkYXRlcyByYXRoZXIgdGhhbiBvbmUgcGF0aCBrZWVwcyB0aGUgYHN0YXRgIFx1MjAxNCBhbmQgdGhlIGRlY2lzaW9uIHRoYXQgYVxuICogbWlzcyBpcyBub3QgYW4gZXJyb3IgXHUyMDE0IGluIHRoZSBjYWxsZXIuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBBVkQgbmFtZSwgdGhlIGVudmlyb25tZW50LCBhbmQgdGhlIGhvbWUgZGlyZWN0b3J5LlxuICogQHJldHVybnMgVGhlIGNhbmRpZGF0ZSBzbmFwc2hvdCBkaXJlY3RvcmllcywgbW9zdCBzcGVjaWZpYyBmaXJzdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkQXZkU25hcHNob3REaXJlY3RvcnlDYW5kaWRhdGVzKHBhcmFtczogQnVpbGRBdmRTbmFwc2hvdERpcmVjdG9yeUNhbmRpZGF0ZXNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IHsgYXZkTmFtZSwgZW52aXJvbm1lbnQsIGhvbWVEaXJlY3RvcnkgfSA9IHBhcmFtcztcblxuICBjb25zdCBhdmRIb21lcyA9IFtcbiAgICBlbnZpcm9ubWVudFsnQU5EUk9JRF9BVkRfSE9NRSddLFxuICAgIHJlc29sdmVBdmRIb21lVW5kZXIoZW52aXJvbm1lbnRbJ0FORFJPSURfU0RLX0hPTUUnXSksXG4gICAgcmVzb2x2ZUF2ZEhvbWVVbmRlcihob21lRGlyZWN0b3J5KVxuICBdO1xuXG4gIHJldHVybiBhdmRIb21lc1xuICAgIC5maWx0ZXIoKGF2ZEhvbWUpOiBhdmRIb21lIGlzIHN0cmluZyA9PiBhdmRIb21lICE9PSB1bmRlZmluZWQgJiYgYXZkSG9tZS5sZW5ndGggPiAwKVxuICAgIC5tYXAoKGF2ZEhvbWUpID0+IGpvaW5QYXRoKGF2ZEhvbWUsIGAke2F2ZE5hbWV9LmF2ZGAsICdzbmFwc2hvdHMnLCBERUZBVUxUX1NOQVBTSE9UX05BTUUpKTtcbn1cblxuLyoqXG4gKiBCdWlsZHMgdGhlIGxpbmUgbG9nZ2VkIHdoZW4gYSBydW4gaGFzIG9wdGVkIGludG8gcmVzdW1pbmcgYSBzbmFwc2hvdC5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIEFWRCBuYW1lIGFuZCB0aGUgc25hcHNob3QncyBzYXZlIHRpbWUsIGlmIGl0IHdhcyBmb3VuZC5cbiAqIEByZXR1cm5zIFRoZSBsb2cgbGluZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkU25hcHNob3RBZ2VNZXNzYWdlKHBhcmFtczogQnVpbGRTbmFwc2hvdEFnZU1lc3NhZ2VQYXJhbXMpOiBzdHJpbmcge1xuICBpZiAocGFyYW1zLnNhdmVkQXQgPT09IHVuZGVmaW5lZCkge1xuICAgIHJldHVybiBgU25hcHNob3QgcmV1c2UgaXMgZW5hYmxlZCBmb3IgQVZEIFwiJHtwYXJhbXMuYXZkTmFtZX1cIiwgYnV0IG5vIFxcYCR7REVGQVVMVF9TTkFQU0hPVF9OQU1FfVxcYCBzbmFwc2hvdCB3YXMgZm91bmQgXHUyMDE0IHRoaXMgcnVuIGNvbGQtYm9vdHMgYW5kIHNhdmVzIG9uZSBmb3IgdGhlIG5leHQuYDtcbiAgfVxuXG4gIHJldHVybiBgU25hcHNob3QgcmV1c2UgaXMgZW5hYmxlZCBmb3IgQVZEIFwiJHtwYXJhbXMuYXZkTmFtZX1cIjogcmVzdW1pbmcgXFxgJHtERUZBVUxUX1NOQVBTSE9UX05BTUV9XFxgIHNhdmVkICR7cGFyYW1zLnNhdmVkQXQudG9JU09TdHJpbmcoKX0uYDtcbn1cblxuLyoqXG4gKiBKb2lucyBwYXRoIHNlZ21lbnRzIHdpdGggYC9gLCB3aGljaCBldmVyeSBwbGF0Zm9ybSdzIHBhdGggQVBJcyBhY2NlcHQuXG4gKlxuICogQHBhcmFtIGJhc2UgLSBUaGUgbGVhZGluZyBzZWdtZW50LCB3aG9zZSB0cmFpbGluZyBzZXBhcmF0b3JzIGFyZSBkcm9wcGVkLlxuICogQHBhcmFtIHNlZ21lbnRzIC0gVGhlIHNlZ21lbnRzIHRvIGFwcGVuZC5cbiAqIEByZXR1cm5zIFRoZSBqb2luZWQgcGF0aC5cbiAqL1xuZnVuY3Rpb24gam9pblBhdGgoYmFzZTogc3RyaW5nLCAuLi5zZWdtZW50czogc3RyaW5nW10pOiBzdHJpbmcge1xuICByZXR1cm4gW2Jhc2UucmVwbGFjZShUUkFJTElOR19TRVBBUkFUT1JfUEFUVEVSTiwgJycpLCAuLi5zZWdtZW50c10uam9pbignLycpO1xufVxuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBBVkQgaG9tZSB1bmRlciBhIGJhc2UgZGlyZWN0b3J5LCB3aGVuIHRoZXJlIGlzIG9uZS5cbiAqXG4gKiBAcGFyYW0gYmFzZSAtIGBBTkRST0lEX1NES19IT01FYCBvciB0aGUgdXNlcidzIGhvbWUgZGlyZWN0b3J5LlxuICogQHJldHVybnMgVGhlIEFWRCBob21lLCBvciBgdW5kZWZpbmVkYCB3aGVuIGBiYXNlYCBpcyB1bnNldC5cbiAqL1xuZnVuY3Rpb24gcmVzb2x2ZUF2ZEhvbWVVbmRlcihiYXNlOiBzdHJpbmcgfCB1bmRlZmluZWQpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICBpZiAoYmFzZSA9PT0gdW5kZWZpbmVkIHx8IGJhc2UubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuXG4gIHJldHVybiBqb2luUGF0aChiYXNlLCAuLi5BVkRfSE9NRV9TRUdNRU5UUyk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUF5REEsTUFBTSx3QkFBd0I7QUFLOUIsTUFBTSxvQkFBb0IsQ0FBQyxZQUFZLEtBQUs7QUFDNUMsTUFBTSw2QkFBNkI7QUFjNUIsU0FBUyxvQ0FBb0MsUUFBNkQ7QUFDL0csUUFBTSxFQUFFLFNBQVMsYUFBYSxjQUFjLElBQUk7QUFFaEQsUUFBTSxXQUFXO0FBQUEsSUFDZixZQUFZLGtCQUFrQjtBQUFBLElBQzlCLG9CQUFvQixZQUFZLGtCQUFrQixDQUFDO0FBQUEsSUFDbkQsb0JBQW9CLGFBQWE7QUFBQSxFQUNuQztBQUVBLFNBQU8sU0FDSixPQUFPLENBQUMsWUFBK0IsWUFBWSxVQUFhLFFBQVEsU0FBUyxDQUFDLEVBQ2xGLElBQUksQ0FBQyxZQUFZLFNBQVMsU0FBUyxHQUFHLE9BQU8sUUFBUSxhQUFhLHFCQUFxQixDQUFDO0FBQzdGO0FBUU8sU0FBUyx3QkFBd0IsUUFBK0M7QUFDckYsTUFBSSxPQUFPLFlBQVksUUFBVztBQUNoQyxXQUFPLHNDQUFzQyxPQUFPLE9BQU8sZUFBZSxxQkFBcUI7QUFBQSxFQUNqRztBQUVBLFNBQU8sc0NBQXNDLE9BQU8sT0FBTyxpQkFBaUIscUJBQXFCLFlBQVksT0FBTyxRQUFRLFlBQVksQ0FBQztBQUMzSTtBQVNBLFNBQVMsU0FBUyxTQUFpQixVQUE0QjtBQUM3RCxTQUFPLENBQUMsS0FBSyxRQUFRLDRCQUE0QixFQUFFLEdBQUcsR0FBRyxRQUFRLEVBQUUsS0FBSyxHQUFHO0FBQzdFO0FBUUEsU0FBUyxvQkFBb0IsTUFBOEM7QUFDekUsTUFBSSxTQUFTLFVBQWEsS0FBSyxXQUFXLEdBQUc7QUFDM0MsV0FBTztBQUFBLEVBQ1Q7QUFFQSxTQUFPLFNBQVMsTUFBTSxHQUFHLGlCQUFpQjtBQUM1QzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/global-setup-core.d.mts

@@ -26,8 +26,8 @@ export interface CoreSetupParams {
      * Whether to install and enable the built plugin in the temp vault. Defaults
      * to `true`. Set to `false` for a **non-plugin** consumer (e.g. a typings
      * crawler) that only needs a registered, empty vault to `evalInObsidian`
-     * against: the plugin `dist`/`manifest.json` read, the copy into
-     * `.obsidian/plugins`, the `community-plugins.json` write, and the enable step
+     * against: the plugin `dist`/`manifest.json` read, the copy into the config
+     * folder's `plugins/`, the `community-plugins.json` write, and the enable step
      * are all skipped, while the transport, temp vault, registration, and
      * worker-facing endpoint provisioning still run unchanged.
      */
@@ -37,6 +37,11 @@ export interface CoreSetupParams {
      * its startup scan indexes them in one pass (see {@link TemporaryVault.populate}).
      * Use this for large fixtures — writing thousands of notes after open and
      * forcing a re-scan is far slower and less reliable.
+     *
+     * Keys naming the config folder are written as `.obsidian/…`; under a
+     * `configDirectory` override {@link remapConfigDirectoryKeys} redirects them to
+     * the folder the vault will actually read, so a map does not have to carry a
+     * second copy of the override.
      */
     readonly populate?: PopulateFilesParams | undefined;
     /**
@@ -87,6 +92,26 @@ export declare function coreSetup(params?: CoreSetupParams): Promise<CoreSetupRe
  * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.
  */
 export declare function coreTeardown(result?: CoreSetupResult): Promise<void>;
+/**
+ * Redirects a populate map's config-folder entries to the folder the vault will actually read.
+ *
+ * A populate map names its destinations vault-relative, and everything that builds one — including
+ * `buildDemoVaultPopulate`, which seeds `.obsidian/*` config files and injected community plugins'
+ * binaries — writes them under a literal `.obsidian/`, because that is the folder Obsidian uses when nothing
+ * overrides it. Under a `configDirectory` override those entries land in a folder the vault never opens, and
+ * the plugins seeded that way come back as the generic "enabled but not loaded" with nothing naming a config
+ * folder. Rewriting the key here fixes every consumer at once — a hand-written map as much as a demo vault's
+ * — and needs no second copy of the override for a caller to keep in sync with their transport options.
+ *
+ * Safe rather than magic: the vault is one the harness made for this run and has exactly one config folder,
+ * so under an override a `.obsidian/` entry is dead weight nothing reads. Only a leading `.obsidian` path
+ * SEGMENT moves; a note whose name merely contains the string does not.
+ *
+ * @param populate - The consumer's populate map.
+ * @param configDirectory - The resolved override, or `undefined` for Obsidian's default (a no-op).
+ * @returns The map with its config-folder keys redirected, or the original map when there is nothing to move.
+ */
+export declare function remapConfigDirectoryKeys(populate: PopulateFilesParams, configDirectory: string | undefined): PopulateFilesParams;
 /**
  * Resolves transport options for an integration run.
  *