obsidian-integration-testing 12.1.1 → 12.2.0

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

@@ -194,6 +194,33 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * @default `2000`
      */
     readonly pluginEnableRetryDelayInMilliseconds?: number;
+    /**
+     * Timeout in milliseconds for a single script executed inside Obsidian — the
+     * per-`evalInObsidian` cap on this transport.
+     *
+     * It is enforced by the transport itself, on the Node side, and is also sent as
+     * the W3C `timeouts.script` capability — but the capability is decoration.
+     * Measured on a live emulator: it is accepted and reads back as
+     * `30000` in the WebView context, and nothing ever acts on it. Over-cap
+     * closures ran past a 60s ceiling without WebDriver raising `script timeout`
+     * once, in both the sleeping and the spinning shape, with and without an
+     * explicit `setTimeouts`.
+     *
+     * What happens past roughly half a minute is worse than a late answer: the
+     * closure completes in the guest on schedule and its Execute Script response
+     * never reaches the client, so the call simply never returns. This timeout is
+     * what turns that silence into an {@link EvalCapExceededError} naming the
+     * closure as the cause.
+     *
+     * Raising it is almost never the right answer. A closure that needs to wait
+     * longer than this should not be waiting inside Obsidian at all — use
+     * `pollInObsidian`, which keeps each closure short and does the waiting
+     * from Node. The knob exists so the cap is explicit and matches
+     * {@link ObsidianCdpTransportOptions.commandTimeoutInMilliseconds} on desktop.
+     *
+     * @default `30000`
+     */
+    readonly scriptTimeoutInMilliseconds?: number;
     /**
      * Timeout in milliseconds for establishing the Appium session (WebDriverIO
      * `remote()` — UiAutomator2 server install + app launch).

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

@@ -11,4 +11,4 @@ export {
   checkIsMobileTransport,
   resolveOwnedConfigDirectory
 };
-//# 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   * Timeout in milliseconds for Obsidian Mobile to get as far as `globalThis.app`\n   * existing after the vault is (re)opened.\n   *\n   * The first of the two budgets the transport spends after `location.reload()`.\n   * It covers the app's own cold start \u2014 the WebView reloading and Obsidian's\n   * bundle coming up \u2014 which on a cold or contended guest can take minutes, and\n   * is not work {@link layoutReadyTimeoutInMilliseconds} should be sized for.\n   * Only once `globalThis.app` appears does that far tighter clock start.\n   *\n   * Splitting the two is what stops a first run after a machine restart from\n   * failing by design: the old single 90s wall clock started at the reload, so a\n   * cold app start spent it before Obsidian had begun laying anything out.\n   *\n   * @default `180000`\n   */\n  readonly appStartTimeoutInMilliseconds?: number;\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 the\n   * emulator to become idle before the Appium session is 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.\n   *\n   * Applies to a **reused** device as well as a harness-started one. A device\n   * that is merely present in `adb devices` can still be mid-`dex2oat`, and\n   * skipping the gate there is what left a run polling a churning guest until\n   * {@link layoutReadyTimeoutInMilliseconds} ran out.\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`, counted\n   * from the moment {@link appStartTimeoutInMilliseconds} is satisfied \u2014 not\n   * from the reload.\n   *\n   * The second of the two budgets the transport spends after `location.reload()`.\n   * It covers only Obsidian's own work \u2014 opening the vault and loading every\n   * plugin \u2014 once the app itself is up, which is why it can stay tight: measured\n   * at ~1s, and \u22648.4s under 12-core + disk + memory stress.\n   *\n   * Blowing it therefore means Obsidian genuinely stalled, **or** that each probe\n   * round-trip is being inflated by a busy guest. The timeout error names which,\n   * by reporting the probe count and slowest round-trip alongside the furthest\n   * startup milestone reached: a handful of probes each taking tens of seconds is\n   * a contended guest, and the knob for that is\n   * {@link deviceIdleTimeoutInMilliseconds}, not this one.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * How old a leftover **host** directory must be before\n   * {@link shouldSweepLeftovers} removes it.\n   *\n   * Governs the host-side sweep only (the `temp-vault-*` staging directories\n   * this run's machine accumulates in its temp dir). The **device** sweep is\n   * unconditional: Android runs hold the exclusive `android` setup lock, so no\n   * concurrent run can own a device vault, and an age gate there would let a\n   * vault leaked minutes ago survive into the next run \u2014 which is the failure\n   * loop the sweep exists to break. Set `0` to remove every host match too.\n   *\n   * @default `7200000`\n   */\n  readonly leftoverMaxAgeInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for waiting, after the device-idle gate, for the\n   * emulator to report a **validated default network** before the Appium session\n   * is established.\n   *\n   * A device can be idle, fully packaged and answering `adb` while still having\n   * no route: the two {@link deviceIdleTimeoutInMilliseconds} signals are\n   * satisfied well before the default network is created and validated, which\n   * lands ~80s into guest uptime. That gap is dangerous rather than merely slow\n   * \u2014 a test that reaches the network there runs to completion against a\n   * silently **empty result**, which no assertion inside the suite can tell\n   * apart from a genuinely empty response.\n   *\n   * The factory polls `dumpsys connectivity` until an active default network\n   * reports validation, proceeding early once it does or after this budget\n   * (best-effort \u2014 a timeout logs a warning naming the missing network and\n   * proceeds). Set `0` to skip the wait, e.g. for a deliberately offline AVD or\n   * a suite that never touches the network.\n   *\n   * Applies to a **reused** device as well as a harness-started one, for the\n   * same reason the idle gate does.\n   *\n   * @default `120000`\n   */\n  readonly networkReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Number of extra attempts to enable the plugin and verify it loaded, on top\n   * of the first attempt.\n   *\n   * On a freshly cold-booted emulator the plugin subsystem can still be settling\n   * when the harness enables the plugin, so the enable lands in the enabled set\n   * but the load races and fails (`\"<id>\" is in the enabled set but not loaded`).\n   * Device-idle and `layoutReady` are already awaited, so this is the narrow\n   * residual race: the harness retries the enable + load-verification this many\n   * times with exponential backoff (see\n   * {@link pluginEnableRetryDelayInMilliseconds}), forcing a genuine reload each\n   * attempt. A captured plugin load error is treated as a deterministic bug and\n   * is **not** retried. Set `0` to disable retry (a single attempt).\n   *\n   * @default `3`\n   */\n  readonly pluginEnableRetryCount?: number;\n\n  /**\n   * Base delay in milliseconds between plugin-enable attempts (see\n   * {@link pluginEnableRetryCount}).\n   *\n   * The delay grows exponentially per retry: the first retry waits this long,\n   * the second twice as long, the third four times, and so on \u2014 giving a\n   * still-settling cold guest progressively more time to become ready.\n   *\n   * @default `2000`\n   */\n  readonly pluginEnableRetryDelayInMilliseconds?: 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   * Whether the auto-started emulator may resume \u2014 and refresh \u2014 the AVD's\n   * saved boot snapshot.\n   *\n   * When `false` (the default) the emulator is started with\n   * `-no-snapshot-load -no-snapshot-save`, so every run cold-boots a guest whose\n   * state nothing carried over. That is the hermetic default a test harness\n   * owes its callers, and it is also the safe one: a snapshot the harness loads\n   * but never writes rots unnoticed, and the failure it eventually produces \u2014 a\n   * device that serves adb, accepts a session, then drops `offline` about half a\n   * minute later \u2014 is indistinguishable from a code regression. Measured on one\n   * AVD back to back, a resumed snapshot killed the guest ~90s in *every* time,\n   * while the same AVD cold-booted in 50s and stayed up.\n   *\n   * Set it to `true` on a **persistent runner** whose AVD is not shared with\n   * anything else: the emulator then both loads and saves `default_boot`, so the\n   * snapshot each run resumes is one a previous run wrote, and the ~112s cold\n   * boot is largely bought back. The trade is test isolation \u2014 a guest that\n   * carries state between runs \u2014 so it is opt-in per project, never a default.\n   * Ignored when reusing an already-running device (nothing is launched).\n   *\n   * @default `false`\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean;\n\n  /**\n   * Whether the harness removes the temporary directories earlier runs leaked.\n   *\n   * When `true` (the default), each run sweeps at start **and** at end: on the\n   * device, every `temp-vault-*` directory under {@link vaultBasePath} (plus the\n   * stale vault registrations in Obsidian Mobile's `localStorage`); on the host,\n   * the leftover `temp-vault-*` and owned `userdata-*` directories older than\n   * {@link leftoverMaxAgeInMilliseconds}.\n   *\n   * A run that dies cannot clean up after itself \u2014 its teardown goes through the\n   * WebView, and a dead WebView is what most Android failures are \u2014 so the\n   * residue accumulates and slows the next run's startup enumeration until it\n   * misses the WebView-readiness budget. The start sweep is the half that breaks\n   * that loop, because it runs before anything that can die.\n   *\n   * @default `true`\n   */\n  readonly shouldSweepLeftovers?: 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   * The vault's **config folder** \u2014 Obsidian's per-vault *Override config\n   * folder* setting, e.g. `'.obsidian-desktop'`. Must start with a dot, must not\n   * be the bare dot, and must not contain a path separator; anything else throws\n   * before Obsidian is launched, because Obsidian itself would silently\n   * substitute `.obsidian`.\n   *\n   * Needed to open a vault that keeps its settings somewhere other than\n   * `.obsidian` \u2014 a vault with a stale `.obsidian` beside the real folder would\n   * otherwise open successfully against the wrong settings and report success.\n   * The override lives in `localStorage`, keyed by vault id, and so is scoped to\n   * a user-data directory: an owned instance gets a fresh temp one and therefore\n   * inherits nothing from the user's Obsidian, however that vault is configured\n   * there.\n   *\n   * Setting it costs one extra boot phase: the instance is launched to the\n   * starter screen, the override is written in that renderer, and the vault is\n   * then opened over IPC. After the vault is ready its actual\n   * `app.vault.configDir` is read back and any mismatch throws\n   * `ConfigDirectoryFallbackError` \u2014 there is no knob to downgrade that, because a\n   * vault opened against the wrong config folder is silently the wrong vault.\n   *\n   * Only meaningful in owned mode; **ignored in attach mode** ({@link ObsidianCdpTransportOptions.port}\n   * set), where the vault is opened by the user's own Obsidian under its own\n   * config.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  readonly configDirectory?: string;\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   * How old a leftover directory must be before {@link shouldSweepLeftovers}\n   * removes it.\n   *\n   * The gate matters most on desktop: runs are deliberately **not** serialized\n   * (each owns an isolated instance), and every project on the machine shares\n   * one temp directory, so a young `temp-vault-*` / `userdata-*` directory may\n   * well belong to a run that is still in flight. Raise it if a run of yours can\n   * outlive the default; set `0` to remove every match regardless of age.\n   *\n   * @default `7200000`\n   */\n  readonly leftoverMaxAgeInMilliseconds?: number;\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   * Whether the harness removes the temporary directories earlier runs leaked.\n   *\n   * When `true` (the default), each run sweeps at start and at end for\n   * `temp-vault-*` staging directories and owned `userdata-*` instance profiles\n   * older than {@link leftoverMaxAgeInMilliseconds}. A run killed mid-flight\n   * never reaches its own cleanup, so without this the temp directory grows\n   * without bound.\n   *\n   * @default `true`\n   */\n  readonly shouldSweepLeftovers?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor (the\n   * oldest installer the app's asar can boot on) throws\n   * `IncompatibleInstallerVersionError` from version resolution, before anything\n   * is downloaded or launched. Set `false` to let the pin proceed to launch\n   * instead \u2014 where the reactive dead-boot fast-fail\n   * (`RendererFailedToInitializeError`, see {@link deadBootGraceInMilliseconds})\n   * still catches the black-screen boot, and the `'unrunnable'` verdict is\n   * surfaced as data rather than thrown. Only applies to an owned instance\n   * (ignored in attach mode, {@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a **silent asar fallback** fails fast after boot.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may not dead-boot \u2014 it can silently revert to the installer's own bundled\n   * asar and run the **wrong (older)** version behind a healthy UI. When `true`\n   * (the default), the transport verifies the running app version against the pin\n   * post-boot and throws `SilentAsarFallbackError` on a mismatch. Set `false` to\n   * let the boot proceed \u2014 the mismatch is then surfaced as data (the fallback\n   * verdict) rather than thrown. Only applies to an owned instance running a\n   * swapped-in asar (ignored in attach mode, {@link port} set, and when no asar is\n   * swapped \u2014 there is nothing to verify).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers **both** compatibility nags: the offline installer\u2194app warning (a\n   * runnable installer below the recommended floor) and the post-boot\n   * runtime-Electron warning (a live Electron below the app's recommended\n   * minimum). When `true` (the default) each fires via the harness log; set\n   * `false` to silence both \u2014 the verdicts are still computed and surfaced as\n   * data (`compatibility` / `electronCompatibility`), only the log is suppressed.\n   * Does not affect the `'unrunnable'` throw (see\n   * {@link shouldThrowOnIncompatibleInstaller}). Only applies to an owned\n   * instance (ignored in attach mode, {@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: 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\n/**\n * Whether these options describe a mobile transport.\n *\n * The same fact as {@link ObsidianTransport.isMobile}, but knowable from the options alone \u2014 so a caller\n * can act on it before paying for a device. Reading it off a live transport means booting the emulator\n * and the Appium session first, which is ~70 s to learn something the discriminant already says.\n *\n * @param options - The resolved transport options.\n * @returns `true` for a mobile transport, `false` for desktop.\n */\nexport function checkIsMobileTransport(options: ObsidianTransportOptions): boolean {\n  return options.type === 'obsidian-android-appium';\n}\n\n/**\n * The config folder a vault the harness **owns** will actually read, or `undefined` when it is\n * Obsidian's own default.\n *\n * {@link ObsidianCdpTransportOptions.configDirectory} is the only knob that moves it, and it is\n * meaningful only in owned mode: in attach mode the vault is opened by the user's own Obsidian under\n * its own config, and on Android there is no override at all. Anything the harness writes into a vault\n * before it is opened has to go where that vault will look, so this is the answer every such writer\n * needs \u2014 see `ensureHeadlessVaultConfig`.\n *\n * @param options - The resolved transport options.\n * @returns The overridden config folder name, or `undefined` for Obsidian's default.\n */\nexport function resolveOwnedConfigDirectory(options: ObsidianTransportOptions): string | undefined {\n  if (options.type !== 'obsidian-cdp' || options.port !== undefined) {\n    return undefined;\n  }\n\n  return options.configDirectory;\n}\n"],
  "mappings": "AA+kBO,SAAS,uBAAuB,SAA4C;AACjF,SAAO,QAAQ,SAAS;AAC1B;AAeO,SAAS,4BAA4B,SAAuD;AACjG,MAAI,QAAQ,SAAS,kBAAkB,QAAQ,SAAS,QAAW;AACjE,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ;AACjB;",
  "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   * Timeout in milliseconds for Obsidian Mobile to get as far as `globalThis.app`\n   * existing after the vault is (re)opened.\n   *\n   * The first of the two budgets the transport spends after `location.reload()`.\n   * It covers the app's own cold start \u2014 the WebView reloading and Obsidian's\n   * bundle coming up \u2014 which on a cold or contended guest can take minutes, and\n   * is not work {@link layoutReadyTimeoutInMilliseconds} should be sized for.\n   * Only once `globalThis.app` appears does that far tighter clock start.\n   *\n   * Splitting the two is what stops a first run after a machine restart from\n   * failing by design: the old single 90s wall clock started at the reload, so a\n   * cold app start spent it before Obsidian had begun laying anything out.\n   *\n   * @default `180000`\n   */\n  readonly appStartTimeoutInMilliseconds?: number;\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 the\n   * emulator to become idle before the Appium session is 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.\n   *\n   * Applies to a **reused** device as well as a harness-started one. A device\n   * that is merely present in `adb devices` can still be mid-`dex2oat`, and\n   * skipping the gate there is what left a run polling a churning guest until\n   * {@link layoutReadyTimeoutInMilliseconds} ran out.\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`, counted\n   * from the moment {@link appStartTimeoutInMilliseconds} is satisfied \u2014 not\n   * from the reload.\n   *\n   * The second of the two budgets the transport spends after `location.reload()`.\n   * It covers only Obsidian's own work \u2014 opening the vault and loading every\n   * plugin \u2014 once the app itself is up, which is why it can stay tight: measured\n   * at ~1s, and \u22648.4s under 12-core + disk + memory stress.\n   *\n   * Blowing it therefore means Obsidian genuinely stalled, **or** that each probe\n   * round-trip is being inflated by a busy guest. The timeout error names which,\n   * by reporting the probe count and slowest round-trip alongside the furthest\n   * startup milestone reached: a handful of probes each taking tens of seconds is\n   * a contended guest, and the knob for that is\n   * {@link deviceIdleTimeoutInMilliseconds}, not this one.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * How old a leftover **host** directory must be before\n   * {@link shouldSweepLeftovers} removes it.\n   *\n   * Governs the host-side sweep only (the `temp-vault-*` staging directories\n   * this run's machine accumulates in its temp dir). The **device** sweep is\n   * unconditional: Android runs hold the exclusive `android` setup lock, so no\n   * concurrent run can own a device vault, and an age gate there would let a\n   * vault leaked minutes ago survive into the next run \u2014 which is the failure\n   * loop the sweep exists to break. Set `0` to remove every host match too.\n   *\n   * @default `7200000`\n   */\n  readonly leftoverMaxAgeInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for waiting, after the device-idle gate, for the\n   * emulator to report a **validated default network** before the Appium session\n   * is established.\n   *\n   * A device can be idle, fully packaged and answering `adb` while still having\n   * no route: the two {@link deviceIdleTimeoutInMilliseconds} signals are\n   * satisfied well before the default network is created and validated, which\n   * lands ~80s into guest uptime. That gap is dangerous rather than merely slow\n   * \u2014 a test that reaches the network there runs to completion against a\n   * silently **empty result**, which no assertion inside the suite can tell\n   * apart from a genuinely empty response.\n   *\n   * The factory polls `dumpsys connectivity` until an active default network\n   * reports validation, proceeding early once it does or after this budget\n   * (best-effort \u2014 a timeout logs a warning naming the missing network and\n   * proceeds). Set `0` to skip the wait, e.g. for a deliberately offline AVD or\n   * a suite that never touches the network.\n   *\n   * Applies to a **reused** device as well as a harness-started one, for the\n   * same reason the idle gate does.\n   *\n   * @default `120000`\n   */\n  readonly networkReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Number of extra attempts to enable the plugin and verify it loaded, on top\n   * of the first attempt.\n   *\n   * On a freshly cold-booted emulator the plugin subsystem can still be settling\n   * when the harness enables the plugin, so the enable lands in the enabled set\n   * but the load races and fails (`\"<id>\" is in the enabled set but not loaded`).\n   * Device-idle and `layoutReady` are already awaited, so this is the narrow\n   * residual race: the harness retries the enable + load-verification this many\n   * times with exponential backoff (see\n   * {@link pluginEnableRetryDelayInMilliseconds}), forcing a genuine reload each\n   * attempt. A captured plugin load error is treated as a deterministic bug and\n   * is **not** retried. Set `0` to disable retry (a single attempt).\n   *\n   * @default `3`\n   */\n  readonly pluginEnableRetryCount?: number;\n\n  /**\n   * Base delay in milliseconds between plugin-enable attempts (see\n   * {@link pluginEnableRetryCount}).\n   *\n   * The delay grows exponentially per retry: the first retry waits this long,\n   * the second twice as long, the third four times, and so on \u2014 giving a\n   * still-settling cold guest progressively more time to become ready.\n   *\n   * @default `2000`\n   */\n  readonly pluginEnableRetryDelayInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for a single script executed inside Obsidian \u2014 the\n   * per-`evalInObsidian` cap on this transport.\n   *\n   * It is enforced by the transport itself, on the Node side, and is also sent as\n   * the W3C `timeouts.script` capability \u2014 but the capability is decoration.\n   * Measured on a live emulator: it is accepted and reads back as\n   * `30000` in the WebView context, and nothing ever acts on it. Over-cap\n   * closures ran past a 60s ceiling without WebDriver raising `script timeout`\n   * once, in both the sleeping and the spinning shape, with and without an\n   * explicit `setTimeouts`.\n   *\n   * What happens past roughly half a minute is worse than a late answer: the\n   * closure completes in the guest on schedule and its Execute Script response\n   * never reaches the client, so the call simply never returns. This timeout is\n   * what turns that silence into an {@link EvalCapExceededError} naming the\n   * closure as the cause.\n   *\n   * Raising it is almost never the right answer. A closure that needs to wait\n   * longer than this should not be waiting inside Obsidian at all \u2014 use\n   * `pollInObsidian`, which keeps each closure short and does the waiting\n   * from Node. The knob exists so the cap is explicit and matches\n   * {@link ObsidianCdpTransportOptions.commandTimeoutInMilliseconds} on desktop.\n   *\n   * @default `30000`\n   */\n  readonly scriptTimeoutInMilliseconds?: 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   * Whether the auto-started emulator may resume \u2014 and refresh \u2014 the AVD's\n   * saved boot snapshot.\n   *\n   * When `false` (the default) the emulator is started with\n   * `-no-snapshot-load -no-snapshot-save`, so every run cold-boots a guest whose\n   * state nothing carried over. That is the hermetic default a test harness\n   * owes its callers, and it is also the safe one: a snapshot the harness loads\n   * but never writes rots unnoticed, and the failure it eventually produces \u2014 a\n   * device that serves adb, accepts a session, then drops `offline` about half a\n   * minute later \u2014 is indistinguishable from a code regression. Measured on one\n   * AVD back to back, a resumed snapshot killed the guest ~90s in *every* time,\n   * while the same AVD cold-booted in 50s and stayed up.\n   *\n   * Set it to `true` on a **persistent runner** whose AVD is not shared with\n   * anything else: the emulator then both loads and saves `default_boot`, so the\n   * snapshot each run resumes is one a previous run wrote, and the ~112s cold\n   * boot is largely bought back. The trade is test isolation \u2014 a guest that\n   * carries state between runs \u2014 so it is opt-in per project, never a default.\n   * Ignored when reusing an already-running device (nothing is launched).\n   *\n   * @default `false`\n   */\n  readonly shouldReuseEmulatorSnapshot?: boolean;\n\n  /**\n   * Whether the harness removes the temporary directories earlier runs leaked.\n   *\n   * When `true` (the default), each run sweeps at start **and** at end: on the\n   * device, every `temp-vault-*` directory under {@link vaultBasePath} (plus the\n   * stale vault registrations in Obsidian Mobile's `localStorage`); on the host,\n   * the leftover `temp-vault-*` and owned `userdata-*` directories older than\n   * {@link leftoverMaxAgeInMilliseconds}.\n   *\n   * A run that dies cannot clean up after itself \u2014 its teardown goes through the\n   * WebView, and a dead WebView is what most Android failures are \u2014 so the\n   * residue accumulates and slows the next run's startup enumeration until it\n   * misses the WebView-readiness budget. The start sweep is the half that breaks\n   * that loop, because it runs before anything that can die.\n   *\n   * @default `true`\n   */\n  readonly shouldSweepLeftovers?: 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   * The vault's **config folder** \u2014 Obsidian's per-vault *Override config\n   * folder* setting, e.g. `'.obsidian-desktop'`. Must start with a dot, must not\n   * be the bare dot, and must not contain a path separator; anything else throws\n   * before Obsidian is launched, because Obsidian itself would silently\n   * substitute `.obsidian`.\n   *\n   * Needed to open a vault that keeps its settings somewhere other than\n   * `.obsidian` \u2014 a vault with a stale `.obsidian` beside the real folder would\n   * otherwise open successfully against the wrong settings and report success.\n   * The override lives in `localStorage`, keyed by vault id, and so is scoped to\n   * a user-data directory: an owned instance gets a fresh temp one and therefore\n   * inherits nothing from the user's Obsidian, however that vault is configured\n   * there.\n   *\n   * Setting it costs one extra boot phase: the instance is launched to the\n   * starter screen, the override is written in that renderer, and the vault is\n   * then opened over IPC. After the vault is ready its actual\n   * `app.vault.configDir` is read back and any mismatch throws\n   * `ConfigDirectoryFallbackError` \u2014 there is no knob to downgrade that, because a\n   * vault opened against the wrong config folder is silently the wrong vault.\n   *\n   * Only meaningful in owned mode; **ignored in attach mode** ({@link ObsidianCdpTransportOptions.port}\n   * set), where the vault is opened by the user's own Obsidian under its own\n   * config.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  readonly configDirectory?: string;\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   * How old a leftover directory must be before {@link shouldSweepLeftovers}\n   * removes it.\n   *\n   * The gate matters most on desktop: runs are deliberately **not** serialized\n   * (each owns an isolated instance), and every project on the machine shares\n   * one temp directory, so a young `temp-vault-*` / `userdata-*` directory may\n   * well belong to a run that is still in flight. Raise it if a run of yours can\n   * outlive the default; set `0` to remove every match regardless of age.\n   *\n   * @default `7200000`\n   */\n  readonly leftoverMaxAgeInMilliseconds?: number;\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   * Whether the harness removes the temporary directories earlier runs leaked.\n   *\n   * When `true` (the default), each run sweeps at start and at end for\n   * `temp-vault-*` staging directories and owned `userdata-*` instance profiles\n   * older than {@link leftoverMaxAgeInMilliseconds}. A run killed mid-flight\n   * never reaches its own cleanup, so without this the temp directory grows\n   * without bound.\n   *\n   * @default `true`\n   */\n  readonly shouldSweepLeftovers?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor (the\n   * oldest installer the app's asar can boot on) throws\n   * `IncompatibleInstallerVersionError` from version resolution, before anything\n   * is downloaded or launched. Set `false` to let the pin proceed to launch\n   * instead \u2014 where the reactive dead-boot fast-fail\n   * (`RendererFailedToInitializeError`, see {@link deadBootGraceInMilliseconds})\n   * still catches the black-screen boot, and the `'unrunnable'` verdict is\n   * surfaced as data rather than thrown. Only applies to an owned instance\n   * (ignored in attach mode, {@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a **silent asar fallback** fails fast after boot.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may not dead-boot \u2014 it can silently revert to the installer's own bundled\n   * asar and run the **wrong (older)** version behind a healthy UI. When `true`\n   * (the default), the transport verifies the running app version against the pin\n   * post-boot and throws `SilentAsarFallbackError` on a mismatch. Set `false` to\n   * let the boot proceed \u2014 the mismatch is then surfaced as data (the fallback\n   * verdict) rather than thrown. Only applies to an owned instance running a\n   * swapped-in asar (ignored in attach mode, {@link port} set, and when no asar is\n   * swapped \u2014 there is nothing to verify).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers **both** compatibility nags: the offline installer\u2194app warning (a\n   * runnable installer below the recommended floor) and the post-boot\n   * runtime-Electron warning (a live Electron below the app's recommended\n   * minimum). When `true` (the default) each fires via the harness log; set\n   * `false` to silence both \u2014 the verdicts are still computed and surfaced as\n   * data (`compatibility` / `electronCompatibility`), only the log is suppressed.\n   * Does not affect the `'unrunnable'` throw (see\n   * {@link shouldThrowOnIncompatibleInstaller}). Only applies to an owned\n   * instance (ignored in attach mode, {@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: 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\n/**\n * Whether these options describe a mobile transport.\n *\n * The same fact as {@link ObsidianTransport.isMobile}, but knowable from the options alone \u2014 so a caller\n * can act on it before paying for a device. Reading it off a live transport means booting the emulator\n * and the Appium session first, which is ~70 s to learn something the discriminant already says.\n *\n * @param options - The resolved transport options.\n * @returns `true` for a mobile transport, `false` for desktop.\n */\nexport function checkIsMobileTransport(options: ObsidianTransportOptions): boolean {\n  return options.type === 'obsidian-android-appium';\n}\n\n/**\n * The config folder a vault the harness **owns** will actually read, or `undefined` when it is\n * Obsidian's own default.\n *\n * {@link ObsidianCdpTransportOptions.configDirectory} is the only knob that moves it, and it is\n * meaningful only in owned mode: in attach mode the vault is opened by the user's own Obsidian under\n * its own config, and on Android there is no override at all. Anything the harness writes into a vault\n * before it is opened has to go where that vault will look, so this is the answer every such writer\n * needs \u2014 see `ensureHeadlessVaultConfig`.\n *\n * @param options - The resolved transport options.\n * @returns The overridden config folder name, or `undefined` for Obsidian's default.\n */\nexport function resolveOwnedConfigDirectory(options: ObsidianTransportOptions): string | undefined {\n  if (options.type !== 'obsidian-cdp' || options.port !== undefined) {\n    return undefined;\n  }\n\n  return options.configDirectory;\n}\n"],
  "mappings": "AA2mBO,SAAS,uBAAuB,SAA4C;AACjF,SAAO,QAAQ,SAAS;AAC1B;AAeO,SAAS,4BAA4B,SAAuD;AACjG,MAAI,QAAQ,SAAS,kBAAkB,QAAQ,SAAS,QAAW;AACjE,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ;AACjB;",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "12.1.1",
+  "version": "12.2.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -172,7 +172,7 @@
     "glob": "^13.0.6",
     "js-yaml": "4.3.2",
     "lodash": "4.18.1",
-    "markdown-it": "^15.0.1",
+    "markdown-it": "^15.0.2",
     "readdir-glob": "^3.0.0",
     "smol-toml": "^1.8.0",
     "test-exclude": "^8.0.0",
@@ -215,7 +215,7 @@
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-astro": "^3.1.0",
     "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsdoc": "^64.3.8",
+    "eslint-plugin-jsdoc": "^64.3.9",
     "eslint-plugin-perfectionist": "^5.11.0",
     "eslint-plugin-tsdoc": "^0.5.2",
     "eslint-plugin-unicorn": "^74.0.0",
@@ -242,7 +242,7 @@
     "typescript": "6.0.3",
     "typescript-eslint": "^8.70.0",
     "unist-util-visit": "^5.1.0",
-    "vite": "^8.2.2",
+    "vite": "^8.3.0",
     "vitest": "^5.0.0",
     "yaml": "^2.9.0"
   },