obsidian-integration-testing 8.2.0 → 8.2.1

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "8.1.2";
+const LIBRARY_VERSION = false ? "dev" : "8.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

package/dist/lib/cjs/spawn-options.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 spawn_options_exports = {};
+__export(spawn_options_exports, {
+  resolveAppiumSpawnFlags: () => resolveAppiumSpawnFlags,
+  resolveEmulatorSpawnFlags: () => resolveEmulatorSpawnFlags
+});
+module.exports = __toCommonJS(spawn_options_exports);
+function resolveAppiumSpawnFlags(isConsoleHidden) {
+  return {
+    detached: !isConsoleHidden,
+    windowsHide: isConsoleHidden
+  };
+}
+function resolveEmulatorSpawnFlags(isWindowHidden) {
+  return {
+    detached: false,
+    windowsHide: isWindowHidden
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAppiumSpawnFlags,
+  resolveEmulatorSpawnFlags
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/spawn-options.d.cts

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * Pure resolution of the `detached` / `windowsHide` spawn flags for the
+ * auto-started Appium server and Android emulator, derived from whether their
+ * console windows should be hidden.
+ *
+ * Kept separate from the integration-only launch code (`transport-factory`,
+ * excluded from unit tests) so the flag resolution stays unit-testable — the
+ * launcher itself needs a real Appium server / emulator. Mirrors the split in
+ * `visibility.ts` and `emulator-args.ts`.
+ *
+ * **Why these exact flags** (empirically verified on Windows):
+ * - `detached: true` sets `DETACHED_PROCESS`, which gives the child no console.
+ *   For a console-subsystem child that means Windows/the child later allocates a
+ *   **fresh, visible** console — and `windowsHide` (which only sets `SW_HIDE` on
+ *   an inherited/new console at `CreateProcess` time) is silently defeated. So a
+ *   process we want hidden must NOT be detached.
+ * - Not detaching lets the child inherit the parent's (hidden) console, and any
+ *   console-app **grandchildren** it spawns (e.g. the emulator's netsim/qemu
+ *   helpers) inherit that hidden console too, instead of each popping their own.
+ * - Teardown does not rely on `detached`: `killProcessTree` uses
+ *   `taskkill /F /T /PID`, and `child.unref()` alone lets the parent event loop
+ *   exit without waiting on the child.
+ */
+/**
+ * The subset of spawn options that control console-window visibility.
+ */
+export interface SpawnVisibilityFlags {
+    /**
+     * Whether to run the child in its own process group / detached from the
+     * parent console (`DETACHED_PROCESS` on Windows).
+     */
+    readonly detached: boolean;
+    /** Whether to hide the child's console window (`windowsHide`). */
+    readonly windowsHide: boolean;
+}
+/**
+ * Resolves the visibility spawn flags for the auto-started Appium server.
+ *
+ * When hidden, the server must NOT be detached (otherwise a console window
+ * appears despite `windowsHide`). When the user opts to see the console, it is
+ * detached so it gets its own dedicated window.
+ *
+ * @param isConsoleHidden - Whether the Appium console should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveAppiumSpawnFlags(isConsoleHidden: boolean): SpawnVisibilityFlags;
+/**
+ * Resolves the visibility spawn flags for the auto-started Android emulator.
+ *
+ * The emulator is never detached: detaching only causes its console-app
+ * grandchildren (netsim/qemu) to allocate their own visible consoles. Its
+ * on-screen device window is a GUI window controlled by the `-no-window`
+ * argument (see `emulator-args.ts`), independent of these console flags.
+ *
+ * @param isWindowHidden - Whether the emulator (and its console) should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveEmulatorSpawnFlags(isWindowHidden: boolean): SpawnVisibilityFlags;

package/dist/lib/cjs/transport-factory.cjs

@@ -55,6 +55,7 @@ var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version_switch = require("./obsidian-version-switch.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
 var import_renderer_boot_detection = require("./renderer-boot-detection.cjs");
+var import_spawn_options = require("./spawn-options.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
 var import_type_guards = require("./type-guards.cjs");
@@ -444,22 +445,26 @@ class AppiumTransportFactory {
   }
   startAppiumServer(port, isAppiumConsoleVisible) {
     const isConsoleHidden = (0, import_visibility.shouldHideAppiumConsole)(isAppiumConsoleVisible);
+    const { detached, windowsHide } = (0, import_spawn_options.resolveAppiumSpawnFlags)(isConsoleHidden);
     const child = (0, import_node_child_process.spawn)(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {
-      detached: true,
+      detached,
       shell: true,
       stdio: isConsoleHidden ? "ignore" : ["ignore", "inherit", "inherit"],
-      windowsHide: isConsoleHidden
+      windowsHide
     });
     child.unref();
     return child;
   }
   startEmulator(avdName, isEmulatorVisible) {
     const emulatorBinary = this.resolveEmulatorBinary();
-    const args = (0, import_emulator_args.buildEmulatorArgs)({ avdName, isHidden: (0, import_visibility.shouldHideEmulatorWindow)(isEmulatorVisible) });
+    const isWindowHidden = (0, import_visibility.shouldHideEmulatorWindow)(isEmulatorVisible);
+    const args = (0, import_emulator_args.buildEmulatorArgs)({ avdName, isHidden: isWindowHidden });
+    const { detached, windowsHide } = (0, import_spawn_options.resolveEmulatorSpawnFlags)(isWindowHidden);
     this.log(`Running: ${emulatorBinary} ${args.join(" ")}`);
     const child = (0, import_node_child_process.spawn)(emulatorBinary, args, {
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"]
+      detached,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide
     });
     let capturedOutput = "";
     let exitInfo;
@@ -797,4 +802,4 @@ function stripForbiddenFetchHeaders(requestOptions) {
   createTransportFromOptions,
   getOrCreateTransport
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync\n} from 'node:fs';\nimport http from 'node:http';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { OwnedInstanceConfig } from './transport-desktop-cdp.cjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  checkIsAppiumDriverInstalled,\n  resolveShouldAutoInstallAppiumDependencies,\n  UIAUTOMATOR2_DRIVER_NAME\n} from './appium-dependencies.cjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.cjs';\nimport {\n  checkDeviceIdle,\n  resolveDeviceIdleTimeoutInMilliseconds\n} from './device-readiness.cjs';\nimport { buildEmulatorArgs } from './emulator-args.cjs';\nimport { exec } from './exec.cjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nimport { checkInstallerCompatibility } from './installer-compatibility.cjs';\nimport { killProcessTree } from './kill-process-tree.cjs';\nimport { log } from './log.cjs';\nimport { getObsidianConfigDir } from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.cjs';\nimport { getVersionMetadata } from './obsidian-metadata.cjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.cjs';\nimport { compareVersions } from './obsidian-version.cjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.cjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst OWNED_USER_DATA_PREFIX = 'userdata-';\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /** The user's newest installed asar to provision as-is (no download). */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /** The app version to download and asar-swap onto the shell. */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /** The app version whose own installer shell to download (a downgrade). */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Details of an emulator process that has exited.\n */\ninterface EmulatorExitInfo {\n  /** Exit code, or `null` if the process was terminated by a signal. */\n  code: null | number;\n\n  /** Terminating signal, or `null` if the process exited normally. */\n  signal: NodeJS.Signals | null;\n}\n\n/**\n * A spawned emulator process together with helpers to inspect its captured\n * output and exit status.\n */\ninterface EmulatorLaunch {\n  /** The spawned emulator process. */\n  process: ChildProcess;\n\n  /** Returns the exit details once the process has exited, otherwise `undefined`. */\n  readExitInfo: () => EmulatorExitInfo | undefined;\n\n  /** Returns the captured stdout+stderr (bounded to the most recent output). */\n  readOutput: () => string;\n\n  /** Stops accumulating output. Call once startup has succeeded. */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /** AVD name to connect to (starting a new emulator if not already running). */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface InstalledShell {\n  /** Absolute path to the installed shell executable. */\n  readonly exePath: string;\n\n  /** The detected shell version, or `undefined` when it cannot be determined. */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** Resolved timeout in milliseconds for the auto-started Appium server to become ready. */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /** The Appium server URL. */\n  readonly appiumUrl: URL;\n\n  /** AVD name to start. */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started Appium server console window is shown (omitted \u2192 hidden). */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /** The Appium server port. */\n  readonly port: number;\n\n  /** Whether missing Appium dependencies may be auto-installed before the server is auto-started. */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /** Whether Appium auto-start is allowed. */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        appiumUrl: url,\n        avdName: options.avdName,\n        deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        isEmulatorVisible: options.isEmulatorVisible,\n        port,\n        shouldAutoInstallAppiumDependencies: resolveShouldAutoInstallAppiumDependencies(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      const sessionConnectionRetryTimeout = resolveSessionConnectionRetryTimeoutInMilliseconds(options);\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(sessionConnectionRetryTimeout)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: sessionConnectionRetryTimeout,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n    this.log('Appium installed.');\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible } = params;\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      await this.suppressErrorDialogs(existingDeviceId);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulator = this.startEmulator(avdName, isEmulatorVisible);\n\n    let actualDeviceId: string;\n    try {\n      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, deviceIdleTimeoutInMilliseconds);\n    } finally {\n      emulator.stopCapture();\n    }\n\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    await this.suppressErrorDialogs(actualDeviceId);\n    return { actualDeviceId, emulatorProcess: emulator.process };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private getDeviceProp(deviceId: string, prop: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', prop],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible })\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ChildProcess {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: isConsoleHidden ? 'ignore' : ['ignore', 'inherit', 'inherit'],\n      windowsHide: isConsoleHidden\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string, isEmulatorVisible?: boolean): EmulatorLaunch {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs({ avdName, isHidden: shouldHideEmulatorWindow(isEmulatorVisible) });\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'pipe', 'pipe']\n    });\n\n    let capturedOutput = '';\n    let exitInfo: EmulatorExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number, emulator: EmulatorLaunch): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  /**\n   * Waits for a freshly-booted emulator to become idle before the session is\n   * established.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProp, packageListOutput] = await Promise.all([\n        this.getDeviceProp(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProp, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[], emulator: EmulatorLaunch, deviceIdleTimeoutInMilliseconds: number): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceIdle(actualDeviceId, deviceIdleTimeoutInMilliseconds);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Builds a descriptive error message for an emulator process that exited during\n * startup, appending the captured output tail when available.\n *\n * @param exitInfo - The emulator's exit details.\n * @param output - The captured stdout+stderr tail.\n * @returns A human-readable error message.\n */\nfunction buildEmulatorExitMessage(exitInfo: EmulatorExitInfo, output: string): string {\n  const reason = exitInfo.signal === null\n    ? `exited prematurely with code ${String(exitInfo.code)}`\n    : `was terminated by signal ${exitInfo.signal}`;\n  const trimmedOutput = output.trim();\n  const details = trimmedOutput.length > 0\n    ? `\\n\\nEmulator output (tail):\\n${trimmedOutput}`\n    : '';\n  return `Android emulator ${reason} during startup.${details}`;\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: throws {@link IncompatibleInstallerVersionError} for an\n * installer below the app's run floor, and logs a warning for a\n * runnable-but-below-recommended installer.\n *\n * @param appVersion - The app (asar) version that will be swapped onto the shell,\n *   or `undefined` when no asar-swap will happen (nothing is checked then).\n * @param installerVersion - The resolved installer/shell version, or `undefined`.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction checkAndReportCompatibility(\n  appVersion: string | undefined,\n  installerVersion: string | undefined\n): InstallerCompatibility | undefined {\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = checkInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  if (compatibility.tier === 'unrunnable') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (compatibility.tier === 'nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      cdpPort: options.port,\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n      ...(options.isHarnessOwnedInstance !== undefined && { isHarnessOwnedInstance: options.isHarnessOwnedInstance })\n    });\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport({\n    ...(options?.host !== undefined && { cdpHost: options.host }),\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    ...(options?.isObsidianAppVisible !== undefined && { isObsidianAppVisible: options.isObsidianAppVisible }),\n    ownedInstance,\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox })\n  });\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDir(): string {\n  const root = join(tmpdir(), 'obsidian-integration-testing');\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_PREFIX));\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDir());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link checkInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = checkAndReportCompatibility(swapAppVersion, shellVersion);\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n    userDataDir: createOwnedUserDataDir()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["http", "killAutoStartedProcesses", "process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync\n} from 'node:fs';\nimport http from 'node:http';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { OwnedInstanceConfig } from './transport-desktop-cdp.cjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  checkIsAppiumDriverInstalled,\n  resolveShouldAutoInstallAppiumDependencies,\n  UIAUTOMATOR2_DRIVER_NAME\n} from './appium-dependencies.cjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.cjs';\nimport {\n  checkDeviceIdle,\n  resolveDeviceIdleTimeoutInMilliseconds\n} from './device-readiness.cjs';\nimport { buildEmulatorArgs } from './emulator-args.cjs';\nimport { exec } from './exec.cjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nimport { checkInstallerCompatibility } from './installer-compatibility.cjs';\nimport { killProcessTree } from './kill-process-tree.cjs';\nimport { log } from './log.cjs';\nimport { getObsidianConfigDir } from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.cjs';\nimport { getVersionMetadata } from './obsidian-metadata.cjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.cjs';\nimport { compareVersions } from './obsidian-version.cjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.cjs';\nimport {\n  resolveAppiumSpawnFlags,\n  resolveEmulatorSpawnFlags\n} from './spawn-options.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.cjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst OWNED_USER_DATA_PREFIX = 'userdata-';\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /** The user's newest installed asar to provision as-is (no download). */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /** The app version to download and asar-swap onto the shell. */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /** The app version whose own installer shell to download (a downgrade). */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Details of an emulator process that has exited.\n */\ninterface EmulatorExitInfo {\n  /** Exit code, or `null` if the process was terminated by a signal. */\n  code: null | number;\n\n  /** Terminating signal, or `null` if the process exited normally. */\n  signal: NodeJS.Signals | null;\n}\n\n/**\n * A spawned emulator process together with helpers to inspect its captured\n * output and exit status.\n */\ninterface EmulatorLaunch {\n  /** The spawned emulator process. */\n  process: ChildProcess;\n\n  /** Returns the exit details once the process has exited, otherwise `undefined`. */\n  readExitInfo: () => EmulatorExitInfo | undefined;\n\n  /** Returns the captured stdout+stderr (bounded to the most recent output). */\n  readOutput: () => string;\n\n  /** Stops accumulating output. Call once startup has succeeded. */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /** AVD name to connect to (starting a new emulator if not already running). */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface InstalledShell {\n  /** Absolute path to the installed shell executable. */\n  readonly exePath: string;\n\n  /** The detected shell version, or `undefined` when it cannot be determined. */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** Resolved timeout in milliseconds for the auto-started Appium server to become ready. */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /** The Appium server URL. */\n  readonly appiumUrl: URL;\n\n  /** AVD name to start. */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started Appium server console window is shown (omitted \u2192 hidden). */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /** The Appium server port. */\n  readonly port: number;\n\n  /** Whether missing Appium dependencies may be auto-installed before the server is auto-started. */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /** Whether Appium auto-start is allowed. */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        appiumUrl: url,\n        avdName: options.avdName,\n        deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        isEmulatorVisible: options.isEmulatorVisible,\n        port,\n        shouldAutoInstallAppiumDependencies: resolveShouldAutoInstallAppiumDependencies(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      const sessionConnectionRetryTimeout = resolveSessionConnectionRetryTimeoutInMilliseconds(options);\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(sessionConnectionRetryTimeout)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: sessionConnectionRetryTimeout,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n    this.log('Appium installed.');\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible } = params;\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      await this.suppressErrorDialogs(existingDeviceId);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulator = this.startEmulator(avdName, isEmulatorVisible);\n\n    let actualDeviceId: string;\n    try {\n      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, deviceIdleTimeoutInMilliseconds);\n    } finally {\n      emulator.stopCapture();\n    }\n\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    await this.suppressErrorDialogs(actualDeviceId);\n    return { actualDeviceId, emulatorProcess: emulator.process };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private getDeviceProp(deviceId: string, prop: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', prop],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible })\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ChildProcess {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const { detached, windowsHide } = resolveAppiumSpawnFlags(isConsoleHidden);\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached,\n      shell: true,\n      stdio: isConsoleHidden ? 'ignore' : ['ignore', 'inherit', 'inherit'],\n      windowsHide\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string, isEmulatorVisible?: boolean): EmulatorLaunch {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);\n    const args = buildEmulatorArgs({ avdName, isHidden: isWindowHidden });\n    const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, args, {\n      detached,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: EmulatorExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number, emulator: EmulatorLaunch): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  /**\n   * Waits for a freshly-booted emulator to become idle before the session is\n   * established.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProp, packageListOutput] = await Promise.all([\n        this.getDeviceProp(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProp, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[], emulator: EmulatorLaunch, deviceIdleTimeoutInMilliseconds: number): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceIdle(actualDeviceId, deviceIdleTimeoutInMilliseconds);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Builds a descriptive error message for an emulator process that exited during\n * startup, appending the captured output tail when available.\n *\n * @param exitInfo - The emulator's exit details.\n * @param output - The captured stdout+stderr tail.\n * @returns A human-readable error message.\n */\nfunction buildEmulatorExitMessage(exitInfo: EmulatorExitInfo, output: string): string {\n  const reason = exitInfo.signal === null\n    ? `exited prematurely with code ${String(exitInfo.code)}`\n    : `was terminated by signal ${exitInfo.signal}`;\n  const trimmedOutput = output.trim();\n  const details = trimmedOutput.length > 0\n    ? `\\n\\nEmulator output (tail):\\n${trimmedOutput}`\n    : '';\n  return `Android emulator ${reason} during startup.${details}`;\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: throws {@link IncompatibleInstallerVersionError} for an\n * installer below the app's run floor, and logs a warning for a\n * runnable-but-below-recommended installer.\n *\n * @param appVersion - The app (asar) version that will be swapped onto the shell,\n *   or `undefined` when no asar-swap will happen (nothing is checked then).\n * @param installerVersion - The resolved installer/shell version, or `undefined`.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction checkAndReportCompatibility(\n  appVersion: string | undefined,\n  installerVersion: string | undefined\n): InstallerCompatibility | undefined {\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = checkInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  if (compatibility.tier === 'unrunnable') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (compatibility.tier === 'nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      cdpPort: options.port,\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n      ...(options.isHarnessOwnedInstance !== undefined && { isHarnessOwnedInstance: options.isHarnessOwnedInstance })\n    });\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport({\n    ...(options?.host !== undefined && { cdpHost: options.host }),\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    ...(options?.isObsidianAppVisible !== undefined && { isObsidianAppVisible: options.isObsidianAppVisible }),\n    ownedInstance,\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox })\n  });\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDir(): string {\n  const root = join(tmpdir(), 'obsidian-integration-testing');\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_PREFIX));\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDir());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link checkInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = checkAndReportCompatibility(swapAppVersion, shellVersion);\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n    userDataDir: createOwnedUserDataDir()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["http", "killAutoStartedProcesses", "process"]
}


package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "8.1.2";
+const LIBRARY_VERSION = false ? "dev" : "8.2.0";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/spawn-options.d.mts

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * Pure resolution of the `detached` / `windowsHide` spawn flags for the
+ * auto-started Appium server and Android emulator, derived from whether their
+ * console windows should be hidden.
+ *
+ * Kept separate from the integration-only launch code (`transport-factory`,
+ * excluded from unit tests) so the flag resolution stays unit-testable — the
+ * launcher itself needs a real Appium server / emulator. Mirrors the split in
+ * `visibility.ts` and `emulator-args.ts`.
+ *
+ * **Why these exact flags** (empirically verified on Windows):
+ * - `detached: true` sets `DETACHED_PROCESS`, which gives the child no console.
+ *   For a console-subsystem child that means Windows/the child later allocates a
+ *   **fresh, visible** console — and `windowsHide` (which only sets `SW_HIDE` on
+ *   an inherited/new console at `CreateProcess` time) is silently defeated. So a
+ *   process we want hidden must NOT be detached.
+ * - Not detaching lets the child inherit the parent's (hidden) console, and any
+ *   console-app **grandchildren** it spawns (e.g. the emulator's netsim/qemu
+ *   helpers) inherit that hidden console too, instead of each popping their own.
+ * - Teardown does not rely on `detached`: `killProcessTree` uses
+ *   `taskkill /F /T /PID`, and `child.unref()` alone lets the parent event loop
+ *   exit without waiting on the child.
+ */
+/**
+ * The subset of spawn options that control console-window visibility.
+ */
+export interface SpawnVisibilityFlags {
+    /**
+     * Whether to run the child in its own process group / detached from the
+     * parent console (`DETACHED_PROCESS` on Windows).
+     */
+    readonly detached: boolean;
+    /** Whether to hide the child's console window (`windowsHide`). */
+    readonly windowsHide: boolean;
+}
+/**
+ * Resolves the visibility spawn flags for the auto-started Appium server.
+ *
+ * When hidden, the server must NOT be detached (otherwise a console window
+ * appears despite `windowsHide`). When the user opts to see the console, it is
+ * detached so it gets its own dedicated window.
+ *
+ * @param isConsoleHidden - Whether the Appium console should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveAppiumSpawnFlags(isConsoleHidden: boolean): SpawnVisibilityFlags;
+/**
+ * Resolves the visibility spawn flags for the auto-started Android emulator.
+ *
+ * The emulator is never detached: detaching only causes its console-app
+ * grandchildren (netsim/qemu) to allocate their own visible consoles. Its
+ * on-screen device window is a GUI window controlled by the `-no-window`
+ * argument (see `emulator-args.ts`), independent of these console flags.
+ *
+ * @param isWindowHidden - Whether the emulator (and its console) should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveEmulatorSpawnFlags(isWindowHidden: boolean): SpawnVisibilityFlags;

package/dist/lib/esm/spawn-options.mjs

@@ -0,0 +1,17 @@
+function resolveAppiumSpawnFlags(isConsoleHidden) {
+  return {
+    detached: !isConsoleHidden,
+    windowsHide: isConsoleHidden
+  };
+}
+function resolveEmulatorSpawnFlags(isWindowHidden) {
+  return {
+    detached: false,
+    windowsHide: isWindowHidden
+  };
+}
+export {
+  resolveAppiumSpawnFlags,
+  resolveEmulatorSpawnFlags
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/transport-factory.mjs

@@ -47,6 +47,10 @@ import {
 } from "./obsidian-version-switch.mjs";
 import { compareVersions } from "./obsidian-version.mjs";
 import { resolveDeadBootGraceInMilliseconds } from "./renderer-boot-detection.mjs";
+import {
+  resolveAppiumSpawnFlags,
+  resolveEmulatorSpawnFlags
+} from "./spawn-options.mjs";
 import { AppiumTransport } from "./transport-appium.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { ensureNonNullable } from "./type-guards.mjs";
@@ -439,22 +443,26 @@ class AppiumTransportFactory {
   }
   startAppiumServer(port, isAppiumConsoleVisible) {
     const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);
+    const { detached, windowsHide } = resolveAppiumSpawnFlags(isConsoleHidden);
     const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {
-      detached: true,
+      detached,
       shell: true,
       stdio: isConsoleHidden ? "ignore" : ["ignore", "inherit", "inherit"],
-      windowsHide: isConsoleHidden
+      windowsHide
     });
     child.unref();
     return child;
   }
   startEmulator(avdName, isEmulatorVisible) {
     const emulatorBinary = this.resolveEmulatorBinary();
-    const args = buildEmulatorArgs({ avdName, isHidden: shouldHideEmulatorWindow(isEmulatorVisible) });
+    const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);
+    const args = buildEmulatorArgs({ avdName, isHidden: isWindowHidden });
+    const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);
     this.log(`Running: ${emulatorBinary} ${args.join(" ")}`);
     const child = spawn(emulatorBinary, args, {
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"]
+      detached,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide
     });
     let capturedOutput = "";
     let exitInfo;
@@ -791,4 +799,4 @@ export {
   createTransportFromOptions,
   getOrCreateTransport
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync\n} from 'node:fs';\nimport http from 'node:http';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { OwnedInstanceConfig } from './transport-desktop-cdp.mjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  checkIsAppiumDriverInstalled,\n  resolveShouldAutoInstallAppiumDependencies,\n  UIAUTOMATOR2_DRIVER_NAME\n} from './appium-dependencies.mjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.mjs';\nimport {\n  checkDeviceIdle,\n  resolveDeviceIdleTimeoutInMilliseconds\n} from './device-readiness.mjs';\nimport { buildEmulatorArgs } from './emulator-args.mjs';\nimport { exec } from './exec.mjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nimport { checkInstallerCompatibility } from './installer-compatibility.mjs';\nimport { killProcessTree } from './kill-process-tree.mjs';\nimport { log } from './log.mjs';\nimport { getObsidianConfigDir } from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.mjs';\nimport { compareVersions } from './obsidian-version.mjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst OWNED_USER_DATA_PREFIX = 'userdata-';\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /** The user's newest installed asar to provision as-is (no download). */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /** The app version to download and asar-swap onto the shell. */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /** The app version whose own installer shell to download (a downgrade). */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Details of an emulator process that has exited.\n */\ninterface EmulatorExitInfo {\n  /** Exit code, or `null` if the process was terminated by a signal. */\n  code: null | number;\n\n  /** Terminating signal, or `null` if the process exited normally. */\n  signal: NodeJS.Signals | null;\n}\n\n/**\n * A spawned emulator process together with helpers to inspect its captured\n * output and exit status.\n */\ninterface EmulatorLaunch {\n  /** The spawned emulator process. */\n  process: ChildProcess;\n\n  /** Returns the exit details once the process has exited, otherwise `undefined`. */\n  readExitInfo: () => EmulatorExitInfo | undefined;\n\n  /** Returns the captured stdout+stderr (bounded to the most recent output). */\n  readOutput: () => string;\n\n  /** Stops accumulating output. Call once startup has succeeded. */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /** AVD name to connect to (starting a new emulator if not already running). */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface InstalledShell {\n  /** Absolute path to the installed shell executable. */\n  readonly exePath: string;\n\n  /** The detected shell version, or `undefined` when it cannot be determined. */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** Resolved timeout in milliseconds for the auto-started Appium server to become ready. */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /** The Appium server URL. */\n  readonly appiumUrl: URL;\n\n  /** AVD name to start. */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started Appium server console window is shown (omitted \u2192 hidden). */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /** The Appium server port. */\n  readonly port: number;\n\n  /** Whether missing Appium dependencies may be auto-installed before the server is auto-started. */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /** Whether Appium auto-start is allowed. */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        appiumUrl: url,\n        avdName: options.avdName,\n        deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        isEmulatorVisible: options.isEmulatorVisible,\n        port,\n        shouldAutoInstallAppiumDependencies: resolveShouldAutoInstallAppiumDependencies(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      const sessionConnectionRetryTimeout = resolveSessionConnectionRetryTimeoutInMilliseconds(options);\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(sessionConnectionRetryTimeout)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: sessionConnectionRetryTimeout,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n    this.log('Appium installed.');\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible } = params;\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      await this.suppressErrorDialogs(existingDeviceId);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulator = this.startEmulator(avdName, isEmulatorVisible);\n\n    let actualDeviceId: string;\n    try {\n      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, deviceIdleTimeoutInMilliseconds);\n    } finally {\n      emulator.stopCapture();\n    }\n\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    await this.suppressErrorDialogs(actualDeviceId);\n    return { actualDeviceId, emulatorProcess: emulator.process };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private getDeviceProp(deviceId: string, prop: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', prop],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible })\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ChildProcess {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached: true,\n      shell: true,\n      stdio: isConsoleHidden ? 'ignore' : ['ignore', 'inherit', 'inherit'],\n      windowsHide: isConsoleHidden\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string, isEmulatorVisible?: boolean): EmulatorLaunch {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const args = buildEmulatorArgs({ avdName, isHidden: shouldHideEmulatorWindow(isEmulatorVisible) });\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, args, {\n      detached: true,\n      stdio: ['ignore', 'pipe', 'pipe']\n    });\n\n    let capturedOutput = '';\n    let exitInfo: EmulatorExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number, emulator: EmulatorLaunch): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  /**\n   * Waits for a freshly-booted emulator to become idle before the session is\n   * established.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProp, packageListOutput] = await Promise.all([\n        this.getDeviceProp(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProp, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[], emulator: EmulatorLaunch, deviceIdleTimeoutInMilliseconds: number): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceIdle(actualDeviceId, deviceIdleTimeoutInMilliseconds);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Builds a descriptive error message for an emulator process that exited during\n * startup, appending the captured output tail when available.\n *\n * @param exitInfo - The emulator's exit details.\n * @param output - The captured stdout+stderr tail.\n * @returns A human-readable error message.\n */\nfunction buildEmulatorExitMessage(exitInfo: EmulatorExitInfo, output: string): string {\n  const reason = exitInfo.signal === null\n    ? `exited prematurely with code ${String(exitInfo.code)}`\n    : `was terminated by signal ${exitInfo.signal}`;\n  const trimmedOutput = output.trim();\n  const details = trimmedOutput.length > 0\n    ? `\\n\\nEmulator output (tail):\\n${trimmedOutput}`\n    : '';\n  return `Android emulator ${reason} during startup.${details}`;\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: throws {@link IncompatibleInstallerVersionError} for an\n * installer below the app's run floor, and logs a warning for a\n * runnable-but-below-recommended installer.\n *\n * @param appVersion - The app (asar) version that will be swapped onto the shell,\n *   or `undefined` when no asar-swap will happen (nothing is checked then).\n * @param installerVersion - The resolved installer/shell version, or `undefined`.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction checkAndReportCompatibility(\n  appVersion: string | undefined,\n  installerVersion: string | undefined\n): InstallerCompatibility | undefined {\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = checkInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  if (compatibility.tier === 'unrunnable') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (compatibility.tier === 'nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      cdpPort: options.port,\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n      ...(options.isHarnessOwnedInstance !== undefined && { isHarnessOwnedInstance: options.isHarnessOwnedInstance })\n    });\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport({\n    ...(options?.host !== undefined && { cdpHost: options.host }),\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    ...(options?.isObsidianAppVisible !== undefined && { isObsidianAppVisible: options.isObsidianAppVisible }),\n    ownedInstance,\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox })\n  });\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDir(): string {\n  const root = join(tmpdir(), 'obsidian-integration-testing');\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_PREFIX));\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDir());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link checkInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = checkAndReportCompatibility(swapAppVersion, shellVersion);\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n    userDataDir: createOwnedUserDataDir()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["killAutoStartedProcesses"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  spawn\n} from 'node:child_process';\nimport {\n  mkdirSync,\n  mkdtempSync\n} from 'node:fs';\nimport http from 'node:http';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  attach,\n  remote\n} from 'webdriverio';\n\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { OwnedInstanceConfig } from './transport-desktop-cdp.mjs';\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  checkIsAppiumDriverInstalled,\n  resolveShouldAutoInstallAppiumDependencies,\n  UIAUTOMATOR2_DRIVER_NAME\n} from './appium-dependencies.mjs';\nimport {\n  resolveAppiumStartTimeoutInMilliseconds,\n  resolveSessionConnectionRetryTimeoutInMilliseconds\n} from './appium-session-config.mjs';\nimport {\n  checkDeviceIdle,\n  resolveDeviceIdleTimeoutInMilliseconds\n} from './device-readiness.mjs';\nimport { buildEmulatorArgs } from './emulator-args.mjs';\nimport { exec } from './exec.mjs';\nimport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';\nimport { checkInstallerCompatibility } from './installer-compatibility.mjs';\nimport { killProcessTree } from './kill-process-tree.mjs';\nimport { log } from './log.mjs';\nimport { getObsidianConfigDir } from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport {\n  detectInstalledShellVersion,\n  ensureShellCached\n} from './obsidian-installer.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  ensureAsarCached,\n  findNewestAsar,\n  resolveConcreteVersion\n} from './obsidian-version-switch.mjs';\nimport { compareVersions } from './obsidian-version.mjs';\nimport { resolveDeadBootGraceInMilliseconds } from './renderer-boot-detection.mjs';\nimport {\n  resolveAppiumSpawnFlags,\n  resolveEmulatorSpawnFlags\n} from './spawn-options.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\nimport {\n  shouldHideAppiumConsole,\n  shouldHideEmulatorWindow\n} from './visibility.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 3;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst OWNED_USER_DATA_PREFIX = 'userdata-';\n// Appium insecure feature letting the UiAutomator2 driver auto-download a\n// Chromedriver matching Obsidian's WebView Chrome version. Enabling it on the\n// Appium server (it has no effect as a capability) avoids the failure\n// \"No Chromedriver found that can automate Chrome ...\".\nconst CHROMEDRIVER_AUTODOWNLOAD_FEATURE = 'uiautomator2:chromedriver_autodownload';\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst EMULATOR_OUTPUT_TAIL_MAX_LENGTH = 8000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS = 120000;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 120000;\n\n/**\n * How the requested app (asar) version will be applied to an owned instance; at\n * most one field is set (see {@link resolveAsarPlan}).\n */\ninterface AsarPlan {\n  /** The user's newest installed asar to provision as-is (no download). */\n  readonly asar?: OwnedInstanceConfig['asar'];\n\n  /** The app version to download and asar-swap onto the shell. */\n  readonly asarVersionToSwap?: string | undefined;\n\n  /** The app version whose own installer shell to download (a downgrade). */\n  readonly downgradeInstallerVersion?: string | undefined;\n}\n\n/**\n * Details of an emulator process that has exited.\n */\ninterface EmulatorExitInfo {\n  /** Exit code, or `null` if the process was terminated by a signal. */\n  code: null | number;\n\n  /** Terminating signal, or `null` if the process exited normally. */\n  signal: NodeJS.Signals | null;\n}\n\n/**\n * A spawned emulator process together with helpers to inspect its captured\n * output and exit status.\n */\ninterface EmulatorLaunch {\n  /** The spawned emulator process. */\n  process: ChildProcess;\n\n  /** Returns the exit details once the process has exited, otherwise `undefined`. */\n  readExitInfo: () => EmulatorExitInfo | undefined;\n\n  /** Returns the captured stdout+stderr (bounded to the most recent output). */\n  readOutput: () => string;\n\n  /** Stops accumulating output. Call once startup has succeeded. */\n  stopCapture: () => void;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /** AVD name to connect to (starting a new emulator if not already running). */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\n/**\n * The locally-installed Obsidian shell resolved by {@link resolveInstalledShellOrNull}.\n */\ninterface InstalledShell {\n  /** Absolute path to the installed shell executable. */\n  readonly exePath: string;\n\n  /** The detected shell version, or `undefined` when it cannot be determined. */\n  readonly shellVersion: string | undefined;\n}\n\n/**\n * Parameters for {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** Resolved timeout in milliseconds for the auto-started Appium server to become ready. */\n  readonly appiumStartTimeoutInMilliseconds: number;\n\n  /** The Appium server URL. */\n  readonly appiumUrl: URL;\n\n  /** AVD name to start. */\n  readonly avdName: string;\n\n  /** Resolved timeout in milliseconds for the post-boot device-idle wait (`0` skips it). */\n  readonly deviceIdleTimeoutInMilliseconds: number;\n\n  /** Whether the auto-started Appium server console window is shown (omitted \u2192 hidden). */\n  readonly isAppiumConsoleVisible?: boolean | undefined;\n\n  /** Whether the auto-started emulator window is shown (omitted \u2192 hidden). */\n  readonly isEmulatorVisible?: boolean | undefined;\n\n  /** The Appium server port. */\n  readonly port: number;\n\n  /** Whether missing Appium dependencies may be auto-installed before the server is auto-started. */\n  readonly shouldAutoInstallAppiumDependencies: boolean;\n\n  /** Whether Appium auto-start is allowed. */\n  readonly shouldAutoStartAppium?: boolean | undefined;\n}\n\n/**\n * Result of {@link AppiumTransportFactory.startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorResult {\n  /** The actual device ID that is connected (may differ from the requested one). */\n  readonly actualDeviceId: string;\n\n  /** The Appium server process, if one was auto-started. */\n  readonly appiumProcess?: ChildProcess | undefined;\n\n  /** The emulator process, if one was auto-started. */\n  readonly emulatorProcess?: ChildProcess | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an Appium transport by establishing a WebDriverIO session.\n   *\n   * If `options.sessionId` is present, reattaches to the existing session\n   * instead of creating a new one. This avoids duplicate Appium/ADB connections\n   * when test workers reuse the global setup's session.\n   *\n   * @param options - Android Appium transport options.\n   * @returns A configured Appium transport.\n   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    if (options.sessionId !== undefined && options.deviceId !== undefined) {\n      return this.attachToExistingSession(options.sessionId, options.deviceId, options);\n    }\n\n    return this.createNewSession(options);\n  }\n\n  private async attachToExistingSession(\n    sessionId: string,\n    deviceId: string,\n    options: ObsidianAndroidAppiumTransportOptions\n  ): Promise<ObsidianTransport> {\n    const url = new URL(options.appiumUrl);\n    const port = Number(url.port);\n    const appId = options.appId ?? APP_PACKAGE;\n\n    this.log(`Reattaching to existing Appium session ${sessionId} (device=${deviceId})`);\n\n    const browser = await attach({\n      capabilities: {\n        platformName: 'Android'\n      },\n      hostname: url.hostname,\n      logLevel: 'warn',\n      path: url.pathname,\n      port,\n      sessionId,\n      transformRequest: stripForbiddenFetchHeaders\n    });\n\n    this.log('Reattached to Appium session.');\n\n    return new AppiumTransport({\n      appId,\n      browser,\n      deviceId,\n      isSessionOwner: false,\n      platform: 'android',\n      ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n      ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n    });\n  }\n\n  private checkAppiumReachable(url: URL): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const statusUrl = new URL('/status', url);\n      const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n        res.resume();\n        resolve();\n      });\n      req.on('timeout', () => {\n        req.destroy();\n        reject(\n          new Error(\n            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n          )\n        );\n      });\n      req.on('error', (err) => {\n        reject(\n          new Error(\n            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n          )\n        );\n      });\n    });\n  }\n\n  private async createNewSession(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, avd=${options.avdName})`);\n\n    const url = new URL(options.appiumUrl);\n\n    const port = Number(url.port);\n    if (isNaN(port)) {\n      throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n    }\n\n    const appId = options.appId ?? APP_PACKAGE;\n\n    let appiumProcess: ChildProcess | undefined;\n    let emulatorProcess: ChildProcess | undefined;\n\n    try {\n      const result = await this.startAppiumAndEmulator({\n        appiumStartTimeoutInMilliseconds: resolveAppiumStartTimeoutInMilliseconds(options),\n        appiumUrl: url,\n        avdName: options.avdName,\n        deviceIdleTimeoutInMilliseconds: resolveDeviceIdleTimeoutInMilliseconds(options),\n        isAppiumConsoleVisible: options.isAppiumConsoleVisible,\n        isEmulatorVisible: options.isEmulatorVisible,\n        port,\n        shouldAutoInstallAppiumDependencies: resolveShouldAutoInstallAppiumDependencies(options),\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      appiumProcess = result.appiumProcess;\n      emulatorProcess = result.emulatorProcess;\n      const actualDeviceId = result.actualDeviceId;\n\n      const sessionConnectionRetryTimeout = resolveSessionConnectionRetryTimeoutInMilliseconds(options);\n      this.log(\n        `Connecting to Appium (device=${actualDeviceId}, app=${appId}, retryTimeout: ${String(sessionConnectionRetryTimeout)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n      );\n      const browser = await remote({\n        capabilities: {\n          'appium:appActivity': APP_ACTIVITY,\n          'appium:appPackage': appId,\n          'appium:autoGrantPermissions': true,\n          'appium:automationName': 'UiAutomator2',\n          'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n          'appium:noReset': true,\n          'appium:udid': actualDeviceId,\n          'appium:uiautomator2ServerInstallTimeout': SERVER_INSTALL_TIMEOUT_IN_MILLISECONDS,\n          'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n          'platformName': 'Android'\n        },\n        connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n        connectionRetryTimeout: sessionConnectionRetryTimeout,\n        hostname: url.hostname,\n        logLevel: 'warn',\n        path: url.pathname,\n        port,\n        transformRequest: stripForbiddenFetchHeaders\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        deviceId: actualDeviceId,\n        platform: 'android',\n        ...(options.layoutReadyTimeoutInMilliseconds !== undefined && { layoutReadyTimeoutInMilliseconds: options.layoutReadyTimeoutInMilliseconds }),\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath }),\n        ...(options.webviewTimeoutInMilliseconds !== undefined && { webviewTimeoutInMilliseconds: options.webviewTimeoutInMilliseconds })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Ensures the Appium toolchain is present before the server is auto-started:\n   * Appium itself, then the `uiautomator2` driver. Each is checked first and\n   * installed only when missing, so a fully-provisioned machine incurs just two\n   * fast version/list probes.\n   *\n   * Only invoked when the harness is about to auto-start the server and\n   * {@link ObsidianAndroidAppiumTransportOptions.shouldAutoInstallAppiumDependencies}\n   * is enabled. Commands are passed as strings so `exec` runs them through the\n   * shell, which resolves the `npm`/`npx` `.cmd` shims on Windows (the array\n   * path spawns without a shell and cannot).\n   */\n  private async ensureAppiumDependencies(): Promise<void> {\n    await this.ensureAppiumInstalled();\n    await this.ensureUiautomator2DriverInstalled();\n  }\n\n  private async ensureAppiumInstalled(): Promise<void> {\n    this.log('Checking whether Appium is installed...');\n    const result = await exec('npx --no-install appium --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      shouldIncludeDetails: true\n    });\n\n    if (result.exitCode === 0) {\n      this.log(`Appium is installed (version ${result.stdout.trim() || 'unknown'}).`);\n      return;\n    }\n\n    this.log('Appium is not installed. Installing globally via `npm install -g appium`...');\n    await exec('npm install -g appium');\n    this.log('Appium installed.');\n  }\n\n  private async ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<EnsureDeviceConnectedResult> {\n    const { avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible } = params;\n    const deviceIdsBefore = await this.getConnectedDeviceIds();\n    this.log(`Checking existing devices for AVD \"${avdName}\"... (connected: [${deviceIdsBefore.join(', ')}])`);\n\n    const existingDeviceId = await this.findDeviceByAvdName(avdName, deviceIdsBefore);\n\n    if (existingDeviceId) {\n      this.log(`AVD \"${avdName}\" is already running on device ${existingDeviceId}, reusing.`);\n      await this.suppressErrorDialogs(existingDeviceId);\n      return { actualDeviceId: existingDeviceId };\n    }\n\n    this.log(`AVD \"${avdName}\" not found on any existing device, starting a new emulator...`);\n    const emulator = this.startEmulator(avdName, isEmulatorVisible);\n\n    let actualDeviceId: string;\n    try {\n      actualDeviceId = await this.waitForNewDevice(deviceIdsBefore, emulator, deviceIdleTimeoutInMilliseconds);\n    } finally {\n      emulator.stopCapture();\n    }\n\n    this.log(`Emulator \"${avdName}\" started, device ${actualDeviceId} is connected.`);\n    await this.suppressErrorDialogs(actualDeviceId);\n    return { actualDeviceId, emulatorProcess: emulator.process };\n  }\n\n  private async ensureUiautomator2DriverInstalled(): Promise<void> {\n    this.log(`Checking whether the ${UIAUTOMATOR2_DRIVER_NAME} driver is installed...`);\n    const driverListJson = await exec('npx --no-install appium driver list --installed --json', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n\n    if (checkIsAppiumDriverInstalled({ driverListJson, driverName: UIAUTOMATOR2_DRIVER_NAME })) {\n      this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is installed.`);\n      return;\n    }\n\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver is not installed. Installing via \\`appium driver install ${UIAUTOMATOR2_DRIVER_NAME}\\`...`);\n    await exec(`npx --no-install appium driver install ${UIAUTOMATOR2_DRIVER_NAME}`);\n    this.log(`The ${UIAUTOMATOR2_DRIVER_NAME} driver installed.`);\n  }\n\n  private async findDeviceByAvdName(avdName: string, deviceIds: string[]): Promise<string | undefined> {\n    for (const deviceId of deviceIds) {\n      const runningAvd = await new Promise<string>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'emu', 'avd', 'name'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.split('\\n')[0]?.trim() ?? '');\n          }\n        );\n      });\n\n      if (runningAvd === avdName) {\n        return deviceId;\n      }\n    }\n\n    return undefined;\n  }\n\n  private async getConnectedDeviceIds(): Promise<string[]> {\n    const output = await new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n\n    const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n    return lines\n      .filter((line) => line.includes('\\tdevice'))\n      .map((line) => line.split('\\t')[0] ?? '');\n  }\n\n  private getDeviceProp(deviceId: string, prop: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', prop],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error (not partial stdout) so a non-responsive guest reads as \"not idle\".\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private listInstalledPackages(deviceId: string): Promise<string> {\n    return new Promise((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'cmd', 'package', 'list', 'packages'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          // Return no output on timeout/error so a churning guest's slow/partial package list can't falsely read as idle.\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private resolveEmulatorBinary(): string {\n    const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n    if (!sdkRoot) {\n      throw new Error(\n        'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n      );\n    }\n    return join(sdkRoot, 'emulator', 'emulator');\n  }\n\n  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<StartAppiumAndEmulatorResult> {\n    const { appiumStartTimeoutInMilliseconds, appiumUrl, avdName, deviceIdleTimeoutInMilliseconds, isAppiumConsoleVisible, isEmulatorVisible, port, shouldAutoInstallAppiumDependencies, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('Appium server is reachable.');\n    } catch (error: unknown) {\n      if (shouldAutoStartAppium === false) {\n        throw error;\n      }\n      needsAppiumStart = true;\n    }\n\n    let appiumProcess: ChildProcess | undefined;\n\n    if (needsAppiumStart) {\n      if (shouldAutoInstallAppiumDependencies) {\n        await this.ensureAppiumDependencies();\n      }\n      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port, isAppiumConsoleVisible);\n    }\n\n    try {\n      const [, deviceResult] = await Promise.all([\n        needsAppiumStart\n          ? this.waitForAppiumReady(appiumUrl, appiumStartTimeoutInMilliseconds).then(() => {\n            this.log('Auto-started Appium server is ready.');\n          })\n          : Promise.resolve(),\n        this.ensureDeviceConnected({ avdName, deviceIdleTimeoutInMilliseconds, isEmulatorVisible })\n      ]);\n\n      return {\n        actualDeviceId: deviceResult.actualDeviceId,\n        appiumProcess,\n        emulatorProcess: deviceResult.emulatorProcess\n      };\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after startup failure.');\n      }\n      throw error;\n    }\n  }\n\n  private startAppiumServer(port: number, isAppiumConsoleVisible?: boolean): ChildProcess {\n    const isConsoleHidden = shouldHideAppiumConsole(isAppiumConsoleVisible);\n    const { detached, windowsHide } = resolveAppiumSpawnFlags(isConsoleHidden);\n    const child = spawn(`npx appium --log-timestamp --port ${String(port)} --allow-insecure=${CHROMEDRIVER_AUTODOWNLOAD_FEATURE}`, {\n      detached,\n      shell: true,\n      stdio: isConsoleHidden ? 'ignore' : ['ignore', 'inherit', 'inherit'],\n      windowsHide\n    });\n\n    child.unref();\n    return child;\n  }\n\n  private startEmulator(avdName: string, isEmulatorVisible?: boolean): EmulatorLaunch {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    const isWindowHidden = shouldHideEmulatorWindow(isEmulatorVisible);\n    const args = buildEmulatorArgs({ avdName, isHidden: isWindowHidden });\n    const { detached, windowsHide } = resolveEmulatorSpawnFlags(isWindowHidden);\n    this.log(`Running: ${emulatorBinary} ${args.join(' ')}`);\n    /*\n     * Pipe (rather than ignore) stdout/stderr so an early failure such as\n     * \"x86_64 emulation currently requires hardware acceleration\" can be\n     * surfaced immediately instead of waiting out the full boot timeout.\n     */\n    const child = spawn(emulatorBinary, args, {\n      detached,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      windowsHide\n    });\n\n    let capturedOutput = '';\n    let exitInfo: EmulatorExitInfo | undefined;\n    let isCapturing = true;\n\n    child.stdout.on('data', appendOutput);\n    child.stderr.on('data', appendOutput);\n    child.once('exit', (code, signal) => {\n      exitInfo = { code, signal };\n    });\n\n    child.unref();\n\n    return {\n      process: child,\n      readExitInfo: () => exitInfo,\n      readOutput: () => capturedOutput,\n      stopCapture: (): void => {\n        /*\n         * Leave the `data` listeners attached so the pipes keep draining (a\n         * full OS pipe buffer would block the long-running emulator); the flag\n         * just freezes the captured tail once startup has succeeded.\n         */\n        isCapturing = false;\n      }\n    };\n\n    function appendOutput(chunk: Buffer): void {\n      if (!isCapturing) {\n        return;\n      }\n      capturedOutput = (capturedOutput + chunk.toString()).slice(-EMULATOR_OUTPUT_TAIL_MAX_LENGTH);\n    }\n  }\n\n  /**\n   * Disables the guest's crash/ANR dialogs on the given device.\n   *\n   * A resource-starved emulator can raise a \"Process system isn't responding\"\n   * ANR (an `ActivityManagerService` timeout) whose dialog overlays the UI. If\n   * it appears before Appium attaches, nothing can dismiss it and the run hangs\n   * or fails intermittently. Setting the `hide_error_dialogs` global \u2014 the same\n   * flag Android's own test infra uses \u2014 tells `ActivityManagerService` to\n   * never draw crash/ANR dialogs, so the ANR can no longer block automation.\n   *\n   * This is the earliest point at which the flag can be set: the framework\n   * (`system_server`) must be up before `settings put` works, so callers invoke\n   * it only after `sys.boot_completed`. It narrows \u2014 but cannot fully close \u2014\n   * the race with an ANR that fires between boot completing and this call; a\n   * pre-baked snapshot with the flag already set is the only way to eliminate\n   * it entirely. Best-effort: a failure is logged, not thrown, since it only\n   * suppresses a symptom.\n   *\n   * @param deviceId - The device UDID to configure.\n   */\n  private async suppressErrorDialogs(deviceId: string): Promise<void> {\n    this.log(`Disabling crash/ANR dialogs on device ${deviceId} (settings put global hide_error_dialogs 1)...`);\n\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'settings', 'put', 'global', 'hide_error_dialogs', '1'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to disable crash/ANR dialogs: ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async waitForAppiumReady(url: URL, timeoutInMilliseconds: number): Promise<void> {\n    const start = Date.now();\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = start + timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.checkAppiumReachable(url);\n        this.log(`Appium server ready after ${String(Date.now() - start)}ms.`);\n        return;\n      } catch {\n        this.log(`Appium server not ready yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n        await new Promise((resolve) => {\n          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n        });\n      }\n    }\n\n    throw new Error(\n      `Auto-started Appium server did not become ready within ${String(timeoutInMilliseconds)}ms`\n    );\n  }\n\n  private async waitForBoot(deviceId: string, deadline: number, emulator: EmulatorLaunch): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const isBooted = await new Promise<boolean>((resolve) => {\n        execFile(\n          'adb',\n          ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n          (_error, stdout) => {\n            resolve(stdout.trim() === '1');\n          }\n        );\n      });\n\n      if (isBooted) {\n        this.log(`Device ${deviceId} boot completed.`);\n        return;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  /**\n   * Waits for a freshly-booted emulator to become idle before the session is\n   * established.\n   *\n   * `sys.boot_completed` fires before the guest is actually idle \u2014 package\n   * optimization and services keep churning \u2014 so establishing the Appium\n   * session immediately makes every serialized UiAutomator2 `adb` round-trip\n   * contend with that work and inflates session establishment ~3x. This polls\n   * a later, quieter signal (boot animation stopped + package manager serving,\n   * via {@link checkDeviceIdle}) and returns as soon as it is satisfied.\n   *\n   * Best-effort: if the guest does not report idle within the budget it logs a\n   * warning and proceeds (a slow session is better than a failed run), and a\n   * budget of `0` skips the wait entirely.\n   *\n   * @param deviceId - The device UDID to poll.\n   * @param timeoutInMilliseconds - Maximum time to wait; `0` skips the wait.\n   */\n  private async waitForDeviceIdle(deviceId: string, timeoutInMilliseconds: number): Promise<void> {\n    if (timeoutInMilliseconds <= 0) {\n      this.log(`Skipping post-boot idle wait for device ${deviceId} (timeout is 0).`);\n      return;\n    }\n\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n    this.log(\n      `Waiting for device ${deviceId} to become idle (timeout: ${String(timeoutInMilliseconds)}ms, poll: ${String(DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n\n    while (Date.now() < deadline) {\n      const [bootAnimationProp, packageListOutput] = await Promise.all([\n        this.getDeviceProp(deviceId, 'init.svc.bootanim'),\n        this.listInstalledPackages(deviceId)\n      ]);\n\n      if (checkDeviceIdle({ bootAnimationProp, packageListOutput })) {\n        this.log(`Device ${deviceId} is idle after ${String(Date.now() - start)}ms.`);\n        return;\n      }\n\n      this.log(`Device ${deviceId} not idle yet (elapsed: ${String(Date.now() - start)}ms). Retrying...`);\n      await new Promise((resolve) => {\n        setTimeout(resolve, DEVICE_IDLE_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    this.log(\n      `Warning: device ${deviceId} did not report idle within ${String(timeoutInMilliseconds)}ms; proceeding with session establishment anyway.`\n    );\n  }\n\n  private async waitForNewDevice(deviceIdsBefore: string[], emulator: EmulatorLaunch, deviceIdleTimeoutInMilliseconds: number): Promise<string> {\n    this.log(\n      `Waiting for a new device to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const currentIds = await this.getConnectedDeviceIds();\n      const newIds = currentIds.filter((id) => !deviceIdsBefore.includes(id));\n\n      if (newIds.length > 0) {\n        const actualDeviceId = newIds[0] ?? '';\n        this.log(`Device ${actualDeviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(actualDeviceId, deadline, emulator);\n        await this.waitForDeviceIdle(actualDeviceId, deviceIdleTimeoutInMilliseconds);\n        await this.wakeScreen(actualDeviceId);\n        return actualDeviceId;\n      }\n\n      const exitInfo = emulator.readExitInfo();\n      if (exitInfo) {\n        throw new Error(buildEmulatorExitMessage(exitInfo, emulator.readOutput()));\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    throw new Error(\n      `No new emulator device appeared within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n    );\n  }\n\n  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to an owned desktop CDP transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cdp') {\n    return createCdpTransport(options);\n  }\n\n  const factory = new AppiumTransportFactory(type);\n  return factory.create(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Builds a descriptive error message for an emulator process that exited during\n * startup, appending the captured output tail when available.\n *\n * @param exitInfo - The emulator's exit details.\n * @param output - The captured stdout+stderr tail.\n * @returns A human-readable error message.\n */\nfunction buildEmulatorExitMessage(exitInfo: EmulatorExitInfo, output: string): string {\n  const reason = exitInfo.signal === null\n    ? `exited prematurely with code ${String(exitInfo.code)}`\n    : `was terminated by signal ${exitInfo.signal}`;\n  const trimmedOutput = output.trim();\n  const details = trimmedOutput.length > 0\n    ? `\\n\\nEmulator output (tail):\\n${trimmedOutput}`\n    : '';\n  return `Android emulator ${reason} during startup.${details}`;\n}\n\n/**\n * Runs the proactive installer\u2194app compatibility check for an asar-swap and acts\n * on the verdict: throws {@link IncompatibleInstallerVersionError} for an\n * installer below the app's run floor, and logs a warning for a\n * runnable-but-below-recommended installer.\n *\n * @param appVersion - The app (asar) version that will be swapped onto the shell,\n *   or `undefined` when no asar-swap will happen (nothing is checked then).\n * @param installerVersion - The resolved installer/shell version, or `undefined`.\n * @returns The verdict, or `undefined` when there is no asar-swap to check.\n */\nfunction checkAndReportCompatibility(\n  appVersion: string | undefined,\n  installerVersion: string | undefined\n): InstallerCompatibility | undefined {\n  if (appVersion === undefined) {\n    return undefined;\n  }\n\n  const compatibility = checkInstallerCompatibility({\n    appVersion,\n    installerVersion,\n    metadata: getVersionMetadata(appVersion)\n  });\n\n  if (compatibility.tier === 'unrunnable') {\n    throw new IncompatibleInstallerVersionError({\n      appVersion: compatibility.appVersion,\n      installerVersion: ensureNonNullable(compatibility.installerVersion),\n      minRunnableInstallerVersion: ensureNonNullable(compatibility.minRunnableInstallerVersion)\n    });\n  }\n\n  if (compatibility.tier === 'nagged') {\n    log(`[transport-factory:obsidian-cdp] ${ensureNonNullable(compatibility.message)}`);\n  }\n\n  return compatibility;\n}\n\n/**\n * Creates a desktop CDP transport. When an explicit `port` is given the\n * transport attaches to an already-running Obsidian on that port; otherwise it\n * launches and owns an isolated instance (the default, hermetic mode).\n *\n * @param options - CDP transport options.\n * @returns A configured CDP transport.\n */\nasync function createCdpTransport(options?: ObsidianCdpTransportOptions): Promise<ObsidianTransport> {\n  if (options?.port !== undefined) {\n    const ownedSuffix = options.isHarnessOwnedInstance ? ' (harness-owned)' : '';\n    log(`[transport-factory:obsidian-cdp] Attaching to running Obsidian${ownedSuffix} (host=${options.host ?? 'localhost'}, port=${String(options.port)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      cdpPort: options.port,\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n      ...(options.isHarnessOwnedInstance !== undefined && { isHarnessOwnedInstance: options.isHarnessOwnedInstance })\n    });\n  }\n\n  log('[transport-factory:obsidian-cdp] Creating owned isolated Obsidian instance');\n  const ownedInstance = await resolveOwnedInstanceConfig(options);\n  return new DesktopCdpTransport({\n    ...(options?.host !== undefined && { cdpHost: options.host }),\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    deadBootGraceInMilliseconds: resolveDeadBootGraceInMilliseconds(options),\n    ...(options?.isObsidianAppVisible !== undefined && { isObsidianAppVisible: options.isObsidianAppVisible }),\n    ownedInstance,\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox })\n  });\n}\n\n/**\n * Creates a fresh, isolated user-data directory for an owned instance.\n *\n * @returns The absolute path to the new directory.\n */\nfunction createOwnedUserDataDir(): string {\n  const root = join(tmpdir(), 'obsidian-integration-testing');\n  mkdirSync(root, { recursive: true });\n  return mkdtempSync(join(root, OWNED_USER_DATA_PREFIX));\n}\n\n/**\n * Decides how the requested app (asar) version will be applied to an owned\n * instance, without downloading anything yet: an upgrade-only asar-swap onto the\n * shell, a downgrade to the app's own installer shell, or the user's newest\n * installed asar when neither version is pinned.\n *\n * @param options - CDP transport options.\n * @param shellVersion - The resolved installer/shell version, or `undefined`.\n * @returns The asar plan (at most one of its fields is set).\n */\nasync function resolveAsarPlan(\n  options: ObsidianCdpTransportOptions | undefined,\n  shellVersion: string | undefined\n): Promise<AsarPlan> {\n  if (options?.obsidianVersion !== undefined) {\n    const asarVersion = await resolveConcreteVersion(options.obsidianVersion);\n    if (shellVersion !== undefined && compareVersions(asarVersion, shellVersion) >= 0) {\n      return { asarVersionToSwap: asarVersion };\n    }\n\n    // Asar-swap is upgrade-only, so it cannot apply a version older than the\n    // Shell's bundled one \u2014 and when the shell version is unknown (a Linux\n    // Path-parse miss) we cannot prove the swap would apply at all. In both\n    // Cases use the requested version's own installer shell, whose bundled asar\n    // Is exactly this version, so the pin is always honored.\n    log(`[transport-factory:obsidian-cdp] Using the ${asarVersion} installer shell (shell version ${shellVersion ?? 'unknown'}; asar-swap is upgrade-only).`);\n    return { downgradeInstallerVersion: asarVersion };\n  }\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    const newest = findNewestAsar(getObsidianConfigDir());\n    if (newest && (shellVersion === undefined || compareVersions(newest.version, shellVersion) >= 0)) {\n      return { asar: { path: newest.path, version: newest.version } };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Resolves the locally-installed Obsidian shell, tolerating its absence.\n *\n * Unlike {@link resolveObsidianExecutable} (which throws when Obsidian is not\n * installed), this returns `undefined` in that case, so a caller pinning an\n * installer version can fall back to downloading the pinned shell instead of\n * failing on a host with no Obsidian installed (e.g. CI).\n *\n * @returns The installed shell's path and detected version, or `undefined` when\n *   no Obsidian is installed.\n */\nasync function resolveInstalledShellOrNull(): Promise<InstalledShell | undefined> {\n  try {\n    const exePath = await resolveObsidianExecutable();\n    return { exePath, shellVersion: detectInstalledShellVersion(exePath) };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Resolves the shell executable, asar provisioning, and isolated user-data dir\n * for a harness-owned instance from the requested version knobs.\n *\n * - `obsidianInstallerVersion` pins the Electron shell (downloads + extracts a\n *   portable build when it differs from the installed shell).\n * - `obsidianVersion` pins the app: an asar-swap when it is >= the shell version\n *   (cheap), otherwise the matching installer shell is used (downgrade).\n * - When neither is set, the user's newest installed asar is copied in (so the\n *   owned instance matches the version the user currently runs) with zero network.\n *\n * The concrete (app, installer) version pair is resolved *before* any shell/asar\n * download, so a proactive installer\u2194app compatibility check\n * ({@link checkInstallerCompatibility}) can fail fast: an installer below the\n * app's run floor throws {@link IncompatibleInstallerVersionError} before\n * anything is downloaded or launched (superseding the reactive dead-boot\n * fast-fail for table-known combos), and a runnable-but-below-recommended\n * installer logs a warning. The verdict is threaded onto the returned config so\n * the transport can surface it as data.\n *\n * @param options - CDP transport options.\n * @returns The resolved owned-instance config.\n */\nasync function resolveOwnedInstanceConfig(options?: ObsidianCdpTransportOptions): Promise<OwnedInstanceConfig> {\n  // Resolve the concrete shell (installer) version first, but for a pinned\n  // Installer DEFER resolving/downloading the actual shell until after the\n  // Proactive compatibility check, so an unrunnable pin fails fast \u2014 before the\n  // (possibly slow) installed-shell detection and any download.\n  let exePath: string | undefined;\n  let shellVersion: string | undefined;\n  let pinnedInstallerVersion: string | undefined;\n\n  if (options?.obsidianInstallerVersion === undefined) {\n    exePath = await resolveObsidianExecutable();\n    shellVersion = detectInstalledShellVersion(exePath);\n  } else {\n    // A pinned installer version fully determines the shell version up front,\n    // Without requiring a locally-installed Obsidian (a CI runner has none).\n    pinnedInstallerVersion = await resolveConcreteVersion(options.obsidianInstallerVersion);\n    shellVersion = pinnedInstallerVersion;\n  }\n\n  // Decide how the app (asar) version will be applied, still WITHOUT downloading.\n  const plan = await resolveAsarPlan(options, shellVersion);\n\n  // The app version that will run as an asar-swap onto `shellVersion` \u2014 the only\n  // Combination that can dead-boot. The downgrade / own-installer paths run the\n  // App's own installer shell, so they always boot and are not checked.\n  const swapAppVersion = plan.asarVersionToSwap ?? plan.asar?.version;\n  const compatibility = checkAndReportCompatibility(swapAppVersion, shellVersion);\n\n  // The pin is known runnable \u2014 resolve/download the deferred shell + asar now.\n  // Reuse the installed shell only when it already matches the pin (saves the\n  // Download); otherwise download and extract the pinned installer.\n  if (pinnedInstallerVersion !== undefined) {\n    const installed = await resolveInstalledShellOrNull();\n    exePath = installed?.shellVersion === pinnedInstallerVersion ? installed.exePath : await ensureShellCached(pinnedInstallerVersion);\n  }\n  if (plan.downgradeInstallerVersion !== undefined) {\n    exePath = await ensureShellCached(plan.downgradeInstallerVersion);\n  }\n\n  const asar = plan.asarVersionToSwap === undefined\n    ? plan.asar\n    : { path: await ensureAsarCached(plan.asarVersionToSwap), version: plan.asarVersionToSwap };\n\n  return {\n    ...(asar && { asar }),\n    ...(compatibility && { compatibility }),\n    exePath: ensureNonNullable(exePath),\n    userDataDir: createOwnedUserDataDir()\n  };\n}\n\n/**\n * Removes `Connection` and `Content-Length` from a WebDriver request's headers.\n *\n * The bundled `webdriver` package sets both headers explicitly. They are\n * forbidden request headers per the Fetch spec: Node up to 25 accepted them\n * silently, but Node 26 rejects them with `UND_ERR_INVALID_ARG`, breaking the\n * Appium `/session` request. The transport layer manages connection reuse and\n * the Fetch API computes `Content-Length` from the body, so dropping both is\n * safe on every Node version. See {@link https://github.com/webdriverio/webdriverio/issues/15265}.\n *\n * @param requestOptions - The request options about to be sent by WebDriverIO.\n * @returns The same request options with the forbidden headers removed.\n */\nfunction stripForbiddenFetchHeaders(requestOptions: RequestInit): RequestInit {\n  if (requestOptions.headers instanceof Headers) {\n    requestOptions.headers.delete('Connection');\n    requestOptions.headers.delete('Content-Length');\n  }\n\n  return requestOptions;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAUA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,OAAO,UAAU;AACjB,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,OAAO,aAAa;AACpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAWP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,YAAY;AACrB,SAAS,yCAAyC;AAClD,SAAS,mCAAmC;AAC5C,SAAS,uBAAuB;AAChC,SAAS,WAAW;AACpB,SAAS,4BAA4B;AACrC,SAAS,iCAAiC;AAC1C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,uBAAuB;AAChC,SAAS,0CAA0C;AACnD;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,uBAAuB;AAChC,SAAS,2BAA2B;AACpC,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,cAAc;AACpB,MAAM,eAAe,GAAG,WAAW;AACnC,MAAM,2CAA2C;AACjD,MAAM,gCAAgC;AACtC,MAAM,2CAA2C;AACjD,MAAM,6CAA6C;AACnD,MAAM,yBAAyB;AAK/B,MAAM,oCAAoC;AAC1C,MAAM,kCAAkC;AACxC,MAAM,yBAAyB;AAC/B,MAAM,4CAA4C;AAClD,MAAM,8CAA8C;AACpD,MAAM,wCAAwC;AAC9C,MAAM,kCAAkC;AACxC,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,yCAAyC;AAC/C,MAAM,wCAAwC;AAgI9C,IAAI;AASJ,MAAM,uBAAuB;AAAA,EACV;AAAA,EAEV,YAAY,MAAc;AAC/B,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAa,OAAO,SAA4E;AAC9F,QAAI,QAAQ,cAAc,UAAa,QAAQ,aAAa,QAAW;AACrE,aAAO,KAAK,wBAAwB,QAAQ,WAAW,QAAQ,UAAU,OAAO;AAAA,IAClF;AAEA,WAAO,KAAK,iBAAiB,OAAO;AAAA,EACtC;AAAA,EAEA,MAAc,wBACZ,WACA,UACA,SAC4B;AAC5B,UAAM,MAAM,IAAI,IAAI,QAAQ,SAAS;AACrC,UAAM,OAAO,OAAO,IAAI,IAAI;AAC5B,UAAM,QAAQ,QAAQ,SAAS;AAE/B,SAAK,IAAI,0CAA0C,SAAS,YAAY,QAAQ,GAAG;AAEnF,UAAM,UAAU,MAAM,OAAO;AAAA,MAC3B,cAAc;AAAA,QACZ,cAAc;AAAA,MAChB;AAAA,MACA,UAAU,IAAI;AAAA,MACd,UAAU;AAAA,MACV,MAAM,IAAI;AAAA,MACV;AAAA,MACA;AAAA,MACA,kBAAkB;AAAA,IACpB,CAAC;AAED,SAAK,IAAI,+BAA+B;AAExC,WAAO,IAAI,gBAAgB;AAAA,MACzB;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB;AAAA,MAChB,UAAU;AAAA,MACV,GAAI,QAAQ,qCAAqC,UAAa,EAAE,kCAAkC,QAAQ,iCAAiC;AAAA,MAC3I,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,MAClF,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IACjI,CAAC;AAAA,EACH;AAAA,EAEQ,qBAAqB,KAAyB;AACpD,WAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,YAAM,YAAY,IAAI,IAAI,WAAW,GAAG;AACxC,YAAM,MAAM,KAAK,IAAI,WAAW,EAAE,SAAS,yCAAyC,GAAG,CAAC,QAAQ;AAC9F,YAAI,OAAO;AACX,gBAAQ;AAAA,MACV,CAAC;AACD,UAAI,GAAG,WAAW,MAAM;AACtB,YAAI,QAAQ;AACZ;AAAA,UACE,IAAI;AAAA,YACF,oBAAoB,IAAI,MAAM,2BAA2B,OAAO,wCAAwC,CAAC;AAAA,UAC3G;AAAA,QACF;AAAA,MACF,CAAC;AACD,UAAI,GAAG,SAAS,CAAC,QAAQ;AACvB;AAAA,UACE,IAAI;AAAA,YACF,iCAAiC,IAAI,MAAM,KAAK,IAAI,OAAO;AAAA,UAC7D;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,iBAAiB,SAA4E;AACzG,SAAK,IAAI,iCAAiC,QAAQ,SAAS,SAAS,QAAQ,OAAO,GAAG;AAEtF,UAAM,MAAM,IAAI,IAAI,QAAQ,SAAS;AAErC,UAAM,OAAO,OAAO,IAAI,IAAI;AAC5B,QAAI,MAAM,IAAI,GAAG;AACf,YAAM,IAAI,MAAM,8BAA8B,IAAI,IAAI,EAAE;AAAA,IAC1D;AAEA,UAAM,QAAQ,QAAQ,SAAS;AAE/B,QAAI;AACJ,QAAI;AAEJ,QAAI;AAsEF,UAASA,4BAAT,WAA0C;AACxC,YAAI,eAAe;AACjB,0BAAgB,aAAa;AAE7B,cAAI,sBAAsB,QAAQ,IAAI,uCAAuC;AAAA,QAC/E;AACA,YAAI,iBAAiB;AACnB,0BAAgB,eAAe;AAC/B,cAAI,sBAAsB,QAAQ,IAAI,kCAAkC;AAAA,QAC1E;AAAA,MACF;AAVS,qCAAAA;AArET,YAAM,SAAS,MAAM,KAAK,uBAAuB;AAAA,QAC/C,kCAAkC,wCAAwC,OAAO;AAAA,QACjF,WAAW;AAAA,QACX,SAAS,QAAQ;AAAA,QACjB,iCAAiC,uCAAuC,OAAO;AAAA,QAC/E,wBAAwB,QAAQ;AAAA,QAChC,mBAAmB,QAAQ;AAAA,QAC3B;AAAA,QACA,qCAAqC,2CAA2C,OAAO;AAAA,QACvF,uBAAuB,QAAQ;AAAA,MACjC,CAAC;AAED,sBAAgB,OAAO;AACvB,wBAAkB,OAAO;AACzB,YAAM,iBAAiB,OAAO;AAE9B,YAAM,gCAAgC,mDAAmD,OAAO;AAChG,WAAK;AAAA,QACH,gCAAgC,cAAc,SAAS,KAAK,mBAAmB,OAAO,6BAA6B,CAAC,gBAAgB,OAAO,6BAA6B,CAAC;AAAA,MAC3K;AACA,YAAM,UAAU,MAAM,OAAO;AAAA,QAC3B,cAAc;AAAA,UACZ,sBAAsB;AAAA,UACtB,qBAAqB;AAAA,UACrB,+BAA+B;AAAA,UAC/B,yBAAyB;AAAA,UACzB,4BAA4B;AAAA,UAC5B,kBAAkB;AAAA,UAClB,eAAe;AAAA,UACf,2CAA2C;AAAA,UAC3C,0CAA0C;AAAA,UAC1C,gBAAgB;AAAA,QAClB;AAAA,QACA,sBAAsB;AAAA,QACtB,wBAAwB;AAAA,QACxB,UAAU,IAAI;AAAA,QACd,UAAU;AAAA,QACV,MAAM,IAAI;AAAA,QACV;AAAA,QACA,kBAAkB;AAAA,MACpB,CAAC;AAED,WAAK,IAAI,6BAA6B;AACtC,YAAM,kBAAkB,IAAI,gBAAgB;AAAA,QAC1C;AAAA,QACA;AAAA,QACA,UAAU;AAAA,QACV,UAAU;AAAA,QACV,GAAI,QAAQ,qCAAqC,UAAa,EAAE,kCAAkC,QAAQ,iCAAiC;AAAA,QAC3I,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,QAClF,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,MACjI,CAAC;AAED,YAAM,kBAAkB,gBAAgB,QAAQ,KAAK,eAAe;AACpE,YAAM,YAA+B;AACrC,gBAAU,UAAU,YAA2B;AAC7C,YAAI;AACF,gBAAM,gBAAgB;AAAA,QACxB,UAAE;AACA,UAAAA,0BAAyB;AAAA,QAC3B;AAAA,MACF;AAEA,gBAAU,cAAc,MAAY;AAClC,QAAAA,0BAAyB;AAAA,MAC3B;AAEA,aAAO;AAAA,IAaT,SAAS,OAAgB;AACvB,UAAI,eAAe;AACjB,wBAAgB,aAAa;AAC7B,aAAK,IAAI,6DAA6D;AAAA,MACxE;AACA,UAAI,iBAAiB;AACnB,wBAAgB,eAAe;AAC/B,aAAK,IAAI,wDAAwD;AAAA,MACnE;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAc,2BAA0C;AACtD,UAAM,KAAK,sBAAsB;AACjC,UAAM,KAAK,kCAAkC;AAAA,EAC/C;AAAA,EAEA,MAAc,wBAAuC;AACnD,SAAK,IAAI,yCAAyC;AAClD,UAAM,SAAS,MAAM,KAAK,qCAAqC;AAAA,MAC7D,SAAS;AAAA,MACT,sBAAsB;AAAA,MACtB,sBAAsB;AAAA,IACxB,CAAC;AAED,QAAI,OAAO,aAAa,GAAG;AACzB,WAAK,IAAI,gCAAgC,OAAO,OAAO,KAAK,KAAK,SAAS,IAAI;AAC9E;AAAA,IACF;AAEA,SAAK,IAAI,6EAA6E;AACtF,UAAM,KAAK,uBAAuB;AAClC,SAAK,IAAI,mBAAmB;AAAA,EAC9B;AAAA,EAEA,MAAc,sBAAsB,QAA2E;AAC7G,UAAM,EAAE,SAAS,iCAAiC,kBAAkB,IAAI;AACxE,UAAM,kBAAkB,MAAM,KAAK,sBAAsB;AACzD,SAAK,IAAI,sCAAsC,OAAO,qBAAqB,gBAAgB,KAAK,IAAI,CAAC,IAAI;AAEzG,UAAM,mBAAmB,MAAM,KAAK,oBAAoB,SAAS,eAAe;AAEhF,QAAI,kBAAkB;AACpB,WAAK,IAAI,QAAQ,OAAO,kCAAkC,gBAAgB,YAAY;AACtF,YAAM,KAAK,qBAAqB,gBAAgB;AAChD,aAAO,EAAE,gBAAgB,iBAAiB;AAAA,IAC5C;AAEA,SAAK,IAAI,QAAQ,OAAO,gEAAgE;AACxF,UAAM,WAAW,KAAK,cAAc,SAAS,iBAAiB;AAE9D,QAAI;AACJ,QAAI;AACF,uBAAiB,MAAM,KAAK,iBAAiB,iBAAiB,UAAU,+BAA+B;AAAA,IACzG,UAAE;AACA,eAAS,YAAY;AAAA,IACvB;AAEA,SAAK,IAAI,aAAa,OAAO,qBAAqB,cAAc,gBAAgB;AAChF,UAAM,KAAK,qBAAqB,cAAc;AAC9C,WAAO,EAAE,gBAAgB,iBAAiB,SAAS,QAAQ;AAAA,EAC7D;AAAA,EAEA,MAAc,oCAAmD;AAC/D,SAAK,IAAI,wBAAwB,wBAAwB,yBAAyB;AAClF,UAAM,iBAAiB,MAAM,KAAK,0DAA0D;AAAA,MAC1F,SAAS;AAAA,MACT,sBAAsB;AAAA,IACxB,CAAC;AAED,QAAI,6BAA6B,EAAE,gBAAgB,YAAY,yBAAyB,CAAC,GAAG;AAC1F,WAAK,IAAI,OAAO,wBAAwB,uBAAuB;AAC/D;AAAA,IACF;AAEA,SAAK,IAAI,OAAO,wBAAwB,oEAAoE,wBAAwB,OAAO;AAC3I,UAAM,KAAK,0CAA0C,wBAAwB,EAAE;AAC/E,SAAK,IAAI,OAAO,wBAAwB,oBAAoB;AAAA,EAC9D;AAAA,EAEA,MAAc,oBAAoB,SAAiB,WAAkD;AACnG,eAAW,YAAY,WAAW;AAChC,YAAM,aAAa,MAAM,IAAI,QAAgB,CAAC,YAAY;AACxD;AAAA,UACE;AAAA,UACA,CAAC,MAAM,UAAU,OAAO,OAAO,MAAM;AAAA,UACrC,EAAE,SAAS,yCAAyC;AAAA,UACpD,CAAC,QAAQ,WAAW;AAClB,oBAAQ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,KAAK,KAAK,EAAE;AAAA,UAC7C;AAAA,QACF;AAAA,MACF,CAAC;AAED,UAAI,eAAe,SAAS;AAC1B,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,wBAA2C;AACvD,UAAM,SAAS,MAAM,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC5D,eAAS,OAAO,CAAC,SAAS,GAAG,EAAE,SAAS,yCAAyC,GAAG,CAAC,OAAO,QAAQ,WAAW;AAC7G,YAAI,OAAO;AACT,iBAAO,IAAI,MAAM,gCAAgC,MAAM,OAAO,iCAAiC,CAAC;AAChG;AAAA,QACF;AACA,YAAI,QAAQ;AACV,eAAK,IAAI,eAAe,OAAO,KAAK,CAAC,EAAE;AAAA,QACzC;AACA,gBAAQ,MAAM;AAAA,MAChB,CAAC;AAAA,IACH,CAAC;AAED,UAAM,QAAQ,OAAO,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;AAC5F,WAAO,MACJ,OAAO,CAAC,SAAS,KAAK,SAAS,SAAU,CAAC,EAC1C,IAAI,CAAC,SAAS,KAAK,MAAM,GAAI,EAAE,CAAC,KAAK,EAAE;AAAA,EAC5C;AAAA,EAEQ,cAAc,UAAkB,MAA+B;AACrE,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,WAAW,IAAI;AAAA,QACzC,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,OAAO,WAAW;AAEjB,kBAAQ,QAAQ,KAAK,MAAM;AAAA,QAC7B;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEQ,sBAAsB,UAAmC;AAC/D,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,OAAO,WAAW,QAAQ,UAAU;AAAA,QAC9D,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,OAAO,WAAW;AAEjB,kBAAQ,QAAQ,KAAK,MAAM;AAAA,QAC7B;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEQ,IAAI,SAAuB;AACjC,QAAI,sBAAsB,KAAK,IAAI,KAAK,OAAO,EAAE;AAAA,EACnD;AAAA,EAEQ,wBAAgC;AACtC,UAAM,UAAU,QAAQ,IAAI,cAAc,KAAK,QAAQ,IAAI,kBAAkB;AAC7E,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,KAAK,SAAS,YAAY,UAAU;AAAA,EAC7C;AAAA,EAEA,MAAc,aAAa,UAAkB,SAAiB,aAAoC;AAChG,UAAM,IAAI,QAAc,CAAC,YAAY;AACnC;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,SAAS,YAAY,OAAO,OAAO,CAAC;AAAA,QAC9D,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,UAAU;AACT,cAAI,OAAO;AACT,iBAAK;AAAA,cACH,sBAAsB,WAAW,cAAc,OAAO,OAAO,CAAC,MAAM,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,YAC9H;AAAA,UACF;AAEA,kBAAQ;AAAA,QACV;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,uBAAuB,QAA6E;AAChH,UAAM,EAAE,kCAAkC,WAAW,SAAS,iCAAiC,wBAAwB,mBAAmB,MAAM,qCAAqC,sBAAsB,IAAI;AAE/M,QAAI,mBAAmB;AAEvB,SAAK,IAAI,6BAA6B,UAAU,IAAI,KAAK;AACzD,QAAI;AACF,YAAM,KAAK,qBAAqB,SAAS;AACzC,WAAK,IAAI,6BAA6B;AAAA,IACxC,SAAS,OAAgB;AACvB,UAAI,0BAA0B,OAAO;AACnC,cAAM;AAAA,MACR;AACA,yBAAmB;AAAA,IACrB;AAEA,QAAI;AAEJ,QAAI,kBAAkB;AACpB,UAAI,qCAAqC;AACvC,cAAM,KAAK,yBAAyB;AAAA,MACtC;AACA,WAAK,IAAI,+CAA+C,OAAO,IAAI,CAAC,KAAK;AACzE,sBAAgB,KAAK,kBAAkB,MAAM,sBAAsB;AAAA,IACrE;AAEA,QAAI;AACF,YAAM,CAAC,EAAE,YAAY,IAAI,MAAM,QAAQ,IAAI;AAAA,QACzC,mBACI,KAAK,mBAAmB,WAAW,gCAAgC,EAAE,KAAK,MAAM;AAChF,eAAK,IAAI,sCAAsC;AAAA,QACjD,CAAC,IACC,QAAQ,QAAQ;AAAA,QACpB,KAAK,sBAAsB,EAAE,SAAS,iCAAiC,kBAAkB,CAAC;AAAA,MAC5F,CAAC;AAED,aAAO;AAAA,QACL,gBAAgB,aAAa;AAAA,QAC7B;AAAA,QACA,iBAAiB,aAAa;AAAA,MAChC;AAAA,IACF,SAAS,OAAgB;AACvB,UAAI,eAAe;AACjB,wBAAgB,aAAa;AAC7B,aAAK,IAAI,0DAA0D;AAAA,MACrE;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEQ,kBAAkB,MAAc,wBAAgD;AACtF,UAAM,kBAAkB,wBAAwB,sBAAsB;AACtE,UAAM,EAAE,UAAU,YAAY,IAAI,wBAAwB,eAAe;AACzE,UAAM,QAAQ,MAAM,qCAAqC,OAAO,IAAI,CAAC,qBAAqB,iCAAiC,IAAI;AAAA,MAC7H;AAAA,MACA,OAAO;AAAA,MACP,OAAO,kBAAkB,WAAW,CAAC,UAAU,WAAW,SAAS;AAAA,MACnE;AAAA,IACF,CAAC;AAED,UAAM,MAAM;AACZ,WAAO;AAAA,EACT;AAAA,EAEQ,cAAc,SAAiB,mBAA6C;AAClF,UAAM,iBAAiB,KAAK,sBAAsB;AAClD,UAAM,iBAAiB,yBAAyB,iBAAiB;AACjE,UAAM,OAAO,kBAAkB,EAAE,SAAS,UAAU,eAAe,CAAC;AACpE,UAAM,EAAE,UAAU,YAAY,IAAI,0BAA0B,cAAc;AAC1E,SAAK,IAAI,YAAY,cAAc,IAAI,KAAK,KAAK,GAAG,CAAC,EAAE;AAMvD,UAAM,QAAQ,MAAM,gBAAgB,MAAM;AAAA,MACxC;AAAA,MACA,OAAO,CAAC,UAAU,QAAQ,MAAM;AAAA,MAChC;AAAA,IACF,CAAC;AAED,QAAI,iBAAiB;AACrB,QAAI;AACJ,QAAI,cAAc;AAElB,UAAM,OAAO,GAAG,QAAQ,YAAY;AACpC,UAAM,OAAO,GAAG,QAAQ,YAAY;AACpC,UAAM,KAAK,QAAQ,CAAC,MAAM,WAAW;AACnC,iBAAW,EAAE,MAAM,OAAO;AAAA,IAC5B,CAAC;AAED,UAAM,MAAM;AAEZ,WAAO;AAAA,MACL,SAAS;AAAA,MACT,cAAc,MAAM;AAAA,MACpB,YAAY,MAAM;AAAA,MAClB,aAAa,MAAY;AAMvB,sBAAc;AAAA,MAChB;AAAA,IACF;AAEA,aAAS,aAAa,OAAqB;AACzC,UAAI,CAAC,aAAa;AAChB;AAAA,MACF;AACA,wBAAkB,iBAAiB,MAAM,SAAS,GAAG,MAAM,CAAC,+BAA+B;AAAA,IAC7F;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,MAAc,qBAAqB,UAAiC;AAClE,SAAK,IAAI,yCAAyC,QAAQ,gDAAgD;AAE1G,UAAM,IAAI,QAAc,CAAC,YAAY;AACnC;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,YAAY,OAAO,UAAU,sBAAsB,GAAG;AAAA,QAChF,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,UAAU;AACT,cAAI,OAAO;AACT,iBAAK;AAAA,cACH,iDAAiD,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,YAC3G;AAAA,UACF;AAEA,kBAAQ;AAAA,QACV;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,mBAAmB,KAAU,uBAA8C;AACvF,UAAM,QAAQ,KAAK,IAAI;AACvB,SAAK;AAAA,MACH,yBAAyB,IAAI,IAAI,cAAc,OAAO,qBAAqB,CAAC,aAAa,OAAO,0CAA0C,CAAC;AAAA,IAC7I;AACA,UAAM,WAAW,QAAQ;AAEzB,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAI;AACF,cAAM,KAAK,qBAAqB,GAAG;AACnC,aAAK,IAAI,6BAA6B,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK;AACrE;AAAA,MACF,QAAQ;AACN,aAAK,IAAI,yCAAyC,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,kBAAkB;AAC9F,cAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,qBAAW,SAAS,0CAA0C;AAAA,QAChE,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,IAAI;AAAA,MACR,0DAA0D,OAAO,qBAAqB,CAAC;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,MAAc,YAAY,UAAkB,UAAkB,UAAyC;AACrG,UAAM,cAAc,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,CAAC;AACrD,SAAK;AAAA,MACH,sBAAsB,QAAQ,kCAAkC,OAAO,WAAW,CAAC,aAAa,OAAO,2CAA2C,CAAC;AAAA,IACrJ;AAEA,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,WAAW,MAAM,IAAI,QAAiB,CAAC,YAAY;AACvD;AAAA,UACE;AAAA,UACA,CAAC,MAAM,UAAU,SAAS,WAAW,oBAAoB;AAAA,UACzD,EAAE,SAAS,yCAAyC;AAAA,UACpD,CAAC,QAAQ,WAAW;AAClB,oBAAQ,OAAO,KAAK,MAAM,GAAG;AAAA,UAC/B;AAAA,QACF;AAAA,MACF,CAAC;AAED,UAAI,UAAU;AACZ,aAAK,IAAI,UAAU,QAAQ,kBAAkB;AAC7C;AAAA,MACF;AAEA,YAAM,WAAW,SAAS,aAAa;AACvC,UAAI,UAAU;AACZ,cAAM,IAAI,MAAM,yBAAyB,UAAU,SAAS,WAAW,CAAC,CAAC;AAAA,MAC3E;AAEA,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,2CAA2C;AAAA,MACjE,CAAC;AAAA,IACH;AAEA,UAAM,IAAI;AAAA,MACR,WAAW,QAAQ,iDAAiD,OAAO,qCAAqC,CAAC;AAAA,IACnH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,MAAc,kBAAkB,UAAkB,uBAA8C;AAC9F,QAAI,yBAAyB,GAAG;AAC9B,WAAK,IAAI,2CAA2C,QAAQ,kBAAkB;AAC9E;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,IAAI;AACvB,UAAM,WAAW,QAAQ;AACzB,SAAK;AAAA,MACH,sBAAsB,QAAQ,6BAA6B,OAAO,qBAAqB,CAAC,aAAa,OAAO,yCAAyC,CAAC;AAAA,IACxJ;AAEA,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,CAAC,mBAAmB,iBAAiB,IAAI,MAAM,QAAQ,IAAI;AAAA,QAC/D,KAAK,cAAc,UAAU,mBAAmB;AAAA,QAChD,KAAK,sBAAsB,QAAQ;AAAA,MACrC,CAAC;AAED,UAAI,gBAAgB,EAAE,mBAAmB,kBAAkB,CAAC,GAAG;AAC7D,aAAK,IAAI,UAAU,QAAQ,kBAAkB,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK;AAC5E;AAAA,MACF;AAEA,WAAK,IAAI,UAAU,QAAQ,2BAA2B,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,kBAAkB;AAClG,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,yCAAyC;AAAA,MAC/D,CAAC;AAAA,IACH;AAEA,SAAK;AAAA,MACH,mBAAmB,QAAQ,+BAA+B,OAAO,qBAAqB,CAAC;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,MAAc,iBAAiB,iBAA2B,UAA0B,iCAA0D;AAC5I,SAAK;AAAA,MACH,uDAAuD,OAAO,qCAAqC,CAAC,aAAa,OAAO,2CAA2C,CAAC;AAAA,IACtK;AACA,UAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,aAAa,MAAM,KAAK,sBAAsB;AACpD,YAAM,SAAS,WAAW,OAAO,CAAC,OAAO,CAAC,gBAAgB,SAAS,EAAE,CAAC;AAEtE,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,iBAAiB,OAAO,CAAC,KAAK;AACpC,aAAK,IAAI,UAAU,cAAc,mDAAmD;AACpF,cAAM,KAAK,YAAY,gBAAgB,UAAU,QAAQ;AACzD,cAAM,KAAK,kBAAkB,gBAAgB,+BAA+B;AAC5E,cAAM,KAAK,WAAW,cAAc;AACpC,eAAO;AAAA,MACT;AAEA,YAAM,WAAW,SAAS,aAAa;AACvC,UAAI,UAAU;AACZ,cAAM,IAAI,MAAM,yBAAyB,UAAU,SAAS,WAAW,CAAC,CAAC;AAAA,MAC3E;AAEA,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,2CAA2C;AAAA,MACjE,CAAC;AAAA,IACH;AAEA,UAAM,IAAI;AAAA,MACR,0CAA0C,OAAO,qCAAqC,CAAC;AAAA,IACzF;AAAA,EACF;AAAA,EAEA,MAAc,WAAW,UAAiC;AACxD,SAAK,IAAI,2BAA2B,QAAQ,KAAK;AAEjD,UAAM,KAAK,aAAa,UAAU,gBAAgB,aAAa;AAC/D,UAAM,KAAK,aAAa,UAAU,cAAc,qBAAqB;AAErE,SAAK,IAAI,kCAAkC,QAAQ,GAAG;AAAA,EACxD;AACF;AAQA,eAAsB,2BAA2B,SAAgE;AAC/G,QAAM,OAAO,SAAS,QAAQ;AAE9B,MAAI,CAAC,WAAW,QAAQ,SAAS,gBAAgB;AAC/C,WAAO,mBAAmB,OAAO;AAAA,EACnC;AAEA,QAAM,UAAU,IAAI,uBAAuB,IAAI;AAC/C,SAAO,QAAQ,OAAO,OAAO;AAC/B;AAYA,eAAsB,qBAAqB,SAAgE;AACzG,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAM,2BAA2B,OAAO;AAEvD,oBAAkB;AAClB,SAAO;AACT;AAUA,SAAS,yBAAyB,UAA4B,QAAwB;AACpF,QAAM,SAAS,SAAS,WAAW,OAC/B,gCAAgC,OAAO,SAAS,IAAI,CAAC,KACrD,4BAA4B,SAAS,MAAM;AAC/C,QAAM,gBAAgB,OAAO,KAAK;AAClC,QAAM,UAAU,cAAc,SAAS,IACnC;AAAA;AAAA;AAAA,EAAgC,aAAa,KAC7C;AACJ,SAAO,oBAAoB,MAAM,mBAAmB,OAAO;AAC7D;AAaA,SAAS,4BACP,YACA,kBACoC;AACpC,MAAI,eAAe,QAAW;AAC5B,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB,4BAA4B;AAAA,IAChD;AAAA,IACA;AAAA,IACA,UAAU,mBAAmB,UAAU;AAAA,EACzC,CAAC;AAED,MAAI,cAAc,SAAS,cAAc;AACvC,UAAM,IAAI,kCAAkC;AAAA,MAC1C,YAAY,cAAc;AAAA,MAC1B,kBAAkB,kBAAkB,cAAc,gBAAgB;AAAA,MAClE,6BAA6B,kBAAkB,cAAc,2BAA2B;AAAA,IAC1F,CAAC;AAAA,EACH;AAEA,MAAI,cAAc,SAAS,UAAU;AACnC,QAAI,oCAAoC,kBAAkB,cAAc,OAAO,CAAC,EAAE;AAAA,EACpF;AAEA,SAAO;AACT;AAUA,eAAe,mBAAmB,SAAmE;AACnG,MAAI,SAAS,SAAS,QAAW;AAC/B,UAAM,cAAc,QAAQ,yBAAyB,qBAAqB;AAC1E,QAAI,iEAAiE,WAAW,UAAU,QAAQ,QAAQ,WAAW,UAAU,OAAO,QAAQ,IAAI,CAAC,GAAG;AACtJ,WAAO,IAAI,oBAAoB;AAAA,MAC7B,GAAI,QAAQ,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,MAC1D,SAAS,QAAQ;AAAA,MACjB,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,MAC/H,GAAI,QAAQ,2BAA2B,UAAa,EAAE,wBAAwB,QAAQ,uBAAuB;AAAA,IAC/G,CAAC;AAAA,EACH;AAEA,MAAI,4EAA4E;AAChF,QAAM,gBAAgB,MAAM,2BAA2B,OAAO;AAC9D,SAAO,IAAI,oBAAoB;AAAA,IAC7B,GAAI,SAAS,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,IAC3D,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,6BAA6B,mCAAmC,OAAO;AAAA,IACvE,GAAI,SAAS,yBAAyB,UAAa,EAAE,sBAAsB,QAAQ,qBAAqB;AAAA,IACxG;AAAA,IACA,GAAI,SAAS,yBAAyB,UAAa,EAAE,sBAAsB,QAAQ,qBAAqB;AAAA,EAC1G,CAAC;AACH;AAOA,SAAS,yBAAiC;AACxC,QAAM,OAAO,KAAK,OAAO,GAAG,8BAA8B;AAC1D,YAAU,MAAM,EAAE,WAAW,KAAK,CAAC;AACnC,SAAO,YAAY,KAAK,MAAM,sBAAsB,CAAC;AACvD;AAYA,eAAe,gBACb,SACA,cACmB;AACnB,MAAI,SAAS,oBAAoB,QAAW;AAC1C,UAAM,cAAc,MAAM,uBAAuB,QAAQ,eAAe;AACxE,QAAI,iBAAiB,UAAa,gBAAgB,aAAa,YAAY,KAAK,GAAG;AACjF,aAAO,EAAE,mBAAmB,YAAY;AAAA,IAC1C;AAOA,QAAI,8CAA8C,WAAW,mCAAmC,gBAAgB,SAAS,+BAA+B;AACxJ,WAAO,EAAE,2BAA2B,YAAY;AAAA,EAClD;AAEA,MAAI,SAAS,6BAA6B,QAAW;AACnD,UAAM,SAAS,eAAe,qBAAqB,CAAC;AACpD,QAAI,WAAW,iBAAiB,UAAa,gBAAgB,OAAO,SAAS,YAAY,KAAK,IAAI;AAChG,aAAO,EAAE,MAAM,EAAE,MAAM,OAAO,MAAM,SAAS,OAAO,QAAQ,EAAE;AAAA,IAChE;AAAA,EACF;AAEA,SAAO,CAAC;AACV;AAaA,eAAe,8BAAmE;AAChF,MAAI;AACF,UAAM,UAAU,MAAM,0BAA0B;AAChD,WAAO,EAAE,SAAS,cAAc,4BAA4B,OAAO,EAAE;AAAA,EACvE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAyBA,eAAe,2BAA2B,SAAqE;AAK7G,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,MAAI,SAAS,6BAA6B,QAAW;AACnD,cAAU,MAAM,0BAA0B;AAC1C,mBAAe,4BAA4B,OAAO;AAAA,EACpD,OAAO;AAGL,6BAAyB,MAAM,uBAAuB,QAAQ,wBAAwB;AACtF,mBAAe;AAAA,EACjB;AAGA,QAAM,OAAO,MAAM,gBAAgB,SAAS,YAAY;AAKxD,QAAM,iBAAiB,KAAK,qBAAqB,KAAK,MAAM;AAC5D,QAAM,gBAAgB,4BAA4B,gBAAgB,YAAY;AAK9E,MAAI,2BAA2B,QAAW;AACxC,UAAM,YAAY,MAAM,4BAA4B;AACpD,cAAU,WAAW,iBAAiB,yBAAyB,UAAU,UAAU,MAAM,kBAAkB,sBAAsB;AAAA,EACnI;AACA,MAAI,KAAK,8BAA8B,QAAW;AAChD,cAAU,MAAM,kBAAkB,KAAK,yBAAyB;AAAA,EAClE;AAEA,QAAM,OAAO,KAAK,sBAAsB,SACpC,KAAK,OACL,EAAE,MAAM,MAAM,iBAAiB,KAAK,iBAAiB,GAAG,SAAS,KAAK,kBAAkB;AAE5F,SAAO;AAAA,IACL,GAAI,QAAQ,EAAE,KAAK;AAAA,IACnB,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,SAAS,kBAAkB,OAAO;AAAA,IAClC,aAAa,uBAAuB;AAAA,EACtC;AACF;AAeA,SAAS,2BAA2B,gBAA0C;AAC5E,MAAI,eAAe,mBAAmB,SAAS;AAC7C,mBAAe,QAAQ,OAAO,YAAY;AAC1C,mBAAe,QAAQ,OAAO,gBAAgB;AAAA,EAChD;AAEA,SAAO;AACT;",
  "names": ["killAutoStartedProcesses"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "8.2.0",
+  "version": "8.2.1",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -152,7 +152,7 @@
     "@eslint/compat": "^2.1.0",
     "@eslint/config-helpers": "^0.6.0",
     "@eslint/js": "^10.0.1",
-    "@obsidian-typings/obsidian-public-latest": "^6.23.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.24.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@total-typescript/ts-reset": "^0.6.1",
     "@tsconfig/strictest": "^2.0.8",
@@ -160,8 +160,8 @@
     "@types/markdown-it": "^14.1.2",
     "@types/semver": "^7.7.1",
     "@types/turndown": "^5.0.6",
-    "@typescript-eslint/rule-tester": "^8.63.0",
-    "@typescript-eslint/utils": "^8.63.0",
+    "@typescript-eslint/rule-tester": "^8.64.0",
+    "@typescript-eslint/utils": "^8.64.0",
     "@vitest/coverage-v8": "^4.1.10",
     "@vitest/runner": "4.1.0",
     "@wdio/protocols": "9.27.0",
@@ -169,7 +169,7 @@
     "better-typescript-lib": "^2.12.0",
     "cspell": "^10.0.1",
     "czg": "^1.13.1",
-    "dprint": "^0.55.1",
+    "dprint": "^0.55.2",
     "esbuild": "^0.28.1",
     "eslint": "^10.7.0",
     "eslint-import-resolver-typescript": "^4.4.5",
@@ -184,8 +184,8 @@
     "jiti": "^2.7.0",
     "jsdom": "^29.1.1",
     "linkinator": "^7.6.1",
-    "markdownlint": "^0.41.0",
-    "markdownlint-cli2": "^0.23.0",
+    "markdownlint": "^0.41.1",
+    "markdownlint-cli2": "^0.23.1",
     "markdownlint-rule-relative-links": "^5.1.1",
     "nano-staged": "^1.0.2",
     "obsidian": "^1.13.1",
@@ -193,8 +193,8 @@
     "ts-jest": "^29.4.11",
     "type-fest": "^5.8.0",
     "typescript": "6.0.3",
-    "typescript-eslint": "^8.63.0",
-    "vite": "^8.1.4",
+    "typescript-eslint": "^8.64.0",
+    "vite": "^8.1.5",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {