obsidian-integration-testing 11.0.0 → 12.1.0

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

@@ -26,10 +26,14 @@ var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+var import_app_startup_progress = require("./app-startup-progress.cjs");
 var import_capture_screenshot = require("./capture-screenshot.cjs");
+var import_error_to_string = require("./error-to-string.cjs");
 var import_exec = require("./exec.cjs");
 var import_leftover_cleanup = require("./leftover-cleanup.cjs");
 var import_log = require("./log.cjs");
+var import_mobile_input = require("./mobile-input.cjs");
+var import_webview_cdp = require("./webview-cdp.cjs");
 const NO_OUTPUT = "(no output)";
 const APP_STATE_FOREGROUND = 4;
 const WEBVIEW_CONTEXT_PREFIX = "WEBVIEW_md.obsidian";
@@ -37,6 +41,7 @@ const WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 6e4;
 const LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 9e4;
+const DEFAULT_APP_START_POLL_TIMEOUT_IN_MILLISECONDS = 18e4;
 const APP_RESTART_DELAY_IN_MILLISECONDS = 2e3;
 const DEFAULT_APP_ID = "md.obsidian";
 const ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS = 3e4;
@@ -56,8 +61,23 @@ class AppiumTransport {
    */
   isMobile = true;
   appId;
+  appStartTimeoutInMilliseconds;
   browser;
   deviceId;
+  /**
+   * The `process.on('exit')` handler that tears the channel down when nothing else will.
+   */
+  disposeInputChannelOnExit = null;
+  /**
+   * The host half of the trusted-input channel: a CDP connection to the WebView, independent of the
+   * Appium session, opened lazily on first evaluate and reused (see **L39**).
+   */
+  inputChannel = null;
+  /**
+   * Set once the trusted-input channel is known not to be openable here (iOS, a remote hub, no local
+   * `adb`), so the attempt is not repeated on every evaluate.
+   */
+  isInputChannelUnavailable = false;
   /**
    * Tracks whether the driver is currently switched to the WebView context.
    *
@@ -88,6 +108,7 @@ class AppiumTransport {
     this.layoutReadyTimeoutInMilliseconds = config.layoutReadyTimeoutInMilliseconds ?? DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;
     this.platform = config.platform;
     this.appId = config.appId ?? DEFAULT_APP_ID;
+    this.appStartTimeoutInMilliseconds = config.appStartTimeoutInMilliseconds ?? DEFAULT_APP_START_POLL_TIMEOUT_IN_MILLISECONDS;
     this.shouldSweepLeftovers = config.shouldSweepLeftovers ?? true;
     this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? DEFAULT_ANDROID_VAULT_BASE_PATH;
     this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;
@@ -139,10 +160,24 @@ class AppiumTransport {
    * deletion so the session remains available for the owning process.
    */
   async dispose() {
+    await this.disposeInputChannel();
     if (this.isSessionOwner) {
       await this.browser.deleteSession();
     }
   }
+  /**
+   * Synchronous teardown for `process.on('exit')` handlers.
+   *
+   * Only the trusted-input channel needs it: the Appium session is the owning process's to end, and an
+   * abrupt exit is exactly when the async {@link AppiumTransport.dispose} never runs — which would strand
+   * the adb port forward on the device.
+   */
+  disposeSync() {
+    const channel = this.inputChannel;
+    this.inputChannel = null;
+    this.unregisterInputChannelExitHandler();
+    channel?.disposeSync();
+  }
   /**
    * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.
    *
@@ -155,6 +190,7 @@ class AppiumTransport {
    */
   async evaluate(expression, _options) {
     await this.ensureWebViewContext();
+    await this.ensureInputChannel();
     try {
       const result = await this.browser.execute(
         `return (${expression})`
@@ -266,7 +302,8 @@ class AppiumTransport {
    * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
    *    `enable-plugin-<path>`)
    * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault
-   * 5. Wait for `app.workspace.layoutReady`
+   * 5. Wait for `globalThis.app` to exist (the app's cold start), then — on a
+   *    separate, tighter budget — for `app.workspace.layoutReady`
    *
    * Existing vault registrations in localStorage are preserved (append, not
    * overwrite) — except the **harness's own** `temp-vault-*` registrations from
@@ -306,6 +343,7 @@ class AppiumTransport {
       deviceVaultPath,
       stalePrefix
     );
+    await this.waitForAppStarted();
     await this.waitForLayoutReady();
   }
   /**
@@ -347,6 +385,55 @@ class AppiumTransport {
     }
     await this.removeDeviceVaultDirectory(deviceVaultPath);
   }
+  /**
+   * Closes the trusted-input channel, if one is open.
+   */
+  async disposeInputChannel() {
+    const channel = this.inputChannel;
+    this.inputChannel = null;
+    this.unregisterInputChannelExitHandler();
+    await channel?.dispose();
+  }
+  /**
+   * Opens the trusted-input channel if it is not already open, and re-opens it if the WebView went away.
+   *
+   * Installs a `Runtime.addBinding` function on the page and services every call to it for the life of the
+   * connection. The binding is exposed on *every* execution context of the page, so it survives the
+   * `location.reload()` that {@link AppiumTransport.registerVault} performs; only a full app restart, which
+   * destroys the WebView target, needs the reconnect below.
+   */
+  async ensureInputChannel() {
+    if (this.inputChannel?.isOpen || this.isInputChannelUnavailable) {
+      return;
+    }
+    if (this.platform !== "android") {
+      this.isInputChannelUnavailable = true;
+      return;
+    }
+    await this.disposeInputChannel();
+    try {
+      const connection = await (0, import_webview_cdp.connectToWebViewCdp)({ appId: this.appId, deviceId: this.deviceId });
+      await connection.send("Runtime.enable");
+      await connection.send("Runtime.addBinding", { name: import_mobile_input.MOBILE_INPUT_BINDING_NAME });
+      connection.on("Runtime.bindingCalled", (params) => {
+        if (params["name"] !== import_mobile_input.MOBILE_INPUT_BINDING_NAME) {
+          return;
+        }
+        const payload = params["payload"];
+        this.handleInputRequest(connection, typeof payload === "string" ? payload : "").catch(() => {
+        });
+      });
+      this.inputChannel = connection;
+      this.disposeInputChannelOnExit = () => {
+        connection.disposeSync();
+      };
+      process.once("exit", this.disposeInputChannelOnExit);
+      (0, import_log.log)("[appium-transport] Trusted-input channel open.");
+    } catch (error) {
+      this.isInputChannelUnavailable = true;
+      (0, import_log.log)(`[appium-transport] Trusted input is unavailable on this device: ${(0, import_error_to_string.errorToString)(error)}`);
+    }
+  }
   /**
    * Switches the driver to the `WEBVIEW_md.obsidian` context.
    *
@@ -396,6 +483,58 @@ class AppiumTransport {
   getDeviceVaultPath(vaultPath) {
     return `${this.vaultBasePath}${extractVaultName(vaultPath)}`;
   }
+  /**
+   * Services one input request from the renderer: inject, then resolve the renderer's promise.
+   *
+   * Every failure path still resolves that promise — with an error message the renderer re-throws — because
+   * a request that is silently dropped would hang the closure until the whole run times out, and report
+   * nothing about why.
+   *
+   * @param connection - The channel the request arrived on.
+   * @param payload - The raw JSON payload the binding was called with.
+   */
+  async handleInputRequest(connection, payload) {
+    let requestId = "";
+    try {
+      const { id, request } = JSON.parse(payload);
+      requestId = id;
+      await connection.sendAll((0, import_mobile_input.toCdpInputCommands)(request));
+      await connection.send("Runtime.evaluate", { expression: (0, import_mobile_input.buildResolveInputExpression)(id) });
+    } catch (error) {
+      const message = (0, import_error_to_string.errorToString)(error);
+      (0, import_log.log)(`[appium-transport] Trusted input failed: ${message}`);
+      if (!requestId) {
+        return;
+      }
+      try {
+        await connection.send("Runtime.evaluate", { expression: (0, import_mobile_input.buildResolveInputExpression)(requestId, message) });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Probes the WebView once for how far Obsidian's startup has got.
+   *
+   * A probe that throws is reported as `undefined` rather than propagated: the
+   * page is mid-`location.reload()` for most of the app-start phase, and a
+   * WebView that cannot answer yet is the *expected* reading there, not an error.
+   *
+   * @returns What the probe saw, or `undefined` when it could not run.
+   */
+  async probeStartup() {
+    try {
+      return await this.browser.execute(() => {
+        const app = globalThis.app;
+        return {
+          hasApp: !!app,
+          hasWorkspace: !!app?.workspace,
+          isLayoutReady: !!app?.workspace?.layoutReady
+        };
+      });
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.
    *
@@ -453,30 +592,97 @@ class AppiumTransport {
       (0, import_log.log)(`[appium-transport] Vault directory removal failed (non-fatal): ${String(error)}`);
     }
   }
+  /**
+   * Drops the `process.on('exit')` handler that would otherwise close an already-closed channel, and would
+   * stack a listener per reconnect.
+   */
+  unregisterInputChannelExitHandler() {
+    if (!this.disposeInputChannelOnExit) {
+      return;
+    }
+    process.off("exit", this.disposeInputChannelOnExit);
+    this.disposeInputChannelOnExit = null;
+  }
+  /**
+   * Polls until `globalThis.app` exists in the WebView — the app has finished
+   * its cold start and Obsidian's own boot has begun.
+   *
+   * This is the **first** of the two budgets spent after `location.reload()`,
+   * and the generous one. Everything it pays for is outside Obsidian's control:
+   * the WebView reloading, and a guest that may still be optimizing packages.
+   * Keeping it separate is the point of the split — the old single wall clock
+   * started here and left the tight layout budget paying for a cold start.
+   */
+  async waitForAppStarted() {
+    (0, import_log.log)(`[appium-transport] Waiting for the app to start (timeout=${String(this.appStartTimeoutInMilliseconds)}ms)...`);
+    await this.waitForStartupMilestone({
+      isSatisfied: import_app_startup_progress.checkAppStarted,
+      phase: "app-start",
+      timeoutInMilliseconds: this.appStartTimeoutInMilliseconds
+    });
+  }
   /**
    * Polls until `app.workspace.layoutReady` is `true` in the WebView.
+   *
+   * The **second** budget, and the tight one: by the time it starts, the app is
+   * already up, so all it covers is Obsidian opening the vault and loading
+   * plugins — ~1s in practice, ≤8.4s under heavy host stress (**L19**).
    */
   async waitForLayoutReady() {
-    const start = Date.now();
-    const deadline = start + this.layoutReadyTimeoutInMilliseconds;
     (0, import_log.log)(`[appium-transport] Waiting for layout ready (timeout=${String(this.layoutReadyTimeoutInMilliseconds)}ms)...`);
+    await this.waitForStartupMilestone({
+      isSatisfied: import_app_startup_progress.checkLayoutReady,
+      phase: "layout-ready",
+      timeoutInMilliseconds: this.layoutReadyTimeoutInMilliseconds
+    });
+  }
+  /**
+   * Polls the WebView until a startup phase's milestone is satisfied, tracking
+   * the evidence that tells a slow Obsidian from a contended guest.
+   *
+   * Each poll costs exactly one `browser.execute` round-trip — deliberately not
+   * an {@link ensureWebViewContext} call, whose `getContexts()` runs
+   * `adb shell cat /proc/net/unix` and was measured at ~17s per **L19**. The
+   * round-trip is timed, and the slowest one is reported on timeout: a phase
+   * that ran out after a handful of probes each taking tens of seconds was
+   * starved by the guest, not by Obsidian.
+   *
+   * @param params - The phase, its budget, and the predicate that ends it.
+   */
+  async waitForStartupMilestone(params) {
+    const { isSatisfied, phase, timeoutInMilliseconds } = params;
+    const start = Date.now();
+    const deadline = start + timeoutInMilliseconds;
+    let furthestMilestone = "no-webview";
+    let pollCount = 0;
+    let slowestRoundTripInMilliseconds = 0;
     while (Date.now() < deadline) {
-      try {
-        const isReady = await this.browser.execute(() => {
-          const app = globalThis.app;
-          return !!app?.workspace?.layoutReady;
-        });
-        if (isReady) {
-          (0, import_log.log)(`[appium-transport] Layout is ready after ${String(Date.now() - start)}ms.`);
-          this.isInWebViewContext = true;
-          return;
-        }
-      } catch {
+      const roundTripStart = Date.now();
+      const milestone = (0, import_app_startup_progress.classifyAppStartupProbe)(await this.probeStartup());
+      const roundTripInMilliseconds = Date.now() - roundTripStart;
+      pollCount++;
+      slowestRoundTripInMilliseconds = Math.max(slowestRoundTripInMilliseconds, roundTripInMilliseconds);
+      if ((0, import_app_startup_progress.compareAppStartupMilestones)(milestone, furthestMilestone) > 0) {
+        furthestMilestone = milestone;
+      }
+      if (isSatisfied(milestone)) {
+        (0, import_log.log)(`[appium-transport] Phase "${phase}" satisfied after ${String(Date.now() - start)}ms (${String(pollCount)} probe(s)).`);
+        this.isInWebViewContext = true;
+        return;
       }
-      (0, import_log.log)(`[appium-transport] Layout not ready yet (elapsed=${String(Date.now() - start)}ms). Retrying...`);
+      (0, import_log.log)(
+        `[appium-transport] Phase "${phase}" not satisfied yet: ${milestone} (elapsed=${String(Date.now() - start)}ms, round-trip=${String(roundTripInMilliseconds)}ms). Retrying...`
+      );
       await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);
     }
-    throw new Error(`Obsidian layout did not become ready within ${String(this.layoutReadyTimeoutInMilliseconds)}ms`);
+    throw new Error((0, import_app_startup_progress.buildStartupTimeoutMessage)({
+      elapsedInMilliseconds: Date.now() - start,
+      milestone: furthestMilestone,
+      phase,
+      pollCount,
+      slowestRoundTripInMilliseconds,
+      timeoutInMilliseconds
+    }));
   }
 }
 function delay(ms) {
@@ -494,4 +700,4 @@ function extractVaultName(vaultPath) {
   AppiumTransport,
   DEFAULT_ANDROID_VAULT_BASE_PATH
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-appium.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Appium transport \u2014 evaluates expressions inside Obsidian Mobile via WebView\n * JavaScript injection. Manages vault lifecycle via localStorage and file push.\n *\n * Configured via `environmentOptions.obsidianTransport` in vitest config:\n *\n * ```typescript\n * // vitest.config.ts\n * environmentOptions: {\n *   obsidianTransport: {\n *     type: 'obsidian-android-appium',\n *     appiumUrl: 'http://localhost:4723',\n *     avdName: 'obsidian_test',\n *   },\n * }\n * ```\n *\n * For BrowserStack, set `appiumUrl` to the BrowserStack hub URL\n * \u2014 the transport itself is hub-agnostic.\n *\n * ## How vault registration works on mobile\n *\n * Obsidian Mobile stores its vault registry in the WebView's `localStorage`:\n *\n * - `mobile-external-vaults` \u2014 JSON array of registered vault paths\n * - `mobile-selected-vault` \u2014 the currently active vault path\n * - `enable-plugin-<vaultPath>` \u2014 `\"true\"` to enable the plugin system for the vault\n *\n * To register a vault programmatically (without UI interaction):\n *\n * 1. Push vault files to the device (e.g. `/sdcard/Documents/<Name>/.obsidian/app.json`)\n * 2. Switch to `WEBVIEW_md.obsidian` context\n * 3. Set the localStorage entries\n * 4. Call `location.reload()` \u2014 Obsidian re-reads localStorage and opens the vault\n *\n * This avoids the onboarding flow entirely.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Browser } from 'webdriverio';\n\nimport { randomUUID } from 'node:crypto';\nimport {\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport {\n  decodeBase64Png,\n  isPng\n} from './capture-screenshot.cjs';\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\n\n/**\n * Session connection info returned by {@link AppiumTransport.getSessionInfo},\n * used to reattach from another process.\n */\nexport interface AppiumSessionInfo {\n  /**\n  The device UDID (e.g. `'emulator-5554'`).\n   */\n  deviceId: string;\n\n  /**\n  The Appium/WebDriver session ID.\n   */\n  sessionId: string;\n}\n\n/**\n * Configuration for the Appium transport.\n */\nexport interface AppiumTransportConfig {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`.\n   */\n  appId?: string;\n\n  /**\n   * The Appium browser/driver instance.\n   * Created by the consumer via e.g. WebDriverIO's `remote()`.\n   */\n  browser: Browser;\n\n  /**\n   * The device UDID (e.g. `'emulator-5554'`).\n   * Used for `adb` commands when pushing files to the device.\n   */\n  deviceId: string;\n\n  /**\n   * Whether this transport owns the Appium session and should delete it on\n   * {@link AppiumTransport.dispose}.\n   *\n   * `true` for sessions created via `remote()` (global setup).\n   * `false` for sessions reattached via `attach()` (test workers).\n   *\n   * @default `true`\n   */\n  isSessionOwner?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * @default `90000`\n   */\n  layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Target platform. Determines WebView context naming and device file paths.\n   */\n  platform: 'android' | 'ios';\n\n  /**\n   * Whether registering a vault also prunes the **other** `temp-vault-*`\n   * registrations earlier runs left in Obsidian Mobile's `localStorage`.\n   *\n   * The device-side directories are swept before the app launches (see the\n   * factory); this removes their now-dangling registry entries, which are what\n   * Obsidian actually enumerates at startup. Unregistering this run's own vault\n   * is unaffected \u2014 that always happens.\n   *\n   * @default `true`\n   */\n  shouldSweepLeftovers?: boolean;\n\n  /**\n   * Base path on the device where Obsidian stores vaults.\n   *\n   * Defaults:\n   * - Android: `/sdcard/Documents/`\n   * - iOS: `@md.obsidian:documents/`\n   */\n  vaultBasePath?: string;\n\n  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * @default `60000`\n   */\n  webviewTimeoutInMilliseconds?: number;\n}\n\nconst NO_OUTPUT = '(no output)';\nconst APP_STATE_FOREGROUND = 4;\nconst WEBVIEW_CONTEXT_PREFIX = 'WEBVIEW_md.obsidian';\nconst WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 90_000;\nconst APP_RESTART_DELAY_IN_MILLISECONDS = 2000;\nconst DEFAULT_APP_ID = 'md.obsidian';\nconst ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS = 30_000;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing, see T88) ---\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OIT_CAPTURE';\nconst CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8000;\nconst ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS = 5000;\nconst LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS = 10_000;\n/**\n * `adb logcat -v time` lines look like `MM-DD HH:MM:SS.mmm LEVEL/TAG( PID): message`.\n * Keep only the tags Chromium/WebView routes JS `console.*` output and uncaught\n * errors to (`chromium`, the Capacitor console bridge, and native `AndroidRuntime`).\n */\nconst CONSOLE_CAPTURE_TAG_RE = /\\/(?:chromium|AndroidRuntime|Capacitor\\/Console)\\(/;\n\n/**\n * Base path on an Android device where Obsidian Mobile stores its vaults.\n *\n * Exported because the transport factory sweeps leftover vaults from it before\n * a transport exists (see the repo's L31).\n */\nexport const DEFAULT_ANDROID_VAULT_BASE_PATH = '/sdcard/Documents/';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: DEFAULT_ANDROID_VAULT_BASE_PATH,\n  ios: '@md.obsidian:documents/'\n};\n\ninterface LoadingApp {\n  workspace?: LoadingWorkspace;\n}\n\ninterface LoadingWorkspace {\n  layoutReady?: boolean;\n}\n\n/**\n * Transport that communicates with Obsidian Mobile via Appium WebView JS injection.\n *\n * Evaluates expressions by switching to the `WEBVIEW_md.obsidian` context and\n * calling `execute()`. Manages vaults by writing to the WebView's `localStorage`\n * (which Obsidian uses as its vault registry on mobile) and pushing files to the device.\n */\nexport class AppiumTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `true` for this transport.\n   */\n  public readonly isMobile = true;\n  private readonly appId: string;\n  private readonly browser: Browser;\n  private readonly deviceId: string;\n  /**\n   * Tracks whether the driver is currently switched to the WebView context.\n   *\n   * Set to `true` after a successful `switchContext(WEBVIEW_md.obsidian)`.\n   * Reset to `false` when the context is known to be invalidated\n   * (e.g. after `location.reload()` in {@link registerVault}).\n   *\n   * When `true`, {@link ensureWebViewContext} skips the expensive\n   * `getContexts()` call (which runs `adb shell cat /proc/net/unix` and\n   * can time out on slow emulators).\n   */\n  private isInWebViewContext = false;\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly shouldSweepLeftovers: boolean;\n  private readonly vaultBasePath: string;\n\n  private readonly webviewTimeoutInMilliseconds: number;\n\n  /**\n   * Creates a new Appium transport.\n   *\n   * @param config - Appium transport configuration.\n   */\n  public constructor(config: AppiumTransportConfig) {\n    this.browser = config.browser;\n    this.deviceId = config.deviceId;\n    this.isSessionOwner = config.isSessionOwner ?? true;\n    this.layoutReadyTimeoutInMilliseconds = config.layoutReadyTimeoutInMilliseconds ?? DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;\n    this.platform = config.platform;\n    this.appId = config.appId ?? DEFAULT_APP_ID;\n    this.shouldSweepLeftovers = config.shouldSweepLeftovers ?? true;\n    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? DEFAULT_ANDROID_VAULT_BASE_PATH;\n    this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Begins a console capture by stamping the device log with a unique marker.\n   *\n   * Uses `adb shell log` to write a marker into `logcat` at capture start so a\n   * later {@link AppiumTransport.readConsoleCaptureSince} can slice out\n   * everything the WebView logged afterwards \u2014 without the invasive `logcat -c`\n   * buffer clear.\n   *\n   * @returns A handle carrying the unique marker.\n   */\n  public async beginConsoleCapture(): Promise<ConsoleCaptureHandle> {\n    const marker = `${CONSOLE_CAPTURE_MARKER_TAG}_${randomUUID()}`;\n    await exec(\n      ['adb', '-s', this.deviceId, 'shell', 'log', '-t', CONSOLE_CAPTURE_MARKER_TAG, marker],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS }\n    );\n    return { marker };\n  }\n\n  /**\n   * Captures a PNG screenshot of the device's screen.\n   *\n   * The image is always the device's native framebuffer \u2014 there is no mobile\n   * equivalent of the desktop viewport override, so\n   * {@link CaptureScreenshotParams.widthInPixels} /\n   * {@link CaptureScreenshotParams.heightInPixels} are ignored. Size a mobile\n   * capture by choosing an AVD whose screen geometry already matches what the\n   * image has to be.\n   *\n   * @param _params - Capture parameters. Ignored on mobile: `cwd` does not select a window (vault targeting is via localStorage), and the size cannot be overridden.\n   * @returns The raw PNG bytes.\n   * @throws Error if the driver returns data that is not a PNG.\n   */\n  public async captureScreenshot(_params: CaptureScreenshotParams): Promise<Uint8Array> {\n    const bytes = decodeBase64Png(await this.browser.takeScreenshot());\n    if (!isPng(bytes)) {\n      throw new Error('Appium screenshot error: takeScreenshot returned data that is not a PNG.');\n    }\n\n    return bytes;\n  }\n\n  /**\n   * Ends the Appium session.\n   *\n   * Only deletes the session if this transport owns it. Transports created\n   * via `attach()` (test workers reusing the global setup's session) skip\n   * deletion so the session remains available for the owning process.\n   */\n  public async dispose(): Promise<void> {\n    if (this.isSessionOwner) {\n      await this.browser.deleteSession();\n    }\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.\n   *\n   * Switches to the `WEBVIEW_md.obsidian` context, executes the expression,\n   * and returns the result string.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param _options - Evaluation options (cwd is not used on mobile \u2014 vault targeting is via localStorage).\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, _options: TransportEvalOptions): Promise<string> {\n    await this.ensureWebViewContext();\n\n    try {\n      const result = await this.browser.execute<null | string | undefined, []>(\n        `return (${expression})`\n      );\n\n      if (result === undefined || result === null) {\n        return NO_OUTPUT;\n      }\n\n      return result;\n    } catch (error: unknown) {\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n      throw error;\n    }\n  }\n\n  /**\n   * Returns the session connection info needed to reattach to this session\n   * from another process (e.g. a test worker).\n   *\n   * @returns The session ID and device ID.\n   */\n  public getSessionInfo(): AppiumSessionInfo {\n    return {\n      deviceId: this.deviceId,\n      sessionId: this.browser.sessionId\n    };\n  }\n\n  /**\n   * Verifies that the Obsidian app is running and the WebView is available.\n   *\n   * @param _vaultPath - Not used on mobile.\n   */\n  public async preflightCheck(_vaultPath: string): Promise<void> {\n    log('[appium-transport] Running preflight check...');\n    const state = await this.browser.queryAppState(this.appId);\n    log(`[appium-transport] App state: ${String(state)} (need ${String(APP_STATE_FOREGROUND)}=foreground)`);\n    if (state !== APP_STATE_FOREGROUND) {\n      log(`[appium-transport] Activating app ${this.appId}...`);\n      this.isInWebViewContext = false;\n      await this.browser.activateApp(this.appId);\n      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);\n    }\n\n    await this.ensureWebViewContext();\n    log('[appium-transport] Preflight check passed.');\n  }\n\n  /**\n   * Pushes vault files to the device via compressed `adb push`.\n   *\n   * Creates a tar.gz archive of the local vault directory, pushes it to the\n   * device as a single file, and extracts it in-place. This avoids the\n   * webdriver `RangeError` on large base64 payloads and is significantly\n   * faster than per-file `browser.pushFile()` calls.\n   *\n   * @param vaultPath - The vault path (used as the vault directory name on device).\n   * @param _files - Map of relative file paths to content buffers (unused \u2014 adb pushes the directory directly).\n   */\n  public async pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n    const archiveName = `vault-${randomUUID()}.tar.gz`;\n    const localArchive = join(tmpdir(), archiveName);\n    const remoteArchive = `/data/local/tmp/${archiveName}`;\n\n    try {\n      log(`[appium-transport] Creating archive: ${localArchive}`);\n      await exec(['tar', 'czf', archiveName, '-C', vaultPath, '.'], { cwd: tmpdir(), isQuiet: true });\n\n      log(`[appium-transport] Pushing archive to device ${this.deviceId}...`);\n      await exec(['adb', '-s', this.deviceId, 'push', localArchive, remoteArchive], { isQuiet: true });\n\n      log(`[appium-transport] Extracting archive on device at ${deviceVaultPath}...`);\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', deviceVaultPath], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'shell', 'tar', 'xzf', remoteArchive, '-C', deviceVaultPath], { isQuiet: true });\n\n      log('[appium-transport] Flushing filesystem buffers...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'sync'], { isQuiet: true });\n\n      log('[appium-transport] Cleaning up remote archive...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'rm', remoteArchive], { isQuiet: true });\n    } finally {\n      await rm(localArchive, { force: true });\n    }\n  }\n\n  /**\n   * Dumps `adb logcat` and returns the WebView console/error output logged\n   * since the marker from {@link AppiumTransport.beginConsoleCapture}.\n   *\n   * Filters to the Chromium/WebView tags that carry JS `console.*` output and\n   * uncaught errors, and caps the result length. Bounded, post-hoc,\n   * failure-path-only \u2014 never a live monitor.\n   *\n   * @param handle - The capture handle (or `undefined` when capture never started).\n   * @returns The captured console/error text, or `undefined` if nothing relevant was logged.\n   */\n  public async readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined> {\n    if (!handle) {\n      return undefined;\n    }\n\n    const dump = await exec(\n      ['adb', '-s', this.deviceId, 'logcat', '-d', '-v', 'time'],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS }\n    );\n\n    const markerIndex = dump.lastIndexOf(handle.marker);\n    const region = markerIndex === -1 ? dump : dump.slice(markerIndex + handle.marker.length);\n    const relevant = region\n      .split('\\n')\n      .filter((line) => CONSOLE_CAPTURE_TAG_RE.test(line))\n      .join('\\n')\n      .trim();\n\n    if (!relevant) {\n      return undefined;\n    }\n\n    return relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH);\n  }\n\n  /**\n   * Registers a vault on mobile by pushing files and configuring localStorage.\n   *\n   * The registration flow:\n   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault\n   * 2. Switch to the WebView context\n   * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,\n   *    `enable-plugin-<path>`)\n   * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault\n   * 5. Wait for `app.workspace.layoutReady`\n   *\n   * Existing vault registrations in localStorage are preserved (append, not\n   * overwrite) \u2014 except the **harness's own** `temp-vault-*` registrations from\n   * earlier runs, which are pruned when {@link AppiumTransportConfig.shouldSweepLeftovers}\n   * is on. Their directories are already gone (the factory sweeps them before\n   * the app launches), and it is this registry \u2014 not the filesystem \u2014 that\n   * Obsidian enumerates at startup, so leaving them is what makes each failed\n   * run slow the next one down.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[appium-transport] Registering vault: ${vaultPath}`);\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    // Push a minimal .obsidian directory so Obsidian recognizes it as a vault.\n    await this.pushObsidianMarker(deviceVaultPath);\n\n    // Switch to WebView and configure localStorage.\n    await this.ensureWebViewContext();\n\n    // Invalidate before reload \u2014 the page will navigate and the WebView\n    // Context may be temporarily unavailable during reload.\n    this.isInWebViewContext = false;\n\n    const stalePrefix = this.shouldSweepLeftovers ? `${this.vaultBasePath}${TEMP_VAULT_DIR_PREFIX}` : '';\n\n    await this.browser.execute(\n      (path: string, prunePrefix: string) => {\n        let existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n\n        if (prunePrefix) {\n          const stale = existing.filter((registered) => registered !== path && registered.startsWith(prunePrefix));\n          for (const registered of stale) {\n            localStorage.removeItem(`enable-plugin-${registered}`);\n          }\n          existing = existing.filter((registered) => !stale.includes(registered));\n        }\n\n        if (!existing.includes(path)) {\n          existing.push(path);\n        }\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(existing));\n        localStorage.setItem('mobile-selected-vault', path);\n        localStorage.setItem(`enable-plugin-${path}`, 'true');\n        location.reload();\n      },\n      deviceVaultPath,\n      stalePrefix\n    );\n\n    // Wait for reload + vault initialization.\n    await this.waitForLayoutReady();\n  }\n\n  /**\n   * Unregisters a vault on mobile by removing it from localStorage.\n   *\n   * Preserves other vault registrations. If the unregistered vault was selected,\n   * switches to the first remaining vault (or clears the selection).\n   *\n   * The vault's **files are then removed from the device over `adb`, whether or\n   * not the `localStorage` step succeeded** \u2014 deliberately, because the\n   * `localStorage` step goes through the WebView and a dead WebView is exactly\n   * what most Android failures are. Routing the removal through the app was what\n   * made every failed run leak its vault (`Vault cleanup error (non-fatal): no\n   * such window`), so the filesystem-level removal must not depend on it.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    try {\n      await this.ensureWebViewContext();\n\n      await this.browser.execute((path: string) => {\n        const existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n        const filtered = existing.filter((v) => v !== path);\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(filtered));\n        localStorage.removeItem(`enable-plugin-${path}`);\n        if (localStorage.getItem('mobile-selected-vault') === path) {\n          if (filtered.length > 0) {\n            localStorage.setItem('mobile-selected-vault', filtered[0] ?? '');\n          } else {\n            localStorage.removeItem('mobile-selected-vault');\n          }\n        }\n      }, deviceVaultPath);\n    } catch (error: unknown) {\n      log(\n        `[appium-transport] Could not deregister ${deviceVaultPath} from localStorage `\n          + `(${String(error)}); removing its files anyway.`\n      );\n    }\n\n    await this.removeDeviceVaultDirectory(deviceVaultPath);\n  }\n\n  /**\n   * Switches the driver to the `WEBVIEW_md.obsidian` context.\n   *\n   * If the context was already verified (cached via {@link isInWebViewContext}),\n   * returns immediately without calling `getContexts()` \u2014 which runs\n   * `adb shell cat /proc/net/unix` and can time out on slow emulators.\n   *\n   * Polls until the context becomes available (the app may still be loading).\n   * Uses the `WEBVIEW_md.obsidian` context specifically to avoid connecting\n   * to Chrome or other WebViews on the device.\n   */\n  private async ensureWebViewContext(): Promise<void> {\n    if (this.isInWebViewContext) {\n      return;\n    }\n\n    const deadline = Date.now() + this.webviewTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for ${WEBVIEW_CONTEXT_PREFIX} context (timeout=${String(this.webviewTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      const contexts = await this.browser.getContexts();\n      const obsidianContext = contexts.find((context): context is string => typeof context === 'string' && context.startsWith(WEBVIEW_CONTEXT_PREFIX));\n\n      if (obsidianContext) {\n        log(`[appium-transport] Found WebView context: ${obsidianContext}`);\n        try {\n          await this.browser.switchContext(obsidianContext);\n          this.isInWebViewContext = true;\n          return;\n        } catch (error: unknown) {\n          log(`[appium-transport] switchContext failed: ${String(error)}. Resetting to NATIVE_APP before retrying...`);\n          try {\n            await this.browser.switchContext('NATIVE_APP');\n          } catch (resetError: unknown) {\n            log(`[appium-transport] NATIVE_APP reset also failed: ${String(resetError)}`);\n          }\n        }\n      }\n\n      log(`[appium-transport] WebView not ready, available contexts: ${JSON.stringify(contexts)}. Retrying...`);\n      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(this.webviewTimeoutInMilliseconds)}ms. Is the Obsidian app fully loaded?`);\n  }\n\n  /**\n   * Converts a host-side vault path to the device-side path.\n   *\n   * @param vaultPath - Absolute path on the host machine.\n   * @returns The device-side vault path.\n   */\n  private getDeviceVaultPath(vaultPath: string): string {\n    return `${this.vaultBasePath}${extractVaultName(vaultPath)}`;\n  }\n\n  /**\n   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.\n   *\n   * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a\n   * cold or loaded emulator \u2014 measured at 9\u201321s per call for this 2-byte marker,\n   * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched\n   * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async pushObsidianMarker(deviceVaultPath: string): Promise<void> {\n    const localMarker = join(tmpdir(), `obsidian-marker-${randomUUID()}.json`);\n    const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;\n\n    try {\n      await writeFile(localMarker, '{}', 'utf-8');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', `${deviceVaultPath}/.obsidian`], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'push', localMarker, remoteMarker], { isQuiet: true });\n    } finally {\n      await rm(localMarker, { force: true });\n    }\n  }\n\n  /**\n   * Removes a vault directory from the device over `adb`, and CHECKS that it is\n   * actually gone.\n   *\n   * Best-effort: a failure is logged, not thrown, so a teardown problem never\n   * masks the test result. The next run's start-of-run sweep picks up whatever\n   * this could not remove.\n   *\n   * The check is the point. `rm -rf` runs with `shouldIgnoreExitCode`, so an\n   * unremoved directory used to leave no trace at all \u2014 which is how runs that\n   * passed end to end were still found to be leaking a vault apiece, invisibly,\n   * until someone counted the directories on the device by hand. A leak is now\n   * named in the log at the moment it happens.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async removeDeviceVaultDirectory(deviceVaultPath: string): Promise<void> {\n    try {\n      log(`[appium-transport] Removing vault directory from device: ${deviceVaultPath}`);\n      await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'rm', '-rf', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      const listing = await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'ls', '-d', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      if (listing.includes(deviceVaultPath)) {\n        log(\n          `[appium-transport] Warning: ${deviceVaultPath} survived removal and is now leaked residue. `\n            + 'The next run\\'s start-of-run sweep will retry it.'\n        );\n      }\n    } catch (error: unknown) {\n      log(`[appium-transport] Vault directory removal failed (non-fatal): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Polls until `app.workspace.layoutReady` is `true` in the WebView.\n   */\n  private async waitForLayoutReady(): Promise<void> {\n    const start = Date.now();\n    const deadline = start + this.layoutReadyTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for layout ready (timeout=${String(this.layoutReadyTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      try {\n        const isReady = await this.browser.execute((): boolean => {\n          // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n          const app = globalThis.app as LoadingApp | undefined;\n          return !!app?.workspace?.layoutReady;\n        });\n        if (isReady) {\n          log(`[appium-transport] Layout is ready after ${String(Date.now() - start)}ms.`);\n          this.isInWebViewContext = true;\n          return;\n        }\n      } catch {\n        // App not ready yet (page may be reloading).\n      }\n\n      log(`[appium-transport] Layout not ready yet (elapsed=${String(Date.now() - start)}ms). Retrying...`);\n      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`Obsidian layout did not become ready within ${String(this.layoutReadyTimeoutInMilliseconds)}ms`);\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Extracts the vault directory name from a host-side vault path.\n *\n * @param vaultPath - Absolute path on the host machine.\n * @returns The last path segment (vault directory name).\n */\nfunction extractVaultName(vaultPath: string): string {\n  const normalized = vaultPath.replace(/[\\\\/]+$/, '');\n  const lastSeparator = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\\\'));\n  return normalized.slice(lastSeparator + 1);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-appium.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Appium transport \u2014 evaluates expressions inside Obsidian Mobile via WebView\n * JavaScript injection. Manages vault lifecycle via localStorage and file push.\n *\n * Configured via `environmentOptions.obsidianTransport` in vitest config:\n *\n * ```typescript\n * // vitest.config.ts\n * environmentOptions: {\n *   obsidianTransport: {\n *     type: 'obsidian-android-appium',\n *     appiumUrl: 'http://localhost:4723',\n *     avdName: 'obsidian_test',\n *   },\n * }\n * ```\n *\n * For BrowserStack, set `appiumUrl` to the BrowserStack hub URL\n * \u2014 the transport itself is hub-agnostic.\n *\n * ## How vault registration works on mobile\n *\n * Obsidian Mobile stores its vault registry in the WebView's `localStorage`:\n *\n * - `mobile-external-vaults` \u2014 JSON array of registered vault paths\n * - `mobile-selected-vault` \u2014 the currently active vault path\n * - `enable-plugin-<vaultPath>` \u2014 `\"true\"` to enable the plugin system for the vault\n *\n * To register a vault programmatically (without UI interaction):\n *\n * 1. Push vault files to the device (e.g. `/sdcard/Documents/<Name>/.obsidian/app.json`)\n * 2. Switch to `WEBVIEW_md.obsidian` context\n * 3. Set the localStorage entries\n * 4. Call `location.reload()` \u2014 Obsidian re-reads localStorage and opens the vault\n *\n * This avoids the onboarding flow entirely.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Browser } from 'webdriverio';\n\nimport { randomUUID } from 'node:crypto';\nimport {\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport type {\n  AppStartupMilestone,\n  AppStartupPhase,\n  StartupProbeResult\n} from './app-startup-progress.cjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type { MobileInputEnvelope } from './mobile-input.cjs';\nimport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nimport type { WebViewCdpConnection } from './webview-cdp.cjs';\n\nimport {\n  buildStartupTimeoutMessage,\n  checkAppStarted,\n  checkLayoutReady,\n  classifyAppStartupProbe,\n  compareAppStartupMilestones\n} from './app-startup-progress.cjs';\nimport {\n  decodeBase64Png,\n  isPng\n} from './capture-screenshot.cjs';\nimport { errorToString } from './error-to-string.cjs';\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport {\n  buildResolveInputExpression,\n  MOBILE_INPUT_BINDING_NAME,\n  toCdpInputCommands\n} from './mobile-input.cjs';\nimport { connectToWebViewCdp } from './webview-cdp.cjs';\n\n/**\n * Session connection info returned by {@link AppiumTransport.getSessionInfo},\n * used to reattach from another process.\n */\nexport interface AppiumSessionInfo {\n  /**\n  The device UDID (e.g. `'emulator-5554'`).\n   */\n  deviceId: string;\n\n  /**\n  The Appium/WebDriver session ID.\n   */\n  sessionId: string;\n}\n\n/**\n * Configuration for the Appium transport.\n */\nexport interface AppiumTransportConfig {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`.\n   */\n  appId?: string;\n\n  /**\n   * Timeout in milliseconds for Obsidian Mobile to get as far as `globalThis.app`\n   * existing after the vault is (re)opened, before the tighter\n   * {@link layoutReadyTimeoutInMilliseconds} clock starts.\n   *\n   * @default `180000`\n   */\n  appStartTimeoutInMilliseconds?: number;\n\n  /**\n   * The Appium browser/driver instance.\n   * Created by the consumer via e.g. WebDriverIO's `remote()`.\n   */\n  browser: Browser;\n\n  /**\n   * The device UDID (e.g. `'emulator-5554'`).\n   * Used for `adb` commands when pushing files to the device.\n   */\n  deviceId: string;\n\n  /**\n   * Whether this transport owns the Appium session and should delete it on\n   * {@link AppiumTransport.dispose}.\n   *\n   * `true` for sessions created via `remote()` (global setup).\n   * `false` for sessions reattached via `attach()` (test workers).\n   *\n   * @default `true`\n   */\n  isSessionOwner?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady`, counted\n   * from the moment {@link appStartTimeoutInMilliseconds} is satisfied \u2014 not from\n   * the reload, so a cold app start is not charged against it.\n   *\n   * @default `90000`\n   */\n  layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Target platform. Determines WebView context naming and device file paths.\n   */\n  platform: 'android' | 'ios';\n\n  /**\n   * Whether registering a vault also prunes the **other** `temp-vault-*`\n   * registrations earlier runs left in Obsidian Mobile's `localStorage`.\n   *\n   * The device-side directories are swept before the app launches (see the\n   * factory); this removes their now-dangling registry entries, which are what\n   * Obsidian actually enumerates at startup. Unregistering this run's own vault\n   * is unaffected \u2014 that always happens.\n   *\n   * @default `true`\n   */\n  shouldSweepLeftovers?: boolean;\n\n  /**\n   * Base path on the device where Obsidian stores vaults.\n   *\n   * Defaults:\n   * - Android: `/sdcard/Documents/`\n   * - iOS: `@md.obsidian:documents/`\n   */\n  vaultBasePath?: string;\n\n  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * @default `60000`\n   */\n  webviewTimeoutInMilliseconds?: number;\n}\n\nconst NO_OUTPUT = '(no output)';\nconst APP_STATE_FOREGROUND = 4;\nconst WEBVIEW_CONTEXT_PREFIX = 'WEBVIEW_md.obsidian';\nconst WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 90_000;\nconst DEFAULT_APP_START_POLL_TIMEOUT_IN_MILLISECONDS = 180_000;\nconst APP_RESTART_DELAY_IN_MILLISECONDS = 2000;\nconst DEFAULT_APP_ID = 'md.obsidian';\nconst ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS = 30_000;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing) ---\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OIT_CAPTURE';\nconst CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8000;\nconst ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS = 5000;\nconst LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS = 10_000;\n/**\n * `adb logcat -v time` lines look like `MM-DD HH:MM:SS.mmm LEVEL/TAG( PID): message`.\n * Keep only the tags Chromium/WebView routes JS `console.*` output and uncaught\n * errors to (`chromium`, the Capacitor console bridge, and native `AndroidRuntime`).\n */\nconst CONSOLE_CAPTURE_TAG_RE = /\\/(?:chromium|AndroidRuntime|Capacitor\\/Console)\\(/;\n\n/**\n * Base path on an Android device where Obsidian Mobile stores its vaults.\n *\n * Exported because the transport factory sweeps leftover vaults from it before\n * a transport exists (see the repo's L31).\n */\nexport const DEFAULT_ANDROID_VAULT_BASE_PATH = '/sdcard/Documents/';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: DEFAULT_ANDROID_VAULT_BASE_PATH,\n  ios: '@md.obsidian:documents/'\n};\n\ninterface LoadingApp {\n  workspace?: LoadingWorkspace;\n}\n\ninterface LoadingWorkspace {\n  layoutReady?: boolean;\n}\n\n/**\n * Parameters for {@link AppiumTransport.waitForStartupMilestone}.\n */\ninterface WaitForStartupMilestoneParams {\n  /**\n  Whether the milestone just observed ends this phase.\n   */\n  readonly isSatisfied: (milestone: AppStartupMilestone) => boolean;\n\n  /**\n  The phase being waited out, named in the log and in the timeout message.\n   */\n  readonly phase: AppStartupPhase;\n\n  /**\n  This phase's budget.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Transport that communicates with Obsidian Mobile via Appium WebView JS injection.\n *\n * Evaluates expressions by switching to the `WEBVIEW_md.obsidian` context and\n * calling `execute()`. Manages vaults by writing to the WebView's `localStorage`\n * (which Obsidian uses as its vault registry on mobile) and pushing files to the device.\n */\nexport class AppiumTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `true` for this transport.\n   */\n  public readonly isMobile = true;\n  private readonly appId: string;\n  private readonly appStartTimeoutInMilliseconds: number;\n  private readonly browser: Browser;\n  private readonly deviceId: string;\n  /**\n   * The `process.on('exit')` handler that tears the channel down when nothing else will.\n   */\n  private disposeInputChannelOnExit: (() => void) | null = null;\n  /**\n   * The host half of the trusted-input channel: a CDP connection to the WebView, independent of the\n   * Appium session, opened lazily on first evaluate and reused (see **L39**).\n   */\n  private inputChannel: null | WebViewCdpConnection = null;\n  /**\n   * Set once the trusted-input channel is known not to be openable here (iOS, a remote hub, no local\n   * `adb`), so the attempt is not repeated on every evaluate.\n   */\n  private isInputChannelUnavailable = false;\n  /**\n   * Tracks whether the driver is currently switched to the WebView context.\n   *\n   * Set to `true` after a successful `switchContext(WEBVIEW_md.obsidian)`.\n   * Reset to `false` when the context is known to be invalidated\n   * (e.g. after `location.reload()` in {@link registerVault}).\n   *\n   * When `true`, {@link ensureWebViewContext} skips the expensive\n   * `getContexts()` call (which runs `adb shell cat /proc/net/unix` and\n   * can time out on slow emulators).\n   */\n  private isInWebViewContext = false;\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly shouldSweepLeftovers: boolean;\n  private readonly vaultBasePath: string;\n\n  private readonly webviewTimeoutInMilliseconds: number;\n\n  /**\n   * Creates a new Appium transport.\n   *\n   * @param config - Appium transport configuration.\n   */\n  public constructor(config: AppiumTransportConfig) {\n    this.browser = config.browser;\n    this.deviceId = config.deviceId;\n    this.isSessionOwner = config.isSessionOwner ?? true;\n    this.layoutReadyTimeoutInMilliseconds = config.layoutReadyTimeoutInMilliseconds ?? DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;\n    this.platform = config.platform;\n    this.appId = config.appId ?? DEFAULT_APP_ID;\n    this.appStartTimeoutInMilliseconds = config.appStartTimeoutInMilliseconds ?? DEFAULT_APP_START_POLL_TIMEOUT_IN_MILLISECONDS;\n    this.shouldSweepLeftovers = config.shouldSweepLeftovers ?? true;\n    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? DEFAULT_ANDROID_VAULT_BASE_PATH;\n    this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Begins a console capture by stamping the device log with a unique marker.\n   *\n   * Uses `adb shell log` to write a marker into `logcat` at capture start so a\n   * later {@link AppiumTransport.readConsoleCaptureSince} can slice out\n   * everything the WebView logged afterwards \u2014 without the invasive `logcat -c`\n   * buffer clear.\n   *\n   * @returns A handle carrying the unique marker.\n   */\n  public async beginConsoleCapture(): Promise<ConsoleCaptureHandle> {\n    const marker = `${CONSOLE_CAPTURE_MARKER_TAG}_${randomUUID()}`;\n    await exec(\n      ['adb', '-s', this.deviceId, 'shell', 'log', '-t', CONSOLE_CAPTURE_MARKER_TAG, marker],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS }\n    );\n    return { marker };\n  }\n\n  /**\n   * Captures a PNG screenshot of the device's screen.\n   *\n   * The image is always the device's native framebuffer \u2014 there is no mobile\n   * equivalent of the desktop viewport override, so\n   * {@link CaptureScreenshotParams.widthInPixels} /\n   * {@link CaptureScreenshotParams.heightInPixels} are ignored. Size a mobile\n   * capture by choosing an AVD whose screen geometry already matches what the\n   * image has to be.\n   *\n   * @param _params - Capture parameters. Ignored on mobile: `cwd` does not select a window (vault targeting is via localStorage), and the size cannot be overridden.\n   * @returns The raw PNG bytes.\n   * @throws Error if the driver returns data that is not a PNG.\n   */\n  public async captureScreenshot(_params: CaptureScreenshotParams): Promise<Uint8Array> {\n    const bytes = decodeBase64Png(await this.browser.takeScreenshot());\n    if (!isPng(bytes)) {\n      throw new Error('Appium screenshot error: takeScreenshot returned data that is not a PNG.');\n    }\n\n    return bytes;\n  }\n\n  /**\n   * Ends the Appium session.\n   *\n   * Only deletes the session if this transport owns it. Transports created\n   * via `attach()` (test workers reusing the global setup's session) skip\n   * deletion so the session remains available for the owning process.\n   */\n  public async dispose(): Promise<void> {\n    await this.disposeInputChannel();\n\n    if (this.isSessionOwner) {\n      await this.browser.deleteSession();\n    }\n  }\n\n  /**\n   * Synchronous teardown for `process.on('exit')` handlers.\n   *\n   * Only the trusted-input channel needs it: the Appium session is the owning process's to end, and an\n   * abrupt exit is exactly when the async {@link AppiumTransport.dispose} never runs \u2014 which would strand\n   * the adb port forward on the device.\n   */\n  public disposeSync(): void {\n    const channel = this.inputChannel;\n    this.inputChannel = null;\n    this.unregisterInputChannelExitHandler();\n    channel?.disposeSync();\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.\n   *\n   * Switches to the `WEBVIEW_md.obsidian` context, executes the expression,\n   * and returns the result string.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param _options - Evaluation options (cwd is not used on mobile \u2014 vault targeting is via localStorage).\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, _options: TransportEvalOptions): Promise<string> {\n    await this.ensureWebViewContext();\n    await this.ensureInputChannel();\n\n    try {\n      const result = await this.browser.execute<null | string | undefined, []>(\n        `return (${expression})`\n      );\n\n      if (result === undefined || result === null) {\n        return NO_OUTPUT;\n      }\n\n      return result;\n    } catch (error: unknown) {\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n      throw error;\n    }\n  }\n\n  /**\n   * Returns the session connection info needed to reattach to this session\n   * from another process (e.g. a test worker).\n   *\n   * @returns The session ID and device ID.\n   */\n  public getSessionInfo(): AppiumSessionInfo {\n    return {\n      deviceId: this.deviceId,\n      sessionId: this.browser.sessionId\n    };\n  }\n\n  /**\n   * Verifies that the Obsidian app is running and the WebView is available.\n   *\n   * @param _vaultPath - Not used on mobile.\n   */\n  public async preflightCheck(_vaultPath: string): Promise<void> {\n    log('[appium-transport] Running preflight check...');\n    const state = await this.browser.queryAppState(this.appId);\n    log(`[appium-transport] App state: ${String(state)} (need ${String(APP_STATE_FOREGROUND)}=foreground)`);\n    if (state !== APP_STATE_FOREGROUND) {\n      log(`[appium-transport] Activating app ${this.appId}...`);\n      this.isInWebViewContext = false;\n      await this.browser.activateApp(this.appId);\n      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);\n    }\n\n    await this.ensureWebViewContext();\n    log('[appium-transport] Preflight check passed.');\n  }\n\n  /**\n   * Pushes vault files to the device via compressed `adb push`.\n   *\n   * Creates a tar.gz archive of the local vault directory, pushes it to the\n   * device as a single file, and extracts it in-place. This avoids the\n   * webdriver `RangeError` on large base64 payloads and is significantly\n   * faster than per-file `browser.pushFile()` calls.\n   *\n   * @param vaultPath - The vault path (used as the vault directory name on device).\n   * @param _files - Map of relative file paths to content buffers (unused \u2014 adb pushes the directory directly).\n   */\n  public async pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n    const archiveName = `vault-${randomUUID()}.tar.gz`;\n    const localArchive = join(tmpdir(), archiveName);\n    const remoteArchive = `/data/local/tmp/${archiveName}`;\n\n    try {\n      log(`[appium-transport] Creating archive: ${localArchive}`);\n      await exec(['tar', 'czf', archiveName, '-C', vaultPath, '.'], { cwd: tmpdir(), isQuiet: true });\n\n      log(`[appium-transport] Pushing archive to device ${this.deviceId}...`);\n      await exec(['adb', '-s', this.deviceId, 'push', localArchive, remoteArchive], { isQuiet: true });\n\n      log(`[appium-transport] Extracting archive on device at ${deviceVaultPath}...`);\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', deviceVaultPath], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'shell', 'tar', 'xzf', remoteArchive, '-C', deviceVaultPath], { isQuiet: true });\n\n      log('[appium-transport] Flushing filesystem buffers...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'sync'], { isQuiet: true });\n\n      log('[appium-transport] Cleaning up remote archive...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'rm', remoteArchive], { isQuiet: true });\n    } finally {\n      await rm(localArchive, { force: true });\n    }\n  }\n\n  /**\n   * Dumps `adb logcat` and returns the WebView console/error output logged\n   * since the marker from {@link AppiumTransport.beginConsoleCapture}.\n   *\n   * Filters to the Chromium/WebView tags that carry JS `console.*` output and\n   * uncaught errors, and caps the result length. Bounded, post-hoc,\n   * failure-path-only \u2014 never a live monitor.\n   *\n   * @param handle - The capture handle (or `undefined` when capture never started).\n   * @returns The captured console/error text, or `undefined` if nothing relevant was logged.\n   */\n  public async readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined> {\n    if (!handle) {\n      return undefined;\n    }\n\n    const dump = await exec(\n      ['adb', '-s', this.deviceId, 'logcat', '-d', '-v', 'time'],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS }\n    );\n\n    const markerIndex = dump.lastIndexOf(handle.marker);\n    const region = markerIndex === -1 ? dump : dump.slice(markerIndex + handle.marker.length);\n    const relevant = region\n      .split('\\n')\n      .filter((line) => CONSOLE_CAPTURE_TAG_RE.test(line))\n      .join('\\n')\n      .trim();\n\n    if (!relevant) {\n      return undefined;\n    }\n\n    return relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH);\n  }\n\n  /**\n   * Registers a vault on mobile by pushing files and configuring localStorage.\n   *\n   * The registration flow:\n   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault\n   * 2. Switch to the WebView context\n   * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,\n   *    `enable-plugin-<path>`)\n   * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault\n   * 5. Wait for `globalThis.app` to exist (the app's cold start), then \u2014 on a\n   *    separate, tighter budget \u2014 for `app.workspace.layoutReady`\n   *\n   * Existing vault registrations in localStorage are preserved (append, not\n   * overwrite) \u2014 except the **harness's own** `temp-vault-*` registrations from\n   * earlier runs, which are pruned when {@link AppiumTransportConfig.shouldSweepLeftovers}\n   * is on. Their directories are already gone (the factory sweeps them before\n   * the app launches), and it is this registry \u2014 not the filesystem \u2014 that\n   * Obsidian enumerates at startup, so leaving them is what makes each failed\n   * run slow the next one down.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[appium-transport] Registering vault: ${vaultPath}`);\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    // Push a minimal .obsidian directory so Obsidian recognizes it as a vault.\n    await this.pushObsidianMarker(deviceVaultPath);\n\n    // Switch to WebView and configure localStorage.\n    await this.ensureWebViewContext();\n\n    // Invalidate before reload \u2014 the page will navigate and the WebView\n    // Context may be temporarily unavailable during reload.\n    this.isInWebViewContext = false;\n\n    const stalePrefix = this.shouldSweepLeftovers ? `${this.vaultBasePath}${TEMP_VAULT_DIR_PREFIX}` : '';\n\n    await this.browser.execute(\n      (path: string, prunePrefix: string) => {\n        let existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n\n        if (prunePrefix) {\n          const stale = existing.filter((registered) => registered !== path && registered.startsWith(prunePrefix));\n          for (const registered of stale) {\n            localStorage.removeItem(`enable-plugin-${registered}`);\n          }\n          existing = existing.filter((registered) => !stale.includes(registered));\n        }\n\n        if (!existing.includes(path)) {\n          existing.push(path);\n        }\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(existing));\n        localStorage.setItem('mobile-selected-vault', path);\n        localStorage.setItem(`enable-plugin-${path}`, 'true');\n        location.reload();\n      },\n      deviceVaultPath,\n      stalePrefix\n    );\n\n    // Wait for reload + vault initialization, as two separately budgeted phases:\n    // The app's cold start first, then Obsidian's own work. See `waitForAppStarted`.\n    await this.waitForAppStarted();\n    await this.waitForLayoutReady();\n  }\n\n  /**\n   * Unregisters a vault on mobile by removing it from localStorage.\n   *\n   * Preserves other vault registrations. If the unregistered vault was selected,\n   * switches to the first remaining vault (or clears the selection).\n   *\n   * The vault's **files are then removed from the device over `adb`, whether or\n   * not the `localStorage` step succeeded** \u2014 deliberately, because the\n   * `localStorage` step goes through the WebView and a dead WebView is exactly\n   * what most Android failures are. Routing the removal through the app was what\n   * made every failed run leak its vault (`Vault cleanup error (non-fatal): no\n   * such window`), so the filesystem-level removal must not depend on it.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    try {\n      await this.ensureWebViewContext();\n\n      await this.browser.execute((path: string) => {\n        const existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n        const filtered = existing.filter((v) => v !== path);\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(filtered));\n        localStorage.removeItem(`enable-plugin-${path}`);\n        if (localStorage.getItem('mobile-selected-vault') === path) {\n          if (filtered.length > 0) {\n            localStorage.setItem('mobile-selected-vault', filtered[0] ?? '');\n          } else {\n            localStorage.removeItem('mobile-selected-vault');\n          }\n        }\n      }, deviceVaultPath);\n    } catch (error: unknown) {\n      log(\n        `[appium-transport] Could not deregister ${deviceVaultPath} from localStorage `\n          + `(${String(error)}); removing its files anyway.`\n      );\n    }\n\n    await this.removeDeviceVaultDirectory(deviceVaultPath);\n  }\n\n  /**\n   * Closes the trusted-input channel, if one is open.\n   */\n  private async disposeInputChannel(): Promise<void> {\n    const channel = this.inputChannel;\n    this.inputChannel = null;\n    this.unregisterInputChannelExitHandler();\n    await channel?.dispose();\n  }\n\n  /**\n   * Opens the trusted-input channel if it is not already open, and re-opens it if the WebView went away.\n   *\n   * Installs a `Runtime.addBinding` function on the page and services every call to it for the life of the\n   * connection. The binding is exposed on *every* execution context of the page, so it survives the\n   * `location.reload()` that {@link AppiumTransport.registerVault} performs; only a full app restart, which\n   * destroys the WebView target, needs the reconnect below.\n   */\n  private async ensureInputChannel(): Promise<void> {\n    if (this.inputChannel?.isOpen || this.isInputChannelUnavailable) {\n      return;\n    }\n\n    // The channel is reachable only over local `adb`, so it does not exist on iOS or against a remote hub\n    // (BrowserStack). Those are supported transports, so this stays **best-effort**: a run that never\n    // Drives input must not fail because the channel could not be opened. A run that *does* drive input\n    // Gets a legible error from the renderer's own guard, which names the missing channel.\n    if (this.platform !== 'android') {\n      this.isInputChannelUnavailable = true;\n      return;\n    }\n\n    await this.disposeInputChannel();\n\n    try {\n      const connection = await connectToWebViewCdp({ appId: this.appId, deviceId: this.deviceId });\n      await connection.send('Runtime.enable');\n      await connection.send('Runtime.addBinding', { name: MOBILE_INPUT_BINDING_NAME });\n      connection.on('Runtime.bindingCalled', (params: Record<string, unknown>) => {\n        if (params['name'] !== MOBILE_INPUT_BINDING_NAME) {\n          return;\n        }\n\n        const payload = params['payload'];\n        // Deliberately not awaited: this runs while the renderer's `Execute Script` is still pending, and\n        // That is the whole point \u2014 the request is serviced concurrently and answered by resolving the\n        // Renderer's promise over this same socket. It handles its own failures, so nothing reaches here.\n        this.handleInputRequest(connection, typeof payload === 'string' ? payload : '').catch(() => {\n          // Unreachable: `handleInputRequest` never rejects.\n        });\n      });\n\n      this.inputChannel = connection;\n\n      // Self-cleaning, deliberately: this transport can be created straight from a test worker, with no\n      // `coreSetup` owning its lifecycle and therefore nothing that ever calls `dispose`/`disposeSync` \u2014\n      // Which is how a run leaves its adb port forward stranded on the device (observed 2026-08-30). The\n      // Handler is removed again on disposal so reconnects do not stack listeners.\n      this.disposeInputChannelOnExit = (): void => {\n        connection.disposeSync();\n      };\n      process.once('exit', this.disposeInputChannelOnExit);\n\n      log('[appium-transport] Trusted-input channel open.');\n    } catch (error: unknown) {\n      // Give up for the life of the transport rather than paying an `adb` round-trip on every eval.\n      // A socket that merely *closed* after a successful connect is a different case \u2014 `isOpen` is false\n      // There while this flag stays unset, so the reconnect above still runs.\n      this.isInputChannelUnavailable = true;\n      log(`[appium-transport] Trusted input is unavailable on this device: ${errorToString(error)}`);\n    }\n  }\n\n  /**\n   * Switches the driver to the `WEBVIEW_md.obsidian` context.\n   *\n   * If the context was already verified (cached via {@link isInWebViewContext}),\n   * returns immediately without calling `getContexts()` \u2014 which runs\n   * `adb shell cat /proc/net/unix` and can time out on slow emulators.\n   *\n   * Polls until the context becomes available (the app may still be loading).\n   * Uses the `WEBVIEW_md.obsidian` context specifically to avoid connecting\n   * to Chrome or other WebViews on the device.\n   */\n  private async ensureWebViewContext(): Promise<void> {\n    if (this.isInWebViewContext) {\n      return;\n    }\n\n    const deadline = Date.now() + this.webviewTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for ${WEBVIEW_CONTEXT_PREFIX} context (timeout=${String(this.webviewTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      const contexts = await this.browser.getContexts();\n      const obsidianContext = contexts.find((context): context is string => typeof context === 'string' && context.startsWith(WEBVIEW_CONTEXT_PREFIX));\n\n      if (obsidianContext) {\n        log(`[appium-transport] Found WebView context: ${obsidianContext}`);\n        try {\n          await this.browser.switchContext(obsidianContext);\n          this.isInWebViewContext = true;\n          return;\n        } catch (error: unknown) {\n          log(`[appium-transport] switchContext failed: ${String(error)}. Resetting to NATIVE_APP before retrying...`);\n          try {\n            await this.browser.switchContext('NATIVE_APP');\n          } catch (resetError: unknown) {\n            log(`[appium-transport] NATIVE_APP reset also failed: ${String(resetError)}`);\n          }\n        }\n      }\n\n      log(`[appium-transport] WebView not ready, available contexts: ${JSON.stringify(contexts)}. Retrying...`);\n      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(this.webviewTimeoutInMilliseconds)}ms. Is the Obsidian app fully loaded?`);\n  }\n\n  /**\n   * Converts a host-side vault path to the device-side path.\n   *\n   * @param vaultPath - Absolute path on the host machine.\n   * @returns The device-side vault path.\n   */\n  private getDeviceVaultPath(vaultPath: string): string {\n    return `${this.vaultBasePath}${extractVaultName(vaultPath)}`;\n  }\n\n  /**\n   * Services one input request from the renderer: inject, then resolve the renderer's promise.\n   *\n   * Every failure path still resolves that promise \u2014 with an error message the renderer re-throws \u2014 because\n   * a request that is silently dropped would hang the closure until the whole run times out, and report\n   * nothing about why.\n   *\n   * @param connection - The channel the request arrived on.\n   * @param payload - The raw JSON payload the binding was called with.\n   */\n  private async handleInputRequest(connection: WebViewCdpConnection, payload: string): Promise<void> {\n    let requestId = '';\n    try {\n      const { id, request } = JSON.parse(payload) as MobileInputEnvelope;\n      requestId = id;\n      await connection.sendAll(toCdpInputCommands(request));\n      await connection.send('Runtime.evaluate', { expression: buildResolveInputExpression(id) });\n    } catch (error: unknown) {\n      const message = errorToString(error);\n      log(`[appium-transport] Trusted input failed: ${message}`);\n      if (!requestId) {\n        return;\n      }\n\n      try {\n        await connection.send('Runtime.evaluate', { expression: buildResolveInputExpression(requestId, message) });\n      } catch {\n        // The socket is gone; the renderer's own timeout is the remaining backstop.\n      }\n    }\n  }\n\n  /**\n   * Probes the WebView once for how far Obsidian's startup has got.\n   *\n   * A probe that throws is reported as `undefined` rather than propagated: the\n   * page is mid-`location.reload()` for most of the app-start phase, and a\n   * WebView that cannot answer yet is the *expected* reading there, not an error.\n   *\n   * @returns What the probe saw, or `undefined` when it could not run.\n   */\n  private async probeStartup(): Promise<StartupProbeResult | undefined> {\n    try {\n      return await this.browser.execute((): StartupProbeResult => {\n        // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n        const app = globalThis.app as LoadingApp | undefined;\n        return {\n          hasApp: !!app,\n          hasWorkspace: !!app?.workspace,\n          isLayoutReady: !!app?.workspace?.layoutReady\n        };\n      });\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.\n   *\n   * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a\n   * cold or loaded emulator \u2014 measured at 9\u201321s per call for this 2-byte marker,\n   * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched\n   * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async pushObsidianMarker(deviceVaultPath: string): Promise<void> {\n    const localMarker = join(tmpdir(), `obsidian-marker-${randomUUID()}.json`);\n    const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;\n\n    try {\n      await writeFile(localMarker, '{}', 'utf-8');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', `${deviceVaultPath}/.obsidian`], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'push', localMarker, remoteMarker], { isQuiet: true });\n    } finally {\n      await rm(localMarker, { force: true });\n    }\n  }\n\n  /**\n   * Removes a vault directory from the device over `adb`, and CHECKS that it is\n   * actually gone.\n   *\n   * Best-effort: a failure is logged, not thrown, so a teardown problem never\n   * masks the test result. The next run's start-of-run sweep picks up whatever\n   * this could not remove.\n   *\n   * The check is the point. `rm -rf` runs with `shouldIgnoreExitCode`, so an\n   * unremoved directory used to leave no trace at all \u2014 which is how runs that\n   * passed end to end were still found to be leaking a vault apiece, invisibly,\n   * until someone counted the directories on the device by hand. A leak is now\n   * named in the log at the moment it happens.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async removeDeviceVaultDirectory(deviceVaultPath: string): Promise<void> {\n    try {\n      log(`[appium-transport] Removing vault directory from device: ${deviceVaultPath}`);\n      await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'rm', '-rf', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      const listing = await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'ls', '-d', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      if (listing.includes(deviceVaultPath)) {\n        log(\n          `[appium-transport] Warning: ${deviceVaultPath} survived removal and is now leaked residue. `\n            + 'The next run\\'s start-of-run sweep will retry it.'\n        );\n      }\n    } catch (error: unknown) {\n      log(`[appium-transport] Vault directory removal failed (non-fatal): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Drops the `process.on('exit')` handler that would otherwise close an already-closed channel, and would\n   * stack a listener per reconnect.\n   */\n  private unregisterInputChannelExitHandler(): void {\n    if (!this.disposeInputChannelOnExit) {\n      return;\n    }\n\n    process.off('exit', this.disposeInputChannelOnExit);\n    this.disposeInputChannelOnExit = null;\n  }\n\n  /**\n   * Polls until `globalThis.app` exists in the WebView \u2014 the app has finished\n   * its cold start and Obsidian's own boot has begun.\n   *\n   * This is the **first** of the two budgets spent after `location.reload()`,\n   * and the generous one. Everything it pays for is outside Obsidian's control:\n   * the WebView reloading, and a guest that may still be optimizing packages.\n   * Keeping it separate is the point of the split \u2014 the old single wall clock\n   * started here and left the tight layout budget paying for a cold start.\n   */\n  private async waitForAppStarted(): Promise<void> {\n    log(`[appium-transport] Waiting for the app to start (timeout=${String(this.appStartTimeoutInMilliseconds)}ms)...`);\n    await this.waitForStartupMilestone({\n      isSatisfied: checkAppStarted,\n      phase: 'app-start',\n      timeoutInMilliseconds: this.appStartTimeoutInMilliseconds\n    });\n  }\n\n  /**\n   * Polls until `app.workspace.layoutReady` is `true` in the WebView.\n   *\n   * The **second** budget, and the tight one: by the time it starts, the app is\n   * already up, so all it covers is Obsidian opening the vault and loading\n   * plugins \u2014 ~1s in practice, \u22648.4s under heavy host stress (**L19**).\n   */\n  private async waitForLayoutReady(): Promise<void> {\n    log(`[appium-transport] Waiting for layout ready (timeout=${String(this.layoutReadyTimeoutInMilliseconds)}ms)...`);\n    await this.waitForStartupMilestone({\n      isSatisfied: checkLayoutReady,\n      phase: 'layout-ready',\n      timeoutInMilliseconds: this.layoutReadyTimeoutInMilliseconds\n    });\n  }\n\n  /**\n   * Polls the WebView until a startup phase's milestone is satisfied, tracking\n   * the evidence that tells a slow Obsidian from a contended guest.\n   *\n   * Each poll costs exactly one `browser.execute` round-trip \u2014 deliberately not\n   * an {@link ensureWebViewContext} call, whose `getContexts()` runs\n   * `adb shell cat /proc/net/unix` and was measured at ~17s per **L19**. The\n   * round-trip is timed, and the slowest one is reported on timeout: a phase\n   * that ran out after a handful of probes each taking tens of seconds was\n   * starved by the guest, not by Obsidian.\n   *\n   * @param params - The phase, its budget, and the predicate that ends it.\n   */\n  private async waitForStartupMilestone(params: WaitForStartupMilestoneParams): Promise<void> {\n    const { isSatisfied, phase, timeoutInMilliseconds } = params;\n    const start = Date.now();\n    const deadline = start + timeoutInMilliseconds;\n\n    let furthestMilestone: AppStartupMilestone = 'no-webview';\n    let pollCount = 0;\n    let slowestRoundTripInMilliseconds = 0;\n\n    while (Date.now() < deadline) {\n      const roundTripStart = Date.now();\n      const milestone = classifyAppStartupProbe(await this.probeStartup());\n      const roundTripInMilliseconds = Date.now() - roundTripStart;\n\n      pollCount++;\n      slowestRoundTripInMilliseconds = Math.max(slowestRoundTripInMilliseconds, roundTripInMilliseconds);\n      if (compareAppStartupMilestones(milestone, furthestMilestone) > 0) {\n        furthestMilestone = milestone;\n      }\n\n      if (isSatisfied(milestone)) {\n        log(`[appium-transport] Phase \"${phase}\" satisfied after ${String(Date.now() - start)}ms (${String(pollCount)} probe(s)).`);\n        this.isInWebViewContext = true;\n        return;\n      }\n\n      log(\n        `[appium-transport] Phase \"${phase}\" not satisfied yet: ${milestone} `\n          + `(elapsed=${String(Date.now() - start)}ms, round-trip=${String(roundTripInMilliseconds)}ms). Retrying...`\n      );\n      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(buildStartupTimeoutMessage({\n      elapsedInMilliseconds: Date.now() - start,\n      milestone: furthestMilestone,\n      phase,\n      pollCount,\n      slowestRoundTripInMilliseconds,\n      timeoutInMilliseconds\n    }));\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Extracts the vault directory name from a host-side vault path.\n *\n * @param vaultPath - Absolute path on the host machine.\n * @returns The last path segment (vault directory name).\n */\nfunction extractVaultName(vaultPath: string): string {\n  const normalized = vaultPath.replace(/[\\\\/]+$/, '');\n  const lastSeparator = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\\\'));\n  return normalized.slice(lastSeparator + 1);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
