obsidian-integration-testing 8.1.2 → 8.2.1

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

@@ -14,4 +14,4 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transport_options_exports = {};
 module.exports = __toCommonJS(transport_options_exports);
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Discriminated union types for configuring the Obsidian transport\n * via vitest `environmentOptions`.\n */\n\n/**\n * Transport options for Android testing via Appium WebView injection.\n */\nexport interface ObsidianAndroidAppiumTransportOptions {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`\n   */\n  readonly appId?: string;\n\n  /**\n   * Timeout in milliseconds for the auto-started Appium server to become ready\n   * (its `/status` endpoint to respond).\n   *\n   * Only applies when the harness auto-starts the Appium server\n   * ({@link shouldAutoStartAppium}); ignored when attaching to an\n   * already-running server. On a cold machine the `npx appium` server can take\n   * a while to finish booting, so raise this if startup times out.\n   *\n   * @default `180000`\n   */\n  readonly appiumStartTimeoutInMilliseconds?: number;\n\n  /**\n   * The Appium server URL (e.g. `'http://localhost:4723'`).\n   */\n  readonly appiumUrl: string;\n\n  /**\n   * The Android AVD (Android Virtual Device) name.\n   *\n   * The transport factory launches `emulator -avd <avdName>` as a background\n   * process and polls until the device appears. The emulator is killed\n   * on transport disposal.\n   *\n   * Run `emulator -list-avds` to see available AVD names.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device UDID to reuse (e.g. `'emulator-5554'`).\n   *\n   * Populated automatically by the global setup after the Appium session is\n   * established. When present alongside {@link sessionId}, the transport\n   * factory skips emulator startup and attaches to the existing session.\n   */\n  readonly deviceId?: string;\n\n  /**\n   * Timeout in milliseconds for waiting, after `sys.boot_completed`, for a\n   * harness-started emulator to become idle before the Appium session is\n   * established.\n   *\n   * `sys.boot_completed` fires *before* the guest is actually idle: package\n   * optimization and system services keep churning, so establishing the session\n   * immediately makes every one of UiAutomator2's serialized `adb` round-trips\n   * contend with that work and inflates session establishment ~3x. The factory\n   * instead waits until the boot animation has stopped and the package manager\n   * is serving, proceeding early once idle or after this budget (best-effort \u2014 a\n   * timeout logs a warning and proceeds). Set `0` to skip the wait. Only applies\n   * to a harness-started emulator, not a reused one.\n   *\n   * @default `60000`\n   */\n  readonly deviceIdleTimeoutInMilliseconds?: number;\n\n  /**\n   * Whether the auto-started Appium server console window is shown.\n   *\n   * When `false` (the default), the `npx appium` server process is spawned with\n   * its console window hidden (`windowsHide`) and its output discarded, so it\n   * neither steals focus nor writes to the invoking terminal. Ignored when\n   * attaching to an already-running Appium server ({@link shouldAutoStartAppium}\n   * `false`, or the server already reachable). Set `true` to see the server log window\n   * and its live output.\n   *\n   * @default `false`\n   */\n  readonly isAppiumConsoleVisible?: boolean;\n\n  /**\n   * Whether the auto-started Android emulator window is shown on screen.\n   *\n   * When `false` (the default), the emulator is started with `-no-window`\n   * (headless), so it never steals focus. Ignored when reusing an already-running\n   * device (nothing is launched to hide). Set `true` to watch the emulator UI.\n   *\n   * @default `false`\n   */\n  readonly isEmulatorVisible?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * Registering a vault triggers a full Obsidian re-init (`location.reload()`\n   * reopens the vault and reloads every plugin \u2014 the heaviest startup step). On\n   * a cold-booted or under-provisioned emulator that init can take a while, so\n   * this budget is the largest of the transport timeouts. Raise it further if\n   * releases still flake on slow CI emulators.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for establishing the Appium session (WebDriverIO\n   * `remote()` \u2014 UiAutomator2 server install + app launch).\n   *\n   * This is the largest and most load-sensitive step of the Android setup:\n   * on a cold or contended emulator it dominates startup and can take a few\n   * minutes. Raise it if session establishment times out under load.\n   *\n   * @default `180000`\n   */\n  readonly sessionConnectionRetryTimeoutInMilliseconds?: number;\n\n  /**\n   * An existing Appium session ID to reattach to.\n   *\n   * Populated automatically by the global setup and provided to test workers\n   * via the framework's context mechanism (e.g. Vitest `provide`/`inject`).\n   * When present, the transport factory uses WebDriverIO's `attach()` instead\n   * of creating a new session, avoiding duplicate Appium/ADB connections.\n   */\n  readonly sessionId?: string;\n\n  /**\n   * Whether to automatically start the Appium server if it is not reachable.\n   *\n   * When `true` (the default), the transport factory spawns `npx appium`\n   * as a background process when the preflight check fails, and kills it\n   * on transport disposal.\n   *\n   * @default `true`\n   */\n  readonly shouldAutoStartAppium?: boolean;\n\n  /**\n   * Discriminant for the transport type.\n   */\n  readonly type: 'obsidian-android-appium';\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  readonly vaultBasePath?: string;\n\n  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * On slow emulators, the ChromeDriver proxy that handles WebView commands\n   * may not be ready immediately after the Appium session starts. This timeout\n   * controls how long to poll before giving up.\n   *\n   * @default `60000`\n   */\n  readonly webviewTimeoutInMilliseconds?: number;\n}\n\n/**\n * Transport options for desktop testing via Chrome DevTools Protocol.\n *\n * This is the default desktop transport. By default the harness **launches and\n * owns an isolated Obsidian instance** in a temporary user-data dir (never\n * touching the user's Obsidian), connected over a free CDP port. Provide\n * {@link ObsidianCdpTransportOptions.port} to instead attach to an\n * already-running Obsidian.\n */\nexport interface ObsidianCdpTransportOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to 30000\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a **dead boot** of the owned\n   * instance.\n   *\n   * When an asar cannot run on the launched Electron shell (the installer\n   * version is too old for the app version), the renderer loads but never\n   * bootstraps: `document.body` stays empty and `window.app` remains\n   * `undefined` \u2014 a black screen. Rather than waiting out the full readiness\n   * timeout, the owned-vault readiness poll concludes the boot is dead once the\n   * renderer has been `document.readyState` `'complete'` for this long with no\n   * `window.app` and an empty `<body>`, and throws a\n   * `RendererFailedToInitializeError`. Only applies to an owned instance\n   * (ignored in attach mode, {@link port} set). Set `0` to disable fast-fail and\n   * restore the plain wait-out-the-readiness-timeout behavior.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   * Defaults to `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Marks {@link port} as the CDP port of a **harness-owned, isolated instance**\n   * that the global setup already launched and prepared (vault registered,\n   * plugin enabled).\n   *\n   * Populated automatically by the global setup and provided to test workers via\n   * the framework's context mechanism (e.g. Vitest `provide`/`inject`). When set,\n   * the worker **attaches** to the owned instance on {@link port} instead of\n   * launching its own, and skips the user-scope vault-registration preflight \u2014\n   * the owned instance's vault lives in an isolated user-data config, not the\n   * user-scope registry. Do not set this manually; for plain attach mode use\n   * {@link port} alone.\n   *\n   * @default `undefined`\n   */\n  readonly isHarnessOwnedInstance?: boolean | undefined;\n\n  /**\n   * Whether the owned desktop Obsidian window is shown on screen.\n   *\n   * When `false`, the harness launches the owned instance with\n   * keep-alive Chromium flags and moves its window **off-screen** once Electron's\n   * remote bridge is available, so the run never steals focus or pops a window in\n   * front of you. Off-screen (not minimized) keeps the renderer live, so\n   * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input behave\n   * identically to a visible window. Defaults to `true`; integration setup\n   * explicitly passes `false` to avoid stealing focus. Ignored in attach mode\n   * ({@link port} set) \u2014 the harness never\n   * moves the user's own running window.\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the **Electron shell** (installer build) the owned instance runs.\n   *\n   * Accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.\n   * The matching GitHub release installer is downloaded and extracted to a\n   * portable shell (cached for reuse). Public releases only \u2014 catalyst builds\n   * have no public installer. Ignored when {@link port} (attach mode) is set.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string | undefined;\n\n  /**\n   * Pins the **Obsidian app version** (asar) the owned instance runs.\n   *\n   * Accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.\n   * Versions at or above the shell version are applied as a cheap asar swap;\n   * older versions transparently use the matching installer shell. When omitted,\n   * the user's currently-installed version is used. Ignored when {@link port}\n   * (attach mode) is set.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string | undefined;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to (the\n   * `--remote-debugging-port` it was launched with). When set, the harness\n   * attaches instead of owning an instance, and the version knobs are ignored.\n   * When omitted, an owned isolated instance is launched on an automatically\n   * chosen free port (no port is hardcoded).\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot an owned instance on Linux when there is no\n   * correctly-configured setuid `chrome-sandbox` helper \u2014 e.g. a portable shell\n   * extracted from an installer, or a CI runner launching as a non-root user, in\n   * which case the renderer otherwise refuses to start. Harmless on\n   * Windows/macOS. Ignored in attach mode ({@link port} set) \u2014 the harness never\n   * relaunches the user's running instance.\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Discriminant for the transport type.\n   */\n  readonly type: 'obsidian-cdp';\n}\n\n/**\n * Discriminated union of all supported transport configurations.\n *\n * Used in vitest `environmentOptions.obsidianTransport` to select and\n * configure the transport for integration tests.\n */\nexport type ObsidianTransportOptions =\n  | ObsidianAndroidAppiumTransportOptions\n  | ObsidianCdpTransportOptions;\n"],
  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Discriminated union types for configuring the Obsidian transport\n * via vitest `environmentOptions`.\n */\n\n/**\n * Transport options for Android testing via Appium WebView injection.\n */\nexport interface ObsidianAndroidAppiumTransportOptions {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`\n   */\n  readonly appId?: string;\n\n  /**\n   * Timeout in milliseconds for the auto-started Appium server to become ready\n   * (its `/status` endpoint to respond).\n   *\n   * Only applies when the harness auto-starts the Appium server\n   * ({@link shouldAutoStartAppium}); ignored when attaching to an\n   * already-running server. On a cold machine the `npx appium` server can take\n   * a while to finish booting, so raise this if startup times out.\n   *\n   * @default `180000`\n   */\n  readonly appiumStartTimeoutInMilliseconds?: number;\n\n  /**\n   * The Appium server URL (e.g. `'http://localhost:4723'`).\n   */\n  readonly appiumUrl: string;\n\n  /**\n   * The Android AVD (Android Virtual Device) name.\n   *\n   * The transport factory launches `emulator -avd <avdName>` as a background\n   * process and polls until the device appears. The emulator is killed\n   * on transport disposal.\n   *\n   * Run `emulator -list-avds` to see available AVD names.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device UDID to reuse (e.g. `'emulator-5554'`).\n   *\n   * Populated automatically by the global setup after the Appium session is\n   * established. When present alongside {@link sessionId}, the transport\n   * factory skips emulator startup and attaches to the existing session.\n   */\n  readonly deviceId?: string;\n\n  /**\n   * Timeout in milliseconds for waiting, after `sys.boot_completed`, for a\n   * harness-started emulator to become idle before the Appium session is\n   * established.\n   *\n   * `sys.boot_completed` fires *before* the guest is actually idle: package\n   * optimization and system services keep churning, so establishing the session\n   * immediately makes every one of UiAutomator2's serialized `adb` round-trips\n   * contend with that work and inflates session establishment ~3x. The factory\n   * instead waits until the boot animation has stopped and the package manager\n   * is serving, proceeding early once idle or after this budget (best-effort \u2014 a\n   * timeout logs a warning and proceeds). Set `0` to skip the wait. Only applies\n   * to a harness-started emulator, not a reused one.\n   *\n   * @default `60000`\n   */\n  readonly deviceIdleTimeoutInMilliseconds?: number;\n\n  /**\n   * Whether the auto-started Appium server console window is shown.\n   *\n   * When `false` (the default), the `npx appium` server process is spawned with\n   * its console window hidden (`windowsHide`) and its output discarded, so it\n   * neither steals focus nor writes to the invoking terminal. Ignored when\n   * attaching to an already-running Appium server ({@link shouldAutoStartAppium}\n   * `false`, or the server already reachable). Set `true` to see the server log window\n   * and its live output.\n   *\n   * @default `false`\n   */\n  readonly isAppiumConsoleVisible?: boolean;\n\n  /**\n   * Whether the auto-started Android emulator window is shown on screen.\n   *\n   * When `false` (the default), the emulator is started with `-no-window`\n   * (headless), so it never steals focus. Ignored when reusing an already-running\n   * device (nothing is launched to hide). Set `true` to watch the emulator UI.\n   *\n   * @default `false`\n   */\n  readonly isEmulatorVisible?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * Registering a vault triggers a full Obsidian re-init (`location.reload()`\n   * reopens the vault and reloads every plugin \u2014 the heaviest startup step). On\n   * a cold-booted or under-provisioned emulator that init can take a while, so\n   * this budget is the largest of the transport timeouts. Raise it further if\n   * releases still flake on slow CI emulators.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for establishing the Appium session (WebDriverIO\n   * `remote()` \u2014 UiAutomator2 server install + app launch).\n   *\n   * This is the largest and most load-sensitive step of the Android setup:\n   * on a cold or contended emulator it dominates startup and can take a few\n   * minutes. Raise it if session establishment times out under load.\n   *\n   * @default `180000`\n   */\n  readonly sessionConnectionRetryTimeoutInMilliseconds?: number;\n\n  /**\n   * An existing Appium session ID to reattach to.\n   *\n   * Populated automatically by the global setup and provided to test workers\n   * via the framework's context mechanism (e.g. Vitest `provide`/`inject`).\n   * When present, the transport factory uses WebDriverIO's `attach()` instead\n   * of creating a new session, avoiding duplicate Appium/ADB connections.\n   */\n  readonly sessionId?: string;\n\n  /**\n   * Whether to automatically install missing Appium dependencies (the\n   * `uiautomator2` driver, and Appium itself) before auto-starting the server.\n   *\n   * When `true` (the default) and the harness is about to auto-start the Appium\n   * server ({@link shouldAutoStartAppium}), the factory first ensures Appium is\n   * installed (globally, via `npm install -g appium`) and that the\n   * `uiautomator2` driver is installed (`appium driver install uiautomator2`),\n   * installing whichever is missing. Ignored when attaching to an\n   * already-running server (nothing is auto-started, so nothing is installed) or\n   * when {@link shouldAutoStartAppium} is `false`. Set it to `false` to manage\n   * the Appium toolchain yourself and skip the machine-mutating global install.\n   *\n   * @default `true`\n   */\n  readonly shouldAutoInstallAppiumDependencies?: boolean;\n\n  /**\n   * Whether to automatically start the Appium server if it is not reachable.\n   *\n   * When `true` (the default), the transport factory spawns `npx appium`\n   * as a background process when the preflight check fails, and kills it\n   * on transport disposal.\n   *\n   * @default `true`\n   */\n  readonly shouldAutoStartAppium?: boolean;\n\n  /**\n   * Discriminant for the transport type.\n   */\n  readonly type: 'obsidian-android-appium';\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  readonly vaultBasePath?: string;\n\n  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * On slow emulators, the ChromeDriver proxy that handles WebView commands\n   * may not be ready immediately after the Appium session starts. This timeout\n   * controls how long to poll before giving up.\n   *\n   * @default `60000`\n   */\n  readonly webviewTimeoutInMilliseconds?: number;\n}\n\n/**\n * Transport options for desktop testing via Chrome DevTools Protocol.\n *\n * This is the default desktop transport. By default the harness **launches and\n * owns an isolated Obsidian instance** in a temporary user-data dir (never\n * touching the user's Obsidian), connected over a free CDP port. Provide\n * {@link ObsidianCdpTransportOptions.port} to instead attach to an\n * already-running Obsidian.\n */\nexport interface ObsidianCdpTransportOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to 30000\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a **dead boot** of the owned\n   * instance.\n   *\n   * When an asar cannot run on the launched Electron shell (the installer\n   * version is too old for the app version), the renderer loads but never\n   * bootstraps: `document.body` stays empty and `window.app` remains\n   * `undefined` \u2014 a black screen. Rather than waiting out the full readiness\n   * timeout, the owned-vault readiness poll concludes the boot is dead once the\n   * renderer has been `document.readyState` `'complete'` for this long with no\n   * `window.app` and an empty `<body>`, and throws a\n   * `RendererFailedToInitializeError`. Only applies to an owned instance\n   * (ignored in attach mode, {@link port} set). Set `0` to disable fast-fail and\n   * restore the plain wait-out-the-readiness-timeout behavior.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   * Defaults to `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Marks {@link port} as the CDP port of a **harness-owned, isolated instance**\n   * that the global setup already launched and prepared (vault registered,\n   * plugin enabled).\n   *\n   * Populated automatically by the global setup and provided to test workers via\n   * the framework's context mechanism (e.g. Vitest `provide`/`inject`). When set,\n   * the worker **attaches** to the owned instance on {@link port} instead of\n   * launching its own, and skips the user-scope vault-registration preflight \u2014\n   * the owned instance's vault lives in an isolated user-data config, not the\n   * user-scope registry. Do not set this manually; for plain attach mode use\n   * {@link port} alone.\n   *\n   * @default `undefined`\n   */\n  readonly isHarnessOwnedInstance?: boolean | undefined;\n\n  /**\n   * Whether the owned desktop Obsidian window is shown on screen.\n   *\n   * When `false`, the harness launches the owned instance with\n   * keep-alive Chromium flags and moves its window **off-screen** once Electron's\n   * remote bridge is available, so the run never steals focus or pops a window in\n   * front of you. Off-screen (not minimized) keeps the renderer live, so\n   * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input behave\n   * identically to a visible window. Defaults to `true`; integration setup\n   * explicitly passes `false` to avoid stealing focus. Ignored in attach mode\n   * ({@link port} set) \u2014 the harness never\n   * moves the user's own running window.\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the **Electron shell** (installer build) the owned instance runs.\n   *\n   * Accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.\n   * The matching GitHub release installer is downloaded and extracted to a\n   * portable shell (cached for reuse). Public releases only \u2014 catalyst builds\n   * have no public installer. Ignored when {@link port} (attach mode) is set.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string | undefined;\n\n  /**\n   * Pins the **Obsidian app version** (asar) the owned instance runs.\n   *\n   * Accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.\n   * Versions at or above the shell version are applied as a cheap asar swap;\n   * older versions transparently use the matching installer shell. When omitted,\n   * the user's currently-installed version is used. Ignored when {@link port}\n   * (attach mode) is set.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string | undefined;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to (the\n   * `--remote-debugging-port` it was launched with). When set, the harness\n   * attaches instead of owning an instance, and the version knobs are ignored.\n   * When omitted, an owned isolated instance is launched on an automatically\n   * chosen free port (no port is hardcoded).\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot an owned instance on Linux when there is no\n   * correctly-configured setuid `chrome-sandbox` helper \u2014 e.g. a portable shell\n   * extracted from an installer, or a CI runner launching as a non-root user, in\n   * which case the renderer otherwise refuses to start. Harmless on\n   * Windows/macOS. Ignored in attach mode ({@link port} set) \u2014 the harness never\n   * relaunches the user's running instance.\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Discriminant for the transport type.\n   */\n  readonly type: 'obsidian-cdp';\n}\n\n/**\n * Discriminated union of all supported transport configurations.\n *\n * Used in vitest `environmentOptions.obsidianTransport` to select and\n * configure the transport for integration tests.\n */\nexport type ObsidianTransportOptions =\n  | ObsidianAndroidAppiumTransportOptions\n  | ObsidianCdpTransportOptions;\n"],
  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
  "names": []
}


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

@@ -120,6 +120,22 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * of creating a new session, avoiding duplicate Appium/ADB connections.
      */
     readonly sessionId?: string;
+    /**
+     * Whether to automatically install missing Appium dependencies (the
+     * `uiautomator2` driver, and Appium itself) before auto-starting the server.
+     *
+     * When `true` (the default) and the harness is about to auto-start the Appium
+     * server ({@link shouldAutoStartAppium}), the factory first ensures Appium is
+     * installed (globally, via `npm install -g appium`) and that the
+     * `uiautomator2` driver is installed (`appium driver install uiautomator2`),
+     * installing whichever is missing. Ignored when attaching to an
+     * already-running server (nothing is auto-started, so nothing is installed) or
+     * when {@link shouldAutoStartAppium} is `false`. Set it to `false` to manage
+     * the Appium toolchain yourself and skip the machine-mutating global install.
+     *
+     * @default `true`
+     */
+    readonly shouldAutoInstallAppiumDependencies?: boolean;
     /**
      * Whether to automatically start the Appium server if it is not reachable.
      *

package/dist/lib/esm/appium-dependencies.d.mts

@@ -0,0 +1,55 @@
+/**
+ * @file
+ *
+ * Pure helpers for deciding whether the harness must auto-install the Appium
+ * dependencies (the `uiautomator2` driver) before it auto-starts the Appium
+ * server, plus resolving the auto-install opt-out from the transport options.
+ * Kept separate from the integration-only `transport-factory` so the parsing and
+ * default resolution stay unit-testable (the factory itself shells out to `npm`
+ * / `npx` and is excluded from unit tests).
+ */
+import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.mjs';
+/**
+ * The Appium driver name required to automate Obsidian Mobile on Android.
+ */
+export declare const UIAUTOMATOR2_DRIVER_NAME = "uiautomator2";
+/**
+ * Parameters for {@link checkIsAppiumDriverInstalled}.
+ */
+export interface CheckIsAppiumDriverInstalledParams {
+    /**
+     * Raw stdout of `appium driver list --installed --json` — a JSON object keyed
+     * by installed driver name (`{}` when none are installed).
+     */
+    readonly driverListJson: string;
+    /** The driver name to look for (e.g. {@link UIAUTOMATOR2_DRIVER_NAME}). */
+    readonly driverName: string;
+}
+/**
+ * Decides whether a given Appium driver is installed, from the raw JSON output
+ * of `appium driver list --installed --json`.
+ *
+ * `--installed` restricts the listing to installed drivers, so a driver is
+ * present exactly when its name is a key of the parsed object. Malformed or
+ * non-object output (an empty string, a log line that leaked onto stdout, a
+ * JSON primitive, `null`) is treated as "not installed" so the caller proceeds
+ * to install — the install command is only issued when this returns `false`.
+ *
+ * @param params - The sampled driver-list output and the driver name to check.
+ * @returns `true` when the driver is listed as installed.
+ */
+export declare function checkIsAppiumDriverInstalled(params: CheckIsAppiumDriverInstalledParams): boolean;
+/**
+ * Resolves whether the harness may auto-install missing Appium dependencies,
+ * applying the default when the option is omitted.
+ *
+ * This only governs the machine-mutating install step (a global `npm install -g
+ * appium` and an `appium driver install`); it is a no-op unless the harness is
+ * also auto-starting the Appium server ({@link
+ * ObsidianAndroidAppiumTransportOptions.shouldAutoStartAppium}). Set it to
+ * `false` to manage the Appium toolchain yourself.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns Whether missing Appium dependencies may be auto-installed.
+ */
+export declare function resolveShouldAutoInstallAppiumDependencies(options: ObsidianAndroidAppiumTransportOptions): boolean;

package/dist/lib/esm/appium-dependencies.mjs

@@ -0,0 +1,22 @@
+const UIAUTOMATOR2_DRIVER_NAME = "uiautomator2";
+function checkIsAppiumDriverInstalled(params) {
+  let parsed;
+  try {
+    parsed = JSON.parse(params.driverListJson);
+  } catch {
+    return false;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return false;
+  }
+  return params.driverName in parsed;
+}
+function resolveShouldAutoInstallAppiumDependencies(options) {
+  return options.shouldAutoInstallAppiumDependencies ?? true;
+}
+export {
+  UIAUTOMATOR2_DRIVER_NAME,
+  checkIsAppiumDriverInstalled,
+  resolveShouldAutoInstallAppiumDependencies
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

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

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

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

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

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