obsidian-integration-testing 9.0.0 → 9.1.1

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

@@ -14,4 +14,4 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transport_options_exports = {};
 module.exports = __toCommonJS(transport_options_exports);
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Discriminated union types for configuring the Obsidian transport\n * via vitest `environmentOptions`.\n */\n\n/**\n * Transport options for Android testing via Appium WebView injection.\n */\nexport interface ObsidianAndroidAppiumTransportOptions {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`\n   */\n  readonly appId?: string;\n\n  /**\n   * Timeout in milliseconds for the auto-started Appium server to become ready\n   * (its `/status` endpoint to respond).\n   *\n   * Only applies when the harness auto-starts the Appium server\n   * ({@link shouldAutoStartAppium}); ignored when attaching to an\n   * already-running server. On a cold machine the `npx appium` server can take\n   * a while to finish booting, so raise this if startup times out.\n   *\n   * @default `180000`\n   */\n  readonly appiumStartTimeoutInMilliseconds?: number;\n\n  /**\n   * The Appium server URL (e.g. `'http://localhost:4723'`).\n   */\n  readonly appiumUrl: string;\n\n  /**\n   * The Android AVD (Android Virtual Device) name.\n   *\n   * The transport factory launches `emulator -avd <avdName>` as a background\n   * process and polls until the device appears. The emulator is killed\n   * on transport disposal.\n   *\n   * Run `emulator -list-avds` to see available AVD names.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device UDID to reuse (e.g. `'emulator-5554'`).\n   *\n   * Populated automatically by the global setup after the Appium session is\n   * established. When present alongside {@link sessionId}, the transport\n   * factory skips emulator startup and attaches to the existing session.\n   */\n  readonly deviceId?: string;\n\n  /**\n   * Timeout in milliseconds for waiting, after `sys.boot_completed`, for a\n   * harness-started emulator to become idle before the Appium session is\n   * established.\n   *\n   * `sys.boot_completed` fires *before* the guest is actually idle: package\n   * optimization and system services keep churning, so establishing the session\n   * immediately makes every one of UiAutomator2's serialized `adb` round-trips\n   * contend with that work and inflates session establishment ~3x. The factory\n   * instead waits until the boot animation has stopped and the package manager\n   * is serving, proceeding early once idle or after this budget (best-effort \u2014 a\n   * timeout logs a warning and proceeds). Set `0` to skip the wait. Only applies\n   * to a harness-started emulator, not a reused one.\n   *\n   * @default `60000`\n   */\n  readonly deviceIdleTimeoutInMilliseconds?: number;\n\n  /**\n   * Whether the auto-started Appium server console window is shown.\n   *\n   * When `false` (the default), the `npx appium` server process is spawned with\n   * its console window hidden (`windowsHide`) and its output discarded, so it\n   * neither steals focus nor writes to the invoking terminal. Ignored when\n   * attaching to an already-running Appium server ({@link shouldAutoStartAppium}\n   * `false`, or the server already reachable). Set `true` to see the server log window\n   * and its live output.\n   *\n   * @default `false`\n   */\n  readonly isAppiumConsoleVisible?: boolean;\n\n  /**\n   * Whether the auto-started Android emulator window is shown on screen.\n   *\n   * When `false` (the default), the emulator is started with `-no-window`\n   * (headless), so it never steals focus. Ignored when reusing an already-running\n   * device (nothing is launched to hide). Set `true` to watch the emulator UI.\n   *\n   * @default `false`\n   */\n  readonly isEmulatorVisible?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * Registering a vault triggers a full Obsidian re-init (`location.reload()`\n   * reopens the vault and reloads every plugin \u2014 the heaviest startup step). On\n   * a cold-booted or under-provisioned emulator that init can take a while, so\n   * this budget is the largest of the transport timeouts. Raise it further if\n   * releases still flake on slow CI emulators.\n   *\n   * @default `90000`\n   */\n  readonly layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Timeout in milliseconds for establishing the Appium session (WebDriverIO\n   * `remote()` \u2014 UiAutomator2 server install + app launch).\n   *\n   * This is the largest and most load-sensitive step of the Android setup:\n   * on a cold or contended emulator it dominates startup and can take a few\n   * minutes. Raise it if session establishment times out under load.\n   *\n   * @default `180000`\n   */\n  readonly sessionConnectionRetryTimeoutInMilliseconds?: number;\n\n  /**\n   * An existing Appium session ID to reattach to.\n   *\n   * Populated automatically by the global setup and provided to test workers\n   * via the framework's context mechanism (e.g. Vitest `provide`/`inject`).\n   * When present, the transport factory uses WebDriverIO's `attach()` instead\n   * of creating a new session, avoiding duplicate Appium/ADB connections.\n   */\n  readonly sessionId?: string;\n\n  /**\n   * Whether to automatically 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": []
}

+//# 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   * 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   * 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

@@ -100,6 +100,34 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * @default `90000`
      */
     readonly layoutReadyTimeoutInMilliseconds?: number;
+    /**
+     * Number of extra attempts to enable the plugin and verify it loaded, on top
+     * of the first attempt.
+     *
+     * On a freshly cold-booted emulator the plugin subsystem can still be settling
+     * when the harness enables the plugin, so the enable lands in the enabled set
+     * but the load races and fails (`"<id>" is in the enabled set but not loaded`).
+     * Device-idle and `layoutReady` are already awaited, so this is the narrow
+     * residual race: the harness retries the enable + load-verification this many
+     * times with exponential backoff (see
+     * {@link pluginEnableRetryDelayInMilliseconds}), forcing a genuine reload each
+     * attempt. A captured plugin load error is treated as a deterministic bug and
+     * is **not** retried. Set `0` to disable retry (a single attempt).
+     *
+     * @default `3`
+     */
+    readonly pluginEnableRetryCount?: number;
+    /**
+     * Base delay in milliseconds between plugin-enable attempts (see
+     * {@link pluginEnableRetryCount}).
+     *
+     * The delay grows exponentially per retry: the first retry waits this long,
+     * the second twice as long, the third four times, and so on — giving a
+     * still-settling cold guest progressively more time to become ready.
+     *
+     * @default `2000`
+     */
+    readonly pluginEnableRetryDelayInMilliseconds?: number;
     /**
      * Timeout in milliseconds for establishing the Appium session (WebDriverIO
      * `remote()` — UiAutomator2 server install + app launch).

package/dist/lib/cjs/transport.cjs

@@ -14,4 +14,4 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transport_exports = {};
 module.exports = __toCommonJS(transport_exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,18 @@
  *
  * Defines the transport interface for communicating with a running Obsidian instance.
  */
+/**
+ * An opaque handle identifying a console-capture window opened by
+ * {@link ObsidianTransport.beginConsoleCapture} and consumed by
+ * {@link ObsidianTransport.readConsoleCaptureSince}.
+ */
+export interface ConsoleCaptureHandle {
+    /**
+     * A unique marker written into the target's log stream at capture start,
+     * used to slice out everything logged after this point.
+     */
+    readonly marker: string;
+}
 /**
  * A pluggable transport that evaluates JavaScript expressions inside a running
  * Obsidian instance and manages vault lifecycle.
@@ -13,6 +25,21 @@
  * - {@link AppiumTransport} — Mobile Obsidian via Appium WebView JS injection
  */
 export interface ObsidianTransport {
+    /**
+     * Begins capturing the target's native console/error stream so a later
+     * {@link ObsidianTransport.readConsoleCaptureSince} can return everything
+     * logged since this call.
+     *
+     * Used to surface the *real* plugin-load error when Obsidian swallows it
+     * before the harness's `loadPlugin` monkey-patch sees it (the error then
+     * only exists in the renderer/WebView console). Optional and platform-specific:
+     * implemented by {@link AppiumTransport} (tails `adb logcat`); absent on
+     * {@link DesktopCdpTransport} (desktop errors are surfaced in-renderer, and a
+     * developer can open DevTools directly).
+     *
+     * @returns An opaque handle to pass to {@link ObsidianTransport.readConsoleCaptureSince}, or `undefined` when unsupported.
+     */
+    beginConsoleCapture?(): Promise<ConsoleCaptureHandle | undefined>;
     /**
      * Disposes of transport resources (e.g. WebSocket connections, Appium sessions).
      */
@@ -64,6 +91,16 @@ export interface ObsidianTransport {
      * @param files - Map of relative file paths to content buffers.
      */
     pushFiles?(vaultPath: string, files: Record<string, Uint8Array>): Promise<void>;
+    /**
+     * Reads the native console/error output captured since the matching
+     * {@link ObsidianTransport.beginConsoleCapture} call.
+     *
+     * A bounded, post-hoc, failure-path-only dump — not a live monitor.
+     *
+     * @param handle - The handle returned by {@link ObsidianTransport.beginConsoleCapture} (or `undefined` when capture was unsupported).
+     * @returns The captured console/error text, or `undefined` when unsupported or nothing relevant was logged.
+     */
+    readConsoleCaptureSince?(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined>;
     /**
      * Registers a vault path so Obsidian can target it.
      *

package/dist/lib/cjs/vault-path-match.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vault_path_match_exports = {};
+__export(vault_path_match_exports, {
+  normalizeVaultPathForComparison: () => normalizeVaultPathForComparison,
+  vaultPathsMatch: () => vaultPathsMatch
+});
+module.exports = __toCommonJS(vault_path_match_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+const IS_CASE_INSENSITIVE_FILESYSTEM = import_node_process.default.platform === "win32";
+function normalizeVaultPathForComparison(path, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  const unifiedSeparators = path.replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return isCaseInsensitive ? unifiedSeparators.toLowerCase() : unifiedSeparators;
+}
+function vaultPathsMatch(basePath, vaultPath, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  return normalizeVaultPathForComparison(basePath, isCaseInsensitive) === normalizeVaultPathForComparison(vaultPath, isCaseInsensitive);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeVaultPathForComparison,
+  vaultPathsMatch
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/vault-path-match.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * Pure matching of a probed vault base path against a requested vault path.
+ *
+ * The desktop CDP transport routes an `evalInObsidian` call to the correct
+ * Obsidian window by probing each target's `app.vault.adapter.getBasePath()` and
+ * comparing it to the requested vault path. That comparison must tolerate benign
+ * formatting differences between the renderer-reported base path and the
+ * Node-side path (path-separator flavor, and case on case-insensitive
+ * filesystems), so it lives here as a pure, unit-tested helper rather than as a
+ * raw `===` inside the integration-only transport module (which is excluded from
+ * unit tests).
+ */
+/**
+ * Normalizes a vault path for comparison: unifies path separators to `/`, strips
+ * any trailing separators, and (on a case-insensitive filesystem) lowercases it.
+ *
+ * @param path - The path to normalize.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns The normalized path.
+ */
+export declare function normalizeVaultPathForComparison(path: string, isCaseInsensitive?: boolean): string;
+/**
+ * Whether a probed base path and a requested vault path refer to the same vault,
+ * comparing via {@link normalizeVaultPathForComparison} so separator-flavor and
+ * (on case-insensitive filesystems) case differences do not cause a false miss.
+ *
+ * @param basePath - The base path probed from an Obsidian target.
+ * @param vaultPath - The requested vault path.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns `true` when the two paths refer to the same vault.
+ */
+export declare function vaultPathsMatch(basePath: string, vaultPath: string, isCaseInsensitive?: boolean): boolean;

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

@@ -40,7 +40,12 @@ function createSetup(options) {
     const transportOptions = environmentOptions?.["obsidianTransport"];
     const label = transportOptions?.type ?? "obsidian-cdp";
     try {
-      setupResult = await (0, import_global_setup_core.coreSetup)({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });
+      setupResult = await (0, import_global_setup_core.coreSetup)({
+        enableCommunityPlugins: options?.enableCommunityPlugins,
+        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 +76,4 @@ const teardown = defaultGlobalSetup.teardown;
   setup,
   teardown
 });
-//# 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"]
}

+//# 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   * Community-plugin ids to enable in the vault in addition to the plugin-under-test,\n   * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each\n   * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)\n   * so the enable finds them on disk.\n   */\n  readonly enableCommunityPlugins?: readonly string[];\n\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({\n        enableCommunityPlugins: options?.enableCommunityPlugins,\n        installPlugin: options?.installPlugin,\n        populate: options?.populate?.(),\n        transportOptions\n      });\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 a renderer eval\n * over the transport, 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;AAkD3C,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;AAAA,QAC5B,wBAAwB,SAAS;AAAA,QACjC,eAAe,SAAS;AAAA,QACxB,UAAU,SAAS,WAAW;AAAA,QAC9B;AAAA,MACF,CAAC;AAAA,IACH,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,13 @@ import { TempVault } from '../temp-vault.cjs';
  * Options for {@link createSetup}.
  */
 export interface CreateSetupOptions {
+    /**
+     * Community-plugin ids to enable in the vault in addition to the plugin-under-test,
+     * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each
+     * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)
+     * so the enable finds them on disk.
+     */
+    readonly enableCommunityPlugins?: readonly string[];
     /**
      * 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
@@ -56,8 +63,8 @@ export declare function getTempVault(): TempVault;
 /**
  * Vitest global setup function (no pre-population).
  *
- * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,
- * and provides `tempVaultPath` to tests.
+ * Copies the built plugin into a temporary vault, enables it via a renderer eval
+ * over the transport, and provides `tempVaultPath` to tests.
  *
  * @param project - The Vitest project.
  * @returns A promise that resolves when setup completes.

package/dist/lib/esm/demo-vault-populate.d.mts

@@ -0,0 +1,71 @@
+/**
+ * @file
+ *
+ * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into
+ * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two
+ * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)
+ * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).
+ *
+ * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,
+ * that turns them on. It intentionally does NOT write `community-plugins.json` — the harness owns that file
+ * (it lists the plugin-under-test), and enabling the extras persists them.
+ */
+import type { PopulateFilesParams } from './temp-vault.mjs';
+/**
+ * Parameters for {@link buildDemoVaultPopulate}.
+ */
+export interface BuildDemoVaultPopulateParams {
+    /**
+     * Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * Names (of files or directories, matched at any depth) to skip while reading the note tree — forwarded to
+     * {@link readDemoVaultTree}.
+     *
+     * @default `['.git', '.obsidian']`
+     */
+    readonly excludedNames?: Iterable<string>;
+    /**
+     * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn
+     * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.
+     */
+    readonly injectPlugins?: readonly InjectPluginParams[];
+    /**
+     * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole
+     * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must
+     * be re-added explicitly. Files that do not exist are skipped.
+     *
+     * @default `['app.json', 'appearance.json', 'core-plugins.json']`
+     */
+    readonly obsidianConfigFiles?: readonly string[];
+}
+/**
+ * A community plugin to seed into the demo vault alongside the note tree.
+ */
+export interface InjectPluginParams {
+    /**
+     * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever
+     * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.
+     */
+    readonly data?: unknown;
+    /**
+     * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).
+     */
+    readonly pluginId: string;
+    /**
+     * Directory to read the plugin's built files from. Every file directly inside it is copied into
+     * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.
+     *
+     * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`
+     */
+    readonly sourceDir?: string;
+}
+/**
+ * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config
+ * files, and every injected plugin's binaries (+ optional `data.json`).
+ *
+ * @param params - The {@link BuildDemoVaultPopulateParams}.
+ * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.
+ */
+export declare function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams;

package/dist/lib/esm/demo-vault-populate.mjs

@@ -0,0 +1,57 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import { join } from "node:path";
+import { readDemoVaultTree } from "./demo-vault-tree.mjs";
+import { ensureNonNullable } from "./type-guards.mjs";
+const OBSIDIAN_CONFIG_DIR = ".obsidian";
+const PLUGINS_DIR = "plugins";
+const DATA_JSON = "data.json";
+const MANIFEST_JSON = "manifest.json";
+const MAIN_JS = "main.js";
+const DATA_JSON_INDENT = 2;
+const DEFAULT_OBSIDIAN_CONFIG_FILES = ["app.json", "appearance.json", "core-plugins.json"];
+function buildDemoVaultPopulate(params) {
+  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;
+  const map = readDemoVaultTree(excludedNames === void 0 ? { demoVaultPath } : { demoVaultPath, excludedNames });
+  for (const configFile of obsidianConfigFiles) {
+    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);
+    if (existsSync(configPath)) {
+      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);
+    }
+  }
+  for (const plugin of injectPlugins) {
+    seedPlugin(demoVaultPath, plugin, map);
+  }
+  return map;
+}
+function seedPlugin(demoVaultPath, plugin, map) {
+  const { data, pluginId } = plugin;
+  const sourceDir = plugin.sourceDir ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;
+  const fileNames = existsSync(sourceDir) ? readdirSync(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
+  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {
+    if (!fileNames.includes(requiredFile)) {
+      throw new Error(
+        `Community plugin "${pluginId}" is not installed in the demo vault (${join(sourceDir, requiredFile)} missing). Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.`
+      );
+    }
+  }
+  for (const fileName of fileNames) {
+    if (fileName === DATA_JSON && data !== void 0) {
+      continue;
+    }
+    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDir, fileName));
+  }
+  if (data !== void 0) {
+    const dataJson = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));
+    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}
+`;
+  }
+}
+export {
+  buildDemoVaultPopulate
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-populate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into\n * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two\n * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)\n * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).\n *\n * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,\n * that turns them on. It intentionally does NOT write `community-plugins.json` \u2014 the harness owns that file\n * (it lists the plugin-under-test), and enabling the extras persists them.\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\n\nimport type { PopulateFilesParams } from './temp-vault.mjs';\n\nimport { readDemoVaultTree } from './demo-vault-tree.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\n\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst DATA_JSON = 'data.json';\nconst MANIFEST_JSON = 'manifest.json';\nconst MAIN_JS = 'main.js';\nconst DATA_JSON_INDENT = 2;\n\nconst DEFAULT_OBSIDIAN_CONFIG_FILES = ['app.json', 'appearance.json', 'core-plugins.json'];\n\n/**\n * Parameters for {@link buildDemoVaultPopulate}.\n */\nexport interface BuildDemoVaultPopulateParams {\n  /**\n   * Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * Names (of files or directories, matched at any depth) to skip while reading the note tree \u2014 forwarded to\n   * {@link readDemoVaultTree}.\n   *\n   * @default `['.git', '.obsidian']`\n   */\n  readonly excludedNames?: Iterable<string>;\n\n  /**\n   * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn\n   * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.\n   */\n  readonly injectPlugins?: readonly InjectPluginParams[];\n\n  /**\n   * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole\n   * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must\n   * be re-added explicitly. Files that do not exist are skipped.\n   *\n   * @default `['app.json', 'appearance.json', 'core-plugins.json']`\n   */\n  readonly obsidianConfigFiles?: readonly string[];\n}\n\n/**\n * A community plugin to seed into the demo vault alongside the note tree.\n */\nexport interface InjectPluginParams {\n  /**\n   * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever\n   * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.\n   */\n  readonly data?: unknown;\n\n  /**\n   * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).\n   */\n  readonly pluginId: string;\n\n  /**\n   * Directory to read the plugin's built files from. Every file directly inside it is copied into\n   * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.\n   *\n   * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`\n   */\n  readonly sourceDir?: string;\n}\n\n/**\n * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config\n * files, and every injected plugin's binaries (+ optional `data.json`).\n *\n * @param params - The {@link BuildDemoVaultPopulateParams}.\n * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.\n */\nexport function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams {\n  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;\n\n  const map = readDemoVaultTree(excludedNames === undefined ? { demoVaultPath } : { demoVaultPath, excludedNames });\n\n  for (const configFile of obsidianConfigFiles) {\n    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);\n    if (existsSync(configPath)) {\n      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);\n    }\n  }\n\n  for (const plugin of injectPlugins) {\n    seedPlugin(demoVaultPath, plugin, map);\n  }\n\n  return map;\n}\n\n/**\n * Seeds one injected plugin's binaries (and optional `data.json`) into the populate map.\n *\n * @param demoVaultPath - The demo vault root, used to resolve the default source directory.\n * @param plugin - The plugin to seed.\n * @param map - The populate map to write into.\n */\nfunction seedPlugin(demoVaultPath: string, plugin: InjectPluginParams, map: PopulateFilesParams): void {\n  const { data, pluginId } = plugin;\n  const sourceDir = plugin.sourceDir ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = existsSync(sourceDir)\n    ? readdirSync(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name)\n    : [];\n\n  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {\n    if (!fileNames.includes(requiredFile)) {\n      throw new Error(\n        `Community plugin \"${pluginId}\" is not installed in the demo vault (${join(sourceDir, requiredFile)} missing). `\n          + 'Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.'\n      );\n    }\n  }\n\n  for (const fileName of fileNames) {\n    // `data.json` is regenerated from `data` below (when provided); skip the on-disk copy to avoid seeding it twice.\n    if (fileName === DATA_JSON && data !== undefined) {\n      continue;\n    }\n    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDir, fileName));\n  }\n\n  if (data !== undefined) {\n    const dataJson: string = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));\n    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}\\n`;\n  }\n}\n"],
  "mappings": "AAaA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AAIrB,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAElC,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,YAAY;AAClB,MAAM,gBAAgB;AACtB,MAAM,UAAU;AAChB,MAAM,mBAAmB;AAEzB,MAAM,gCAAgC,CAAC,YAAY,mBAAmB,mBAAmB;AAkElF,SAAS,uBAAuB,QAA2D;AAChG,QAAM,EAAE,eAAe,eAAe,gBAAgB,CAAC,GAAG,sBAAsB,8BAA8B,IAAI;AAElH,QAAM,MAAM,kBAAkB,kBAAkB,SAAY,EAAE,cAAc,IAAI,EAAE,eAAe,cAAc,CAAC;AAEhH,aAAW,cAAc,qBAAqB;AAC5C,UAAM,aAAa,KAAK,eAAe,qBAAqB,UAAU;AACtE,QAAI,WAAW,UAAU,GAAG;AAC1B,UAAI,GAAG,mBAAmB,IAAI,UAAU,EAAE,IAAI,aAAa,UAAU;AAAA,IACvE;AAAA,EACF;AAEA,aAAW,UAAU,eAAe;AAClC,eAAW,eAAe,QAAQ,GAAG;AAAA,EACvC;AAEA,SAAO;AACT;AASA,SAAS,WAAW,eAAuB,QAA4B,KAAgC;AACrG,QAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,QAAM,YAAY,OAAO,aAAa,KAAK,eAAe,qBAAqB,aAAa,QAAQ;AACpG,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,YAAY,WAAW,SAAS,IAClC,YAAY,WAAW,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IAC3G,CAAC;AAEL,aAAW,gBAAgB,CAAC,SAAS,aAAa,GAAG;AACnD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,yCAAyC,KAAK,WAAW,YAAY,CAAC;AAAA,MAErG;AAAA,IACF;AAAA,EACF;AAEA,aAAW,YAAY,WAAW;AAEhC,QAAI,aAAa,aAAa,SAAS,QAAW;AAChD;AAAA,IACF;AACA,QAAI,GAAG,YAAY,IAAI,QAAQ,EAAE,IAAI,aAAa,KAAK,WAAW,QAAQ,CAAC;AAAA,EAC7E;AAEA,MAAI,SAAS,QAAW;AACtB,UAAM,WAAmB,kBAAkB,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACvF,QAAI,GAAG,YAAY,IAAI,SAAS,EAAE,IAAI,GAAG,QAAQ;AAAA;AAAA,EACnD;AACF;",
  "names": []
}


package/dist/lib/esm/enable-plugin.d.mts

@@ -19,7 +19,10 @@ export interface EnablePluginParams {
  */
 export interface EnablePluginResult {
     /**
-     * The error message if the plugin failed to load, or `undefined` if it loaded successfully.
+     * The error message captured by the `loadPlugin` monkey-patch, or `undefined`
+     * when the patch saw no throw. When Obsidian swallows the error *before* the
+     * patch (leaving this empty) but the plugin still failed to load, the real
+     * cause — if it reached the renderer console — is in {@link EnablePluginResult.rendererConsoleErrors}.
      */
     readonly errorMessage: string | undefined;
     /**
@@ -32,6 +35,14 @@ export interface EnablePluginResult {
      * This is the definitive check — a plugin that is enabled but not loaded has failed.
      */
     readonly isLoaded: boolean;
+    /**
+     * Console/error output captured in the renderer during the enable window —
+     * populated **only** when the plugin failed to load and the monkey-patch saw
+     * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would
+     * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.
+     * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).
+     */
+    readonly rendererConsoleErrors: string | undefined;
 }
 /**
  * Enables a plugin inside Obsidian and captures any load error.
@@ -48,3 +59,17 @@ export interface EnablePluginResult {
  * @returns The enable result with error message and enabled status.
  */
 export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult>;
+/**
+ * The generic last-resort message shown when a plugin is in the enabled set but
+ * not loaded and no real error could be captured (neither the `loadPlugin`
+ * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a
+ * cause).
+ *
+ * Host-side helper — used by the setup orchestration to compose the final
+ * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}
+ * stays self-contained.
+ *
+ * @param pluginId - The ID of the plugin that failed to load.
+ * @returns The generic failure message.
+ */
+export declare function getGenericPluginLoadFailureMessage(pluginId: string): string;