obsidian-integration-testing 11.0.0 → 12.1.0

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

@@ -29,6 +29,23 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * The Appium server URL (e.g. `'http://localhost:4723'`).
      */
     readonly appiumUrl: string;
+    /**
+     * Timeout in milliseconds for Obsidian Mobile to get as far as `globalThis.app`
+     * existing after the vault is (re)opened.
+     *
+     * The first of the two budgets the transport spends after `location.reload()`.
+     * It covers the app's own cold start — the WebView reloading and Obsidian's
+     * bundle coming up — which on a cold or contended guest can take minutes, and
+     * is not work {@link layoutReadyTimeoutInMilliseconds} should be sized for.
+     * Only once `globalThis.app` appears does that far tighter clock start.
+     *
+     * Splitting the two is what stops a first run after a machine restart from
+     * failing by design: the old single 90s wall clock started at the reload, so a
+     * cold app start spent it before Obsidian had begun laying anything out.
+     *
+     * @default `180000`
+     */
+    readonly appStartTimeoutInMilliseconds?: number;
     /**
      * The Android AVD (Android Virtual Device) name.
      *
@@ -48,9 +65,8 @@ export interface ObsidianAndroidAppiumTransportOptions {
      */
     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.
+     * Timeout in milliseconds for waiting, after `sys.boot_completed`, for the
+     * 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
@@ -58,8 +74,12 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * 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.
+     * timeout logs a warning and proceeds). Set `0` to skip the wait.
+     *
+     * Applies to a **reused** device as well as a harness-started one. A device
+     * that is merely present in `adb devices` can still be mid-`dex2oat`, and
+     * skipping the gate there is what left a run polling a churning guest until
+     * {@link layoutReadyTimeoutInMilliseconds} ran out.
      *
      * @default `60000`
      */
@@ -88,14 +108,21 @@ export interface ObsidianAndroidAppiumTransportOptions {
      */
     readonly isEmulatorVisible?: boolean;
     /**
-     * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after
-     * the vault is (re)opened.
+     * Timeout in milliseconds for waiting for `app.workspace.layoutReady`, counted
+     * from the moment {@link appStartTimeoutInMilliseconds} is satisfied — not
+     * from the reload.
+     *
+     * The second of the two budgets the transport spends after `location.reload()`.
+     * It covers only Obsidian's own work — opening the vault and loading every
+     * plugin — once the app itself is up, which is why it can stay tight: measured
+     * at ~1s, and ≤8.4s under 12-core + disk + memory stress.
      *
-     * 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.
+     * Blowing it therefore means Obsidian genuinely stalled, **or** that each probe
+     * round-trip is being inflated by a busy guest. The timeout error names which,
+     * by reporting the probe count and slowest round-trip alongside the furthest
+     * startup milestone reached: a handful of probes each taking tens of seconds is
+     * a contended guest, and the knob for that is
+     * {@link deviceIdleTimeoutInMilliseconds}, not this one.
      *
      * @default `90000`
      */
@@ -114,6 +141,31 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * @default `7200000`
      */
     readonly leftoverMaxAgeInMilliseconds?: number;
+    /**
+     * Timeout in milliseconds for waiting, after the device-idle gate, for the
+     * emulator to report a **validated default network** before the Appium session
+     * is established.
+     *
+     * A device can be idle, fully packaged and answering `adb` while still having
+     * no route: the two {@link deviceIdleTimeoutInMilliseconds} signals are
+     * satisfied well before the default network is created and validated, which
+     * lands ~80s into guest uptime. That gap is dangerous rather than merely slow
+     * — a test that reaches the network there runs to completion against a
+     * silently **empty result**, which no assertion inside the suite can tell
+     * apart from a genuinely empty response.
+     *
+     * The factory polls `dumpsys connectivity` until an active default network
+     * reports validation, proceeding early once it does or after this budget
+     * (best-effort — a timeout logs a warning naming the missing network and
+     * proceeds). Set `0` to skip the wait, e.g. for a deliberately offline AVD or
+     * a suite that never touches the network.
+     *
+     * Applies to a **reused** device as well as a harness-started one, for the
+     * same reason the idle gate does.
+     *
+     * @default `120000`
+     */
+    readonly networkReadyTimeoutInMilliseconds?: number;
     /**
      * Number of extra attempts to enable the plugin and verify it loaded, on top
      * of the first attempt.
@@ -188,6 +240,30 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * @default `true`
      */
     readonly shouldAutoStartAppium?: boolean;
+    /**
+     * Whether the auto-started emulator may resume — and refresh — the AVD's
+     * saved boot snapshot.
+     *
+     * When `false` (the default) the emulator is started with
+     * `-no-snapshot-load -no-snapshot-save`, so every run cold-boots a guest whose
+     * state nothing carried over. That is the hermetic default a test harness
+     * owes its callers, and it is also the safe one: a snapshot the harness loads
+     * but never writes rots unnoticed, and the failure it eventually produces — a
+     * device that serves adb, accepts a session, then drops `offline` about half a
+     * minute later — is indistinguishable from a code regression. Measured on one
+     * AVD back to back, a resumed snapshot killed the guest ~90s in *every* time,
+     * while the same AVD cold-booted in 50s and stayed up.
+     *
+     * Set it to `true` on a **persistent runner** whose AVD is not shared with
+     * anything else: the emulator then both loads and saves `default_boot`, so the
+     * snapshot each run resumes is one a previous run wrote, and the ~112s cold
+     * boot is largely bought back. The trade is test isolation — a guest that
+     * carries state between runs — so it is opt-in per project, never a default.
+     * Ignored when reusing an already-running device (nothing is launched).
+     *
+     * @default `false`
+     */
+    readonly shouldReuseEmulatorSnapshot?: boolean;
     /**
      * Whether the harness removes the temporary directories earlier runs leaked.
      *
@@ -244,6 +320,35 @@ export interface ObsidianCdpTransportOptions {
      * Defaults to 30000
      */
     readonly commandTimeoutInMilliseconds?: number;
+    /**
+     * The vault's **config folder** — Obsidian's per-vault *Override config
+     * folder* setting, e.g. `'.obsidian-desktop'`. Must start with a dot, must not
+     * be the bare dot, and must not contain a path separator; anything else throws
+     * before Obsidian is launched, because Obsidian itself would silently
+     * substitute `.obsidian`.
+     *
+     * Needed to open a vault that keeps its settings somewhere other than
+     * `.obsidian` — a vault with a stale `.obsidian` beside the real folder would
+     * otherwise open successfully against the wrong settings and report success.
+     * The override lives in `localStorage`, keyed by vault id, and so is scoped to
+     * a user-data directory: an owned instance gets a fresh temp one and therefore
+     * inherits nothing from the user's Obsidian, however that vault is configured
+     * there.
+     *
+     * Setting it costs one extra boot phase: the instance is launched to the
+     * starter screen, the override is written in that renderer, and the vault is
+     * then opened over IPC. After the vault is ready its actual
+     * `app.vault.configDir` is read back and any mismatch throws
+     * `ConfigDirectoryFallbackError` — there is no knob to downgrade that, because a
+     * vault opened against the wrong config folder is silently the wrong vault.
+     *
+     * Only meaningful in owned mode; **ignored in attach mode** ({@link ObsidianCdpTransportOptions.port}
+     * set), where the vault is opened by the user's own Obsidian under its own
+     * config.
+     *
+     * @default `undefined` (Obsidian's own default, `.obsidian`)
+     */
+    readonly configDirectory?: string;
     /**
      * Grace window in milliseconds for fast-failing a **dead boot** of the owned
      * instance.
@@ -442,3 +547,17 @@ export type ObsidianTransportOptions = ObsidianAndroidAppiumTransportOptions | O
  * @returns `true` for a mobile transport, `false` for desktop.
  */
 export declare function checkIsMobileTransport(options: ObsidianTransportOptions): boolean;
+/**
+ * The config folder a vault the harness **owns** will actually read, or `undefined` when it is
+ * Obsidian's own default.
+ *
+ * {@link ObsidianCdpTransportOptions.configDirectory} is the only knob that moves it, and it is
+ * meaningful only in owned mode: in attach mode the vault is opened by the user's own Obsidian under
+ * its own config, and on Android there is no override at all. Anything the harness writes into a vault
+ * before it is opened has to go where that vault will look, so this is the answer every such writer
+ * needs — see `ensureHeadlessVaultConfig`.
+ *
+ * @param options - The resolved transport options.
+ * @returns The overridden config folder name, or `undefined` for Obsidian's default.
+ */
+export declare function resolveOwnedConfigDirectory(options: ObsidianTransportOptions): string | undefined;

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

@@ -1,7 +1,14 @@
 function checkIsMobileTransport(options) {
   return options.type === "obsidian-android-appium";
 }
+function resolveOwnedConfigDirectory(options) {
+  if (options.type !== "obsidian-cdp" || options.port !== void 0) {
+    return void 0;
+  }
+  return options.configDirectory;
+}
 export {
-  checkIsMobileTransport
+  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   * The Android AVD (Android Virtual Device) name.\n   *\n   * The transport factory launches `emulator -avd <avdName>` as a background\n   * process and polls until the device appears. The emulator is killed\n   * on transport disposal.\n   *\n   * Run `emulator -list-avds` to see available AVD names.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device UDID to reuse (e.g. `'emulator-5554'`).\n   *\n   * Populated automatically by the global setup after the Appium session is\n   * established. When present alongside {@link sessionId}, the transport\n   * factory skips emulator startup and attaches to the existing session.\n   */\n  readonly deviceId?: string;\n\n  /**\n   * Timeout in milliseconds for waiting, after `sys.boot_completed`, for a\n   * harness-started emulator to become idle before the Appium session is\n   * established.\n   *\n   * `sys.boot_completed` fires *before* the guest is actually idle: package\n   * optimization and system services keep churning, so establishing the session\n   * immediately makes every one of UiAutomator2's serialized `adb` round-trips\n   * contend with that work and inflates session establishment ~3x. The factory\n   * instead waits until the boot animation has stopped and the package manager\n   * is serving, proceeding early once idle or after this budget (best-effort \u2014 a\n   * timeout logs a warning and proceeds). Set `0` to skip the wait. Only applies\n   * to a harness-started emulator, not a reused one.\n   *\n   * @default `60000`\n   */\n  readonly deviceIdleTimeoutInMilliseconds?: number;\n\n  /**\n   * Whether the auto-started Appium server console window is shown.\n   *\n   * When `false` (the default), the `npx appium` server process is spawned with\n   * its console window hidden (`windowsHide`) and its output discarded, so it\n   * neither steals focus nor writes to the invoking terminal. Ignored when\n   * attaching to an already-running Appium server ({@link shouldAutoStartAppium}\n   * `false`, or the server already reachable). Set `true` to see the server log window\n   * and its live output.\n   *\n   * @default `false`\n   */\n  readonly isAppiumConsoleVisible?: boolean;\n\n  /**\n   * Whether the auto-started Android emulator window is shown on screen.\n   *\n   * When `false` (the default), the emulator is started with `-no-window`\n   * (headless), so it never steals focus. Ignored when reusing an already-running\n   * device (nothing is launched to hide). Set `true` to watch the emulator UI.\n   *\n   * @default `false`\n   */\n  readonly isEmulatorVisible?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * Registering a vault triggers a full Obsidian re-init (`location.reload()`\n   * reopens the vault and reloads every plugin \u2014 the heaviest startup step). On\n   * a cold-booted or under-provisioned emulator that init can take a while, so\n   * this budget is the largest of the transport timeouts. Raise it further if\n   * releases still flake on slow CI emulators.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * 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   * 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 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   * 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"],
  "mappings": "AAkeO,SAAS,uBAAuB,SAA4C;AACjF,SAAO,QAAQ,SAAS;AAC1B;",
  "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 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": []
}


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

@@ -120,7 +120,13 @@ export interface ObsidianTransport {
      * Registers a vault path so Obsidian can target it.
      *
      * On desktop: uses Electron IPC to open the vault and polls for readiness.
-     * On mobile: pushes vault files to the device and restarts the app.
+     * On mobile: pushes only a minimal `.obsidian` marker so the folder is recognized as a vault,
+     * points the app's `localStorage` at it, and reloads.
+     *
+     * It does **not** carry the vault's contents across on either platform — that is
+     * {@link ObsidianTransport.pushFiles}' job, which `TemporaryVault.register` runs first. A caller
+     * driving a transport directly has to push before registering, or the app opens an empty vault
+     * with nothing raised to say so.
      *
      * @param vaultPath - The absolute path to the vault folder.
      */

package/dist/lib/esm/vault-plugin-install.d.mts

@@ -0,0 +1,64 @@
+/**
+ * @file
+ *
+ * Installs a built plugin into a **harness-owned** vault's config folder, before
+ * that vault is ever opened: the build output into
+ * `<configDirectory>/plugins/<pluginId>/`, and the id into
+ * `<configDirectory>/community-plugins.json` so Obsidian enables it on load.
+ *
+ * Carved out of `global-setup-core`'s `copyPluginIntoVault` for the same reason
+ * `ensureHeadlessVaultConfig` was carved out of the `app.json` write: the write
+ * has to go where the vault will actually look, and a `configDirectory` override
+ * moves that. `copyPluginIntoVault` still owns the parts around it — resolving
+ * `dist/dev` vs `dist/build`, reading the manifest, and refusing a desktop-only
+ * plugin on a mobile transport — and delegates only the write here, which is
+ * what makes the override path reachable from a unit test.
+ *
+ * Writing into `.obsidian` while the vault reads `.obsidian-desktop` installs the
+ * plugin into a folder nothing looks at, and the enable that follows fails with
+ * the generic "enabled but not loaded" shape, naming nothing about a config
+ * folder. `resolveOwnedConfigDirectory` (`transport-options.ts`) is the one
+ * answer to "which folder will this vault read"; every caller here takes its
+ * result.
+ */
+/**
+ * Parameters for {@link installPluginIntoVault}.
+ */
+export interface InstallPluginIntoVaultParams {
+    /**
+     * The vault's config folder name, when it is overridden away from
+     * {@link DEFAULT_CONFIG_DIRECTORY}. Installing into `.obsidian` while the vault
+     * reads `.obsidian-desktop` leaves the plugin where nothing looks for it, so
+     * the override has to reach this far.
+     *
+     * @default `'.obsidian'`
+     */
+    readonly configDirectory?: string | undefined;
+    /**
+     * The directory holding the built plugin (`main.js`, `manifest.json`, …) —
+     * the resolved `dist/dev` or `dist/build`.
+     */
+    readonly distPath: string;
+    /**
+     * The plugin's id, which names both its folder and its
+     * `community-plugins.json` entry.
+     */
+    readonly pluginId: string;
+    /**
+     * The absolute path of the harness-owned vault to install into.
+     */
+    readonly vaultPath: string;
+}
+/**
+ * Copies the built plugin into the vault's config folder and marks it as an
+ * enabled community plugin.
+ *
+ * Only ever call this on a vault the harness owns: it overwrites
+ * `community-plugins.json` outright, because the harness is the one that decides
+ * what a throwaway vault has enabled. Extra community plugins are seeded through
+ * `populate` and enabled after open instead, so they do not need to survive this
+ * write.
+ *
+ * @param params - The vault to install into, its config folder, and the build to install.
+ */
+export declare function installPluginIntoVault(params: InstallPluginIntoVaultParams): Promise<void>;

package/dist/lib/esm/vault-plugin-install.mjs

@@ -0,0 +1,20 @@
+import {
+  cp,
+  mkdir,
+  writeFile
+} from "node:fs/promises";
+import { join } from "node:path";
+import { DEFAULT_CONFIG_DIRECTORY } from "./config-directory.mjs";
+const PLUGINS_DIR = "plugins";
+const COMMUNITY_PLUGINS_JSON = "community-plugins.json";
+async function installPluginIntoVault(params) {
+  const { configDirectory = DEFAULT_CONFIG_DIRECTORY, distPath, pluginId, vaultPath } = params;
+  const pluginDirectory = join(vaultPath, configDirectory, PLUGINS_DIR, pluginId);
+  await mkdir(pluginDirectory, { recursive: true });
+  await cp(distPath, pluginDirectory, { recursive: true });
+  await writeFile(join(vaultPath, configDirectory, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+}
+export {
+  installPluginIntoVault
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vault-teardown-verdict.d.mts

@@ -0,0 +1,57 @@
+/**
+ * @file
+ *
+ * Pure decision for whether unregistering a vault may tear its window down.
+ *
+ * The desktop CDP transport used to answer this with a single flag. Its
+ * readiness guard asks `ownedConfig || isHarnessOwnedInstance` — the two ways
+ * "the harness owns this instance" can be true — while its teardown guard asked
+ * only `ownedConfig`. A **worker** attached to a harness-owned instance has
+ * `isHarnessOwnedInstance: true` and no `ownedConfig` at all (the global setup
+ * owns the config; the worker was handed only the port), so it fell straight
+ * through the teardown guard and ran `destroyCurrentWindow()` against the vault
+ * it was asked to unregister. When that vault is the one the whole run shares,
+ * its window is the only one — destroying it quits the app, and every later file
+ * fails with `ECONNREFUSED` on a closed CDP port, which reads as a harness
+ * outage rather than as a teardown that overreached.
+ *
+ * Making the two guards identical would fix that and break something else: an
+ * attached worker that registers its **own** `TemporaryVault` does need that
+ * window closed, and a blanket early-return leaks one stale window per temp
+ * vault for the life of the run — each pointing at a directory the disposal has
+ * already deleted. Since every worker in a `createSetup` run is an attached one,
+ * that is the common path, not an edge case.
+ *
+ * So the invariant is narrower than either guard expressed: **a worker attached
+ * to a harness-owned instance may tear down only a vault it registered itself.**
+ * Everything else in that instance belongs to the global setup that launched it.
+ *
+ * Kept out of the integration-only transport module (excluded from unit tests,
+ * `LF:0` in coverage) for the same reason `vault-path-match.ts` is — so the
+ * decision is unit-testable while the transport keeps only the plumbing.
+ */
+/**
+ * Parameters for {@link shouldTearDownVaultWindow}.
+ */
+export interface ShouldTearDownVaultWindowParams {
+    /**
+    Whether this transport is a worker attached to an instance the harness launched elsewhere.
+     */
+    readonly isHarnessOwnedInstance: boolean;
+    /**
+    Whether this transport launched and owns the instance itself.
+     */
+    readonly isOwnedInstance: boolean;
+    /**
+    Whether this transport is the one that registered the vault being unregistered.
+     */
+    readonly isSelfRegistered: boolean;
+}
+/**
+ * Whether unregistering a vault may destroy its window and remove it from the
+ * registry, or must leave the instance untouched.
+ *
+ * @param params - Who owns the instance, and who registered the vault.
+ * @returns `true` when the window may be torn down.
+ */
+export declare function shouldTearDownVaultWindow(params: ShouldTearDownVaultWindowParams): boolean;

package/dist/lib/esm/vault-teardown-verdict.mjs

@@ -0,0 +1,18 @@
+function shouldTearDownVaultWindow(params) {
+  const {
+    isHarnessOwnedInstance,
+    isOwnedInstance,
+    isSelfRegistered
+  } = params;
+  if (isOwnedInstance) {
+    return false;
+  }
+  if (isHarnessOwnedInstance) {
+    return isSelfRegistered;
+  }
+  return true;
+}
+export {
+  shouldTearDownVaultWindow
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/version-matrix.d.mts

@@ -5,7 +5,7 @@
  * version.
  *
  * Support is the range `[latest public, latest catalyst]` and both ends must be
- * verified (G99). The two ends are moving targets, and they periodically
+ * verified. The two ends are moving targets, and they periodically
  * **coincide** — when public catches up to catalyst, both specifiers provision
  * the same build, so running the suites twice re-runs the same build and buys
  * nothing. Worse, a consumer that ran both still reports "green on public AND
@@ -23,7 +23,7 @@
 import type { DesktopReleasesManifest } from './obsidian-version.mjs';
 /**
  * The version specifiers a matrix run defaults to: both ends of the supported
- * range (G99). They are de-duplicated on their resolved versions, so when public
+ * range. They are de-duplicated on their resolved versions, so when public
  * has caught up to catalyst this yields a single run.
  */
 export declare const DEFAULT_OBSIDIAN_VERSION_SPECS: readonly string[];