obsidian-integration-testing 5.6.0 → 6.2.0

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   * 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   * 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   * 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   * 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   * 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`), so it never steals focus. Ignored\n   * when 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   *\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   * 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 default), 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. Set `true` to watch the window (e.g. when\n   * debugging). Ignored in attach mode ({@link port} set) \u2014 the harness never\n   * moves the user's own running window.\n   *\n   * @default `false`\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   * 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

@@ -13,6 +13,18 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * Defaults to `'md.obsidian'`
      */
     readonly appId?: string;
+    /**
+     * Timeout in milliseconds for the auto-started Appium server to become ready
+     * (its `/status` endpoint to respond).
+     *
+     * Only applies when the harness auto-starts the Appium server
+     * ({@link shouldAutoStartAppium}); ignored when attaching to an
+     * already-running server. On a cold machine the `npx appium` server can take
+     * a while to finish booting, so raise this if startup times out.
+     *
+     * @default `180000`
+     */
+    readonly appiumStartTimeoutInMilliseconds?: number;
     /**
      * The Appium server URL (e.g. `'http://localhost:4723'`).
      */
@@ -35,6 +47,68 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * factory skips emulator startup and attaches to the existing session.
      */
     readonly deviceId?: string;
+    /**
+     * Timeout in milliseconds for waiting, after `sys.boot_completed`, for a
+     * harness-started emulator to become idle before the Appium session is
+     * established.
+     *
+     * `sys.boot_completed` fires *before* the guest is actually idle: package
+     * optimization and system services keep churning, so establishing the session
+     * immediately makes every one of UiAutomator2's serialized `adb` round-trips
+     * contend with that work and inflates session establishment ~3x. The factory
+     * instead waits until the boot animation has stopped and the package manager
+     * is serving, proceeding early once idle or after this budget (best-effort — a
+     * timeout logs a warning and proceeds). Set `0` to skip the wait. Only applies
+     * to a harness-started emulator, not a reused one.
+     *
+     * @default `60000`
+     */
+    readonly deviceIdleTimeoutInMilliseconds?: number;
+    /**
+     * Whether the auto-started Appium server console window is shown.
+     *
+     * When `false` (the default), the `npx appium` server process is spawned with
+     * its console window hidden (`windowsHide`), so it never steals focus. Ignored
+     * when attaching to an already-running Appium server ({@link shouldAutoStartAppium}
+     * `false`, or the server already reachable). Set `true` to see the server log window.
+     *
+     * @default `false`
+     */
+    readonly isAppiumConsoleVisible?: boolean;
+    /**
+     * Whether the auto-started Android emulator window is shown on screen.
+     *
+     * When `false` (the default), the emulator is started with `-no-window`
+     * (headless), so it never steals focus. Ignored when reusing an already-running
+     * device (nothing is launched to hide). Set `true` to watch the emulator UI.
+     *
+     * @default `false`
+     */
+    readonly isEmulatorVisible?: boolean;
+    /**
+     * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after
+     * the vault is (re)opened.
+     *
+     * Registering a vault triggers a full Obsidian re-init (`location.reload()`
+     * reopens the vault and reloads every plugin — the heaviest startup step). On
+     * a cold-booted or under-provisioned emulator that init can take a while, so
+     * this budget is the largest of the transport timeouts. Raise it further if
+     * releases still flake on slow CI emulators.
+     *
+     * @default `90000`
+     */
+    readonly layoutReadyTimeoutInMilliseconds?: number;
+    /**
+     * Timeout in milliseconds for establishing the Appium session (WebDriverIO
+     * `remote()` — UiAutomator2 server install + app launch).
+     *
+     * This is the largest and most load-sensitive step of the Android setup:
+     * on a cold or contended emulator it dominates startup and can take a few
+     * minutes. Raise it if session establishment times out under load.
+     *
+     * @default `180000`
+     */
+    readonly sessionConnectionRetryTimeoutInMilliseconds?: number;
     /**
      * An existing Appium session ID to reattach to.
      *
@@ -113,6 +187,21 @@ export interface ObsidianCdpTransportOptions {
      * @default `undefined`
      */
     readonly isHarnessOwnedInstance?: boolean | undefined;
+    /**
+     * Whether the owned desktop Obsidian window is shown on screen.
+     *
+     * When `false` (the default), the harness launches the owned instance with
+     * keep-alive Chromium flags and moves its window **off-screen** once Electron's
+     * remote bridge is available, so the run never steals focus or pops a window in
+     * front of you. Off-screen (not minimized) keeps the renderer live, so
+     * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input behave
+     * identically to a visible window. Set `true` to watch the window (e.g. when
+     * debugging). Ignored in attach mode ({@link port} set) — the harness never
+     * moves the user's own running window.
+     *
+     * @default `false`
+     */
+    readonly isObsidianAppVisible?: boolean;
     /**
      * Pins the **Electron shell** (installer build) the owned instance runs.
      *

package/dist/lib/cjs/visibility.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var visibility_exports = {};
+__export(visibility_exports, {
+  OWNED_HIDDEN_LAUNCH_FLAGS: () => OWNED_HIDDEN_LAUNCH_FLAGS,
+  resolveOwnedHiddenLaunchArgs: () => resolveOwnedHiddenLaunchArgs,
+  shouldHideAppiumConsole: () => shouldHideAppiumConsole,
+  shouldHideEmulatorWindow: () => shouldHideEmulatorWindow,
+  shouldHideObsidianApp: () => shouldHideObsidianApp
+});
+module.exports = __toCommonJS(visibility_exports);
+const OWNED_HIDDEN_LAUNCH_FLAGS = [
+  "--disable-features=CalculateNativeWinOcclusion",
+  "--disable-background-timer-throttling",
+  "--disable-backgrounding-occluded-windows",
+  "--disable-renderer-backgrounding"
+];
+function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible) {
+  return shouldHideObsidianApp(isObsidianAppVisible) ? [...OWNED_HIDDEN_LAUNCH_FLAGS] : [];
+}
+function shouldHideAppiumConsole(isAppiumConsoleVisible) {
+  return !(isAppiumConsoleVisible ?? false);
+}
+function shouldHideEmulatorWindow(isEmulatorVisible) {
+  return !(isEmulatorVisible ?? false);
+}
+function shouldHideObsidianApp(isObsidianAppVisible) {
+  return !(isObsidianAppVisible ?? false);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OWNED_HIDDEN_LAUNCH_FLAGS,
+  resolveOwnedHiddenLaunchArgs,
+  shouldHideAppiumConsole,
+  shouldHideEmulatorWindow,
+  shouldHideObsidianApp
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/visibility.d.cts

@@ -0,0 +1,61 @@
+/**
+ * @file
+ *
+ * Pure resolution of the process-visibility options — whether the launched
+ * desktop Obsidian window, Android emulator window, and Appium server console
+ * are shown on screen. All three surfaces are **hidden by default** (`is*Visible`
+ * is `false` when omitted) so an integration run never steals focus or pops
+ * windows in front of the user.
+ *
+ * Kept separate from the integration-only launch/spawn code (`transport-factory`,
+ * `transport-desktop-cdp`, `obsidian-instance`, all excluded from unit tests) so
+ * the hidden-by-default resolution stays unit-testable — those launchers need a
+ * real Obsidian / emulator / Appium server.
+ */
+/**
+ * Chromium switches passed to a **hidden** owned desktop instance.
+ *
+ * The harness hides the window by moving it **off-screen** (not minimizing it).
+ * An off-screen window still reports `visibilityState: 'visible'` to Chromium, so
+ * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input all keep
+ * working exactly as when visible — but only if Chromium never decides to
+ * background it. These flags guarantee that: native occlusion tracking is
+ * disabled and the timer/renderer backgrounding heuristics are switched off, so
+ * an off-screen (or covered) renderer is never throttled or frozen.
+ *
+ * A *minimized* window, by contrast, freezes `requestAnimationFrame` regardless
+ * of any flag (there is no surface to composite), which is why the harness moves
+ * the window off-screen rather than minimizing it.
+ */
+export declare const OWNED_HIDDEN_LAUNCH_FLAGS: string[];
+/**
+ * Resolves the extra Chromium launch args for an owned desktop instance: the
+ * {@link OWNED_HIDDEN_LAUNCH_FLAGS} when the window is hidden (the default), or
+ * an empty list when it is visible.
+ *
+ * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
+ * @returns The extra launch args (possibly empty).
+ */
+export declare function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible?: boolean): string[];
+/**
+ * Whether the auto-started Appium server console window should be hidden.
+ *
+ * @param isAppiumConsoleVisible - The resolved option value (omitted → hidden).
+ * @returns `true` when the console window should be hidden (the default).
+ */
+export declare function shouldHideAppiumConsole(isAppiumConsoleVisible?: boolean): boolean;
+/**
+ * Whether the auto-started Android emulator window should be hidden
+ * (via the emulator's `-no-window` flag).
+ *
+ * @param isEmulatorVisible - The resolved option value (omitted → hidden).
+ * @returns `true` when the emulator window should be hidden (the default).
+ */
+export declare function shouldHideEmulatorWindow(isEmulatorVisible?: boolean): boolean;
+/**
+ * Whether the owned desktop Obsidian window should be hidden (moved off-screen).
+ *
+ * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
+ * @returns `true` when the window should be hidden (the default).
+ */
+export declare function shouldHideObsidianApp(isObsidianAppVisible?: boolean): boolean;

package/dist/lib/esm/appium-session-config.d.mts

@@ -0,0 +1,44 @@
+/**
+ * @file
+ *
+ * Resolves tunable Appium server-start and session-establishment timeouts from
+ * the transport options, applying defaults. Kept separate from the
+ * integration-only `transport-factory` so the default resolution stays
+ * unit-testable (the factory itself needs a real Appium server and is excluded
+ * from unit tests).
+ */
+import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.mjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.appiumStartTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 180000;
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.sessionConnectionRetryTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;
+/**
+ * Resolves the auto-started Appium server readiness timeout, applying the
+ * default when the option is omitted.
+ *
+ * This governs how long the factory polls the auto-started Appium server's
+ * `/status` endpoint before giving up. Only relevant when the harness
+ * auto-starts the server; when attaching to an already-running server the wait
+ * is skipped entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveAppiumStartTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
+/**
+ * Resolves the Appium session connection retry timeout, applying the default
+ * when the option is omitted.
+ *
+ * This governs how long WebDriverIO's `remote()` waits for the session to be
+ * established (UiAutomator2 server install + app launch) — empirically the
+ * largest and most load-sensitive step of the Android setup, so it is the knob
+ * to raise when session establishment times out on a cold or contended emulator.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveSessionConnectionRetryTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

package/dist/lib/esm/appium-session-config.mjs

@@ -0,0 +1,15 @@
+const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
+const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 18e4;
+function resolveAppiumStartTimeoutInMilliseconds(options) {
+  return options.appiumStartTimeoutInMilliseconds ?? DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS;
+}
+function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
+  return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
+}
+export {
+  DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
+  DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
+  resolveAppiumStartTimeoutInMilliseconds,
+  resolveSessionConnectionRetryTimeoutInMilliseconds
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/connect-to-cdp.d.mts

@@ -80,6 +80,15 @@ export interface ConnectToCdpOptions {
      * @default `'localhost'`
      */
     readonly host?: string;
+    /**
+     * Whether the Obsidian window is shown on screen. Unlike the test transports
+     * (hidden by default), `connectToCdp` **defaults to `true`** — it is meant for
+     * watching/debugging a real Obsidian. Set `false` to launch it off-screen.
+     * Ignored in attach mode ({@link port} set).
+     *
+     * @default `true`
+     */
+    readonly isObsidianAppVisible?: boolean;
     /**
      * Pins the Electron shell (installer build) the owned instance runs. Accepts
      * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when

package/dist/lib/esm/connect-to-cdp.mjs

@@ -5,6 +5,7 @@ import { createTransportFromOptions } from "./transport-factory.mjs";
 const DEFAULT_CDP_HOST = "localhost";
 async function connectToCdp(options) {
   const transportOptions = {
+    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
     type: "obsidian-cdp",
     ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
     ...options?.host !== void 0 && { host: options.host },
@@ -60,4 +61,4 @@ function resolveEndpoint(transport, options) {
 export {
   connectToCdp
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * `typeIntoEditor`, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any\n   * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault\n   * path pre-bound to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AA0IzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * `typeIntoEditor`, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any\n   * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault\n   * path pre-bound to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAoJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/esm/device-readiness.d.mts

@@ -0,0 +1,55 @@
+/**
+ * @file
+ *
+ * Pure helpers for deciding when a freshly-booted Android emulator is idle
+ * enough to establish an Appium session, plus resolving the idle-wait timeout
+ * from the transport options. Kept separate from the integration-only
+ * `transport-factory` so the parsing and default resolution stay unit-testable
+ * (the factory itself needs a real emulator and is excluded from unit tests).
+ *
+ * `sys.boot_completed` fires *before* the guest is actually idle: package
+ * optimization (`dex2oat`) and system services keep churning after it, so a
+ * session established the instant it fires makes every one of UiAutomator2's
+ * serialized `adb` round-trips contend with that work and inflate ~3x. Gating
+ * the session on a later, quieter signal (the boot animation has stopped and
+ * the package manager is serving) lets it run against an idle guest instead.
+ */
+import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.mjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * Parameters for {@link checkDeviceIdle}.
+ */
+export interface CheckDeviceIdleParams {
+    /** Raw stdout of `adb shell getprop init.svc.bootanim`. */
+    readonly bootAnimationProp: string;
+    /** Raw stdout of `adb shell cmd package list packages`. */
+    readonly packageListOutput: string;
+}
+/**
+ * Decides whether a booted emulator is idle enough to start an Appium session,
+ * from the raw output of the two probe commands.
+ *
+ * The guest is considered idle once the boot animation has stopped **and** the
+ * package manager is serving (it lists at least one package). Both are binary,
+ * later-than-`sys.boot_completed` signals, so this returns `true` well after the
+ * premature boot-completed flag but without any latency thresholds.
+ *
+ * @param params - The sampled probe outputs.
+ * @returns `true` when the guest is idle enough to proceed.
+ */
+export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
+/**
+ * Resolves the post-boot device-idle wait timeout, applying the default when
+ * the option is omitted.
+ *
+ * This bounds how long the factory waits for a freshly-started emulator to
+ * become idle (see {@link checkDeviceIdle}) before establishing the session. A
+ * value of `0` skips the wait entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveDeviceIdleTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

package/dist/lib/esm/device-readiness.mjs

@@ -0,0 +1,17 @@
+const BOOT_ANIMATION_STOPPED_STATE = "stopped";
+const PACKAGE_LINE_PREFIX = "package:";
+const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 6e4;
+function checkDeviceIdle(params) {
+  const isBootAnimationStopped = params.bootAnimationProp.trim() === BOOT_ANIMATION_STOPPED_STATE;
+  const isPackageManagerReady = params.packageListOutput.split("\n").some((line) => line.trim().startsWith(PACKAGE_LINE_PREFIX));
+  return isBootAnimationStopped && isPackageManagerReady;
+}
+function resolveDeviceIdleTimeoutInMilliseconds(options) {
+  return options.deviceIdleTimeoutInMilliseconds ?? DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS;
+}
+export {
+  DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  checkDeviceIdle,
+  resolveDeviceIdleTimeoutInMilliseconds
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/emulator-args.d.mts

@@ -3,10 +3,22 @@
  *
  * Builds the argument list for spawning the Android emulator.
  */
+/**
+ * Parameters for {@link buildEmulatorArgs}.
+ */
+export interface BuildEmulatorArgsParams {
+    /** The Android Virtual Device name. */
+    readonly avdName: string;
+    /**
+     * Whether to run the emulator headless (`-no-window`), so it never steals
+     * focus. Resolved from the `isEmulatorVisible` transport option.
+     */
+    readonly isHidden: boolean;
+}
 /**
  * Builds the argument list for spawning the Android emulator.
  *
- * @param avdName - The Android Virtual Device name.
+ * @param params - The emulator argument parameters.
  * @returns The argument array to pass to the emulator binary.
  */
-export declare function buildEmulatorArgs(avdName: string): string[];
+export declare function buildEmulatorArgs(params: BuildEmulatorArgsParams): string[];

package/dist/lib/esm/emulator-args.mjs

@@ -1,8 +1,12 @@
 const DNS_SERVER = "8.8.8.8";
-function buildEmulatorArgs(avdName) {
-  return ["-avd", avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+function buildEmulatorArgs(params) {
+  const args = ["-avd", params.avdName, "-no-snapshot-save", "-dns-server", DNS_SERVER];
+  if (params.isHidden) {
+    args.push("-no-window");
+  }
+  return args;
 }
 export {
   buildEmulatorArgs
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3MudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBCdWlsZHMgdGhlIGFyZ3VtZW50IGxpc3QgZm9yIHNwYXduaW5nIHRoZSBBbmRyb2lkIGVtdWxhdG9yLlxuICovXG5cbmNvbnN0IEROU19TRVJWRVIgPSAnOC44LjguOCc7XG5cbi8qKlxuICogQnVpbGRzIHRoZSBhcmd1bWVudCBsaXN0IGZvciBzcGF3bmluZyB0aGUgQW5kcm9pZCBlbXVsYXRvci5cbiAqXG4gKiBAcGFyYW0gYXZkTmFtZSAtIFRoZSBBbmRyb2lkIFZpcnR1YWwgRGV2aWNlIG5hbWUuXG4gKiBAcmV0dXJucyBUaGUgYXJndW1lbnQgYXJyYXkgdG8gcGFzcyB0byB0aGUgZW11bGF0b3IgYmluYXJ5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRFbXVsYXRvckFyZ3MoYXZkTmFtZTogc3RyaW5nKTogc3RyaW5nW10ge1xuICByZXR1cm4gWyctYXZkJywgYXZkTmFtZSwgJy1uby1zbmFwc2hvdC1zYXZlJywgJy1kbnMtc2VydmVyJywgRE5TX1NFUlZFUl07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFNQSxNQUFNLGFBQWE7QUFRWixTQUFTLGtCQUFrQixTQUEyQjtBQUMzRCxTQUFPLENBQUMsUUFBUSxTQUFTLHFCQUFxQixlQUFlLFVBQVU7QUFDekU7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VtdWxhdG9yLWFyZ3MudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBCdWlsZHMgdGhlIGFyZ3VtZW50IGxpc3QgZm9yIHNwYXduaW5nIHRoZSBBbmRyb2lkIGVtdWxhdG9yLlxuICovXG5cbmNvbnN0IEROU19TRVJWRVIgPSAnOC44LjguOCc7XG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGJ1aWxkRW11bGF0b3JBcmdzfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZEVtdWxhdG9yQXJnc1BhcmFtcyB7XG4gIC8qKiBUaGUgQW5kcm9pZCBWaXJ0dWFsIERldmljZSBuYW1lLiAqL1xuICByZWFkb25seSBhdmROYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdG8gcnVuIHRoZSBlbXVsYXRvciBoZWFkbGVzcyAoYC1uby13aW5kb3dgKSwgc28gaXQgbmV2ZXIgc3RlYWxzXG4gICAqIGZvY3VzLiBSZXNvbHZlZCBmcm9tIHRoZSBgaXNFbXVsYXRvclZpc2libGVgIHRyYW5zcG9ydCBvcHRpb24uXG4gICAqL1xuICByZWFkb25seSBpc0hpZGRlbjogYm9vbGVhbjtcbn1cblxuLyoqXG4gKiBCdWlsZHMgdGhlIGFyZ3VtZW50IGxpc3QgZm9yIHNwYXduaW5nIHRoZSBBbmRyb2lkIGVtdWxhdG9yLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgZW11bGF0b3IgYXJndW1lbnQgcGFyYW1ldGVycy5cbiAqIEByZXR1cm5zIFRoZSBhcmd1bWVudCBhcnJheSB0byBwYXNzIHRvIHRoZSBlbXVsYXRvciBiaW5hcnkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBidWlsZEVtdWxhdG9yQXJncyhwYXJhbXM6IEJ1aWxkRW11bGF0b3JBcmdzUGFyYW1zKTogc3RyaW5nW10ge1xuICBjb25zdCBhcmdzID0gWyctYXZkJywgcGFyYW1zLmF2ZE5hbWUsICctbm8tc25hcHNob3Qtc2F2ZScsICctZG5zLXNlcnZlcicsIEROU19TRVJWRVJdO1xuICBpZiAocGFyYW1zLmlzSGlkZGVuKSB7XG4gICAgYXJncy5wdXNoKCctbm8td2luZG93Jyk7XG4gIH1cbiAgcmV0dXJuIGFyZ3M7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFNQSxNQUFNLGFBQWE7QUFzQlosU0FBUyxrQkFBa0IsUUFBMkM7QUFDM0UsUUFBTSxPQUFPLENBQUMsUUFBUSxPQUFPLFNBQVMscUJBQXFCLGVBQWUsVUFBVTtBQUNwRixNQUFJLE9BQU8sVUFBVTtBQUNuQixTQUFLLEtBQUssWUFBWTtBQUFBLEVBQ3hCO0FBQ0EsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/library.mjs

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

package/dist/lib/esm/obsidian-instance.d.mts

@@ -21,6 +21,12 @@ export interface LaunchOwnedObsidianInstanceParams {
     readonly cdpHost?: string;
     /** Absolute path to the Obsidian executable (shell) to launch. */
     readonly exePath: string;
+    /**
+     * Extra command-line args appended after `--user-data-dir` and
+     * `--remote-debugging-port` — used to pass the keep-alive Chromium flags when
+     * the instance is launched hidden (off-screen). Empty by default.
+     */
+    readonly extraArgs?: readonly string[];
     /** Absolute path to the isolated user-data dir to pass via `--user-data-dir`. */
     readonly userDataDir: string;
 }