obsidian-integration-testing 8.3.0 → 9.0.0

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

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

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


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

@@ -302,6 +302,22 @@ export interface ObsidianCdpTransportOptions {
      * @default `true`
      */
     readonly shouldThrowOnIncompatibleInstaller?: boolean;
+    /**
+     * Whether a **silent asar fallback** fails fast after boot.
+     *
+     * When an asar is swapped onto an installer shell too old for it, the instance
+     * may not dead-boot — it can silently revert to the installer's own bundled
+     * asar and run the **wrong (older)** version behind a healthy UI. When `true`
+     * (the default), the transport verifies the running app version against the pin
+     * post-boot and throws `SilentAsarFallbackError` on a mismatch. Set `false` to
+     * let the boot proceed — the mismatch is then surfaced as data (the fallback
+     * verdict) rather than thrown. Only applies to an owned instance running a
+     * swapped-in asar (ignored in attach mode, {@link port} set, and when no asar is
+     * swapped — there is nothing to verify).
+     *
+     * @default `true`
+     */
+    readonly shouldThrowOnSilentAsarFallback?: boolean;
     /**
      * Whether the owned-instance compatibility **nag warnings** are emitted.
      *

package/dist/lib/cjs/vitest/global-setup-no-plugin.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var global_setup_no_plugin_exports = {};
+__export(global_setup_no_plugin_exports, {
+  getTempVault: () => import_global_setup2.getTempVault,
+  setup: () => setup,
+  teardown: () => teardown
+});
+module.exports = __toCommonJS(global_setup_no_plugin_exports);
+var import_global_setup = require("./global-setup.cjs");
+var import_global_setup2 = require("./global-setup.cjs");
+const noPluginGlobalSetup = (0, import_global_setup.createSetup)({ installPlugin: false });
+const setup = noPluginGlobalSetup.setup;
+const teardown = noPluginGlobalSetup.teardown;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTempVault,
+  setup,
+  teardown
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3ZpdGVzdC9nbG9iYWwtc2V0dXAtbm8tcGx1Z2luLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVml0ZXN0ICoqcGx1Z2luLWxlc3MqKiBnbG9iYWwgc2V0dXAvdGVhcmRvd24gYWRhcHRlci5cbiAqXG4gKiBUaGUgY291bnRlcnBhcnQgdG8gYC4vZ2xvYmFsLXNldHVwLnRzYCAod2hpY2ggaW5zdGFsbHMgYW5kIGVuYWJsZXMgdGhlIGJ1aWx0XG4gKiBwbHVnaW4pLiBUaGlzIG9uZSBydW5zIHtAbGluayBjcmVhdGVTZXR1cH0gd2l0aCBgaW5zdGFsbFBsdWdpbjogZmFsc2VgLCBzbyBpdFxuICogbGF1bmNoZXMgdGhlIG93bmVkIE9ic2lkaWFuIGluc3RhbmNlLCByZWdpc3RlcnMgYW4gKiplbXB0eSoqIHRlbXAgdmF1bHQsIGFuZFxuICogcHVibGlzaGVzIHRoZSBvd25lZC1pbnN0YW5jZSBlbmRwb2ludCB0byB3b3JrZXJzIFx1MjAxNCBidXQgY29waWVzL2VuYWJsZXMgbm9cbiAqIHBsdWdpbi4gUG9pbnQgYSBub24tcGx1Z2luIGNvbnN1bWVyJ3MgYGdsb2JhbFNldHVwYCBzdHJhaWdodCBhdFxuICogYG9ic2lkaWFuLWludGVncmF0aW9uLXRlc3Rpbmcvdml0ZXN0LWdsb2JhbC1zZXR1cC1uby1wbHVnaW5gOyBubyB3cmFwcGVyIG5lZWRlZC5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gSW50ZWdyYXRpb24tdGltZSBzZXR1cCBjb3ZlcmVkIGJ5IGludGVncmF0aW9uIHRlc3RzLCBub3QgdW5pdCB0ZXN0cy4gKi9cblxuaW1wb3J0IHsgY3JlYXRlU2V0dXAgfSBmcm9tICcuL2dsb2JhbC1zZXR1cC5janMnO1xuXG5jb25zdCBub1BsdWdpbkdsb2JhbFNldHVwID0gY3JlYXRlU2V0dXAoeyBpbnN0YWxsUGx1Z2luOiBmYWxzZSB9KTtcblxuLyoqXG4gKiBWaXRlc3QgZ2xvYmFsIHNldHVwIGZ1bmN0aW9uIChwbHVnaW4tbGVzczsgbm8gcHJlLXBvcHVsYXRpb24pLlxuICpcbiAqIFJlZ2lzdGVycyBhbiBlbXB0eSB0ZW1wIHZhdWx0IGFuZCBwcm92aWRlcyBgdGVtcFZhdWx0UGF0aGAgdG8gdGVzdHMsIHdpdGhvdXRcbiAqIGNvcHlpbmcgb3IgZW5hYmxpbmcgYW55IHBsdWdpbi5cbiAqL1xuZXhwb3J0IGNvbnN0IHNldHVwID0gbm9QbHVnaW5HbG9iYWxTZXR1cC5zZXR1cDtcblxuLyoqXG4gKiBWaXRlc3QgZ2xvYmFsIHRlYXJkb3duIGZ1bmN0aW9uLlxuICpcbiAqIFJlbW92ZXMgdGhlIHRlbXBvcmFyeSB2YXVsdCBjcmVhdGVkIGR1cmluZyBzZXR1cC5cbiAqL1xuZXhwb3J0IGNvbnN0IHRlYXJkb3duID0gbm9QbHVnaW5HbG9iYWxTZXR1cC50ZWFyZG93bjtcblxuZXhwb3J0IHsgZ2V0VGVtcFZhdWx0IH0gZnJvbSAnLi9nbG9iYWwtc2V0dXAuY2pzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBZUEsMEJBQTRCO0FBbUI1QixJQUFBQSx1QkFBNkI7QUFqQjdCLE1BQU0sMEJBQXNCLGlDQUFZLEVBQUUsZUFBZSxNQUFNLENBQUM7QUFRekQsTUFBTSxRQUFRLG9CQUFvQjtBQU9sQyxNQUFNLFdBQVcsb0JBQW9COyIsCiAgIm5hbWVzIjogWyJpbXBvcnRfZ2xvYmFsX3NldHVwIl0KfQo=

package/dist/lib/cjs/vitest/global-setup-no-plugin.d.cts

@@ -0,0 +1,26 @@
+/**
+ * @file
+ *
+ * Vitest **plugin-less** global setup/teardown adapter.
+ *
+ * The counterpart to `./global-setup.ts` (which installs and enables the built
+ * plugin). This one runs {@link createSetup} with `installPlugin: false`, so it
+ * launches the owned Obsidian instance, registers an **empty** temp vault, and
+ * publishes the owned-instance endpoint to workers — but copies/enables no
+ * plugin. Point a non-plugin consumer's `globalSetup` straight at
+ * `obsidian-integration-testing/vitest-global-setup-no-plugin`; no wrapper needed.
+ */
+/**
+ * Vitest global setup function (plugin-less; no pre-population).
+ *
+ * Registers an empty temp vault and provides `tempVaultPath` to tests, without
+ * copying or enabling any plugin.
+ */
+export declare const setup: (this: void, project: import("vitest/node").TestProject) => Promise<void>;
+/**
+ * Vitest global teardown function.
+ *
+ * Removes the temporary vault created during setup.
+ */
+export declare const teardown: (this: void) => Promise<void>;
+export { getTempVault } from './global-setup.cjs';

package/dist/lib/cjs/vitest/global-setup.cjs

@@ -40,7 +40,7 @@ function createSetup(options) {
     const transportOptions = environmentOptions?.["obsidianTransport"];
     const label = transportOptions?.type ?? "obsidian-cdp";
     try {
-      setupResult = await (0, import_global_setup_core.coreSetup)({ populate: options?.populate?.(), transportOptions });
+      setupResult = await (0, import_global_setup_core.coreSetup)({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });
     } catch (error) {
       (0, import_log.log)(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${(0, import_error_to_string.errorToString)(error)}`);
       project.provide("setupError", (0, import_error_to_string.errorToString)(error));
@@ -71,4 +71,4 @@ const teardown = defaultGlobalSetup.teardown;
   setup,
   teardown
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.cjs';\nimport type { PopulateFilesParams } from '../temp-vault.cjs';\nimport type { ObsidianTransportOptions } from '../transport-options.cjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.cjs';\nimport { errorToString } from '../error-to-string.cjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.cjs';\nimport { log } from '../log.cjs';\nimport { TempVault } from '../temp-vault.cjs';\n\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('tempVaultPath'));\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run.\n      // Individual tests in this project will fail with the stored error\n      // When they try to inject the temp vault path.\n      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);\n      project.provide('setupError', errorToString(error));\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('tempVaultPath', setupResult.tempVault.path);\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = inject('tempVaultPath');\n  const setupErrorMessage = inject('setupError');\n  if (setupErrorMessage) {\n    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);\n  }\n  return new TempVault(tempVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and provides `tempVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,oBAAuB;AAMvB,8BAGO;AACP,6BAA8B;AAC9B,+BAGO;AACP,iBAAoB;AACpB,wBAA0B;AAAA,IAE1B,qDAA4B,UAAM,sBAAO,mBAAmB,CAAC;AAAA,IAC7D,8CAAqB,UAAM,sBAAO,eAAe,CAAC;AA0C3C,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,UAAM,oCAAU,EAAE,eAAe,SAAS,eAAe,UAAU,SAAS,WAAW,GAAG,iBAAiB,CAAC;AAAA,IAC5H,SAAS,OAAgB;AAIvB,0BAAI,sBAAsB,KAAK,gEAA4D,sCAAc,KAAK,CAAC,EAAE;AACjH,cAAQ,QAAQ,kBAAc,sCAAc,KAAK,CAAC;AAClD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,iBAAiB,YAAY,UAAU,IAAI;AAAA,EAC7D;AAEA,iBAAeC,YAA0B;AACvC,cAAM,uCAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,eAA0B;AACxC,QAAM,oBAAgB,sBAAO,eAAe;AAC5C,QAAM,wBAAoB,sBAAO,YAAY;AAC7C,MAAI,mBAAmB;AACrB,UAAM,IAAI,MAAM,0DAAqD,iBAAiB,EAAE;AAAA,EAC1F;AACA,SAAO,IAAI,4BAAU,aAAa;AACpC;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}


package/dist/lib/cjs/vitest/global-setup.d.cts

@@ -13,6 +13,15 @@ import { TempVault } from '../temp-vault.cjs';
  * Options for {@link createSetup}.
  */
 export interface CreateSetupOptions {
+    /**
+     * Whether to install and enable the built plugin in the temp vault. Defaults
+     * to `true`. Set to `false` for a **non-plugin** consumer that only needs a
+     * registered, empty vault to `evalInObsidian` against — the owned instance is
+     * still launched and its endpoint published to workers, so re-exporting
+     * `createSetup({ installPlugin: false })` reuses the same attach wiring with no
+     * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.
+     */
+    readonly installPlugin?: boolean;
     /**
      * Returns files/folders to write into the vault before Obsidian opens it (see
      * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,
@@ -31,7 +40,8 @@ export interface VitestGlobalSetup {
  * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault
  * before Obsidian opens it — use this for a dedicated large-vault/performance
  * project. The plain {@link setup} / {@link teardown} exports are the no-populate
- * case (`createSetup()`).
+ * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer
+ * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).
  *
  * @param options - Setup options.
  * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.

package/dist/lib/esm/asar-fallback-detection.d.mts

@@ -0,0 +1,75 @@
+/**
+ * @file
+ *
+ * Pure verdict on whether a booted owned Obsidian instance is actually running
+ * the pinned app (asar) version, or **silently fell back** to the installer's own
+ * bundled asar. Kept separate from the integration-only `transport-desktop-cdp`
+ * (which reads the live version over CDP and is excluded from unit tests) so the
+ * tier logic stays unit-testable — mirroring the `installer-compatibility` /
+ * `electron-compatibility` / `renderer-boot-detection` split.
+ *
+ * When an asar is swapped onto an installer shell below its real boot floor, the
+ * renderer does not always dead-boot (the black screen `renderer-boot-detection`
+ * catches). Some app versions instead **silently revert to the installer's own
+ * bundled asar** and render a perfectly healthy UI of the *wrong (older)* version.
+ * The dead-boot detector reads that healthy UI as a false-positive "runnable" —
+ * exactly how Obsidian `1.13.0` on installer `1.1.9` was first mis-measured (it
+ * reports `apiVersion` `1.1.9`, not `1.13.0`).
+ *
+ * The discriminator is the **running** app version, read live post-boot
+ * (`ipcRenderer.sendSync('version')` / `obsidianModule.apiVersion`, which both
+ * track the asar actually running). This verdict compares it to the pinned
+ * version: equal ⇒ `'match'`, different ⇒ `'fallback'` (the pin was not honored),
+ * and `'unknown'` when either version is unavailable (no asar was swapped, or the
+ * live version could not be read) — in which case nothing is thrown or warned.
+ */
+/**
+ * The silent-asar-fallback verdict for a booted owned instance, carried as data
+ * on the transport / connection result so consumers can assert on it.
+ */
+export interface AsarFallback {
+    /** A human-readable explanation, present for the `'fallback'` tier. */
+    readonly message?: string;
+    /** The pinned app (asar) version that was requested, or `null` when none. */
+    readonly requestedVersion: null | string;
+    /** The app (asar) version actually running, or `null` when unreadable. */
+    readonly runningApiVersion: null | string;
+    /** The resolved fallback tier. */
+    readonly tier: AsarFallbackTier;
+}
+/**
+ * The silent-asar-fallback tier for a booted owned instance.
+ *
+ * - `'match'` — the running app version equals the pinned version; the pin was
+ *   honored.
+ * - `'fallback'` — the running app version differs from the pinned version; the
+ *   installer silently ran a different (its own bundled) asar instead of the pin.
+ * - `'unknown'` — cannot be determined (no asar was swapped, so there is no pin to
+ *   verify, or the live running version could not be read).
+ */
+export type AsarFallbackTier = 'fallback' | 'match' | 'unknown';
+/**
+ * Parameters for {@link checkAsarFallback}.
+ */
+export interface CheckAsarFallbackParams {
+    /**
+     * The pinned Obsidian app (asar) version the owned instance was asked to run,
+     * or `undefined` when no asar was swapped (so there is nothing to verify).
+     */
+    readonly requestedVersion: string | undefined;
+    /**
+     * The Obsidian app (asar) version the instance is actually running, read live
+     * post-boot, or `undefined` when it could not be read.
+     */
+    readonly runningApiVersion: string | undefined;
+}
+/**
+ * Computes the silent-asar-fallback verdict for a booted owned instance.
+ *
+ * Only `'fallback'` warrants action (a throw / warning); `'match'` and `'unknown'`
+ * are silent. Comparison is a pure `x.y.z` version compare — no I/O.
+ *
+ * @param params - The pinned version and the live running version.
+ * @returns The fallback verdict.
+ */
+export declare function checkAsarFallback(params: CheckAsarFallbackParams): AsarFallback;

package/dist/lib/esm/asar-fallback-detection.mjs

@@ -0,0 +1,24 @@
+import { compareVersions } from "./obsidian-version.mjs";
+function checkAsarFallback(params) {
+  const { requestedVersion, runningApiVersion } = params;
+  if (requestedVersion === void 0 || runningApiVersion === void 0) {
+    return {
+      requestedVersion: requestedVersion ?? null,
+      runningApiVersion: runningApiVersion ?? null,
+      tier: "unknown"
+    };
+  }
+  if (compareVersions(runningApiVersion, requestedVersion) === 0) {
+    return { requestedVersion, runningApiVersion, tier: "match" };
+  }
+  return {
+    message: `Obsidian was pinned to app version ${requestedVersion} but is actually running ${runningApiVersion} \u2014 the installer silently fell back to its own bundled asar instead of running the pinned version. Pin an obsidianInstallerVersion at or above ${requestedVersion}'s run floor so the pin actually runs.`,
+    requestedVersion,
+    runningApiVersion,
+    tier: "fallback"
+  };
+}
+export {
+  checkAsarFallback
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/avd-list.d.mts

@@ -0,0 +1,38 @@
+/**
+ * @file
+ *
+ * Pure helpers for parsing `emulator -list-avds` output: extracting the
+ * available AVD names and checking whether a requested AVD exists.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the parsing stays unit-testable — the factory itself shells out
+ * to the `emulator` binary.
+ */
+/**
+ * Parameters for {@link checkAvdExists}.
+ */
+export interface CheckAvdExistsParams {
+    /** Raw stdout of `emulator -list-avds` — one AVD name per line. */
+    readonly avdListOutput: string;
+    /** The AVD name to look for. */
+    readonly avdName: string;
+}
+/**
+ * Decides whether a given AVD exists, from the raw stdout of
+ * `emulator -list-avds`.
+ *
+ * @param params - The listing output and the AVD name to check.
+ * @returns `true` when the AVD name appears in the listing.
+ */
+export declare function checkAvdExists(params: CheckAvdExistsParams): boolean;
+/**
+ * Parses the available AVD names from the raw stdout of `emulator -list-avds`.
+ *
+ * The command prints one AVD name per line; blank lines and surrounding
+ * whitespace are ignored. Some emulator builds emit an informational banner
+ * (e.g. `INFO    | ...`) to stdout before the list, so those lines are dropped.
+ *
+ * @param avdListOutput - Raw stdout of `emulator -list-avds`.
+ * @returns The available AVD names, in listed order.
+ */
+export declare function listAvailableAvds(avdListOutput: string): string[];

package/dist/lib/esm/avd-list.mjs

@@ -0,0 +1,11 @@
+function checkAvdExists(params) {
+  return listAvailableAvds(params.avdListOutput).includes(params.avdName);
+}
+function listAvailableAvds(avdListOutput) {
+  return avdListOutput.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.includes("|"));
+}
+export {
+  checkAvdExists,
+  listAvailableAvds
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -18,7 +18,20 @@
  * resolution stays unit-testable — mirroring the `visibility.ts` /
  * `appium-session-config.ts` pure-resolver split.
  */
+import type { AsarFallbackTier } from './asar-fallback-detection.mjs';
 import type { InstallerCompatibilityTier } from './installer-compatibility.mjs';
+/**
+ * The action to take for a resolved silent-asar-fallback verdict, given the
+ * throw/warn knobs.
+ *
+ * - `'throw'` — the verdict is `'fallback'` and the throw is enabled; the caller
+ *   throws `SilentAsarFallbackError`.
+ * - `'warn'` — the verdict is `'fallback'` but the throw is disabled and warnings
+ *   are on; the caller logs the fallback warning and lets the boot proceed (the
+ *   verdict is still surfaced as data).
+ * - `'silent'` — nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).
+ */
+export type AsarFallbackAction = 'silent' | 'throw' | 'warn';
 /**
  * The action to take for a resolved installer↔app compatibility verdict, given
  * the throw/warn knobs.
@@ -33,6 +46,17 @@ import type { InstallerCompatibilityTier } from './installer-compatibility.mjs';
  * - `'silent'` — nothing to do (`'ok'` / `'unknown'`, or warnings disabled).
  */
 export type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';
+/**
+ * Parameters for {@link resolveAsarFallbackAction}.
+ */
+export interface ResolveAsarFallbackActionParams {
+    /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */
+    readonly shouldThrowOnSilentAsarFallback: boolean;
+    /** Whether a non-throwing fallback verdict is logged. */
+    readonly shouldWarnOnCompatibilityIssues: boolean;
+    /** The resolved silent-asar-fallback tier. */
+    readonly tier: AsarFallbackTier;
+}
 /**
  * Parameters for {@link resolveInstallerCompatibilityAction}.
  */
@@ -44,6 +68,14 @@ export interface ResolveInstallerCompatibilityActionParams {
     /** The resolved installer↔app compatibility tier. */
     readonly tier: InstallerCompatibilityTier;
 }
+/**
+ * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn
+ * knobs. Pure — the caller performs the throw/log side effects.
+ *
+ * @param params - The verdict tier and the resolved throw/warn knobs.
+ * @returns The action the caller should take.
+ */
+export declare function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction;
 /**
  * Resolves what to do for an installer↔app compatibility verdict, given the
  * throw/warn knobs. Pure — the caller performs the throw/log side effects.
@@ -60,6 +92,15 @@ export declare function resolveInstallerCompatibilityAction(params: ResolveInsta
  * @returns `true` when an unrunnable pin should throw (the default).
  */
 export declare function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean;
+/**
+ * Whether a booted owned instance running a different app (asar) version than the
+ * pin — a silent fallback to the installer's own bundled asar — should fail fast
+ * with {@link SilentAsarFallbackError}.
+ *
+ * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted → throw).
+ * @returns `true` when a silent fallback should throw (the default).
+ */
+export declare function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean;
 /**
  * Whether the owned-instance compatibility nag warnings should be emitted (both
  * the installer↔app `'nagged'` warning and the runtime-Electron `'nagged'`

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

@@ -1,3 +1,13 @@
+function resolveAsarFallbackAction(params) {
+  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;
+  if (tier !== "fallback") {
+    return "silent";
+  }
+  if (shouldThrowOnSilentAsarFallback) {
+    return "throw";
+  }
+  return shouldWarnOnCompatibilityIssues ? "warn" : "silent";
+}
 function resolveInstallerCompatibilityAction(params) {
   const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;
   if (tier === "unrunnable") {
@@ -14,12 +24,17 @@ function resolveInstallerCompatibilityAction(params) {
 function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller) {
   return shouldThrowOnIncompatibleInstaller ?? true;
 }
+function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback) {
+  return shouldThrowOnSilentAsarFallback ?? true;
+}
 function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues) {
   return shouldWarnOnCompatibilityIssues ?? true;
 }
 export {
+  resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction,
   resolveShouldThrowOnIncompatibleInstaller,
+  resolveShouldThrowOnSilentAsarFallback,
   resolveShouldWarnOnCompatibilityIssues
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/compatibility-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure resolution of the two owned-instance compatibility knobs \u2014 whether the\n * installer\u2194app / runtime-Electron nag warnings are emitted, and whether an\n * `'unrunnable'` installer\u2194app pair fails fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * Both default to today's behavior (`true`): warnings on, and an unrunnable pin\n * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`\n * silences both nags (the verdicts are still computed and surfaced as data);\n * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin\n * proceed to launch, where the reactive dead-boot fast-fail\n * (`RendererFailedToInitializeError`) still catches it.\n *\n * Kept separate from the integration-only launch code (`transport-factory`,\n * `transport-desktop-cdp`, both excluded from unit tests) so the default\n * resolution stays unit-testable \u2014 mirroring the `visibility.ts` /\n * `appium-session-config.ts` pure-resolver split.\n */\n\nimport type { AsarFallbackTier } from './asar-fallback-detection.mjs';\nimport type { InstallerCompatibilityTier } from './installer-compatibility.mjs';\n\n/**\n * The action to take for a resolved silent-asar-fallback verdict, given the\n * throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'fallback'` and the throw is enabled; the caller\n *   throws `SilentAsarFallbackError`.\n * - `'warn'` \u2014 the verdict is `'fallback'` but the throw is disabled and warnings\n *   are on; the caller logs the fallback warning and lets the boot proceed (the\n *   verdict is still surfaced as data).\n * - `'silent'` \u2014 nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).\n */\nexport type AsarFallbackAction = 'silent' | 'throw' | 'warn';\n\n/**\n * The action to take for a resolved installer\u2194app compatibility verdict, given\n * the throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'unrunnable'` and the proactive throw is enabled;\n *   the caller throws `IncompatibleInstallerVersionError` before launch.\n * - `'warn-unrunnable'` \u2014 the verdict is `'unrunnable'` but the throw is disabled\n *   and warnings are on; the caller logs a \"proceeding to launch\" warning and\n *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).\n * - `'warn-nagged'` \u2014 the verdict is `'nagged'` and warnings are on; the caller\n *   logs the recommended-installer warning.\n * - `'silent'` \u2014 nothing to do (`'ok'` / `'unknown'`, or warnings disabled).\n */\nexport type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';\n\n/**\n * Parameters for {@link resolveAsarFallbackAction}.\n */\nexport interface ResolveAsarFallbackActionParams {\n  /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */\n  readonly shouldThrowOnSilentAsarFallback: boolean;\n\n  /** Whether a non-throwing fallback verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved silent-asar-fallback tier. */\n  readonly tier: AsarFallbackTier;\n}\n\n/**\n * Parameters for {@link resolveInstallerCompatibilityAction}.\n */\nexport interface ResolveInstallerCompatibilityActionParams {\n  /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /** Whether a nag / proceeding-unrunnable verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved installer\u2194app compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn\n * knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction {\n  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier !== 'fallback') {\n    return 'silent';\n  }\n\n  if (shouldThrowOnSilentAsarFallback) {\n    return 'throw';\n  }\n\n  return shouldWarnOnCompatibilityIssues ? 'warn' : 'silent';\n}\n\n/**\n * Resolves what to do for an installer\u2194app compatibility verdict, given the\n * throw/warn knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction {\n  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier === 'unrunnable') {\n    if (shouldThrowOnIncompatibleInstaller) {\n      return 'throw';\n    }\n\n    return shouldWarnOnCompatibilityIssues ? 'warn-unrunnable' : 'silent';\n  }\n\n  if (tier === 'nagged') {\n    return shouldWarnOnCompatibilityIssues ? 'warn-nagged' : 'silent';\n  }\n\n  return 'silent';\n}\n\n/**\n * Whether an `'unrunnable'` installer\u2194app pair should fail fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted \u2192 throw).\n * @returns `true` when an unrunnable pin should throw (the default).\n */\nexport function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean {\n  return shouldThrowOnIncompatibleInstaller ?? true;\n}\n\n/**\n * Whether a booted owned instance running a different app (asar) version than the\n * pin \u2014 a silent fallback to the installer's own bundled asar \u2014 should fail fast\n * with {@link SilentAsarFallbackError}.\n *\n * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted \u2192 throw).\n * @returns `true` when a silent fallback should throw (the default).\n */\nexport function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean {\n  return shouldThrowOnSilentAsarFallback ?? true;\n}\n\n/**\n * Whether the owned-instance compatibility nag warnings should be emitted (both\n * the installer\u2194app `'nagged'` warning and the runtime-Electron `'nagged'`\n * warning).\n *\n * @param shouldWarnOnCompatibilityIssues - The resolved option value (omitted \u2192 warn).\n * @returns `true` when the warnings should be emitted (the default).\n */\nexport function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean {\n  return shouldWarnOnCompatibilityIssues ?? true;\n}\n"],
  "mappings": "AAuFO,SAAS,0BAA0B,QAA6D;AACrG,QAAM,EAAE,iCAAiC,iCAAiC,KAAK,IAAI;AAEnF,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,iCAAiC;AACnC,WAAO;AAAA,EACT;AAEA,SAAO,kCAAkC,SAAS;AACpD;AASO,SAAS,oCAAoC,QAAiF;AACnI,QAAM,EAAE,oCAAoC,iCAAiC,KAAK,IAAI;AAEtF,MAAI,SAAS,cAAc;AACzB,QAAI,oCAAoC;AACtC,aAAO;AAAA,IACT;AAEA,WAAO,kCAAkC,oBAAoB;AAAA,EAC/D;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,kCAAkC,gBAAgB;AAAA,EAC3D;AAEA,SAAO;AACT;AASO,SAAS,0CAA0C,oCAAuD;AAC/G,SAAO,sCAAsC;AAC/C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;",
  "names": []
}


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

@@ -11,6 +11,7 @@
  * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
  */
 import type { Except } from 'type-fest';
+import type { AsarFallback } from './asar-fallback-detection.mjs';
 import type { ContextId } from './context-id.mjs';
 import type { ElectronCompatibility } from './electron-compatibility.mjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.mjs';
@@ -25,6 +26,16 @@ import { TempVault } from './temp-vault.mjs';
  * removing its directory) automatically.
  */
 export interface CdpConnection extends AsyncDisposable {
+    /**
+     * The silent-asar-fallback verdict for an owned instance, read live after boot:
+     * whether the app version it is actually running matches the swapped-in pin, or
+     * the installer silently reverted to its own bundled asar. `undefined` in attach
+     * mode, when no asar was swapped, or when the running version was unreadable. A
+     * `'fallback'` verdict reaches here only when the throw is disabled
+     * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);
+     * otherwise it throws `SilentAsarFallbackError` before the connection is created.
+     */
+    readonly asarFallback?: AsarFallback | undefined;
     /**
      * The base CDP URL, e.g. `http://localhost:51888`.
      */
@@ -178,6 +189,20 @@ export interface ConnectToCdpOptions {
      * @default `true`
      */
     readonly shouldThrowOnIncompatibleInstaller?: boolean;
+    /**
+     * Whether a post-boot **silent asar fallback** fails fast.
+     *
+     * When an asar is swapped onto an installer shell too old for it, the instance
+     * may silently revert to the installer's own bundled asar and run the **wrong
+     * (older)** version behind a healthy UI. When `true` (the default), the running
+     * app version is verified against the pin post-boot and a mismatch throws
+     * `SilentAsarFallbackError`. Set `false` to let the boot proceed — the mismatch
+     * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.
+     * Ignored in attach mode ({@link port} set) and when no asar is swapped.
+     *
+     * @default `true`
+     */
+    readonly shouldThrowOnSilentAsarFallback?: boolean;
     /**
      * Whether the owned-instance compatibility **nag warnings** are emitted.
      *