obsidian-integration-testing 4.3.0 → 5.0.0

package/README.md

@@ -71,7 +71,7 @@ globalThis.__obsidianIntegrationTesting = {
 
 After setup, `globalThis.__obsidianIntegrationTesting.tempVaultPath` is available in test workers.
 
-By default this uses the **`CLI` transport** (requires `CLI` enabled in Obsidian settings). See [Transport modes](#transport-modes) for alternatives.
+By default this launches a **harness-owned, isolated `CDP` instance** (a temporary Obsidian that never touches your real config). See [Transport modes](#transport-modes) for version pinning, attaching to a running Obsidian, and mobile.
 
 ### Write integration tests
 
@@ -365,7 +365,7 @@ Both files share the same `createSetup` instance (via the common module), so `te
 >
 > **Parallelism:**
 >
-> The Obsidian `CLI` does not support executing multiple commands concurrently. If your test runner launches tests in parallel, `CLI` calls may collide and produce flaky failures. Disable file-level parallelism in your Vitest config:
+> A test run shares a single Obsidian instance and one temporary vault. Running test files in parallel makes them race on that shared instance and vault, producing flaky failures. Disable file-level parallelism in your Vitest config:
 >
 > ```ts
 > // vitest.config.ts
@@ -432,48 +432,20 @@ const title2 = await evalInObsidian({
 
 The transport determines how the library communicates with Obsidian. Configure it via transport options in your test framework's config (see [Quick start](#quick-start)):
 
-| Type                       | Platform | Mechanism                                                   |
-|----------------------------|----------|-------------------------------------------------------------|
-| `obsidian-cli` (default)   | Desktop  | Obsidian `Command Line Interface` (`CLI`) (`obsidian eval`) |
-| `obsidian-cdp`             | Desktop  | Obsidian `Chrome DevTools Protocol` (`CDP`)                 |
-| `obsidian-android-appium`  | Mobile   | Obsidian Android Appium WebView JS injection                |
+| Type                      | Platform | Mechanism                                   |
+|---------------------------|----------|---------------------------------------------|
+| `obsidian-cdp` (default)  | Desktop  | Obsidian `Chrome DevTools Protocol` (`CDP`) |
+| `obsidian-android-appium` | Mobile   | Obsidian Android Appium WebView injection   |
 
-#### `CLI` transport (default)
+#### `CDP` transport (default)
 
-Shells out to the Obsidian `Command Line Interface` (`CLI`) binary for each eval call. This is the default when no `obsidianTransport` is configured.
+By default the library **launches and owns an isolated Obsidian instance** in a temporary `--user-data-dir` on a free `--remote-debugging-port`, and communicates with it over the Obsidian `Chrome DevTools Protocol` (`CDP`). The owned instance never touches your real Obsidian — your config, vault registry, running window, and auto-update are all left untouched — and it runs in parallel with your everyday Obsidian.
 
 **Setup:**
 
-1. [Install the Obsidian `CLI`](https://obsidian.md/help/cli#Install+Obsidian+CLI).
-2. Enable `CLI` in Obsidian: `Settings → General → Developer tools → Enable CLI`.
-
-No additional vitest configuration needed — `CLI` is the default transport.
-
-#### `CDP` transport
-
-Connects via WebSocket to Obsidian `Chrome DevTools Protocol` (`CDP`) endpoint. No `CLI` binary needed, no `CLI enabled` setting required, and lower overhead per eval.
-
-**Setup:**
-
-1. Launch Obsidian with the `--remote-debugging-port` flag:
-
-   ```powershell
-   # Windows (PowerShell) — uses Obsidian from PATH (e.g. scoop), falling back to the installer location
-   $obsidian = (Get-Command Obsidian.exe -ErrorAction SilentlyContinue).Source
-   if (-not $obsidian) { $obsidian = "$env:LOCALAPPDATA\Programs\Obsidian\Obsidian.exe" }
-   Start-Process $obsidian -ArgumentList '--remote-debugging-port=8315'
-   ```
-
-   ```bash
-   # macOS
-   /Applications/Obsidian.app/Contents/MacOS/Obsidian --remote-debugging-port=8315
-
-   # Linux
-   obsidian --remote-debugging-port=8315
-   ```
-
+1. [Install Obsidian](https://obsidian.md/download) (the desktop app) so a shell is available to launch.
 2. Ensure [`Node.js`](https://nodejs.org/) 22+ is installed (uses built-in `WebSocket` and `fetch` globals).
-3. Configure vitest:
+3. No transport configuration is required — the owned `CDP` instance is the default:
 
    ```ts
    // vitest.config.ts
@@ -481,27 +453,52 @@ Connects via WebSocket to Obsidian `Chrome DevTools Protocol` (`CDP`) endpoint.
      test: {
        fileParallelism: false,
        globalSetup: ['obsidian-integration-testing/vitest-global-setup'],
-       environmentOptions: {
-         obsidianTransport: { type: 'obsidian-cdp' },
-       },
      },
    });
    ```
 
-   Optional configuration:
+##### Pinning an Obsidian version
 
-   ```ts
-   environmentOptions: {
-     obsidianTransport: {
-       type: 'obsidian-cdp',
-
-       // default values can be omitted
-       host: 'localhost',
-       port: 8315,
-       commandTimeoutInMilliseconds: 30000
-     },
-   }
-   ```
+To run the tests against a specific Obsidian version, set `obsidianVersion` and/or `obsidianInstallerVersion`. Each accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Downloaded asars and installer shells are cached under the system temp dir for reuse.
+
+```ts
+environmentOptions: {
+  obsidianTransport: {
+    type: 'obsidian-cdp',
+    // The Obsidian app version (asar). At or above the installed shell version
+    // it is applied as a fast asar swap; an older version transparently
+    // downloads the matching installer.
+    obsidianVersion: '1.8.10',
+  },
+}
+```
+
+- **`obsidianVersion`** pins the app code (asar). When omitted, the owned instance runs the same version your installed Obsidian currently runs.
+- **`obsidianInstallerVersion`** pins the Electron shell (installer build), downloaded and extracted from the matching GitHub release (Windows installers require [7-Zip](https://www.7-zip.org/) on `PATH`). Public releases only — catalyst/beta builds have no public installer, so a catalyst version can only be pinned at the asar level.
+
+##### Attaching to a running Obsidian
+
+To attach to an already-running Obsidian instead of owning one, launch Obsidian with `--remote-debugging-port=<port>` and set `port` to that same port (the version-pinning options do not apply in attach mode):
+
+```powershell
+# Windows (PowerShell) — uses Obsidian from PATH (e.g. scoop), falling back to the installer location
+$obsidian = (Get-Command Obsidian.exe -ErrorAction SilentlyContinue).Source
+if (-not $obsidian) { $obsidian = "$env:LOCALAPPDATA\Programs\Obsidian\Obsidian.exe" }
+Start-Process $obsidian -ArgumentList '--remote-debugging-port=8315'
+```
+
+```ts
+environmentOptions: {
+  obsidianTransport: {
+    type: 'obsidian-cdp',
+    port: 8315, // must match the --remote-debugging-port Obsidian was launched with
+
+    // default values can be omitted
+    host: 'localhost',
+    commandTimeoutInMilliseconds: 30000,
+  },
+}
+```
 
 #### Obsidian Android Appium transport
 

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

@@ -40,10 +40,11 @@ var import_enable_plugin = require("./enable-plugin.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_log = require("./log.cjs");
 var import_serialize_error = require("./serialize-error.cjs");
+var import_setup_lock = require("./setup-lock.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
-const DEFAULT_TRANSPORT_TYPE = "obsidian-cli";
+const DEFAULT_TRANSPORT_TYPE = "obsidian-cdp";
 const DIST_DEV = "dist/dev";
 const DIST_BUILD = "dist/build";
 const MAIN_JS = "main.js";
@@ -53,6 +54,8 @@ const COMMUNITY_PLUGINS_JSON = "community-plugins.json";
 const activeSetups = /* @__PURE__ */ new Set();
 const disposedResults = /* @__PURE__ */ new WeakSet();
 let isCleanupHandlerRegistered = false;
+const setupLocks = /* @__PURE__ */ new Map();
+const ANDROID_LOCK_SCOPE = "android";
 async function coreSetup(params) {
   const projectRoot = findProjectRoot();
   const envFilePath = (0, import_node_path.join)(projectRoot, ".env");
@@ -61,11 +64,19 @@ async function coreSetup(params) {
   }
   const transportOptions = params?.transportOptions;
   const label = transportOptions?.type ?? DEFAULT_TRANSPORT_TYPE;
-  (0, import_log.log)(`[integration-setup:${label}] Creating transport...`);
-  const transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
-  (0, import_log.log)(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);
+  const lockScope = getLockScope(transportOptions);
+  let lock;
+  if (lockScope !== void 0) {
+    (0, import_log.log)(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);
+    lock = await (0, import_setup_lock.acquireSetupLock)({ label, scope: lockScope });
+    (0, import_log.log)(`[integration-setup:${label}] Setup lock acquired.`);
+  }
+  let transport;
   let tempVault;
   try {
+    (0, import_log.log)(`[integration-setup:${label}] Creating transport...`);
+    transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
+    (0, import_log.log)(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);
     (0, import_log.log)(`[integration-setup:${label}] Project root: ${projectRoot}`);
     const distPath = await resolveDistPath(projectRoot);
     const manifestJson = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(distPath, "manifest.json"), "utf-8"));
@@ -106,28 +117,32 @@ async function coreSetup(params) {
       throw new Error(`Plugin "${pluginId}" failed to load: ${errorMessage}`);
     }
     (0, import_log.log)(`[integration-setup:${label}] Plugin "${pluginId}" enabled successfully.`);
+    const augmentedOptions = augmentTransportOptions(transportOptions, transport);
+    const result = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };
+    activeSetups.add(result);
+    if (lock) {
+      setupLocks.set(result, lock);
+    }
+    registerProcessCleanupHandler();
+    return result;
   } catch (error) {
     (0, import_log.log)(`[integration-setup:${label}] Setup failed, cleaning up...`);
     try {
-      if (tempVault) {
+      if (tempVault && transport) {
         await tempVault.dispose(transport);
       }
     } catch (cleanupError) {
       (0, import_log.log)(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${(0, import_serialize_error.serializeError)(cleanupError)}`);
     }
     try {
-      await transport.dispose?.();
+      await transport?.dispose?.();
     } catch (cleanupError) {
       (0, import_log.log)(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${(0, import_serialize_error.serializeError)(cleanupError)}`);
     }
+    lock?.release();
     (0, import_log.log)(`[integration-setup:${label}] NOTE: If the test runner reports "No test files found", ignore it \u2014 it is a side effect of the setup failure above.`);
     throw error;
   }
-  const augmentedOptions = augmentTransportOptions(transportOptions, transport);
-  const result = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };
-  activeSetups.add(result);
-  registerProcessCleanupHandler();
-  return result;
 }
 async function coreTeardown(result) {
   if (!result || disposedResults.has(result)) {
@@ -141,6 +156,7 @@ async function coreTeardown(result) {
     (0, import_log.log)(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${(0, import_serialize_error.serializeError)(error)}`);
   } finally {
     activeSetups.delete(result);
+    releaseSetupLock(result);
   }
 }
 function augmentTransportOptions(options, transport) {
@@ -168,6 +184,9 @@ function findProjectRoot() {
     dir = parent;
   }
 }
+function getLockScope(transportOptions) {
+  return transportOptions?.type === "obsidian-android-appium" ? ANDROID_LOCK_SCOPE : void 0;
+}
 function registerProcessCleanupHandler() {
   if (isCleanupHandlerRegistered) {
     return;
@@ -211,10 +230,18 @@ function registerProcessCleanupHandler() {
       } catch (error) {
         (0, import_log.log)(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${(0, import_serialize_error.serializeError)(error)}`);
       }
+      releaseSetupLock(result);
     }
     activeSetups.clear();
   });
 }
+function releaseSetupLock(result) {
+  const lock = setupLocks.get(result);
+  if (lock) {
+    lock.release();
+    setupLocks.delete(result);
+  }
+}
 async function resolveDistPath(projectRoot) {
   const devPath = (0, import_node_path.join)(projectRoot, DIST_DEV);
   const buildPath = (0, import_node_path.join)(projectRoot, DIST_BUILD);
@@ -250,4 +277,4 @@ async function teardownAsync(result) {
   coreSetup,
   coreTeardown
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\n\nimport type { PopulateFilesParams } from './temp-vault.cjs';\nimport type { ObsidianTransportOptions } from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { enablePluginWithErrorCapture } from './enable-plugin.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { log } from './log.cjs';\nimport { serializeError } from './serialize-error.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, defaults to the CLI transport. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cli\"`, `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, copies the built\n * plugin into a temporary vault, registers the vault with Obsidian, and\n * enables the plugin.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = params?.transportOptions;\n  const label = transportOptions?.type ?? DEFAULT_TRANSPORT_TYPE;\n  log(`[integration-setup:${label}] Creating transport...`);\n  const transport = await createTransportFromOptions(transportOptions);\n  log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const distPath = await resolveDistPath(projectRoot);\n    const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n    const pluginId = manifestJson.id;\n\n    if (transport.isMobile && manifestJson.isDesktopOnly) {\n      throw new Error(\n        `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n      );\n    }\n\n    const mainJs = join(distPath, MAIN_JS);\n    const buildStat = await stat(mainJs);\n\n    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n    await mkdir(pluginDir, { recursive: true });\n    await cp(distPath, pluginDir, { recursive: true });\n    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    // Enable the plugin and verify it loaded. Obsidian's enablePlugin() wraps\n    // LoadPlugin() in a try-catch that swallows errors and returns false.\n    // We monkey-patch loadPlugin() to capture the error before it's swallowed.\n    log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n    const { errorMessage } = await evalInObsidian({\n      args: { pluginId },\n      fn: enablePluginWithErrorCapture,\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath: tempVault.path\n    });\n\n    if (errorMessage) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${errorMessage}`);\n    }\n\n    log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully.`);\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${serializeError(cleanupError)}`);\n    }\n    try {\n      await transport.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${serializeError(cleanupError)}`);\n    }\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n\n  const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n  const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n  activeSetups.add(result);\n  registerProcessCleanupHandler();\n  return result;\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${serializeError(error)}`);\n  } finally {\n    activeSetups.delete(result);\n  }\n}\n\n/**\n * Augments transport options with session reuse info when the transport\n * supports it (currently Appium only).\n *\n * The augmented options are provided to test workers so they can reattach\n * to the existing session instead of creating a new one.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type !== 'obsidian-android-appium' || !(transport instanceof AppiumTransport)) {\n    return options;\n  }\n\n  const sessionInfo = transport.getSessionInfo();\n  log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n\n  return {\n    ...options,\n    deviceId: sessionInfo.deviceId,\n    sessionId: sessionInfo.sessionId\n  };\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${serializeError(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${serializeError(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${serializeError(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${serializeError(error)}`);\n      }\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${serializeError(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${serializeError(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\n\nimport type { SetupLock } from './setup-lock.cjs';\nimport type { PopulateFilesParams } from './temp-vault.cjs';\nimport type { ObsidianTransportOptions } from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { enablePluginWithErrorCapture } from './enable-plugin.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { log } from './log.cjs';\nimport { serializeError } from './serialize-error.cjs';\nimport { acquireSetupLock } from './setup-lock.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, defaults to the CLI transport. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, copies the built\n * plugin into a temporary vault, registers the vault with Obsidian, and\n * enables the plugin.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = params?.transportOptions;\n  const label = transportOptions?.type ?? DEFAULT_TRANSPORT_TYPE;\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  let transport: ObsidianTransport | undefined;\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const distPath = await resolveDistPath(projectRoot);\n    const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n    const pluginId = manifestJson.id;\n\n    if (transport.isMobile && manifestJson.isDesktopOnly) {\n      throw new Error(\n        `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n      );\n    }\n\n    const mainJs = join(distPath, MAIN_JS);\n    const buildStat = await stat(mainJs);\n\n    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n    await mkdir(pluginDir, { recursive: true });\n    await cp(distPath, pluginDir, { recursive: true });\n    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    // Enable the plugin and verify it loaded. Obsidian's enablePlugin() wraps\n    // LoadPlugin() in a try-catch that swallows errors and returns false.\n    // We monkey-patch loadPlugin() to capture the error before it's swallowed.\n    log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n    const { errorMessage } = await evalInObsidian({\n      args: { pluginId },\n      fn: enablePluginWithErrorCapture,\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath: tempVault.path\n    });\n\n    if (errorMessage) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${errorMessage}`);\n    }\n\n    log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully.`);\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault && transport) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${serializeError(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${serializeError(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${serializeError(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n}\n\n/**\n * Augments transport options with session reuse info when the transport\n * supports it (currently Appium only).\n *\n * The augmented options are provided to test workers so they can reattach\n * to the existing session instead of creating a new one.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type !== 'obsidian-android-appium' || !(transport instanceof AppiumTransport)) {\n    return options;\n  }\n\n  const sessionInfo = transport.getSessionInfo();\n  log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n\n  return {\n    ...options,\n    deviceId: sessionInfo.deviceId,\n    sessionId: sessionInfo.sessionId\n  };\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${serializeError(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${serializeError(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${serializeError(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${serializeError(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${serializeError(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${serializeError(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -32,7 +32,7 @@ export interface CoreSetupResult {
     readonly tempVault: TempVault;
     /** The transport instance used during setup. */
     readonly transport: ObsidianTransport;
-    /** Short label for log messages (e.g. `"obsidian-cli"`, `"obsidian-cdp"`). */
+    /** Short label for log messages (e.g. `"obsidian-cdp"`). */
     readonly transportLabel: string;
     /** The transport options that were resolved. */
     readonly transportOptions: ObsidianTransportOptions | undefined;

package/dist/lib/cjs/index.cjs

@@ -21,7 +21,6 @@ __export(index_exports, {
   AppiumTransport: () => import_transport_appium.AppiumTransport,
   ContextId: () => import_context_id.ContextId,
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
-  DesktopCliTransport: () => import_transport_desktop_cli.DesktopCliTransport,
   TempVault: () => import_temp_vault.TempVault,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
   evalInObsidian: () => import_eval_in_obsidian.evalInObsidian,
@@ -37,7 +36,6 @@ var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
-var import_transport_desktop_cli = require("./transport-desktop-cli.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
 var import_vault_registry = require("./vault-registry.cjs");
 // Annotate the CommonJS export names for ESM import in node:
@@ -45,7 +43,6 @@ var import_vault_registry = require("./vault-registry.cjs");
   AppiumTransport,
   ContextId,
   DesktopCdpTransport,
-  DesktopCliTransport,
   TempVault,
   createTransportFromOptions,
   evalInObsidian,
@@ -54,4 +51,4 @@ var import_vault_registry = require("./vault-registry.cjs");
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -12,10 +12,9 @@ export type { PopulateFileContent, PopulateFilesParams } from './temp-vault.cjs'
 export { TempVault } from './temp-vault.cjs';
 export type { AppiumSessionInfo, AppiumTransportConfig } from './transport-appium.cjs';
 export { AppiumTransport } from './transport-appium.cjs';
-export type { DesktopCdpTransportConfig } from './transport-desktop-cdp.cjs';
+export type { DesktopCdpTransportConfig, OwnedInstanceAsar, OwnedInstanceConfig } from './transport-desktop-cdp.cjs';
 export { DesktopCdpTransport } from './transport-desktop-cdp.cjs';
-export { DesktopCliTransport } from './transport-desktop-cli.cjs';
 export { createTransportFromOptions } from './transport-factory.cjs';
-export type { ObsidianAndroidAppiumTransportOptions, ObsidianCdpTransportOptions, ObsidianCliTransportOptions, ObsidianTransportOptions } from './transport-options.cjs';
+export type { ObsidianAndroidAppiumTransportOptions, ObsidianCdpTransportOptions, ObsidianTransportOptions } from './transport-options.cjs';
 export type { ObsidianTransport, TransportEvalOptions } from './transport.cjs';
 export { registerVault, unregisterVault } from './vault-registry.cjs';

package/dist/lib/cjs/kill-process-tree.cjs

@@ -0,0 +1,57 @@
+"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 kill_process_tree_exports = {};
+__export(kill_process_tree_exports, {
+  killProcessTree: () => killProcessTree
+});
+module.exports = __toCommonJS(kill_process_tree_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_log = require("./log.cjs");
+function killProcessTree(child) {
+  if (child.pid === void 0) {
+    return;
+  }
+  if (import_node_process.default.platform === "win32") {
+    try {
+      (0, import_node_child_process.execFileSync)("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+    } catch (error) {
+      (0, import_log.log)(
+        `[kill-process-tree] taskkill for PID ${String(child.pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+      );
+    }
+  } else {
+    child.kill("SIGKILL");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  killProcessTree
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/kill-process-tree.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @file
+ *
+ * Cross-platform helper to kill a child process and its entire process tree.
+ */
+import type { ChildProcess } from 'node:child_process';
+/**
+ * Kills a child process and its entire process tree.
+ *
+ * On Windows, `child.kill()` only sends SIGTERM to the direct process,
+ * leaving spawned grandchildren (e.g. Electron renderer/GPU helpers, QEMU,
+ * UiAutomator) alive. `taskkill /F /T /PID` forcefully terminates the entire tree.
+ *
+ * @param child - The child process to kill.
+ */
+export declare function killProcessTree(child: ChildProcess): void;

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "4.2.6";
+const LIBRARY_VERSION = false ? "dev" : "4.4.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION