obsidian-integration-testing 16.0.0 → 17.0.0

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

@@ -47,6 +47,7 @@ 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;
+const ADB_MARKER_READ_TIMEOUT_IN_MILLISECONDS = 3e4;
 const CAP_RECOVERY_GRACE_IN_MILLISECONDS = import_eval_cap.DEFAULT_EVAL_CAP_IN_MILLISECONDS;
 const CONSOLE_CAPTURE_MARKER_TAG = "OBSIDIAN_INTEGRATION_TESTING_CAPTURE";
 const CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8e3;
@@ -314,7 +315,11 @@ class AppiumTransport {
    * Registers a vault on mobile by pushing files and configuring localStorage.
    *
    * The registration flow:
-   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault
+   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault —
+   *    **unless one is already there**, which is the usual case, since `register` pushes the
+   *    whole vault first and that carries the run's real `app.json` across. See
+   *    {@link pushObsidianMarker}: the marker is a truncating overwrite, so pushing it
+   *    unconditionally destroyed the headless defaults it had just been handed.
    * 2. Switch to the WebView context
    * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
    *    `enable-plugin-<path>`)
@@ -577,6 +582,37 @@ class AppiumTransport {
       }
     }
   }
+  /**
+   * Answers whether the device already holds a usable `app.json` at the given path.
+   *
+   * Reads the file rather than testing for it, for the reason
+   * {@link pushObsidianMarker} spells out: only output that parses as a JSON
+   * **object** counts as present, so a merged stderr, an empty file, or a read that
+   * failed outright all answer `false` and let the caller push. Never throws — a
+   * probe that cannot answer is an answer of `false`.
+   *
+   * @param remoteMarker - The device-side `app.json` path.
+   * @returns `true` when the device holds an `app.json` that parses as a JSON object.
+   */
+  async hasDeviceAppJson(remoteMarker) {
+    let output;
+    try {
+      output = await (0, import_exec.exec)(["adb", "-s", this.deviceId, "shell", "cat", remoteMarker], {
+        isQuiet: true,
+        shouldIgnoreExitCode: true,
+        timeoutInMilliseconds: ADB_MARKER_READ_TIMEOUT_IN_MILLISECONDS
+      });
+    } catch (error) {
+      (0, import_log.log)(`[appium-transport] Could not read ${remoteMarker} (treating it as absent): ${(0, import_error_to_string.errorToString)(error)}`);
+      return false;
+    }
+    try {
+      const parsed = JSON.parse(output);
+      return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+    } catch {
+      return false;
+    }
+  }
   /**
    * Probes the WebView once for how far Obsidian's startup has got.
    *
@@ -601,18 +637,52 @@ class AppiumTransport {
     }
   }
   /**
-   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.
+   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push` — but
+   * only over a device that has not got one already.
    *
    * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a
    * cold or loaded emulator — measured at 9–21s per call for this 2-byte marker,
    * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched
    * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.
    *
+   * ### Why it has to skip rather than always push
+   *
+   * `adb push` is a **truncating overwrite**, not a merge, and the marker is `{}`.
+   * `register` runs {@link pushFiles} first, which tars the whole host vault —
+   * dotfiles included — so by the time this runs the device is already holding the
+   * real `app.json` `ensureHeadlessVaultConfig` wrote for this run. Pushing the
+   * marker over it threw `alwaysUpdateLinks: true` away one call after it arrived,
+   * and Obsidian then opened the vault with the shipped default (off): every
+   * Android rename that touched links stopped on the interactive *"Update links?"*
+   * sheet, hanging the singleton `FileManager.updateQueue` behind it. That is the
+   * rename wall `src/headless-vault-config.ts` exists to remove, live on Android
+   * only, from 6.0.0 (when this push arrived) to 16.0.1. It cost two projects
+   * several runs apiece, and it surfaced as `EvalCapExceededError` naming the
+   * transport cap, which sends the reader after the waiting rather than the sheet.
+   *
+   * The marker exists solely to make Obsidian **recognize** the directory as a
+   * vault, and a real `app.json` does that better than `{}` does. So an existing
+   * one is left exactly as it is.
+   *
+   * ### Why the probe is `cat` and not the teardown's `ls -d`
+   *
+   * `adb shell` merges the device's stderr into stdout on a legacy shell protocol,
+   * and `ls`'s failure message *contains the path it was asked about* — so an
+   * `includes(path)` test can read **absent** as **present**, skip the push, and
+   * leave a genuinely unmarked vault that Obsidian will not open. Reading the file
+   * instead makes the ambiguity harmless: an error message does not parse as a JSON
+   * object, so anything unexpected falls through to the push, which is exactly the
+   * behaviour this replaces.
+   *
    * @param deviceVaultPath - The device-side vault directory path.
    */
   async pushObsidianMarker(deviceVaultPath) {
-    const localMarker = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `obsidian-marker-${(0, import_node_crypto.randomUUID)()}.json`);
     const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;
+    if (await this.hasDeviceAppJson(remoteMarker)) {
+      (0, import_log.log)(`[appium-transport] Vault marker already on the device, leaving it as it is: ${remoteMarker}`);
+      return;
+    }
+    const localMarker = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `obsidian-marker-${(0, import_node_crypto.randomUUID)()}.json`);
     try {
       await (0, import_promises.writeFile)(localMarker, "{}", "utf-8");
       await (0, import_exec.exec)(["adb", "-s", this.deviceId, "shell", "mkdir", "-p", `${deviceVaultPath}/.obsidian`], { isQuiet: true });
@@ -765,4 +835,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 {\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 {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nimport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport {\n  buildClaimInputExpression,\n  buildResolveInputExpression,\n  checkInputClaimGranted,\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   * The per-script cap, in milliseconds, this session was given as its W3C\n   * `timeouts.script` capability.\n   *\n   * Carried only so a script timeout can be reported with the number that\n   * produced it; the capability itself is set when the session is created.\n   *\n   * @default `30000`\n   */\n  scriptTimeoutInMilliseconds?: number;\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 * Extra budget granted to the ONE eval that follows a cap overrun, on top of the cap itself. The\n * abandoned closure keeps running in the guest, and Appium serializes commands per session, so the next\n * command waits out whatever is left of it. Sized at the default cap again \u2014 derived from it rather than\n * restated, so the two cannot drift \u2014 which is a pragmatic ceiling rather than a proof: a closure can\n * outrun any number picked here. It does not need to be a proof, because a guest that is still busy after\n * it simply produces another overrun on the next eval, which is granted the grace in turn \u2014 so the session\n * recovers over successive evals instead of compounding, and every one of those evals reports the same\n * honest diagnosis.\n */\nconst CAP_RECOVERY_GRACE_IN_MILLISECONDS = DEFAULT_EVAL_CAP_IN_MILLISECONDS;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing) ---\n/**\n * The `logcat` tag stamped at capture start, and the prefix of the unique marker written under it.\n *\n * Process-local rather than a protocol: `beginConsoleCapture` writes it and `readConsoleCaptureSince` searches the dump for\n * the same string, both from this constant, so the value is free to change. It only has to be unlikely to occur in an\n * unrelated log line.\n */\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OBSIDIAN_INTEGRATION_TESTING_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\n/**\n * Parameters for {@link AppiumTransport.waitForStartupMilestone}.\n */\ninterface AppiumTransportWaitForStartupMilestoneParams {\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\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 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  /**\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\n  /**\n   * Whether the previous eval ended in a cap overrun, so the next one is owed the recovery grace.\n   *\n   * The abandoned closure is still running in the guest, and Appium serializes commands per session, so\n   * the next command queues behind whatever is left of it. See {@link AppiumTransport.evaluateWithinCap}.\n   */\n  private isRecoveringFromCapOverrun = false;\n\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly scriptTimeoutInMilliseconds: number;\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.scriptTimeoutInMilliseconds = config.scriptTimeoutInMilliseconds ?? DEFAULT_EVAL_CAP_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  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `CaptureScreenshotParams` is one bag shared by the `captureScreenshot` of both transports, so no per-owner name can satisfy both.\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  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `TransportEvalOptions` is one bag shared by the `evaluate` of both transports, so no per-owner name can satisfy both.\n  public async evaluate(expression: string, _options: TransportEvalOptions): Promise<string> {\n    await this.ensureWebViewContext();\n    await this.ensureInputChannel();\n\n    try {\n      /*\n       * The cap is enforced HERE, on the Node side, and not by the `timeouts.script` capability the\n       * Session also declares. Measured on a live emulator: the capability is accepted and reads\n       * Back as 30000 in the WebView context, and nothing ever enforces it \u2014 over-cap closures in both the\n       * Sleeping and the spinning shape, with and without an explicit `setTimeouts`, ran past a 60s ceiling\n       * Without WebDriver raising `script timeout` even once. What actually happens past roughly half a\n       * Minute is worse than a late answer: the closure COMPLETES in the guest on schedule (timers armed at\n       * 30s and 40s fired within ~13ms of nominal, on a visible and focused page) and its Execute Script\n       * Response never reaches this client \u2014 so the promise below simply never settles.\n       *\n       * A hang is the one failure mode a test author cannot act on, so the wait is bounded here.\n       */\n      const result = await this.evaluateWithinCap(`return (${expression})`);\n\n      return result ?? NO_OUTPUT;\n    } catch (error: unknown) {\n      /*\n       * A cap overrun is the one failure here that says nothing about the context: the closure outstayed\n       * Its budget, the WebView is still the WebView. Resetting the flag would charge the NEXT eval a\n       * ~17s `switchContext` (**L19**) to recover from something that was never lost.\n       */\n      if (error instanceof EvalCapExceededError) {\n        throw error;\n      }\n\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n\n      /*\n       * Kept as a fast path even though this driver was measured never raising it: it costs nothing,\n       * It is the correct translation if a future driver does enforce the capability, and it keeps the two\n       * Transports reporting one error for one condition.\n       */\n      if (isScriptTimeoutError(error)) {\n        throw new EvalCapExceededError({\n          capInMilliseconds: this.scriptTimeoutInMilliseconds,\n          cause: error,\n          optionName: 'scriptTimeoutInMilliseconds',\n          transportName: 'Android (Appium)'\n        });\n      }\n\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    return relevant ? relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH) : undefined;\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   * Runs one Execute Script under the per-eval cap, raising {@link EvalCapExceededError} if it outlasts it.\n   *\n   * The cap covers the script ALONE \u2014 `ensureWebViewContext` and `ensureInputChannel` run before it,\n   * because a `switchContext` legitimately costs ~17s (**L19**) and charging that to a test's own budget\n   * would report the harness's setup as the test's overrun.\n   *\n   * The abandoned request is deliberately left in flight rather than cancelled. Nothing can cancel it:\n   * `Runtime.terminateExecution` over the transport's own CDP channel was measured releasing nothing,\n   * and a guest-side abort hook could not even be installed in time. What the same runs did show is that\n   * the session usually keeps serving \u2014 a vault read-back was answered 528ms after one such abandonment,\n   * with the session free \u2014 so bounding the wait costs a test its closure, not the rest of its suite.\n   *\n   * @param script - The script to run, already wrapped in its `return (...)`.\n   * @returns The script's result.\n   */\n  private async evaluateWithinCap(script: string): Promise<null | string | undefined> {\n    /*\n     * The eval AFTER an overrun gets a grace period on top of the cap, and this is not generosity. Appium\n     * Serializes commands per session, and an abandoned closure keeps running in the guest \u2014 so the next\n     * Command queues behind whatever is left of it and, on the bare cap, is capped in its turn. That is\n     * Measured: with the cap firing at 30s against a 40s closure, the following vault read-back failed at\n     * 30 206ms, while the same read-back issued after the closure had finished was answered in 528ms.\n     *\n     * Waiting on the abandoned request instead would not work: that promise is the one that never settles.\n     * What frees the session is the GUEST finishing, on a schedule this side cannot know \u2014 so the grace is\n     * a ceiling, not a delay. It costs nothing when the session comes back promptly, which is the norm.\n     */\n    const budgetInMilliseconds = this.isRecoveringFromCapOverrun\n      ? this.scriptTimeoutInMilliseconds + CAP_RECOVERY_GRACE_IN_MILLISECONDS\n      : this.scriptTimeoutInMilliseconds;\n    this.isRecoveringFromCapOverrun = false;\n\n    let capTimer: NodeJS.Timeout | undefined;\n\n    const cap = new Promise<never>((_resolve, reject) => {\n      capTimer = setTimeout(() => {\n        this.isRecoveringFromCapOverrun = true;\n        reject(\n          new EvalCapExceededError({\n            capInMilliseconds: budgetInMilliseconds,\n            cause: new Error(`The Appium Execute Script carrying this closure did not answer within ${String(budgetInMilliseconds)}ms.`),\n            optionName: 'scriptTimeoutInMilliseconds',\n            transportName: 'Android (Appium)'\n          })\n        );\n      }, budgetInMilliseconds);\n    });\n\n    try {\n      return await Promise.race([\n        this.browser.execute<null | string | undefined, []>(script),\n        cap\n      ]);\n    } finally {\n      if (capTimer !== undefined) {\n        clearTimeout(capTimer);\n      }\n    }\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\n      // Exactly-once across every attached host. `Runtime.bindingCalled` is broadcast to ALL attached\n      // CDP sessions, so without this each process injects the gesture again: measured 2026-09-10, a\n      // Vitest main process and its worker serviced request `id=1` in the same millisecond, and one\n      // `clickElement` reached the page as two `pointerdown` / `touchstart` pairs.\n      //\n      // A LOSER MUST RETURN SILENTLY: the winner is the one that injects and the one that resolves the\n      // renderer's promise, so answering here as well would resolve a request whose gesture this\n      // process never sent.\n      const claim = await connection.send('Runtime.evaluate', { expression: buildClaimInputExpression(id), returnByValue: true });\n      if (!checkInputClaimGranted(claim)) {\n        return;\n      }\n\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: AppiumTransportWaitForStartupMilestoneParams): 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": []
}

+//# 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 {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nimport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.cjs';\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport {\n  buildClaimInputExpression,\n  buildResolveInputExpression,\n  checkInputClaimGranted,\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   * The per-script cap, in milliseconds, this session was given as its W3C\n   * `timeouts.script` capability.\n   *\n   * Carried only so a script timeout can be reported with the number that\n   * produced it; the capability itself is set when the session is created.\n   *\n   * @default `30000`\n   */\n  scriptTimeoutInMilliseconds?: number;\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;\nconst ADB_MARKER_READ_TIMEOUT_IN_MILLISECONDS = 30_000;\n/*\n * Extra budget granted to the ONE eval that follows a cap overrun, on top of the cap itself. The\n * abandoned closure keeps running in the guest, and Appium serializes commands per session, so the next\n * command waits out whatever is left of it. Sized at the default cap again \u2014 derived from it rather than\n * restated, so the two cannot drift \u2014 which is a pragmatic ceiling rather than a proof: a closure can\n * outrun any number picked here. It does not need to be a proof, because a guest that is still busy after\n * it simply produces another overrun on the next eval, which is granted the grace in turn \u2014 so the session\n * recovers over successive evals instead of compounding, and every one of those evals reports the same\n * honest diagnosis.\n */\nconst CAP_RECOVERY_GRACE_IN_MILLISECONDS = DEFAULT_EVAL_CAP_IN_MILLISECONDS;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing) ---\n/**\n * The `logcat` tag stamped at capture start, and the prefix of the unique marker written under it.\n *\n * Process-local rather than a protocol: `beginConsoleCapture` writes it and `readConsoleCaptureSince` searches the dump for\n * the same string, both from this constant, so the value is free to change. It only has to be unlikely to occur in an\n * unrelated log line.\n */\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OBSIDIAN_INTEGRATION_TESTING_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\n/**\n * Parameters for {@link AppiumTransport.waitForStartupMilestone}.\n */\ninterface AppiumTransportWaitForStartupMilestoneParams {\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\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 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  /**\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\n  /**\n   * Whether the previous eval ended in a cap overrun, so the next one is owed the recovery grace.\n   *\n   * The abandoned closure is still running in the guest, and Appium serializes commands per session, so\n   * the next command queues behind whatever is left of it. See {@link AppiumTransport.evaluateWithinCap}.\n   */\n  private isRecoveringFromCapOverrun = false;\n\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly scriptTimeoutInMilliseconds: number;\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.scriptTimeoutInMilliseconds = config.scriptTimeoutInMilliseconds ?? DEFAULT_EVAL_CAP_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  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `CaptureScreenshotParams` is one bag shared by the `captureScreenshot` of both transports, so no per-owner name can satisfy both.\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  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Permanent: `TransportEvalOptions` is one bag shared by the `evaluate` of both transports, so no per-owner name can satisfy both.\n  public async evaluate(expression: string, _options: TransportEvalOptions): Promise<string> {\n    await this.ensureWebViewContext();\n    await this.ensureInputChannel();\n\n    try {\n      /*\n       * The cap is enforced HERE, on the Node side, and not by the `timeouts.script` capability the\n       * Session also declares. Measured on a live emulator: the capability is accepted and reads\n       * Back as 30000 in the WebView context, and nothing ever enforces it \u2014 over-cap closures in both the\n       * Sleeping and the spinning shape, with and without an explicit `setTimeouts`, ran past a 60s ceiling\n       * Without WebDriver raising `script timeout` even once. What actually happens past roughly half a\n       * Minute is worse than a late answer: the closure COMPLETES in the guest on schedule (timers armed at\n       * 30s and 40s fired within ~13ms of nominal, on a visible and focused page) and its Execute Script\n       * Response never reaches this client \u2014 so the promise below simply never settles.\n       *\n       * A hang is the one failure mode a test author cannot act on, so the wait is bounded here.\n       */\n      const result = await this.evaluateWithinCap(`return (${expression})`);\n\n      return result ?? NO_OUTPUT;\n    } catch (error: unknown) {\n      /*\n       * A cap overrun is the one failure here that says nothing about the context: the closure outstayed\n       * Its budget, the WebView is still the WebView. Resetting the flag would charge the NEXT eval a\n       * ~17s `switchContext` (**L19**) to recover from something that was never lost.\n       */\n      if (error instanceof EvalCapExceededError) {\n        throw error;\n      }\n\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n\n      /*\n       * Kept as a fast path even though this driver was measured never raising it: it costs nothing,\n       * It is the correct translation if a future driver does enforce the capability, and it keeps the two\n       * Transports reporting one error for one condition.\n       */\n      if (isScriptTimeoutError(error)) {\n        throw new EvalCapExceededError({\n          capInMilliseconds: this.scriptTimeoutInMilliseconds,\n          cause: error,\n          optionName: 'scriptTimeoutInMilliseconds',\n          transportName: 'Android (Appium)'\n        });\n      }\n\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    return relevant ? relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH) : undefined;\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 \u2014\n   *    **unless one is already there**, which is the usual case, since `register` pushes the\n   *    whole vault first and that carries the run's real `app.json` across. See\n   *    {@link pushObsidianMarker}: the marker is a truncating overwrite, so pushing it\n   *    unconditionally destroyed the headless defaults it had just been handed.\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   * Runs one Execute Script under the per-eval cap, raising {@link EvalCapExceededError} if it outlasts it.\n   *\n   * The cap covers the script ALONE \u2014 `ensureWebViewContext` and `ensureInputChannel` run before it,\n   * because a `switchContext` legitimately costs ~17s (**L19**) and charging that to a test's own budget\n   * would report the harness's setup as the test's overrun.\n   *\n   * The abandoned request is deliberately left in flight rather than cancelled. Nothing can cancel it:\n   * `Runtime.terminateExecution` over the transport's own CDP channel was measured releasing nothing,\n   * and a guest-side abort hook could not even be installed in time. What the same runs did show is that\n   * the session usually keeps serving \u2014 a vault read-back was answered 528ms after one such abandonment,\n   * with the session free \u2014 so bounding the wait costs a test its closure, not the rest of its suite.\n   *\n   * @param script - The script to run, already wrapped in its `return (...)`.\n   * @returns The script's result.\n   */\n  private async evaluateWithinCap(script: string): Promise<null | string | undefined> {\n    /*\n     * The eval AFTER an overrun gets a grace period on top of the cap, and this is not generosity. Appium\n     * Serializes commands per session, and an abandoned closure keeps running in the guest \u2014 so the next\n     * Command queues behind whatever is left of it and, on the bare cap, is capped in its turn. That is\n     * Measured: with the cap firing at 30s against a 40s closure, the following vault read-back failed at\n     * 30 206ms, while the same read-back issued after the closure had finished was answered in 528ms.\n     *\n     * Waiting on the abandoned request instead would not work: that promise is the one that never settles.\n     * What frees the session is the GUEST finishing, on a schedule this side cannot know \u2014 so the grace is\n     * a ceiling, not a delay. It costs nothing when the session comes back promptly, which is the norm.\n     */\n    const budgetInMilliseconds = this.isRecoveringFromCapOverrun\n      ? this.scriptTimeoutInMilliseconds + CAP_RECOVERY_GRACE_IN_MILLISECONDS\n      : this.scriptTimeoutInMilliseconds;\n    this.isRecoveringFromCapOverrun = false;\n\n    let capTimer: NodeJS.Timeout | undefined;\n\n    const cap = new Promise<never>((_resolve, reject) => {\n      capTimer = setTimeout(() => {\n        this.isRecoveringFromCapOverrun = true;\n        reject(\n          new EvalCapExceededError({\n            capInMilliseconds: budgetInMilliseconds,\n            cause: new Error(`The Appium Execute Script carrying this closure did not answer within ${String(budgetInMilliseconds)}ms.`),\n            optionName: 'scriptTimeoutInMilliseconds',\n            transportName: 'Android (Appium)'\n          })\n        );\n      }, budgetInMilliseconds);\n    });\n\n    try {\n      return await Promise.race([\n        this.browser.execute<null | string | undefined, []>(script),\n        cap\n      ]);\n    } finally {\n      if (capTimer !== undefined) {\n        clearTimeout(capTimer);\n      }\n    }\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\n      // Exactly-once across every attached host. `Runtime.bindingCalled` is broadcast to ALL attached\n      // CDP sessions, so without this each process injects the gesture again: measured 2026-09-10, a\n      // Vitest main process and its worker serviced request `id=1` in the same millisecond, and one\n      // `clickElement` reached the page as two `pointerdown` / `touchstart` pairs.\n      //\n      // A LOSER MUST RETURN SILENTLY: the winner is the one that injects and the one that resolves the\n      // renderer's promise, so answering here as well would resolve a request whose gesture this\n      // process never sent.\n      const claim = await connection.send('Runtime.evaluate', { expression: buildClaimInputExpression(id), returnByValue: true });\n      if (!checkInputClaimGranted(claim)) {\n        return;\n      }\n\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   * Answers whether the device already holds a usable `app.json` at the given path.\n   *\n   * Reads the file rather than testing for it, for the reason\n   * {@link pushObsidianMarker} spells out: only output that parses as a JSON\n   * **object** counts as present, so a merged stderr, an empty file, or a read that\n   * failed outright all answer `false` and let the caller push. Never throws \u2014 a\n   * probe that cannot answer is an answer of `false`.\n   *\n   * @param remoteMarker - The device-side `app.json` path.\n   * @returns `true` when the device holds an `app.json` that parses as a JSON object.\n   */\n  private async hasDeviceAppJson(remoteMarker: string): Promise<boolean> {\n    let output: string;\n    try {\n      output = await exec(['adb', '-s', this.deviceId, 'shell', 'cat', remoteMarker], {\n        isQuiet: true,\n        shouldIgnoreExitCode: true,\n        timeoutInMilliseconds: ADB_MARKER_READ_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch (error: unknown) {\n      log(`[appium-transport] Could not read ${remoteMarker} (treating it as absent): ${errorToString(error)}`);\n      return false;\n    }\n\n    try {\n      const parsed: unknown = JSON.parse(output);\n      return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed);\n    } catch {\n      return false;\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` \u2014 but\n   * only over a device that has not got one already.\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   * ### Why it has to skip rather than always push\n   *\n   * `adb push` is a **truncating overwrite**, not a merge, and the marker is `{}`.\n   * `register` runs {@link pushFiles} first, which tars the whole host vault \u2014\n   * dotfiles included \u2014 so by the time this runs the device is already holding the\n   * real `app.json` `ensureHeadlessVaultConfig` wrote for this run. Pushing the\n   * marker over it threw `alwaysUpdateLinks: true` away one call after it arrived,\n   * and Obsidian then opened the vault with the shipped default (off): every\n   * Android rename that touched links stopped on the interactive *\"Update links?\"*\n   * sheet, hanging the singleton `FileManager.updateQueue` behind it. That is the\n   * rename wall `src/headless-vault-config.ts` exists to remove, live on Android\n   * only, from 6.0.0 (when this push arrived) to 16.0.1. It cost two projects\n   * several runs apiece, and it surfaced as `EvalCapExceededError` naming the\n   * transport cap, which sends the reader after the waiting rather than the sheet.\n   *\n   * The marker exists solely to make Obsidian **recognize** the directory as a\n   * vault, and a real `app.json` does that better than `{}` does. So an existing\n   * one is left exactly as it is.\n   *\n   * ### Why the probe is `cat` and not the teardown's `ls -d`\n   *\n   * `adb shell` merges the device's stderr into stdout on a legacy shell protocol,\n   * and `ls`'s failure message *contains the path it was asked about* \u2014 so an\n   * `includes(path)` test can read **absent** as **present**, skip the push, and\n   * leave a genuinely unmarked vault that Obsidian will not open. Reading the file\n   * instead makes the ambiguity harmless: an error message does not parse as a JSON\n   * object, so anything unexpected falls through to the push, which is exactly the\n   * behaviour this replaces.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async pushObsidianMarker(deviceVaultPath: string): Promise<void> {\n    const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;\n\n    if (await this.hasDeviceAppJson(remoteMarker)) {\n      log(`[appium-transport] Vault marker already on the device, leaving it as it is: ${remoteMarker}`);\n      return;\n    }\n\n    const localMarker = join(tmpdir(), `obsidian-marker-${randomUUID()}.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: AppiumTransportWaitForStartupMilestoneParams): 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": []
}


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

@@ -303,7 +303,11 @@ export declare class AppiumTransport implements ObsidianTransport {
      * Registers a vault on mobile by pushing files and configuring localStorage.
      *
      * The registration flow:
-     * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault
+     * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault —
+     *    **unless one is already there**, which is the usual case, since `register` pushes the
+     *    whole vault first and that carries the run's real `app.json` across. See
+     *    {@link pushObsidianMarker}: the marker is a truncating overwrite, so pushing it
+     *    unconditionally destroyed the headless defaults it had just been handed.
      * 2. Switch to the WebView context
      * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
      *    `enable-plugin-<path>`)
@@ -398,6 +402,19 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param payload - The raw JSON payload the binding was called with.
      */
     private handleInputRequest;
+    /**
+     * Answers whether the device already holds a usable `app.json` at the given path.
+     *
+     * Reads the file rather than testing for it, for the reason
+     * {@link pushObsidianMarker} spells out: only output that parses as a JSON
+     * **object** counts as present, so a merged stderr, an empty file, or a read that
+     * failed outright all answer `false` and let the caller push. Never throws — a
+     * probe that cannot answer is an answer of `false`.
+     *
+     * @param remoteMarker - The device-side `app.json` path.
+     * @returns `true` when the device holds an `app.json` that parses as a JSON object.
+     */
+    private hasDeviceAppJson;
     /**
      * Probes the WebView once for how far Obsidian's startup has got.
      *
@@ -409,13 +426,43 @@ export declare class AppiumTransport implements ObsidianTransport {
      */
     private probeStartup;
     /**
-     * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.
+     * Pushes the minimal `.obsidian/app.json` vault marker via `adb push` — but
+     * only over a device that has not got one already.
      *
      * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a
      * cold or loaded emulator — measured at 9–21s per call for this 2-byte marker,
      * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched
      * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.
      *
+     * ### Why it has to skip rather than always push
+     *
+     * `adb push` is a **truncating overwrite**, not a merge, and the marker is `{}`.
+     * `register` runs {@link pushFiles} first, which tars the whole host vault —
+     * dotfiles included — so by the time this runs the device is already holding the
+     * real `app.json` `ensureHeadlessVaultConfig` wrote for this run. Pushing the
+     * marker over it threw `alwaysUpdateLinks: true` away one call after it arrived,
+     * and Obsidian then opened the vault with the shipped default (off): every
+     * Android rename that touched links stopped on the interactive *"Update links?"*
+     * sheet, hanging the singleton `FileManager.updateQueue` behind it. That is the
+     * rename wall `src/headless-vault-config.ts` exists to remove, live on Android
+     * only, from 6.0.0 (when this push arrived) to 16.0.1. It cost two projects
+     * several runs apiece, and it surfaced as `EvalCapExceededError` naming the
+     * transport cap, which sends the reader after the waiting rather than the sheet.
+     *
+     * The marker exists solely to make Obsidian **recognize** the directory as a
+     * vault, and a real `app.json` does that better than `{}` does. So an existing
+     * one is left exactly as it is.
+     *
+     * ### Why the probe is `cat` and not the teardown's `ls -d`
+     *
+     * `adb shell` merges the device's stderr into stdout on a legacy shell protocol,
+     * and `ls`'s failure message *contains the path it was asked about* — so an
+     * `includes(path)` test can read **absent** as **present**, skip the push, and
+     * leave a genuinely unmarked vault that Obsidian will not open. Reading the file
+     * instead makes the ambiguity harmless: an error message does not parse as a JSON
+     * object, so anything unexpected falls through to the push, which is exactly the
+     * behaviour this replaces.
+     *
      * @param deviceVaultPath - The device-side vault directory path.
      */
     private pushObsidianMarker;