obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/cjs/demo-vault-populate.d.cts

@@ -9,6 +9,12 @@
  * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,
  * that turns them on. It intentionally does NOT write `community-plugins.json` — the harness owns that file
  * (it lists the plugin-under-test), and enabling the extras persists them.
+ *
+ * Stays **synchronous**, so an injected plugin whose binaries are absent is a throw rather than a download.
+ * `demo-vault-bootstrap.ts` owns the headless install the throw's message points at — including
+ * `buildDemoVaultPopulateAsync`, the self-healing sibling of {@link buildDemoVaultPopulate}. The
+ * missing-plugin detection ({@link resolveMissingInjectedPlugins}) lives here and is shared with it, so the
+ * two paths cannot disagree about what "not installed" means.
  */
 import type { PopulateFilesParams } from './temporary-vault.cjs';
 /**
@@ -53,13 +59,56 @@ export interface InjectPluginParams {
      * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).
      */
     readonly pluginId: string;
+    /**
+     * The GitHub repository (`owner/name`) publishing this plugin, consulted **only** by the headless
+     * bootstrap (`bootstrapDemoVaultPlugins` / `buildDemoVaultPopulateAsync` / the
+     * `bootstrap-demo-vault` CLI) when the binaries are missing from the demo vault. Supplying it skips
+     * the lookup in Obsidian's community plugin registry, which is also the way to bootstrap a plugin
+     * that is not listed there at all. Never used when the files are already on disk.
+     */
+    readonly repo?: string | undefined;
     /**
      * Directory to read the plugin's built files from. Every file directly inside it is copied into
      * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.
      *
+     * Setting this also opts the plugin **out** of the headless bootstrap: an explicit source directory
+     * names a local build output, not somewhere to download a published release into.
+     *
      * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`
      */
     readonly sourceDirectory?: string;
+    /**
+     * The release tag the headless bootstrap downloads from, pinning the installed version. Omit for the
+     * repository's latest release — what the in-app community browser installs. Like
+     * {@link InjectPluginParams.repo}, consulted only while bootstrapping missing binaries.
+     */
+    readonly version?: string | undefined;
+}
+/**
+ * Parameters for {@link resolveInjectedPluginSourceDirectory}.
+ */
+export interface ResolveInjectedPluginSourceDirectoryParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+    The injected plugin whose source directory to resolve.
+     */
+    readonly plugin: InjectPluginParams;
+}
+/**
+ * Parameters for {@link resolveMissingInjectedPlugins}.
+ */
+export interface ResolveMissingInjectedPluginsParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+    The injected plugins to check.
+     */
+    readonly injectPlugins: readonly InjectPluginParams[];
 }
 /**
  * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config
@@ -69,3 +118,24 @@ export interface InjectPluginParams {
  * @returns The populate map, ready to hand to a global setup's `populate` or {@link TemporaryVault.populate}.
  */
 export declare function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams;
+/**
+ * Resolves the directory an injected plugin's built files are read from.
+ *
+ * @param params - The {@link ResolveInjectedPluginSourceDirectoryParams}.
+ * @returns The explicit {@link InjectPluginParams.sourceDirectory} when set, otherwise the plugin's folder
+ *   inside the demo vault.
+ */
+export declare function resolveInjectedPluginSourceDirectory(params: ResolveInjectedPluginSourceDirectoryParams): string;
+/**
+ * Selects the injected plugins whose binaries are missing from the demo vault and can therefore be
+ * installed headlessly — the exact set {@link buildDemoVaultPopulate} would otherwise throw on.
+ *
+ * Plugins carrying an explicit {@link InjectPluginParams.sourceDirectory} are excluded: that names a local
+ * build output, not somewhere to download a published release into.
+ *
+ * Shared with the bootstrap so "missing" has one definition rather than two that can drift apart.
+ *
+ * @param params - The {@link ResolveMissingInjectedPluginsParams}.
+ * @returns The plugins to bootstrap, in the order given.
+ */
+export declare function resolveMissingInjectedPlugins(params: ResolveMissingInjectedPluginsParams): InjectPluginParams[];

package/dist/lib/cjs/device-readiness.cjs

@@ -19,25 +19,60 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var device_readiness_exports = {};
 __export(device_readiness_exports, {
   DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS,
   checkDeviceIdle: () => checkDeviceIdle,
-  resolveDeviceIdleTimeoutInMilliseconds: () => resolveDeviceIdleTimeoutInMilliseconds
+  checkNetworkValidated: () => checkNetworkValidated,
+  resolveDeviceIdleTimeoutInMilliseconds: () => resolveDeviceIdleTimeoutInMilliseconds,
+  resolveNetworkReadyTimeoutInMilliseconds: () => resolveNetworkReadyTimeoutInMilliseconds
 });
 module.exports = __toCommonJS(device_readiness_exports);
+const ACTIVE_DEFAULT_NETWORK_PATTERN = /^\s*Active default network:\s*(?<networkId>\S+)/m;
 const BOOT_ANIMATION_STOPPED_STATE = "stopped";
+const FIRST_VALIDATED_PATTERN = /\bfirstValidated\s+(?<timestamp>\d+)/;
+const NETWORK_AGENT_INFO_MARKER = "NetworkAgentInfo{";
+const NETWORK_ID_PATTERN = /^\d+$/;
 const PACKAGE_LINE_PREFIX = "package:";
+const VALIDATED_SCORE_POLICY = "IS_VALIDATED";
 const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 6e4;
+const DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS = 12e4;
 function checkDeviceIdle(params) {
   const isBootAnimationStopped = params.bootAnimationProperty.trim() === BOOT_ANIMATION_STOPPED_STATE;
   const isPackageManagerReady = params.packageListOutput.split("\n").some((line) => line.trimStart().startsWith(PACKAGE_LINE_PREFIX));
   return isBootAnimationStopped && isPackageManagerReady;
 }
+function checkNetworkValidated(params) {
+  const activeNetworkId = ACTIVE_DEFAULT_NETWORK_PATTERN.exec(params.connectivityOutput)?.groups?.["networkId"] ?? "";
+  if (!NETWORK_ID_PATTERN.test(activeNetworkId)) {
+    return false;
+  }
+  const agentInfo = extractNetworkAgentInfo(params.connectivityOutput, activeNetworkId);
+  if (agentInfo.includes(VALIDATED_SCORE_POLICY)) {
+    return true;
+  }
+  const firstValidatedTimestamp = Number(FIRST_VALIDATED_PATTERN.exec(agentInfo)?.groups?.["timestamp"] ?? "0");
+  return firstValidatedTimestamp > 0;
+}
 function resolveDeviceIdleTimeoutInMilliseconds(options) {
   return options.deviceIdleTimeoutInMilliseconds ?? DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS;
 }
+function resolveNetworkReadyTimeoutInMilliseconds(options) {
+  return options.networkReadyTimeoutInMilliseconds ?? DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS;
+}
+function extractNetworkAgentInfo(connectivityOutput, networkId) {
+  const startIndex = connectivityOutput.indexOf(`${NETWORK_AGENT_INFO_MARKER}network{${networkId}}`);
+  if (startIndex === -1) {
+    return "";
+  }
+  const lineEndIndex = connectivityOutput.indexOf("\n", startIndex);
+  return lineEndIndex === -1 ? connectivityOutput.slice(startIndex) : connectivityOutput.slice(startIndex, lineEndIndex);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS,
   checkDeviceIdle,
-  resolveDeviceIdleTimeoutInMilliseconds
+  checkNetworkValidated,
+  resolveDeviceIdleTimeoutInMilliseconds,
+  resolveNetworkReadyTimeoutInMilliseconds
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/device-readiness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for deciding when a freshly-booted Android emulator is ready\n * enough to establish an Appium session, plus resolving the two readiness-wait\n * timeouts from the transport options. Kept separate from the integration-only\n * `transport-factory` so the parsing and default resolution stay unit-testable\n * (the factory itself needs a real emulator and is excluded from unit tests).\n *\n * Readiness is two independent questions, waited on in two phases:\n *\n * 1. **Is the guest idle?** `sys.boot_completed` fires *before* it is: package\n *    optimization (`dex2oat`) and system services keep churning after it, so a\n *    session established the instant it fires makes every one of UiAutomator2's\n *    serialized `adb` round-trips contend with that work and inflate ~3x. Gating\n *    the session on a later, quieter signal (the boot animation has stopped and\n *    the package manager is serving) lets it run against an idle guest instead.\n * 2. **Does the guest have a network?** Both idle signals are true well *before*\n *    the default network is created and validated \u2014 that lands ~80s into guest\n *    uptime, tens of seconds after the idle gate clears \u2014 and neither says\n *    anything about connectivity, so an idle-only gate hands the suite a device\n *    with no route. See {@link checkNetworkValidated} for the measurement and\n *    for why the three obvious connectivity probes are all wrong here.\n */\n\nimport type { ObsidianAndroidAppiumTransportOptions } from './transport-options.cjs';\n\nconst ACTIVE_DEFAULT_NETWORK_PATTERN = /^\\s*Active default network:\\s*(?<networkId>\\S+)/m;\nconst BOOT_ANIMATION_STOPPED_STATE = 'stopped';\nconst FIRST_VALIDATED_PATTERN = /\\bfirstValidated\\s+(?<timestamp>\\d+)/;\nconst NETWORK_AGENT_INFO_MARKER = 'NetworkAgentInfo{';\nconst NETWORK_ID_PATTERN = /^\\d+$/;\nconst PACKAGE_LINE_PREFIX = 'package:';\nconst VALIDATED_SCORE_POLICY = 'IS_VALIDATED';\n\n/**\n * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.\n */\nexport const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60_000;\n\n/**\n * Default for {@link ObsidianAndroidAppiumTransportOptions.networkReadyTimeoutInMilliseconds}.\n *\n * The budget starts *after* `sys.boot_completed`, where the measured wait on a\n * cold WHPX emulator is ~30s (validation at ~80s from boot, against a boot flag\n * at ~56s). The default is headroom for the starved/CI regime the other Android\n * budgets are already sized for, not the expected cost.\n */\nexport const DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS = 120_000;\n\n/**\n * Parameters for {@link checkDeviceIdle}.\n */\nexport interface CheckDeviceIdleParams {\n  /**\n  Raw stdout of `adb shell getprop init.svc.bootanim`.\n   */\n  readonly bootAnimationProperty: string;\n\n  /**\n  Raw stdout of `adb shell cmd package list packages`.\n   */\n  readonly packageListOutput: string;\n}\n\n/**\n * Parameters for {@link checkNetworkValidated}.\n */\nexport interface CheckNetworkValidatedParams {\n  /**\n  Raw stdout of `adb shell dumpsys connectivity`.\n   */\n  readonly connectivityOutput: string;\n}\n\n/**\n * Decides whether a booted emulator is idle enough to start an Appium session,\n * from the raw output of the two probe commands.\n *\n * The guest is considered idle once the boot animation has stopped **and** the\n * package manager is serving (it lists at least one package). Both are binary,\n * later-than-`sys.boot_completed` signals, so this returns `true` well after the\n * premature boot-completed flag but without any latency thresholds.\n *\n * @param params - The sampled probe outputs.\n * @returns `true` when the guest is idle enough to proceed.\n */\nexport function checkDeviceIdle(params: CheckDeviceIdleParams): boolean {\n  const isBootAnimationStopped = params.bootAnimationProperty.trim() === BOOT_ANIMATION_STOPPED_STATE;\n  const isPackageManagerReady = params.packageListOutput\n    .split('\\n')\n    .some((line) => line.trimStart().startsWith(PACKAGE_LINE_PREFIX));\n  return isBootAnimationStopped && isPackageManagerReady;\n}\n\n/**\n * Decides whether a booted emulator has a working network, from the raw output\n * of `adb shell dumpsys connectivity`.\n *\n * Ready means the dump names an **active default network** *and* that network's\n * own agent info reports validation \u2014 either an `IS_VALIDATED` score policy or a\n * non-zero `firstValidated` timestamp. Both are required: a default network\n * exists for seconds before it validates, and during that window it carries no\n * usable route.\n *\n * Why this matters at all: the two {@link checkDeviceIdle} signals are satisfied\n * well before this one. Validation lands ~70-80s into guest uptime \u2014 measured on\n * `obsidian_test`, `created 70635 firstValidated 72681`, and on a cold boot of\n * `obsidian_screenshots`, `created 66870 firstValidated 79870`, which at 85s\n * uptime still scored `EVER_EVALUATED&IS_UNMETERED` with no `IS_VALIDATED` and\n * no `firstValidated` field at all. Against a boot flag at ~56s that leaves a\n * gap of tens of seconds on a fast host, and more on a slow one. A suite started\n * in that gap does not merely run slowly: a test that reaches the network runs\n * to completion against a silently empty result, which no assertion inside the\n * suite can tell apart from a genuinely empty feed.\n *\n * `dumpsys connectivity` is the honest source, and the three probes that look\n * like better ones are all wrong \u2014 each of them misled a full day of\n * investigation before this was understood:\n *\n * - `ip route` shows **no** default route on a healthy device: Android uses\n *   per-network policy routing, and the route lives in table 1015, not `main`.\n * - `ping` fails on a healthy device: QEMU user-mode NAT does not forward ICMP\n *   on Windows hosts.\n * - `getprop net.dns1` is empty on every modern Android: DNS went per-network\n *   in 8/9.\n *\n * @param params - The sampled probe output.\n * @returns `true` when the guest has a validated default network.\n */\nexport function checkNetworkValidated(params: CheckNetworkValidatedParams): boolean {\n  const activeNetworkId = ACTIVE_DEFAULT_NETWORK_PATTERN.exec(params.connectivityOutput)?.groups?.['networkId'] ?? '';\n  if (!NETWORK_ID_PATTERN.test(activeNetworkId)) {\n    return false;\n  }\n\n  const agentInfo = extractNetworkAgentInfo(params.connectivityOutput, activeNetworkId);\n  if (agentInfo.includes(VALIDATED_SCORE_POLICY)) {\n    return true;\n  }\n\n  const firstValidatedTimestamp = Number(FIRST_VALIDATED_PATTERN.exec(agentInfo)?.groups?.['timestamp'] ?? '0');\n  return firstValidatedTimestamp > 0;\n}\n\n/**\n * Resolves the post-boot device-idle wait timeout, applying the default when\n * the option is omitted.\n *\n * This bounds how long the factory waits for a freshly-started emulator to\n * become idle (see {@link checkDeviceIdle}) before establishing the session. A\n * value of `0` skips the wait entirely.\n *\n * @param options - The Android Appium transport options.\n * @returns The timeout in milliseconds.\n */\nexport function resolveDeviceIdleTimeoutInMilliseconds(\n  options: ObsidianAndroidAppiumTransportOptions\n): number {\n  return options.deviceIdleTimeoutInMilliseconds ?? DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS;\n}\n\n/**\n * Resolves the network-ready wait timeout, applying the default when the option\n * is omitted.\n *\n * This bounds how long the factory waits, after the idle gate, for the guest to\n * report a validated default network (see {@link checkNetworkValidated}) before\n * establishing the session. A value of `0` skips the wait entirely.\n *\n * @param options - The Android Appium transport options.\n * @returns The timeout in milliseconds.\n */\nexport function resolveNetworkReadyTimeoutInMilliseconds(\n  options: ObsidianAndroidAppiumTransportOptions\n): number {\n  return options.networkReadyTimeoutInMilliseconds ?? DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS;\n}\n\n/**\n * Extracts the `NetworkAgentInfo{\u2026}` entry for one network id from a\n * connectivity dump.\n *\n * **Bounded to the entry's own line, and that bound is load-bearing.** A real\n * dump lists the active network's agent under `Current Networks:` and then, much\n * further down, a `NetworkOffer` per provider \u2014 and those offers carry\n * `IS_VALIDATED` in their score policies whatever the live network is doing. A\n * dump sampled here with an unvalidated default network held seven such offers,\n * so reading past the agent's own line reports *every* dump as validated. One\n * entry is one line in the observed output; an entry that ever wraps reads as\n * not-ready, which is the safe direction to be wrong in.\n *\n * @param connectivityOutput - Raw stdout of `adb shell dumpsys connectivity`.\n * @param networkId - The network id whose entry to extract.\n * @returns The entry's line, or an empty string when the dump has no such entry.\n */\nfunction extractNetworkAgentInfo(connectivityOutput: string, networkId: string): string {\n  const startIndex = connectivityOutput.indexOf(`${NETWORK_AGENT_INFO_MARKER}network{${networkId}}`);\n  if (startIndex === -1) {\n    return '';\n  }\n\n  const lineEndIndex = connectivityOutput.indexOf('\\n', startIndex);\n  return lineEndIndex === -1\n    ? connectivityOutput.slice(startIndex)\n    : connectivityOutput.slice(startIndex, lineEndIndex);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,MAAM,iCAAiC;AACvC,MAAM,+BAA+B;AACrC,MAAM,0BAA0B;AAChC,MAAM,4BAA4B;AAClC,MAAM,qBAAqB;AAC3B,MAAM,sBAAsB;AAC5B,MAAM,yBAAyB;AAKxB,MAAM,8CAA8C;AAUpD,MAAM,gDAAgD;AAuCtD,SAAS,gBAAgB,QAAwC;AACtE,QAAM,yBAAyB,OAAO,sBAAsB,KAAK,MAAM;AACvE,QAAM,wBAAwB,OAAO,kBAClC,MAAM,IAAI,EACV,KAAK,CAAC,SAAS,KAAK,UAAU,EAAE,WAAW,mBAAmB,CAAC;AAClE,SAAO,0BAA0B;AACnC;AAqCO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,kBAAkB,+BAA+B,KAAK,OAAO,kBAAkB,GAAG,SAAS,WAAW,KAAK;AACjH,MAAI,CAAC,mBAAmB,KAAK,eAAe,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,wBAAwB,OAAO,oBAAoB,eAAe;AACpF,MAAI,UAAU,SAAS,sBAAsB,GAAG;AAC9C,WAAO;AAAA,EACT;AAEA,QAAM,0BAA0B,OAAO,wBAAwB,KAAK,SAAS,GAAG,SAAS,WAAW,KAAK,GAAG;AAC5G,SAAO,0BAA0B;AACnC;AAaO,SAAS,uCACd,SACQ;AACR,SAAO,QAAQ,mCAAmC;AACpD;AAaO,SAAS,yCACd,SACQ;AACR,SAAO,QAAQ,qCAAqC;AACtD;AAmBA,SAAS,wBAAwB,oBAA4B,WAA2B;AACtF,QAAM,aAAa,mBAAmB,QAAQ,GAAG,yBAAyB,WAAW,SAAS,GAAG;AACjG,MAAI,eAAe,IAAI;AACrB,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,mBAAmB,QAAQ,MAAM,UAAU;AAChE,SAAO,iBAAiB,KACpB,mBAAmB,MAAM,UAAU,IACnC,mBAAmB,MAAM,YAAY,YAAY;AACvD;",
  "names": []
}


package/dist/lib/cjs/device-readiness.d.cts

@@ -1,24 +1,41 @@
 /**
  * @file
  *
- * Pure helpers for deciding when a freshly-booted Android emulator is idle
- * enough to establish an Appium session, plus resolving the idle-wait timeout
- * from the transport options. Kept separate from the integration-only
+ * Pure helpers for deciding when a freshly-booted Android emulator is ready
+ * enough to establish an Appium session, plus resolving the two readiness-wait
+ * timeouts from the transport options. Kept separate from the integration-only
  * `transport-factory` so the parsing and default resolution stay unit-testable
  * (the factory itself needs a real emulator and is excluded from unit tests).
  *
- * `sys.boot_completed` fires *before* the guest is actually idle: package
- * optimization (`dex2oat`) and system services keep churning after it, so a
- * session established the instant it fires makes every one of UiAutomator2's
- * serialized `adb` round-trips contend with that work and inflate ~3x. Gating
- * the session on a later, quieter signal (the boot animation has stopped and
- * the package manager is serving) lets it run against an idle guest instead.
+ * Readiness is two independent questions, waited on in two phases:
+ *
+ * 1. **Is the guest idle?** `sys.boot_completed` fires *before* it is: package
+ *    optimization (`dex2oat`) and system services keep churning after it, so a
+ *    session established the instant it fires makes every one of UiAutomator2's
+ *    serialized `adb` round-trips contend with that work and inflate ~3x. Gating
+ *    the session on a later, quieter signal (the boot animation has stopped and
+ *    the package manager is serving) lets it run against an idle guest instead.
+ * 2. **Does the guest have a network?** Both idle signals are true well *before*
+ *    the default network is created and validated — that lands ~80s into guest
+ *    uptime, tens of seconds after the idle gate clears — and neither says
+ *    anything about connectivity, so an idle-only gate hands the suite a device
+ *    with no route. See {@link checkNetworkValidated} for the measurement and
+ *    for why the three obvious connectivity probes are all wrong here.
  */
 import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.cjs';
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.networkReadyTimeoutInMilliseconds}.
+ *
+ * The budget starts *after* `sys.boot_completed`, where the measured wait on a
+ * cold WHPX emulator is ~30s (validation at ~80s from boot, against a boot flag
+ * at ~56s). The default is headroom for the starved/CI regime the other Android
+ * budgets are already sized for, not the expected cost.
+ */
+export declare const DEFAULT_NETWORK_READY_TIMEOUT_IN_MILLISECONDS = 120000;
 /**
  * Parameters for {@link checkDeviceIdle}.
  */
@@ -32,6 +49,15 @@ export interface CheckDeviceIdleParams {
      */
     readonly packageListOutput: string;
 }
+/**
+ * Parameters for {@link checkNetworkValidated}.
+ */
+export interface CheckNetworkValidatedParams {
+    /**
+    Raw stdout of `adb shell dumpsys connectivity`.
+     */
+    readonly connectivityOutput: string;
+}
 /**
  * Decides whether a booted emulator is idle enough to start an Appium session,
  * from the raw output of the two probe commands.
@@ -45,6 +71,42 @@ export interface CheckDeviceIdleParams {
  * @returns `true` when the guest is idle enough to proceed.
  */
 export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
+/**
+ * Decides whether a booted emulator has a working network, from the raw output
+ * of `adb shell dumpsys connectivity`.
+ *
+ * Ready means the dump names an **active default network** *and* that network's
+ * own agent info reports validation — either an `IS_VALIDATED` score policy or a
+ * non-zero `firstValidated` timestamp. Both are required: a default network
+ * exists for seconds before it validates, and during that window it carries no
+ * usable route.
+ *
+ * Why this matters at all: the two {@link checkDeviceIdle} signals are satisfied
+ * well before this one. Validation lands ~70-80s into guest uptime — measured on
+ * `obsidian_test`, `created 70635 firstValidated 72681`, and on a cold boot of
+ * `obsidian_screenshots`, `created 66870 firstValidated 79870`, which at 85s
+ * uptime still scored `EVER_EVALUATED&IS_UNMETERED` with no `IS_VALIDATED` and
+ * no `firstValidated` field at all. Against a boot flag at ~56s that leaves a
+ * gap of tens of seconds on a fast host, and more on a slow one. A suite started
+ * in that gap does not merely run slowly: a test that reaches the network runs
+ * to completion against a silently empty result, which no assertion inside the
+ * suite can tell apart from a genuinely empty feed.
+ *
+ * `dumpsys connectivity` is the honest source, and the three probes that look
+ * like better ones are all wrong — each of them misled a full day of
+ * investigation before this was understood:
+ *
+ * - `ip route` shows **no** default route on a healthy device: Android uses
+ *   per-network policy routing, and the route lives in table 1015, not `main`.
+ * - `ping` fails on a healthy device: QEMU user-mode NAT does not forward ICMP
+ *   on Windows hosts.
+ * - `getprop net.dns1` is empty on every modern Android: DNS went per-network
+ *   in 8/9.
+ *
+ * @param params - The sampled probe output.
+ * @returns `true` when the guest has a validated default network.
+ */
+export declare function checkNetworkValidated(params: CheckNetworkValidatedParams): boolean;
 /**
  * Resolves the post-boot device-idle wait timeout, applying the default when
  * the option is omitted.
@@ -57,3 +119,15 @@ export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
  * @returns The timeout in milliseconds.
  */
 export declare function resolveDeviceIdleTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
+/**
+ * Resolves the network-ready wait timeout, applying the default when the option
+ * is omitted.
+ *
+ * This bounds how long the factory waits, after the idle gate, for the guest to
+ * report a validated default network (see {@link checkNetworkValidated}) before
+ * establishing the session. A value of `0` skips the wait entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveNetworkReadyTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

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

@@ -23,7 +23,11 @@ __export(emulator_arguments_exports, {
 module.exports = __toCommonJS(emulator_arguments_exports);
 const DNS_SERVER = "8.8.8.8";
 function buildEmulatorArguments(params) {
-  const emulatorArguments = ["-avd", params.avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+  const emulatorArguments = ["-avd", params.avdName];
+  if (!params.shouldReuseSnapshot) {
+    emulatorArguments.push("-no-snapshot-load", "-no-snapshot-save");
+  }
+  emulatorArguments.push("-dns-server", DNS_SERVER);
   if (params.isHidden) {
     emulatorArguments.push("-no-window");
   }
@@ -33,4 +37,4 @@ function buildEmulatorArguments(params) {
 0 && (module.exports = {
   buildEmulatorArguments
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3VtZW50cy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEJ1aWxkcyB0aGUgYXJndW1lbnQgbGlzdCBmb3Igc3Bhd25pbmcgdGhlIEFuZHJvaWQgZW11bGF0b3IuXG4gKi9cblxuY29uc3QgRE5TX1NFUlZFUiA9ICc4LjguOC44JztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgYnVpbGRFbXVsYXRvckFyZ3VtZW50c30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQnVpbGRFbXVsYXRvckFyZ3VtZW50c1BhcmFtcyB7XG4gIC8qKlxuICBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgYXZkTmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHJ1biB0aGUgZW11bGF0b3IgaGVhZGxlc3MgKGAtbm8td2luZG93YCksIHNvIGl0IG5ldmVyIHN0ZWFsc1xuICAgKiBmb2N1cy4gUmVzb2x2ZWQgZnJvbSB0aGUgYGlzRW11bGF0b3JWaXNpYmxlYCB0cmFuc3BvcnQgb3B0aW9uLlxuICAgKi9cbiAgcmVhZG9ubHkgaXNIaWRkZW46IGJvb2xlYW47XG59XG5cbi8qKlxuICogQnVpbGRzIHRoZSBhcmd1bWVudCBsaXN0IGZvciBzcGF3bmluZyB0aGUgQW5kcm9pZCBlbXVsYXRvci5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIGVtdWxhdG9yIGFyZ3VtZW50IHBhcmFtZXRlcnMuXG4gKiBAcmV0dXJucyBUaGUgYXJndW1lbnQgYXJyYXkgdG8gcGFzcyB0byB0aGUgZW11bGF0b3IgYmluYXJ5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRFbXVsYXRvckFyZ3VtZW50cyhwYXJhbXM6IEJ1aWxkRW11bGF0b3JBcmd1bWVudHNQYXJhbXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGVtdWxhdG9yQXJndW1lbnRzID0gWyctYXZkJywgcGFyYW1zLmF2ZE5hbWUsICctbm8tc25hcHNob3Qtc2F2ZScsICctZG5zLXNlcnZlcicsIEROU19TRVJWRVJdO1xuICBpZiAocGFyYW1zLmlzSGlkZGVuKSB7XG4gICAgZW11bGF0b3JBcmd1bWVudHMucHVzaCgnLW5vLXdpbmRvdycpO1xuICB9XG4gIHJldHVybiBlbXVsYXRvckFyZ3VtZW50cztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFNQSxNQUFNLGFBQWE7QUF3QlosU0FBUyx1QkFBdUIsUUFBZ0Q7QUFDckYsUUFBTSxvQkFBb0IsQ0FBQyxRQUFRLE9BQU8sU0FBUyxxQkFBcUIsZUFBZSxVQUFVO0FBQ2pHLE1BQUksT0FBTyxVQUFVO0FBQ25CLHNCQUFrQixLQUFLLFlBQVk7QUFBQSxFQUNyQztBQUNBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,6 +2,24 @@
  * @file
  *
  * Builds the argument list for spawning the Android emulator.
+ *
+ * **The harness owns the snapshot it loads, or it loads none.** This file used
+ * to pass `-no-snapshot-save` alone — the one combination that is never
+ * correct. It never *writes* `default_boot`, yet every run *resumed* it, so the
+ * guest each run started from was state nothing had validated since whenever a
+ * human last saved it. Measured 2026-09-03, same AVD back to back:
+ *
+ * | Launch | Result |
+ * | --- | --- |
+ * | snapshot resumed (`-no-snapshot-save` alone) | guest dies ~90s in, every time |
+ * | `-no-snapshot-load` (cold) | booted in 50s, alive at 60/120/180/240s |
+ *
+ * A resumed snapshot rots silently, and the failure it eventually produces —
+ * a device that serves adb, accepts a session and then drops `offline` a
+ * half-minute later — is indistinguishable from a code regression. So the
+ * default is a full cold boot, and snapshot reuse is an explicit opt-in that
+ * takes **both** halves: load and save together, so the snapshot the next run
+ * resumes is one this run wrote.
  */
 /**
  * Parameters for {@link buildEmulatorArguments}.
@@ -16,6 +34,14 @@ export interface BuildEmulatorArgumentsParams {
      * focus. Resolved from the `isEmulatorVisible` transport option.
      */
     readonly isHidden: boolean;
+    /**
+     * Whether the emulator may resume — and refresh — the AVD's saved boot
+     * snapshot. Resolved from the `shouldReuseEmulatorSnapshot` transport option.
+     *
+     * `false` (the default) cold-boots hermetically. `true` buys back the ~112s
+     * boot on a persistent runner, at the cost of test isolation.
+     */
+    readonly shouldReuseSnapshot: boolean;
 }
 /**
  * Builds the argument list for spawning the Android emulator.

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

@@ -0,0 +1,71 @@
+"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_backend_exports = {};
+__export(emulator_backend_exports, {
+  parsePosixProcessList: () => parsePosixProcessList,
+  parseWindowsTaskList: () => parseWindowsTaskList,
+  selectEmulatorBackendPids: () => selectEmulatorBackendPids
+});
+module.exports = __toCommonJS(emulator_backend_exports);
+const EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\w.-]+|qemu-system-[\w.-]+)$/;
+const EXECUTABLE_SUFFIX_PATTERN = /\.exe$/;
+const RADIX_DECIMAL = 10;
+const TASK_LIST_FIELDS_READ = 2;
+function parsePosixProcessList(processListOutput) {
+  const entries = [];
+  for (const rawLine of processListOutput.split("\n")) {
+    const line = rawLine.trim();
+    const separatorIndex = line.indexOf(" ");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);
+    if (Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });
+  }
+  return entries;
+}
+function parseWindowsTaskList(taskListOutput) {
+  const entries = [];
+  for (const rawLine of taskListOutput.split("\n")) {
+    const [rawName = "", rawPid = ""] = rawLine.trim().replaceAll('"', "").split(",", TASK_LIST_FIELDS_READ);
+    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);
+    if (rawName.length === 0 || Number.isNaN(pid)) {
+      continue;
+    }
+    entries.push({ name: rawName, pid });
+  }
+  return entries;
+}
+function selectEmulatorBackendPids(params) {
+  return params.processes.filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid)).map((entry) => entry.pid);
+}
+function checkIsEmulatorBackendName(name) {
+  const baseName = name.slice(Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\")) + 1);
+  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ""));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePosixProcessList,
+  parseWindowsTaskList,
+  selectEmulatorBackendPids
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-backend.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for finding the Android emulator process that **outlives the pid\n * the harness killed**.\n *\n * Under `-no-window` the emulator's backend process is\n * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the\n * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The\n * launcher exits or is killed, and the backend is what actually holds the AVD's\n * `multiinstance.lock` and the console/adb ports \u2014 so `taskkill /F /T` against\n * the launcher's pid reports success while the emulator keeps running. Every\n * later run against that AVD then dies with `Running multiple emulators with the\n * same AVD is an experimental feature`, which never reaches the user because the\n * emulator writes it to its own stdout.\n *\n * Note that the obvious filter \u2014 `-Name qemu-system-x86_64` / matching that\n * exact image name \u2014 does **not** match the `-headless` build, which is how the\n * leftover stays invisible through several rounds of \"no emulator is running\".\n *\n * Ownership is decided by a **pre-launch snapshot**: a backend already running\n * before this run started its own belongs to somebody else (another AVD, or one\n * the user booted by hand) and is never touched. Kept separate from the\n * integration-only `transport-factory` so the parsing and the selection stay\n * unit-testable.\n */\n\n/**\n * One process from a host process listing.\n */\nexport interface ProcessListEntry {\n  /**\n  The process/image name, as the platform's listing reports it.\n   */\n  readonly name: string;\n\n  /**\n  The process ID.\n   */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link selectEmulatorBackendPids}.\n */\nexport interface SelectEmulatorBackendPidsParams {\n  /**\n  Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.\n   */\n  readonly knownPids: readonly number[];\n\n  /**\n  The host's current process listing.\n   */\n  readonly processes: readonly ProcessListEntry[];\n}\n\n/**\n * Matches the emulator launcher and both QEMU backend builds \u2014 crucially\n * including the `-headless` suffix `-no-window` runs produce.\n */\nconst EMULATOR_BACKEND_NAME_PATTERN = /^(?:emulator|emulator64-[\\w.-]+|qemu-system-[\\w.-]+)$/;\nconst EXECUTABLE_SUFFIX_PATTERN = /\\.exe$/;\nconst RADIX_DECIMAL = 10;\n/**\n * Only the image name and the PID are read, so the split stops after them.\n */\nconst TASK_LIST_FIELDS_READ = 2;\n\n/**\n * Parses `ps -eo pid=,comm=` output.\n *\n * @param processListOutput - Raw stdout of the `ps` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parsePosixProcessList(processListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of processListOutput.split('\\n')) {\n    const line = rawLine.trim();\n    const separatorIndex = line.indexOf(' ');\n    if (separatorIndex === -1) {\n      continue;\n    }\n\n    const pid = Number.parseInt(line.slice(0, separatorIndex), RADIX_DECIMAL);\n    if (Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: line.slice(separatorIndex + 1).trim(), pid });\n  }\n\n  return entries;\n}\n\n/**\n * Parses `tasklist /FO CSV /NH` output.\n *\n * Only the first two fields are read \u2014 the image name and the PID \u2014 so the\n * memory column's own commas cannot confuse the split.\n *\n * @param taskListOutput - Raw stdout of the `tasklist` listing.\n * @returns One entry per parsable row, in listed order.\n */\nexport function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[] {\n  const entries: ProcessListEntry[] = [];\n\n  for (const rawLine of taskListOutput.split('\\n')) {\n    const [rawName = '', rawPid = ''] = rawLine.trim().replaceAll('\"', '').split(',', TASK_LIST_FIELDS_READ);\n    const pid = Number.parseInt(rawPid, RADIX_DECIMAL);\n    if (rawName.length === 0 || Number.isNaN(pid)) {\n      continue;\n    }\n\n    entries.push({ name: rawName, pid });\n  }\n\n  return entries;\n}\n\n/**\n * Selects the emulator processes this run is responsible for killing.\n *\n * @param params - The current listing plus the PIDs that predate this run's emulator.\n * @returns The PIDs of emulator processes this run owns, in listed order.\n */\nexport function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[] {\n  return params.processes\n    .filter((entry) => checkIsEmulatorBackendName(entry.name) && !params.knownPids.includes(entry.pid))\n    .map((entry) => entry.pid);\n}\n\nfunction checkIsEmulatorBackendName(name: string): boolean {\n  const baseName = name.slice(Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\\\')) + 1);\n  return EMULATOR_BACKEND_NAME_PATTERN.test(baseName.toLowerCase().replace(EXECUTABLE_SUFFIX_PATTERN, ''));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6DA,MAAM,gCAAgC;AACtC,MAAM,4BAA4B;AAClC,MAAM,gBAAgB;AAItB,MAAM,wBAAwB;AAQvB,SAAS,sBAAsB,mBAA+C;AACnF,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,kBAAkB,MAAM,IAAI,GAAG;AACnD,UAAM,OAAO,QAAQ,KAAK;AAC1B,UAAM,iBAAiB,KAAK,QAAQ,GAAG;AACvC,QAAI,mBAAmB,IAAI;AACzB;AAAA,IACF;AAEA,UAAM,MAAM,OAAO,SAAS,KAAK,MAAM,GAAG,cAAc,GAAG,aAAa;AACxE,QAAI,OAAO,MAAM,GAAG,GAAG;AACrB;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,KAAK,MAAM,iBAAiB,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;AAAA,EACnE;AAEA,SAAO;AACT;AAWO,SAAS,qBAAqB,gBAA4C;AAC/E,QAAM,UAA8B,CAAC;AAErC,aAAW,WAAW,eAAe,MAAM,IAAI,GAAG;AAChD,UAAM,CAAC,UAAU,IAAI,SAAS,EAAE,IAAI,QAAQ,KAAK,EAAE,WAAW,KAAK,EAAE,EAAE,MAAM,KAAK,qBAAqB;AACvG,UAAM,MAAM,OAAO,SAAS,QAAQ,aAAa;AACjD,QAAI,QAAQ,WAAW,KAAK,OAAO,MAAM,GAAG,GAAG;AAC7C;AAAA,IACF;AAEA,YAAQ,KAAK,EAAE,MAAM,SAAS,IAAI,CAAC;AAAA,EACrC;AAEA,SAAO;AACT;AAQO,SAAS,0BAA0B,QAAmD;AAC3F,SAAO,OAAO,UACX,OAAO,CAAC,UAAU,2BAA2B,MAAM,IAAI,KAAK,CAAC,OAAO,UAAU,SAAS,MAAM,GAAG,CAAC,EACjG,IAAI,CAAC,UAAU,MAAM,GAAG;AAC7B;AAEA,SAAS,2BAA2B,MAAuB;AACzD,QAAM,WAAW,KAAK,MAAM,KAAK,IAAI,KAAK,YAAY,GAAG,GAAG,KAAK,YAAY,IAAI,CAAC,IAAI,CAAC;AACvF,SAAO,8BAA8B,KAAK,SAAS,YAAY,EAAE,QAAQ,2BAA2B,EAAE,CAAC;AACzG;",
  "names": []
}


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

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Pure helpers for finding the Android emulator process that **outlives the pid
+ * the harness killed**.
+ *
+ * Under `-no-window` the emulator's backend process is
+ * `qemu-system-x86_64-headless` (`qemu-system-x86_64` when windowed), not the
+ * `emulator` launcher the harness spawned and holds a `ChildProcess` for. The
+ * launcher exits or is killed, and the backend is what actually holds the AVD's
+ * `multiinstance.lock` and the console/adb ports — so `taskkill /F /T` against
+ * the launcher's pid reports success while the emulator keeps running. Every
+ * later run against that AVD then dies with `Running multiple emulators with the
+ * same AVD is an experimental feature`, which never reaches the user because the
+ * emulator writes it to its own stdout.
+ *
+ * Note that the obvious filter — `-Name qemu-system-x86_64` / matching that
+ * exact image name — does **not** match the `-headless` build, which is how the
+ * leftover stays invisible through several rounds of "no emulator is running".
+ *
+ * Ownership is decided by a **pre-launch snapshot**: a backend already running
+ * before this run started its own belongs to somebody else (another AVD, or one
+ * the user booted by hand) and is never touched. Kept separate from the
+ * integration-only `transport-factory` so the parsing and the selection stay
+ * unit-testable.
+ */
+/**
+ * One process from a host process listing.
+ */
+export interface ProcessListEntry {
+    /**
+    The process/image name, as the platform's listing reports it.
+     */
+    readonly name: string;
+    /**
+    The process ID.
+     */
+    readonly pid: number;
+}
+/**
+ * Parameters for {@link selectEmulatorBackendPids}.
+ */
+export interface SelectEmulatorBackendPidsParams {
+    /**
+    Emulator backend PIDs seen **before** this run launched its emulator, which it therefore does not own.
+     */
+    readonly knownPids: readonly number[];
+    /**
+    The host's current process listing.
+     */
+    readonly processes: readonly ProcessListEntry[];
+}
+/**
+ * Parses `ps -eo pid=,comm=` output.
+ *
+ * @param processListOutput - Raw stdout of the `ps` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parsePosixProcessList(processListOutput: string): ProcessListEntry[];
+/**
+ * Parses `tasklist /FO CSV /NH` output.
+ *
+ * Only the first two fields are read — the image name and the PID — so the
+ * memory column's own commas cannot confuse the split.
+ *
+ * @param taskListOutput - Raw stdout of the `tasklist` listing.
+ * @returns One entry per parsable row, in listed order.
+ */
+export declare function parseWindowsTaskList(taskListOutput: string): ProcessListEntry[];
+/**
+ * Selects the emulator processes this run is responsible for killing.
+ *
+ * @param params - The current listing plus the PIDs that predate this run's emulator.
+ * @returns The PIDs of emulator processes this run owns, in listed order.
+ */
+export declare function selectEmulatorBackendPids(params: SelectEmulatorBackendPidsParams): number[];