obsidian-integration-testing 12.0.0 → 12.1.1

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,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RldmljZS1yZWFkaW5lc3MudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBQdXJlIGhlbHBlcnMgZm9yIGRlY2lkaW5nIHdoZW4gYSBmcmVzaGx5LWJvb3RlZCBBbmRyb2lkIGVtdWxhdG9yIGlzIGlkbGVcbiAqIGVub3VnaCB0byBlc3RhYmxpc2ggYW4gQXBwaXVtIHNlc3Npb24sIHBsdXMgcmVzb2x2aW5nIHRoZSBpZGxlLXdhaXQgdGltZW91dFxuICogZnJvbSB0aGUgdHJhbnNwb3J0IG9wdGlvbnMuIEtlcHQgc2VwYXJhdGUgZnJvbSB0aGUgaW50ZWdyYXRpb24tb25seVxuICogYHRyYW5zcG9ydC1mYWN0b3J5YCBzbyB0aGUgcGFyc2luZyBhbmQgZGVmYXVsdCByZXNvbHV0aW9uIHN0YXkgdW5pdC10ZXN0YWJsZVxuICogKHRoZSBmYWN0b3J5IGl0c2VsZiBuZWVkcyBhIHJlYWwgZW11bGF0b3IgYW5kIGlzIGV4Y2x1ZGVkIGZyb20gdW5pdCB0ZXN0cykuXG4gKlxuICogYHN5cy5ib290X2NvbXBsZXRlZGAgZmlyZXMgKmJlZm9yZSogdGhlIGd1ZXN0IGlzIGFjdHVhbGx5IGlkbGU6IHBhY2thZ2VcbiAqIG9wdGltaXphdGlvbiAoYGRleDJvYXRgKSBhbmQgc3lzdGVtIHNlcnZpY2VzIGtlZXAgY2h1cm5pbmcgYWZ0ZXIgaXQsIHNvIGFcbiAqIHNlc3Npb24gZXN0YWJsaXNoZWQgdGhlIGluc3RhbnQgaXQgZmlyZXMgbWFrZXMgZXZlcnkgb25lIG9mIFVpQXV0b21hdG9yMidzXG4gKiBzZXJpYWxpemVkIGBhZGJgIHJvdW5kLXRyaXBzIGNvbnRlbmQgd2l0aCB0aGF0IHdvcmsgYW5kIGluZmxhdGUgfjN4LiBHYXRpbmdcbiAqIHRoZSBzZXNzaW9uIG9uIGEgbGF0ZXIsIHF1aWV0ZXIgc2lnbmFsICh0aGUgYm9vdCBhbmltYXRpb24gaGFzIHN0b3BwZWQgYW5kXG4gKiB0aGUgcGFja2FnZSBtYW5hZ2VyIGlzIHNlcnZpbmcpIGxldHMgaXQgcnVuIGFnYWluc3QgYW4gaWRsZSBndWVzdCBpbnN0ZWFkLlxuICovXG5cbmltcG9ydCB0eXBlIHsgT2JzaWRpYW5BbmRyb2lkQXBwaXVtVHJhbnNwb3J0T3B0aW9ucyB9IGZyb20gJy4vdHJhbnNwb3J0LW9wdGlvbnMuY2pzJztcblxuY29uc3QgQk9PVF9BTklNQVRJT05fU1RPUFBFRF9TVEFURSA9ICdzdG9wcGVkJztcbmNvbnN0IFBBQ0tBR0VfTElORV9QUkVGSVggPSAncGFja2FnZTonO1xuXG4vKipcbiAqIERlZmF1bHQgZm9yIHtAbGluayBPYnNpZGlhbkFuZHJvaWRBcHBpdW1UcmFuc3BvcnRPcHRpb25zLmRldmljZUlkbGVUaW1lb3V0SW5NaWxsaXNlY29uZHN9LlxuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9ERVZJQ0VfSURMRV9USU1FT1VUX0lOX01JTExJU0VDT05EUyA9IDYwXzAwMDtcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB7QGxpbmsgY2hlY2tEZXZpY2VJZGxlfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDaGVja0RldmljZUlkbGVQYXJhbXMge1xuICAvKipcbiAgUmF3IHN0ZG91dCBvZiBgYWRiIHNoZWxsIGdldHByb3AgaW5pdC5zdmMuYm9vdGFuaW1gLlxuICAgKi9cbiAgcmVhZG9ubHkgYm9vdEFuaW1hdGlvblByb3BlcnR5OiBzdHJpbmc7XG5cbiAgLyoqXG4gIFJhdyBzdGRvdXQgb2YgYGFkYiBzaGVsbCBjbWQgcGFja2FnZSBsaXN0IHBhY2thZ2VzYC5cbiAgICovXG4gIHJlYWRvbmx5IHBhY2thZ2VMaXN0T3V0cHV0OiBzdHJpbmc7XG59XG5cbi8qKlxuICogRGVjaWRlcyB3aGV0aGVyIGEgYm9vdGVkIGVtdWxhdG9yIGlzIGlkbGUgZW5vdWdoIHRvIHN0YXJ0IGFuIEFwcGl1bSBzZXNzaW9uLFxuICogZnJvbSB0aGUgcmF3IG91dHB1dCBvZiB0aGUgdHdvIHByb2JlIGNvbW1hbmRzLlxuICpcbiAqIFRoZSBndWVzdCBpcyBjb25zaWRlcmVkIGlkbGUgb25jZSB0aGUgYm9vdCBhbmltYXRpb24gaGFzIHN0b3BwZWQgKiphbmQqKiB0aGVcbiAqIHBhY2thZ2UgbWFuYWdlciBpcyBzZXJ2aW5nIChpdCBsaXN0cyBhdCBsZWFzdCBvbmUgcGFja2FnZSkuIEJvdGggYXJlIGJpbmFyeSxcbiAqIGxhdGVyLXRoYW4tYHN5cy5ib290X2NvbXBsZXRlZGAgc2lnbmFscywgc28gdGhpcyByZXR1cm5zIGB0cnVlYCB3ZWxsIGFmdGVyIHRoZVxuICogcHJlbWF0dXJlIGJvb3QtY29tcGxldGVkIGZsYWcgYnV0IHdpdGhvdXQgYW55IGxhdGVuY3kgdGhyZXNob2xkcy5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIHNhbXBsZWQgcHJvYmUgb3V0cHV0cy5cbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBndWVzdCBpcyBpZGxlIGVub3VnaCB0byBwcm9jZWVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY2hlY2tEZXZpY2VJZGxlKHBhcmFtczogQ2hlY2tEZXZpY2VJZGxlUGFyYW1zKTogYm9vbGVhbiB7XG4gIGNvbnN0IGlzQm9vdEFuaW1hdGlvblN0b3BwZWQgPSBwYXJhbXMuYm9vdEFuaW1hdGlvblByb3BlcnR5LnRyaW0oKSA9PT0gQk9PVF9BTklNQVRJT05fU1RPUFBFRF9TVEFURTtcbiAgY29uc3QgaXNQYWNrYWdlTWFuYWdlclJlYWR5ID0gcGFyYW1zLnBhY2thZ2VMaXN0T3V0cHV0XG4gICAgLnNwbGl0KCdcXG4nKVxuICAgIC5zb21lKChsaW5lKSA9PiBsaW5lLnRyaW1TdGFydCgpLnN0YXJ0c1dpdGgoUEFDS0FHRV9MSU5FX1BSRUZJWCkpO1xuICByZXR1cm4gaXNCb290QW5pbWF0aW9uU3RvcHBlZCAmJiBpc1BhY2thZ2VNYW5hZ2VyUmVhZHk7XG59XG5cbi8qKlxuICogUmVzb2x2ZXMgdGhlIHBvc3QtYm9vdCBkZXZpY2UtaWRsZSB3YWl0IHRpbWVvdXQsIGFwcGx5aW5nIHRoZSBkZWZhdWx0IHdoZW5cbiAqIHRoZSBvcHRpb24gaXMgb21pdHRlZC5cbiAqXG4gKiBUaGlzIGJvdW5kcyBob3cgbG9uZyB0aGUgZmFjdG9yeSB3YWl0cyBmb3IgYSBmcmVzaGx5LXN0YXJ0ZWQgZW11bGF0b3IgdG9cbiAqIGJlY29tZSBpZGxlIChzZWUge0BsaW5rIGNoZWNrRGV2aWNlSWRsZX0pIGJlZm9yZSBlc3RhYmxpc2hpbmcgdGhlIHNlc3Npb24uIEFcbiAqIHZhbHVlIG9mIGAwYCBza2lwcyB0aGUgd2FpdCBlbnRpcmVseS5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSBBbmRyb2lkIEFwcGl1bSB0cmFuc3BvcnQgb3B0aW9ucy5cbiAqIEByZXR1cm5zIFRoZSB0aW1lb3V0IGluIG1pbGxpc2Vjb25kcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVEZXZpY2VJZGxlVGltZW91dEluTWlsbGlzZWNvbmRzKFxuICBvcHRpb25zOiBPYnNpZGlhbkFuZHJvaWRBcHBpdW1UcmFuc3BvcnRPcHRpb25zXG4pOiBudW1iZXIge1xuICByZXR1cm4gb3B0aW9ucy5kZXZpY2VJZGxlVGltZW91dEluTWlsbGlzZWNvbmRzID8/IERFRkFVTFRfREVWSUNFX0lETEVfVElNRU9VVF9JTl9NSUxMSVNFQ09ORFM7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQW1CQSxNQUFNLCtCQUErQjtBQUNyQyxNQUFNLHNCQUFzQjtBQUtyQixNQUFNLDhDQUE4QztBQTZCcEQsU0FBUyxnQkFBZ0IsUUFBd0M7QUFDdEUsUUFBTSx5QkFBeUIsT0FBTyxzQkFBc0IsS0FBSyxNQUFNO0FBQ3ZFLFFBQU0sd0JBQXdCLE9BQU8sa0JBQ2xDLE1BQU0sSUFBSSxFQUNWLEtBQUssQ0FBQyxTQUFTLEtBQUssVUFBVSxFQUFFLFdBQVcsbUJBQW1CLENBQUM7QUFDbEUsU0FBTywwQkFBMEI7QUFDbkM7QUFhTyxTQUFTLHVDQUNkLFNBQ1E7QUFDUixTQUFPLFFBQVEsbUNBQW1DO0FBQ3BEOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# 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/device-screenshot.cjs

@@ -0,0 +1,42 @@
+"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 device_screenshot_exports = {};
+__export(device_screenshot_exports, {
+  captureDeviceScreenshot: () => captureDeviceScreenshot
+});
+module.exports = __toCommonJS(device_screenshot_exports);
+var import_adb = require("./adb.cjs");
+var import_capture_screenshot = require("./capture-screenshot.cjs");
+async function captureDeviceScreenshot(params) {
+  const bytes = await (0, import_adb.runAdbBinary)({
+    commandArguments: ["exec-out", "screencap", "-p"],
+    deviceId: params.deviceId
+  });
+  if (!(0, import_capture_screenshot.isPng)(bytes)) {
+    throw new Error(
+      `captureDeviceScreenshot: ${params.deviceId} returned ${String(bytes.length)} bytes that are not a PNG. A device that is still booting, or an adb transport that decoded the stream as text, both look like this.`
+    );
+  }
+  return bytes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureDeviceScreenshot
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * Photographs the DEVICE, not the web page.
+ *
+ * `captureObsidianScreenshot` goes through Appium in the WebView context, so on
+ * Android it captures the page: no status bar, and — the reason this exists —
+ * no soft keyboard, because the IME is a system window and not part of the
+ * page. A frame that is meant to show what a phone looks like therefore cannot
+ * be taken that way.
+ *
+ * `adb exec-out screencap -p` reads the framebuffer instead, which is the same
+ * route the trusted-input passes already use. The trade is deliberate and worth
+ * writing down at every call site: a device capture carries the status-bar clock
+ * and battery, so it is **not byte-reproducible** the way a page capture is.
+ * Reach for this only for the shots that need the keyboard; leave the rest on
+ * `captureObsidianScreenshot`.
+ */
+/**
+ * Parameters for {@link captureDeviceScreenshot}.
+ */
+export interface CaptureDeviceScreenshotParams {
+    /**
+     * The device to photograph.
+     */
+    readonly deviceId: string;
+}
+/**
+ * Captures the device's framebuffer as a PNG.
+ *
+ * @param params - The device to photograph.
+ * @returns A {@link Promise} that resolves to the raw PNG bytes.
+ * @throws Error if what came back is not a PNG — which is what a truncated or text-decoded capture looks
+ *   like, and is far cheaper to catch here than in an image diff.
+ */
+export declare function captureDeviceScreenshot(params: CaptureDeviceScreenshotParams): Promise<Uint8Array>;

package/dist/lib/cjs/device-setting-restore.cjs

@@ -0,0 +1,45 @@
+"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 device_setting_restore_exports = {};
+__export(device_setting_restore_exports, {
+  DeviceSettingRestoreKind: () => DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore: () => resolveDeviceSettingRestore
+});
+module.exports = __toCommonJS(device_setting_restore_exports);
+var DeviceSettingRestoreKind = /* @__PURE__ */ ((DeviceSettingRestoreKind2) => {
+  DeviceSettingRestoreKind2["Delete"] = "delete";
+  DeviceSettingRestoreKind2["Write"] = "write";
+  return DeviceSettingRestoreKind2;
+})(DeviceSettingRestoreKind || {});
+const UNSET_SETTING_VALUE = "null";
+function resolveDeviceSettingRestore(previousValue) {
+  if (previousValue === UNSET_SETTING_VALUE) {
+    return { kind: "delete" /* Delete */ };
+  }
+  return {
+    kind: "write" /* Write */,
+    value: previousValue
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeviceSettingRestoreKind,
+  resolveDeviceSettingRestore
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/device-setting-restore.d.cts

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * Decides how a device setting that was changed for a capture gets put back.
+ *
+ * A suite that flips a setting owes the device its original value back —
+ * including the case where it never had one. `settings get` prints the literal
+ * `null` for a setting that has never been written, and `settings put … null`
+ * does **not** reproduce that state: it writes the four-character string
+ * `null`. Restoring an unset setting takes `settings delete`, which is why this
+ * is a decision rather than a straight write-back.
+ *
+ * Pure and unit-tested; the calls that carry it out live in `device-settings`.
+ */
+/**
+ * How a setting is restored.
+ */
+export declare enum DeviceSettingRestoreKind {
+    /**
+     * The setting had never been written, so restoring it means removing it again.
+     */
+    Delete = "delete",
+    /**
+     * The setting held a value, which is written back verbatim.
+     */
+    Write = "write"
+}
+/**
+ * What restoring a setting requires: putting a value back, or removing it again.
+ */
+export type DeviceSettingRestore = DeviceSettingRestoreDelete | DeviceSettingRestoreWrite;
+/**
+ * Restoring a setting by removing it, because it had never been written.
+ */
+export interface DeviceSettingRestoreDelete {
+    /**
+     * Discriminates the union.
+     */
+    readonly kind: DeviceSettingRestoreKind.Delete;
+}
+/**
+ * Restoring a setting by writing its previous value back.
+ */
+export interface DeviceSettingRestoreWrite {
+    /**
+     * Discriminates the union.
+     */
+    readonly kind: DeviceSettingRestoreKind.Write;
+    /**
+     * The value to write back, exactly as it was read.
+     */
+    readonly value: string;
+}
+/**
+ * Decides how a setting read before a change is put back afterwards.
+ *
+ * @param previousValue - Exactly what `readDeviceSetting` returned before the change.
+ * @returns Whether to write the value back or to remove the setting again.
+ */
+export declare function resolveDeviceSettingRestore(previousValue: string): DeviceSettingRestore;

package/dist/lib/cjs/device-settings-command.cjs

@@ -0,0 +1,49 @@
+"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 device_settings_command_exports = {};
+__export(device_settings_command_exports, {
+  DeviceSettingNamespace: () => DeviceSettingNamespace,
+  DeviceSettingVerb: () => DeviceSettingVerb,
+  buildDeviceSettingsCommandArguments: () => buildDeviceSettingsCommandArguments
+});
+module.exports = __toCommonJS(device_settings_command_exports);
+var DeviceSettingNamespace = /* @__PURE__ */ ((DeviceSettingNamespace2) => {
+  DeviceSettingNamespace2["Global"] = "global";
+  DeviceSettingNamespace2["Secure"] = "secure";
+  DeviceSettingNamespace2["System"] = "system";
+  return DeviceSettingNamespace2;
+})(DeviceSettingNamespace || {});
+var DeviceSettingVerb = /* @__PURE__ */ ((DeviceSettingVerb2) => {
+  DeviceSettingVerb2["Delete"] = "delete";
+  DeviceSettingVerb2["Get"] = "get";
+  DeviceSettingVerb2["Put"] = "put";
+  return DeviceSettingVerb2;
+})(DeviceSettingVerb || {});
+function buildDeviceSettingsCommandArguments(params) {
+  const namespace = params.namespace ?? "secure" /* Secure */;
+  const value = params.verb === "put" /* Put */ && params.value !== void 0 ? [params.value] : [];
+  return ["shell", "settings", params.verb, namespace, params.name, ...value];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeviceSettingNamespace,
+  DeviceSettingVerb,
+  buildDeviceSettingsCommandArguments
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/device-settings-command.d.cts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Builds the `adb shell settings …` argument list.
+ *
+ * Split out of {@link ./device-settings.ts} for the same reason
+ * {@link ./adb-device-list.ts} is split out of the transport factory: the
+ * argument list is pure and worth unit-testing, while the call that runs it is
+ * integration-time code that a unit test cannot reach. Keeping them in one file
+ * would put the namespace default inside a coverage-ignored block, where nothing
+ * checks that it is what the documentation claims.
+ */
+/**
+ * The `settings` namespaces this helper addresses.
+ */
+export declare enum DeviceSettingNamespace {
+    /**
+     * Device-wide settings, e.g. `hide_error_dialogs`.
+     */
+    Global = "global",
+    /**
+     * Per-user settings the system reads, e.g. `show_ime_with_hard_keyboard`.
+     */
+    Secure = "secure",
+    /**
+     * Per-user settings apps may read, e.g. `screen_brightness`.
+     */
+    System = "system"
+}
+/**
+ * The `settings` sub-commands this helper issues.
+ */
+export declare enum DeviceSettingVerb {
+    /**
+     * Removes the setting, returning it to never-having-been-written.
+     */
+    Delete = "delete",
+    /**
+     * Reads the setting, printing `null` when it has never been written.
+     */
+    Get = "get",
+    /**
+     * Writes the setting.
+     */
+    Put = "put"
+}
+/**
+ * Parameters for {@link buildDeviceSettingsCommandArguments}.
+ */
+export interface BuildDeviceSettingsCommandArgumentsParams {
+    /**
+     * The setting's name within {@link namespace}, e.g. `show_ime_with_hard_keyboard`.
+     */
+    readonly name: string;
+    /**
+     * The settings namespace the name lives in.
+     *
+     * @default {@link DeviceSettingNamespace.Secure}
+     */
+    readonly namespace?: DeviceSettingNamespace;
+    /**
+     * The value to write. Meaningful only for {@link DeviceSettingVerb.Put}.
+     */
+    readonly value?: string;
+    /**
+     * The sub-command to issue.
+     */
+    readonly verb: DeviceSettingVerb;
+}
+/**
+ * Builds the arguments for `adb shell settings <verb> <namespace> <name> [value]`.
+ *
+ * @param params - The sub-command, the setting, its namespace and — for a write — its value.
+ * @returns The arguments to hand to `runAdbText`, `shell` included.
+ */
+export declare function buildDeviceSettingsCommandArguments(params: BuildDeviceSettingsCommandArgumentsParams): string[];