obsidian-integration-testing 8.3.0 → 9.0.0

package/dist/lib/cjs/transport-desktop-cdp.cjs

@@ -35,6 +35,8 @@ var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
+var import_asar_fallback_detection = require("./asar-fallback-detection.cjs");
+var import_compatibility_options = require("./compatibility-options.cjs");
 var import_dismiss_trust_dialog = require("./dismiss-trust-dialog.cjs");
 var import_electron_compatibility = require("./electron-compatibility.cjs");
 var import_exec = require("./exec.cjs");
@@ -45,8 +47,10 @@ var import_obsidian_executable = require("./obsidian-executable.cjs");
 var import_obsidian_instance = require("./obsidian-instance.cjs");
 var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version_switch = require("./obsidian-version-switch.cjs");
+var import_owned_vault_seed = require("./owned-vault-seed.cjs");
 var import_renderer_boot_detection = require("./renderer-boot-detection.cjs");
 var import_renderer_failed_to_initialize_error = require("./renderer-failed-to-initialize-error.cjs");
+var import_silent_asar_fallback_error = require("./silent-asar-fallback-error.cjs");
 var import_type_guards = require("./type-guards.cjs");
 var import_visibility = require("./visibility.cjs");
 const COMMAND_TIMEOUT_IN_MILLISECONDS = 3e4;
@@ -56,6 +60,8 @@ const USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS = 500;
 const NO_OUTPUT = "(no output)";
 const VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 3e4;
+const OWNED_LAUNCH_MAX_ATTEMPTS = 3;
+const OWNED_RELAUNCH_SETTLE_IN_MILLISECONDS = 3e3;
 const VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1e3;
 const AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
 const AUTO_START_TIMEOUT_IN_MILLISECONDS = 3e4;
@@ -69,6 +75,7 @@ class DesktopCdpTransport {
    */
   isMobile = false;
   activeVaultPath = null;
+  asarFallback;
   cdpHost;
   cdpPort;
   cdpUrl;
@@ -81,6 +88,7 @@ class DesktopCdpTransport {
   ownedConfig;
   ownedInstance;
   shouldDisableSandbox;
+  shouldThrowOnSilentAsarFallback;
   shouldWarnOnCompatibilityIssues;
   ws = null;
   /**
@@ -89,16 +97,29 @@ class DesktopCdpTransport {
    * @param config - CDP connection configuration.
    */
   constructor(config) {
-    this.cdpHost = config?.cdpHost ?? "localhost";
-    this.commandTimeoutInMilliseconds = config?.commandTimeoutInMilliseconds ?? COMMAND_TIMEOUT_IN_MILLISECONDS;
-    this.deadBootGraceInMilliseconds = config?.deadBootGraceInMilliseconds ?? import_renderer_boot_detection.DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS;
-    this.isHarnessOwnedInstance = config?.isHarnessOwnedInstance ?? false;
-    this.isObsidianAppVisible = config?.isObsidianAppVisible ?? true;
-    this.ownedConfig = config?.ownedInstance;
-    this.shouldDisableSandbox = config?.shouldDisableSandbox ?? false;
-    this.shouldWarnOnCompatibilityIssues = config?.shouldWarnOnCompatibilityIssues ?? true;
-    this.cdpPort = config?.cdpPort ?? 0;
-    this.cdpUrl = config?.cdpPort === void 0 ? "" : `http://${this.cdpHost}:${String(config.cdpPort)}`;
+    const {
+      cdpHost = "localhost",
+      cdpPort,
+      commandTimeoutInMilliseconds = COMMAND_TIMEOUT_IN_MILLISECONDS,
+      deadBootGraceInMilliseconds = import_renderer_boot_detection.DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
+      isHarnessOwnedInstance = false,
+      isObsidianAppVisible = true,
+      ownedInstance,
+      shouldDisableSandbox = false,
+      shouldThrowOnSilentAsarFallback = true,
+      shouldWarnOnCompatibilityIssues = true
+    } = config ?? {};
+    this.cdpHost = cdpHost;
+    this.commandTimeoutInMilliseconds = commandTimeoutInMilliseconds;
+    this.deadBootGraceInMilliseconds = deadBootGraceInMilliseconds;
+    this.isHarnessOwnedInstance = isHarnessOwnedInstance;
+    this.isObsidianAppVisible = isObsidianAppVisible;
+    this.ownedConfig = ownedInstance;
+    this.shouldDisableSandbox = shouldDisableSandbox;
+    this.shouldThrowOnSilentAsarFallback = shouldThrowOnSilentAsarFallback;
+    this.shouldWarnOnCompatibilityIssues = shouldWarnOnCompatibilityIssues;
+    this.cdpPort = cdpPort ?? 0;
+    this.cdpUrl = cdpPort === void 0 ? "" : `http://${cdpHost}:${String(cdpPort)}`;
   }
   /**
    * Disposes of the active WebSocket connection and, in owned-instance mode,
@@ -165,6 +186,21 @@ class DesktopCdpTransport {
     }
     return String(resultObj.value);
   }
+  /**
+   * Returns the silent-asar-fallback verdict for this owned instance — whether the
+   * app version it is actually running matches the swapped-in pin, or the installer
+   * silently reverted to its own bundled asar (read live post-boot). Returns
+   * `undefined` when this is not an owned instance, the instance has not booted
+   * yet, or the verdict could not be determined (no asar was swapped, or the live
+   * version was unreadable). A `'fallback'` verdict reaches this surface only when
+   * the throw is disabled ({@link DesktopCdpTransportConfig.shouldThrowOnSilentAsarFallback}
+   * `false`); otherwise it throws `SilentAsarFallbackError`.
+   *
+   * @returns The silent-asar-fallback verdict, or `undefined`.
+   */
+  getAsarFallback() {
+    return this.asarFallback;
+  }
   /**
    * Returns the resolved installer↔app compatibility verdict for this owned
    * instance, so callers can assert on it. Returns `undefined` when this is not
@@ -295,39 +331,90 @@ class DesktopCdpTransport {
     }
   }
   /**
-   * Best-effort tier-2 runtime nag: reads the live Electron version and running
-   * app version from the booted owned renderer and warns when the Electron the
-   * instance is actually running is older than the app's recommended minimum.
-   * Stores the verdict on {@link getElectronCompatibility}.
+   * Computes and stores the runtime-Electron compatibility verdict (on
+   * {@link getElectronCompatibility}) from an already-read version pair, warning
+   * when the live Electron is below the app's recommended minimum. Never throws; a
+   * boot whose running app version was unreadable is skipped (nothing to judge).
    *
-   * The app version is read **live** — the running app version from the main
-   * process (`ipcRenderer.sendSync('version')`, the same IPC channel the namespace
-   * bootstrap uses) rather than from the resolved config — so the nag reflects the
-   * version genuinely running across every owned sub-path (asar-swap / downgrade /
-   * own-installer) and stays truthful even under a silent asar fallback.
-   * `process.versions.electron` gives the shell's live Electron. Both are read at
-   * the renderer top level (no `require('obsidian')`, which resolves only inside a
-   * plugin-load context). Never throws — a read failure is logged and ignored, so
-   * it cannot break an otherwise-ready boot.
+   * @param appVersion - The live running app version, or `undefined` when unreadable.
+   * @param actualElectronVersion - The live Electron version, or `undefined` when unreadable.
+   */
+  applyElectronCompatibility(appVersion, actualElectronVersion) {
+    if (appVersion === void 0) {
+      return;
+    }
+    const verdict = (0, import_electron_compatibility.checkElectronCompatibility)({
+      actualElectronVersion,
+      appVersion,
+      metadata: (0, import_obsidian_metadata.getVersionMetadata)(appVersion)
+    });
+    this.electronCompatibility = verdict;
+    if (verdict.tier === "nagged" && this.shouldWarnOnCompatibilityIssues) {
+      (0, import_log.log)(`[cdp-transport] ${(0, import_type_guards.ensureNonNullable)(verdict.message)}`);
+    }
+  }
+  /**
+   * Verifies the running app (asar) version matches the swapped-in pin, storing the
+   * verdict on {@link getAsarFallback}. On a **silent fallback** (the installer ran
+   * its own bundled asar instead of the pin) it throws {@link SilentAsarFallbackError}
+   * when the throw is enabled, otherwise warns (when warnings are on) and lets the
+   * boot proceed. A boot with no swapped-in asar, or an unreadable running version,
+   * is `'unknown'` — nothing is thrown or warned. This is the healthy-UI companion to
+   * the black-screen {@link RendererFailedToInitializeError} dead-boot fast-fail.
+   *
+   * @param runningApiVersion - The live running app version, or `undefined` when unreadable.
+   */
+  checkRuntimeAsarFallback(runningApiVersion) {
+    const verdict = (0, import_asar_fallback_detection.checkAsarFallback)({
+      requestedVersion: this.ownedConfig?.asar?.version,
+      runningApiVersion
+    });
+    this.asarFallback = verdict;
+    const action = (0, import_compatibility_options.resolveAsarFallbackAction)({
+      shouldThrowOnSilentAsarFallback: this.shouldThrowOnSilentAsarFallback,
+      shouldWarnOnCompatibilityIssues: this.shouldWarnOnCompatibilityIssues,
+      tier: verdict.tier
+    });
+    if (action === "throw") {
+      throw new import_silent_asar_fallback_error.SilentAsarFallbackError({
+        requestedVersion: (0, import_type_guards.ensureNonNullable)(verdict.requestedVersion),
+        runningApiVersion: (0, import_type_guards.ensureNonNullable)(verdict.runningApiVersion)
+      });
+    }
+    if (action === "warn") {
+      (0, import_log.log)(`[cdp-transport] ${(0, import_type_guards.ensureNonNullable)(verdict.message)}`);
+    }
+  }
+  /**
+   * Runs the post-boot runtime compatibility checks for an owned instance, once the
+   * vault is ready. Reads the live running app version and Electron version **once**
+   * from the booted renderer's main process, then: (1) verifies the running app
+   * version matches the swapped-in pin — throwing {@link SilentAsarFallbackError} on
+   * a silent fallback (when enabled); and (2) runs the best-effort runtime-Electron
+   * nag. Only the asar-fallback check can throw, so this must run outside the
+   * readiness poll's try/catch (a swallowed throw would loop until timeout).
+   *
+   * Both are read at the renderer top level: `ipcRenderer.sendSync('version')` (the
+   * running app version, truthful even under a silent asar fallback) and
+   * `process.versions.electron` (the live shell Electron); neither uses
+   * `require('obsidian')`, which resolves only inside a plugin-load context. A read
+   * failure leaves both unknown (logged, non-fatal) — an unreadable running version
+   * cannot be judged a fallback, so the boot is not broken by a flaky read.
    *
    * @param vaultPath - The vault path to evaluate in.
    */
-  async checkRuntimeElectronCompatibility(vaultPath) {
+  async checkRuntimeCompatibility(vaultPath) {
+    let appVersion;
+    let actualElectronVersion;
     try {
-      const appVersion = await this.evaluate("String(window.electron.ipcRenderer.sendSync('version'))", { cwd: vaultPath });
-      const actualElectronVersion = await this.evaluate("String(process.versions.electron)", { cwd: vaultPath });
-      const verdict = (0, import_electron_compatibility.checkElectronCompatibility)({
-        actualElectronVersion,
-        appVersion,
-        metadata: (0, import_obsidian_metadata.getVersionMetadata)(appVersion)
-      });
-      this.electronCompatibility = verdict;
-      if (verdict.tier === "nagged" && this.shouldWarnOnCompatibilityIssues) {
-        (0, import_log.log)(`[cdp-transport] ${(0, import_type_guards.ensureNonNullable)(verdict.message)}`);
-      }
+      const rawAppVersion = await this.evaluate("String(window.electron.ipcRenderer.sendSync('version'))", { cwd: vaultPath });
+      appVersion = rawAppVersion === "" || rawAppVersion === "undefined" ? void 0 : rawAppVersion;
+      actualElectronVersion = await this.evaluate("String(process.versions.electron)", { cwd: vaultPath });
     } catch (error) {
-      (0, import_log.log)(`[cdp-transport] Could not check runtime Electron compatibility (non-fatal): ${String(error)}`);
+      (0, import_log.log)(`[cdp-transport] Could not read runtime versions (non-fatal): ${String(error)}`);
     }
+    this.checkRuntimeAsarFallback(appVersion);
+    this.applyElectronCompatibility(appVersion, actualElectronVersion);
   }
   /**
    * Connects to a CDP target's WebSocket endpoint.
@@ -478,6 +565,27 @@ class DesktopCdpTransport {
     const targets = await response.json();
     return targets.filter((t) => t.type === "page");
   }
+  /**
+   * Kills the currently-running owned instance (if any) and waits for it to exit,
+   * so the next launch gets a pristine single-window instance.
+   *
+   * Relaunching over a live instance is forwarded by Electron's single-instance
+   * lock on the shared user-data dir and surfaces the vault picker, and opening a
+   * second window via IPC leaves stale windows that break vault-target routing —
+   * hence a full kill + wait-for-exit (releasing the lock) between launches. A
+   * no-op on the first attempt, when no instance is running yet.
+   */
+  async killRunningOwnedInstance() {
+    if (!this.ownedInstance) {
+      return;
+    }
+    (0, import_log.log)("[cdp-transport] Killing running owned instance before (re)launch.");
+    this.disconnect();
+    const previousCdpUrl = this.cdpUrl;
+    this.ownedInstance.kill();
+    this.ownedInstance = void 0;
+    await this.waitForInstanceExit(previousCdpUrl);
+  }
   /**
    * Moves the owned instance's window off-screen so a hidden run never steals
    * focus. Uses Electron's remote bridge (`window.electron.remote`) — the only
@@ -493,8 +601,13 @@ class DesktopCdpTransport {
    */
   async moveOwnedWindowOffscreen() {
     const moveExpr = `(() => {
-      const remote = window.electron && window.electron.remote;
-      if (!remote || typeof remote.getCurrentWindow !== 'function') { return 'no-bridge'; }
+      let remote = (window.electron && window.electron.remote) || null;
+      if (!remote) {
+        try { remote = require('electron').remote || null; } catch (requireError) { remote = null; }
+      }
+      if (!remote || typeof remote.getCurrentWindow !== 'function') {
+        return (typeof window.app === 'undefined') ? 'not-ready' : 'no-bridge';
+      }
       const win = remote.getCurrentWindow();
       const displays = remote.screen.getAllDisplays();
       const maxRight = Math.max(...displays.map((display) => display.bounds.x + display.bounds.width));
@@ -624,7 +737,9 @@ class DesktopCdpTransport {
     const ws = await this.connectToTarget(target);
     try {
       const response = await this.sendCommand(ws, "Runtime.evaluate", {
-        expression: "app.vault.adapter.getBasePath()",
+        // Old Obsidian versions (e.g. 0.6.x) predate the `getBasePath()` method but
+        // Expose the `basePath` property; the method exists from ~0.9.20 onward.
+        expression: "app.vault.adapter.getBasePath ? app.vault.adapter.getBasePath() : app.vault.adapter.basePath",
         returnByValue: true
       });
       return String(response.result?.result?.value);
@@ -642,42 +757,46 @@ class DesktopCdpTransport {
    */
   async registerVaultInOwnedInstance(vaultPath) {
     const config = (0, import_type_guards.ensureNonNullable)(this.ownedConfig);
-    if (this.ownedInstance) {
-      (0, import_log.log)(`[cdp-transport] Relaunching owned instance for new vault: ${vaultPath}`);
-      this.disconnect();
-      const previousCdpUrl = this.cdpUrl;
-      this.ownedInstance.kill();
-      this.ownedInstance = void 0;
-      await this.waitForInstanceExit(previousCdpUrl);
-    } else {
-      (0, import_log.log)(`[cdp-transport] Launching owned Obsidian instance for vault: ${vaultPath}`);
-    }
     (0, import_node_fs.mkdirSync)(config.userDataDir, { recursive: true });
     if (config.asar) {
       (0, import_obsidian_version_switch.copyAsarIntoUserData)(config.asar.path, config.asar.version, config.userDataDir);
     }
     const vaultId = (0, import_node_crypto.randomBytes)(VAULT_ID_BYTE_LENGTH).toString("hex");
-    const obsidianJson = {
-      updateDisabled: true,
-      vaults: { [vaultId]: { open: true, path: vaultPath, ts: Date.now() } }
-    };
+    const obsidianJson = (0, import_owned_vault_seed.buildOwnedObsidianJson)({ ts: Date.now(), vaultId, vaultPath });
     (0, import_node_fs.writeFileSync)((0, import_node_path.join)(config.userDataDir, "obsidian.json"), JSON.stringify(obsidianJson));
-    const instance = await (0, import_obsidian_instance.launchOwnedObsidianInstance)({
-      cdpHost: this.cdpHost,
-      exePath: config.exePath,
-      extraArgs: [
-        ...(0, import_visibility.resolveOwnedHiddenLaunchArgs)(this.isObsidianAppVisible),
-        ...(0, import_visibility.resolveSandboxLaunchArgs)(this.shouldDisableSandbox)
-      ],
-      userDataDir: config.userDataDir
-    });
-    this.ownedInstance = instance;
-    this.cdpPort = instance.port;
-    this.cdpUrl = instance.cdpUrl;
-    if ((0, import_visibility.shouldHideObsidianApp)(this.isObsidianAppVisible)) {
-      await this.moveOwnedWindowOffscreen();
+    let lastError;
+    for (let attempt = 1; attempt <= OWNED_LAUNCH_MAX_ATTEMPTS; attempt++) {
+      await this.killRunningOwnedInstance();
+      if (attempt > 1) {
+        await delay(OWNED_RELAUNCH_SETTLE_IN_MILLISECONDS);
+      }
+      const instance = await (0, import_obsidian_instance.launchOwnedObsidianInstance)({
+        cdpHost: this.cdpHost,
+        exePath: config.exePath,
+        extraArgs: [
+          ...(0, import_visibility.resolveOwnedHiddenLaunchArgs)(this.isObsidianAppVisible),
+          ...(0, import_visibility.resolveSandboxLaunchArgs)(this.shouldDisableSandbox)
+        ],
+        userDataDir: config.userDataDir
+      });
+      this.ownedInstance = instance;
+      this.cdpPort = instance.port;
+      this.cdpUrl = instance.cdpUrl;
+      if ((0, import_visibility.shouldHideObsidianApp)(this.isObsidianAppVisible)) {
+        await this.moveOwnedWindowOffscreen();
+      }
+      try {
+        await this.waitForOwnedVaultReady(vaultPath);
+        return;
+      } catch (error) {
+        if (error instanceof import_renderer_failed_to_initialize_error.RendererFailedToInitializeError || error instanceof import_silent_asar_fallback_error.SilentAsarFallbackError) {
+          throw error;
+        }
+        lastError = error;
+        (0, import_log.log)(`[cdp-transport] Owned vault not ready (attempt ${String(attempt)}/${String(OWNED_LAUNCH_MAX_ATTEMPTS)}): ${String(error)}`);
+      }
     }
-    await this.waitForOwnedVaultReady(vaultPath);
+    throw lastError instanceof Error ? lastError : new Error(`Owned vault at ${vaultPath} did not become ready`);
   }
   /**
    * Sends a CDP command over WebSocket and waits for the response.
@@ -763,15 +882,16 @@ class DesktopCdpTransport {
     (0, import_log.log)(`[cdp-transport] Waiting for owned vault to become ready (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);
     const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;
     let documentCompleteSince = null;
+    let isReady = false;
     while (Date.now() < deadline) {
       try {
         await this.findTargetForVault(vaultPath);
         await this.waitForLayoutReady(vaultPath);
         await this.dismissTrustDialog(vaultPath);
-        await this.checkRuntimeElectronCompatibility(vaultPath);
-        (0, import_log.log)("[cdp-transport] Owned vault is ready.");
-        return;
+        isReady = true;
+        break;
       } catch {
+        this.disconnect();
       }
       if (this.deadBootGraceInMilliseconds > 0) {
         const observation = await this.probeRendererBootState();
@@ -788,7 +908,11 @@ class DesktopCdpTransport {
       }
       await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);
     }
-    throw new Error(`Owned vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+    if (!isReady) {
+      throw new Error(`Owned vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+    }
+    await this.checkRuntimeCompatibility(vaultPath);
+    (0, import_log.log)("[cdp-transport] Owned vault is ready.");
   }
 }
 function delay(ms) {
@@ -816,4 +940,4 @@ function tryRemoveDir(dir) {
 0 && (module.exports = {
   DesktopCdpTransport
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CDP transport \u2014 evaluates expressions via Chrome DevTools Protocol\n * over WebSocket and manages vaults via Electron IPC.\n *\n * Two modes:\n * - **Owned (default)**: the transport launches and owns an isolated Obsidian\n *   instance against a temporary `--user-data-dir` on a free `--remote-debugging-port`,\n *   never touching the user's Obsidian. Supports version pinning via the user-data asar.\n * - **Attach**: when an explicit CDP port is configured, the transport connects\n *   to an already-running Obsidian on that port.\n *\n * It connects to page targets, sends `Runtime.evaluate` commands, and routes to\n * the correct vault target using `getBasePath()` probing.\n *\n * Requirements: Node.js 22+ (uses built-in `WebSocket` and `fetch` globals).\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n  mkdirSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { OwnedObsidianInstance } from './obsidian-instance.cjs';\nimport type { RendererBootObservation } from './renderer-boot-detection.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { DISMISS_TRUST_DIALOG_EXPR } from './dismiss-trust-dialog.cjs';\nimport { checkElectronCompatibility } from './electron-compatibility.cjs';\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport {\n  getVaultId,\n  isVaultRegistered,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport { launchOwnedObsidianInstance } from './obsidian-instance.cjs';\nimport { getVersionMetadata } from './obsidian-metadata.cjs';\nimport { copyAsarIntoUserData } from './obsidian-version-switch.cjs';\nimport {\n  checkRendererBootState,\n  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS\n} from './renderer-boot-detection.cjs';\nimport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\nimport {\n  resolveOwnedHiddenLaunchArgs,\n  resolveSandboxLaunchArgs,\n  shouldHideObsidianApp\n} from './visibility.cjs';\n\n/**\n * Configuration for the CDP transport.\n */\nexport interface DesktopCdpTransportConfig {\n  /**\n   * CDP host. Defaults to `'localhost'`.\n   */\n  cdpHost?: string;\n\n  /**\n   * CDP port for **attach** mode (the `--remote-debugging-port` the running\n   * Obsidian was launched with). In owned-instance mode this is ignored \u2014 a\n   * free port is chosen at launch.\n   */\n  cdpPort?: number;\n\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to `30000`.\n   */\n  commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance (empty `<body>` with no `window.app` after the renderer reached\n   * `document.readyState` `'complete'`). Defaults to\n   * {@link DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS}. `0` disables fast-fail.\n   */\n  deadBootGraceInMilliseconds?: number;\n\n  /**\n   * When attaching (i.e. {@link cdpPort} is set), marks the target as a\n   * **harness-owned, already-prepared** instance. Suppresses the user-scope\n   * vault-registration preflight, since the owned instance's vault lives in an\n   * isolated user-data config rather than the user-scope registry.\n   */\n  isHarnessOwnedInstance?: boolean;\n\n  /**\n   * Whether the owned Obsidian window is shown on screen. When `false` (the\n   * default), the owned instance is launched with keep-alive Chromium flags and\n   * its window is moved off-screen after launch. Only meaningful in owned mode;\n   * attach mode never touches the (user's) window.\n   *\n   * @default `true`\n   */\n  isObsidianAppVisible?: boolean;\n\n  /**\n   * When set, the transport launches and owns an isolated Obsidian instance\n   * instead of attaching to a running one. This is the default desktop mode.\n   */\n  ownedInstance?: OwnedInstanceConfig;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`). Needed to boot on Linux without a correctly-configured\n   * setuid `chrome-sandbox` helper (e.g. an extracted portable shell, or CI as a\n   * non-root user); harmless on Windows/macOS. Only meaningful in owned mode.\n   *\n   * @default `false`\n   */\n  shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether the post-boot runtime-Electron compatibility nag warning is emitted\n   * when the live Electron is below the app's recommended minimum. The verdict is\n   * always computed and surfaced via {@link DesktopCdpTransport.getElectronCompatibility};\n   * this only gates the log. Only meaningful in owned mode.\n   *\n   * @default `true`\n   */\n  shouldWarnOnCompatibilityIssues?: boolean;\n}\n\n/**\n * An asar to provision into a harness-owned instance's user-data dir before launch.\n */\nexport interface OwnedInstanceAsar {\n  /** Absolute path to the cached/source asar file. */\n  readonly path: string;\n\n  /** The asar's `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Configuration for a harness-owned, isolated Obsidian instance.\n *\n * When present, the transport launches and owns its own Obsidian process\n * against an isolated user-data dir instead of attaching to a running instance.\n */\nexport interface OwnedInstanceConfig {\n  /** Optional asar to provision into {@link userDataDir} before launch. */\n  readonly asar?: OwnedInstanceAsar | undefined;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict, when it could be determined\n   * (an asar-swap onto a known shell version). Surfaced by\n   * {@link DesktopCdpTransport.getCompatibility}. An `'unrunnable'` verdict reaches\n   * this surface only when the proactive throw is disabled\n   * (`shouldThrowOnIncompatibleInstaller: false`); otherwise it throws\n   * `IncompatibleInstallerVersionError` before the config is built.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /** Absolute path to the Obsidian shell executable to launch. */\n  readonly exePath: string;\n\n  /**\n   * Absolute path to the isolated user-data dir. Created and owned by the\n   * transport, and deleted on dispose.\n   */\n  readonly userDataDir: string;\n}\n\ninterface CdpExceptionDetails {\n  exception?: CdpExceptionObject;\n  text: string;\n}\n\ninterface CdpExceptionObject {\n  description?: string;\n}\n\ninterface CdpResponse {\n  id: number;\n  result?: CdpResponseResult;\n}\n\ninterface CdpResponseResult {\n  readonly exceptionDetails?: CdpExceptionDetails;\n  readonly result?: CdpValue;\n}\n\ninterface CdpTarget {\n  id: string;\n  title: string;\n  type: string;\n  url: string;\n  webSocketDebuggerUrl: string;\n}\n\ninterface CdpValue {\n  type: string;\n  value?: unknown;\n}\n\n/**\n * The CDP endpoint of a launched, harness-owned instance.\n */\ninterface OwnedInstanceEndpoint {\n  /** CDP host (e.g. `'localhost'`). */\n  readonly host: string;\n\n  /** The free CDP port the owned instance was launched on. */\n  readonly port: number;\n}\n\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_ID_BYTE_LENGTH = 8;\nconst USER_DATA_RM_TIMEOUT_IN_MILLISECONDS = 10000;\nconst USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS = 500;\nconst NO_OUTPUT = '(no output)';\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\nconst INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS = 500;\nconst OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS = 200;\nconst OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS = 20000;\nconst OWNED_WINDOW_HIDE_POLL_INTERVAL_IN_MILLISECONDS = 250;\n\n/**\n * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.\n *\n * Connects to Obsidian's CDP WebSocket endpoint, sends `Runtime.evaluate`\n * commands, and routes expressions to the correct vault target.\n */\nexport class DesktopCdpTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n  private activeVaultPath: null | string = null;\n  private readonly cdpHost: string;\n  private cdpPort: number;\n  private cdpUrl: string;\n  private readonly commandTimeoutInMilliseconds: number;\n  private readonly deadBootGraceInMilliseconds: number;\n  private electronCompatibility: ElectronCompatibility | undefined;\n  private readonly isHarnessOwnedInstance: boolean;\n  private readonly isObsidianAppVisible: boolean;\n  private messageId = 0;\n  private readonly ownedConfig: OwnedInstanceConfig | undefined;\n  private ownedInstance: OwnedObsidianInstance | undefined;\n  private readonly shouldDisableSandbox: boolean;\n  private readonly shouldWarnOnCompatibilityIssues: boolean;\n  private ws: null | WebSocket = null;\n\n  /**\n   * Creates a new CDP transport.\n   *\n   * @param config - CDP connection configuration.\n   */\n  public constructor(config?: DesktopCdpTransportConfig) {\n    this.cdpHost = config?.cdpHost ?? 'localhost';\n    this.commandTimeoutInMilliseconds = config?.commandTimeoutInMilliseconds ?? COMMAND_TIMEOUT_IN_MILLISECONDS;\n    this.deadBootGraceInMilliseconds = config?.deadBootGraceInMilliseconds ?? DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS;\n    this.isHarnessOwnedInstance = config?.isHarnessOwnedInstance ?? false;\n    this.isObsidianAppVisible = config?.isObsidianAppVisible ?? true;\n    this.ownedConfig = config?.ownedInstance;\n    this.shouldDisableSandbox = config?.shouldDisableSandbox ?? false;\n    this.shouldWarnOnCompatibilityIssues = config?.shouldWarnOnCompatibilityIssues ?? true;\n    // Owned mode picks a free port at launch (assigned in registerVault).\n    // Attach mode connects to the configured port; no port is hardcoded.\n    this.cdpPort = config?.cdpPort ?? 0;\n    this.cdpUrl = config?.cdpPort === undefined ? '' : `http://${this.cdpHost}:${String(config.cdpPort)}`;\n  }\n\n  /**\n   * Disposes of the active WebSocket connection and, in owned-instance mode,\n   * kills the owned Obsidian process and removes its isolated user-data dir.\n   *\n   * The removal is retried because Windows briefly holds the just-killed\n   * process's file handles, which would otherwise fail `rmSync` with `EPERM`.\n   */\n  public async dispose(): Promise<void> {\n    this.disconnect();\n    if (!this.ownedConfig) {\n      return;\n    }\n\n    this.ownedInstance?.kill();\n    const { userDataDir } = this.ownedConfig;\n    const deadline = Date.now() + USER_DATA_RM_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      if (tryRemoveDir(userDataDir)) {\n        return;\n      }\n      await delay(USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS);\n    }\n    if (!tryRemoveDir(userDataDir)) {\n      log(`[cdp-transport] Could not remove owned user-data dir within ${String(USER_DATA_RM_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal): ${userDataDir}`);\n    }\n  }\n\n  /**\n   * Synchronous disposal \u2014 kills the owned instance and makes a best-effort\n   * removal of its user-data dir. Safe to call from a process `exit` handler\n   * (where async retries are impossible; a leftover temp dir is acceptable).\n   */\n  public disposeSync(): void {\n    this.disconnect();\n    if (this.ownedConfig) {\n      this.ownedInstance?.kill();\n      if (!tryRemoveDir(this.ownedConfig.userDataDir)) {\n        log(`[cdp-transport] Owned user-data dir not removed synchronously (process may still hold handles): ${this.ownedConfig.userDataDir}`);\n      }\n    }\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via CDP `Runtime.evaluate`.\n   *\n   * Routes to the correct vault target based on `options.cwd`.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const ws = await this.ensureConnection(options.cwd);\n    const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n      awaitPromise: true,\n      expression,\n      returnByValue: true\n    });\n\n    if (response.result?.exceptionDetails) {\n      const desc = response.result.exceptionDetails.exception?.description\n        ?? response.result.exceptionDetails.text;\n      throw new Error(`CDP evaluation error: ${desc}`);\n    }\n\n    const resultObj = response.result?.result;\n    if (!resultObj || resultObj.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObj.value);\n  }\n\n  /**\n   * Returns the resolved installer\u2194app compatibility verdict for this owned\n   * instance, so callers can assert on it. Returns `undefined` when this is not\n   * an owned instance, or the verdict could not be determined (e.g. an\n   * undetectable shell version, or the app version is absent from the table).\n   *\n   * @returns The compatibility verdict, or `undefined`.\n   */\n  public getCompatibility(): InstallerCompatibility | undefined {\n    return this.ownedConfig?.compatibility;\n  }\n\n  /**\n   * Returns the runtime Electron compatibility verdict for this owned instance \u2014\n   * whether the Electron version it is actually running is new enough for the\n   * running app version (read live post-boot; see {@link ObsidianVersionMetadata.minRecommendedElectronVersion}).\n   * Returns `undefined` when this is not an owned instance, the instance has not\n   * booted yet, or the verdict could not be determined (the live version was\n   * unreadable, or the app version carries no recommended Electron version).\n   *\n   * @returns The runtime Electron compatibility verdict, or `undefined`.\n   */\n  public getElectronCompatibility(): ElectronCompatibility | undefined {\n    return this.electronCompatibility;\n  }\n\n  /**\n   * Returns the CDP endpoint of the owned, launched instance so the global setup\n   * can hand it to test workers (which then **attach** to it instead of\n   * launching their own). Returns `undefined` when this transport is not an\n   * owned instance, or its instance has not been launched yet.\n   *\n   * @returns The owned instance's CDP host and port, or `undefined`.\n   */\n  public getOwnedInstanceEndpoint(): OwnedInstanceEndpoint | undefined {\n    if (!this.ownedConfig || !this.ownedInstance) {\n      return undefined;\n    }\n    return { host: this.cdpHost, port: this.cdpPort };\n  }\n\n  /**\n   * Verifies that the CDP endpoint is reachable and has Obsidian targets.\n   *\n   * If Obsidian is not running, attempts to auto-start it via URI protocol\n   * and polls until CDP becomes available.\n   *\n   * @param vaultPath - The vault path (used for vault registration check).\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    if (this.ownedConfig || this.isHarnessOwnedInstance) {\n      // Owned instance (launched here) or a worker attached to one: readiness is\n      // Guaranteed by the global setup's registerVault, and the vault lives in\n      // The isolated config \u2014 there is nothing to verify against the user-scope\n      // Registry.\n      return;\n    }\n\n    log(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    try {\n      const targets = await this.getPageTargets();\n      if (targets.length === 0) {\n        throw new Error('No page targets');\n      }\n      log(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);\n    } catch {\n      await this.ensureObsidianRunning();\n    }\n  }\n\n  /**\n   * Registers a vault via Electron IPC evaluated through CDP.\n   *\n   * Uses an existing Obsidian target to send the `vault-open` IPC command,\n   * then polls until the new vault's target appears.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    if (this.ownedConfig) {\n      await this.registerVaultInOwnedInstance(vaultPath);\n      return;\n    }\n\n    await this.openVaultInRunningInstance(vaultPath);\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    if (this.ownedConfig) {\n      // The owned instance is killed wholesale on dispose; no per-vault\n      // Unregister is needed (and the registry lives in the isolated config).\n      return;\n    }\n\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const target = await this.findTargetForVault(vaultPath);\n      const ws = await this.connectToTarget(target);\n      try {\n        const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: destroyExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } catch {\n      // Window may already be closed.\n    }\n\n    if (this.activeVaultPath === vaultPath) {\n      this.disconnect();\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const targets = await this.getPageTargets();\n    if (targets.length > 0) {\n      const ws = await this.connectToTarget(ensureNonNullable(targets[0]));\n      try {\n        await ensureNamespaceBootstrapped(this, vaultPath);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: removeExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } else {\n      log('[cdp-transport] No CDP targets for removal IPC \u2014 removing directly from obsidian.json.');\n      removeVaultFromConfig(vaultPath);\n    }\n  }\n\n  /**\n   * Best-effort tier-2 runtime nag: reads the live Electron version and running\n   * app version from the booted owned renderer and warns when the Electron the\n   * instance is actually running is older than the app's recommended minimum.\n   * Stores the verdict on {@link getElectronCompatibility}.\n   *\n   * The app version is read **live** \u2014 the running app version from the main\n   * process (`ipcRenderer.sendSync('version')`, the same IPC channel the namespace\n   * bootstrap uses) rather than from the resolved config \u2014 so the nag reflects the\n   * version genuinely running across every owned sub-path (asar-swap / downgrade /\n   * own-installer) and stays truthful even under a silent asar fallback.\n   * `process.versions.electron` gives the shell's live Electron. Both are read at\n   * the renderer top level (no `require('obsidian')`, which resolves only inside a\n   * plugin-load context). Never throws \u2014 a read failure is logged and ignored, so\n   * it cannot break an otherwise-ready boot.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async checkRuntimeElectronCompatibility(vaultPath: string): Promise<void> {\n    try {\n      const appVersion = await this.evaluate('String(window.electron.ipcRenderer.sendSync(\\'version\\'))', { cwd: vaultPath });\n      const actualElectronVersion = await this.evaluate('String(process.versions.electron)', { cwd: vaultPath });\n      const verdict = checkElectronCompatibility({\n        actualElectronVersion,\n        appVersion,\n        metadata: getVersionMetadata(appVersion)\n      });\n      this.electronCompatibility = verdict;\n      if (verdict.tier === 'nagged' && this.shouldWarnOnCompatibilityIssues) {\n        log(`[cdp-transport] ${ensureNonNullable(verdict.message)}`);\n      }\n    } catch (error) {\n      log(`[cdp-transport] Could not check runtime Electron compatibility (non-fatal): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Connects to a CDP target's WebSocket endpoint.\n   *\n   * @param target - The CDP target to connect to.\n   * @returns The open WebSocket connection.\n   */\n  private async connectToTarget(target: CdpTarget): Promise<WebSocket> {\n    const ws = new WebSocket(target.webSocketDebuggerUrl);\n    await new Promise<void>((resolve, reject) => {\n      ws.onopen = (): void => {\n        resolve();\n      };\n      ws.onerror = (): void => {\n        reject(new Error(`Failed to connect to CDP target: ${target.webSocketDebuggerUrl}`));\n      };\n    });\n    return ws;\n  }\n\n  /**\n   * Disconnects the active WebSocket connection.\n   */\n  private disconnect(): void {\n    if (this.ws?.readyState === WebSocket.OPEN) {\n      this.ws.close();\n    }\n    this.ws = null;\n    this.activeVaultPath = null;\n  }\n\n  /**\n   * Dismisses the \"Do you trust the author of this vault?\" dialog if present.\n   *\n   * Acts as a safety net when `enable-plugin-<id>` is written in one renderer\n   * but not yet visible to the newly-opened vault's renderer (race observed\n   * in Obsidian 1.13.0).\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async dismissTrustDialog(vaultPath: string): Promise<void> {\n    const result = await this.evaluate(DISMISS_TRUST_DIALOG_EXPR, { cwd: vaultPath });\n    if (result === 'true') {\n      log('[cdp-transport] Dismissed \"Do you trust the author\" dialog.');\n    }\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param ws - An open WebSocket to an existing Obsidian target.\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async enablePluginsInLocalStorage(ws: WebSocket, vaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cdp-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await this.sendCommand(ws, 'Runtime.evaluate', {\n      expression: `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`,\n      returnByValue: true\n    });\n    log(`[cdp-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Ensures there is an active WebSocket connection to the correct vault target.\n   *\n   * Reuses the existing connection if it targets the requested vault.\n   * Otherwise, finds the correct target and reconnects.\n   *\n   * @param vaultPath - The vault path to target.\n   * @returns The active WebSocket connection.\n   */\n  private async ensureConnection(vaultPath: string): Promise<WebSocket> {\n    if (this.ws?.readyState === WebSocket.OPEN && this.activeVaultPath === vaultPath) {\n      return this.ws;\n    }\n\n    this.disconnect();\n\n    const target = await this.findTargetForVault(vaultPath);\n    this.ws = await this.connectToTarget(target);\n    this.activeVaultPath = vaultPath;\n    return this.ws;\n  }\n\n  /**\n   * Launches Obsidian with `--remote-debugging-port` and polls until CDP becomes available.\n   */\n  private async ensureObsidianRunning(): Promise<void> {\n    log('[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...');\n\n    const launchCommand = await getObsidianLaunchCommand(this.cdpPort);\n    try {\n      await exec(launchCommand, { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        const targets = await this.getPageTargets();\n        if (targets.length > 0) {\n          log(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);\n          return;\n        }\n      } catch {\n        log('[cdp-transport] CDP not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);\n  }\n\n  /**\n   * Finds the CDP target that has the given vault open.\n   *\n   * For a single target, returns it directly. For multiple targets,\n   * probes each by evaluating `getBasePath()` to find the match.\n   *\n   * @param vaultPath - The vault path to match.\n   * @returns The matching CDP target.\n   */\n  private async findTargetForVault(vaultPath: string): Promise<CdpTarget> {\n    const targets = await this.getPageTargets();\n\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets found');\n    }\n\n    if (targets.length === 1) {\n      return ensureNonNullable(targets[0]);\n    }\n\n    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (basePath === vaultPath) {\n          return target;\n        }\n      } catch {\n        // Not a vault target or not ready.\n      }\n    }\n\n    throw new Error(`No CDP target found for vault: ${vaultPath}`);\n  }\n\n  /**\n   * Fetches the list of page-type targets from the CDP `/json` endpoint.\n   *\n   * @returns The list of page targets.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    const response = await fetch(`${this.cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.filter((t) => t.type === 'page');\n  }\n\n  /**\n   * Moves the owned instance's window off-screen so a hidden run never steals\n   * focus. Uses Electron's remote bridge (`window.electron.remote`) \u2014 the only\n   * cross-platform way to reposition the window \u2014 placing it just beyond the\n   * right edge of all displays. The window stays \"visible\" to Chromium (so\n   * timers, `requestAnimationFrame`, `:hover`, and trusted input keep working),\n   * unlike minimizing, which would freeze `requestAnimationFrame`.\n   *\n   * The remote bridge is not available the instant CDP starts serving, so this\n   * polls until the move succeeds. Best-effort: if the window cannot be moved\n   * within the timeout, the keep-alive launch flags still apply and the run\n   * proceeds (worst case the window is briefly visible).\n   */\n  private async moveOwnedWindowOffscreen(): Promise<void> {\n    const moveExpr = `(() => {\n      const remote = window.electron && window.electron.remote;\n      if (!remote || typeof remote.getCurrentWindow !== 'function') { return 'no-bridge'; }\n      const win = remote.getCurrentWindow();\n      const displays = remote.screen.getAllDisplays();\n      const maxRight = Math.max(...displays.map((display) => display.bounds.x + display.bounds.width));\n      win.setPosition(maxRight + ${String(OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS)}, 0);\n      return 'moved';\n    })()`;\n\n    const deadline = Date.now() + OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        const target = (await this.getPageTargets())[0];\n        if (target) {\n          const ws = await this.connectToTarget(target);\n          try {\n            const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n              expression: moveExpr,\n              returnByValue: true\n            });\n            if (response.result?.result?.value === 'moved') {\n              log('[cdp-transport] Moved owned Obsidian window off-screen (hidden mode).');\n              return;\n            }\n          } finally {\n            ws.close();\n          }\n        }\n      } catch {\n        // CDP endpoint / target / remote bridge not ready yet \u2014 keep polling.\n      }\n      await delay(OWNED_WINDOW_HIDE_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    log(`[cdp-transport] Could not move owned window off-screen within ${String(OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal; keep-alive flags still applied).`);\n  }\n\n  /**\n   * Opens a vault in an already-running Obsidian instance via the `vault-open`\n   * Electron IPC (evaluated through CDP on an existing target), then polls until\n   * the new vault's window target appears, is layout-ready, and its trust dialog\n   * (if any) has been dismissed.\n   *\n   * Shared by the attach-mode {@link registerVault} and the owned-mode\n   * \"instance already launched\" path, so opening an additional vault never\n   * relaunches the process (which would surface the vault picker).\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async openVaultInRunningInstance(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Registering vault: ${vaultPath}`);\n    const targets = await this.getPageTargets();\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets available. Is Obsidian running?');\n    }\n\n    const ipcWs = await this.connectToTarget(ensureNonNullable(targets[0]));\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const ipcExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpr,\n        returnByValue: true\n      });\n\n      await this.enablePluginsInLocalStorage(ipcWs, vaultPath);\n    } finally {\n      ipcWs.close();\n    }\n\n    log(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        log('[cdp-transport] Vault target found.');\n        await this.waitForLayoutReady(vaultPath);\n        await this.dismissTrustDialog(vaultPath);\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Samples the vault renderer's bootstrap state \u2014 whether the document is\n   * `complete`, whether `window.app` exists, and the `<body>` child count \u2014 from\n   * the first page target, for dead-boot detection. This works even when the app\n   * never bootstrapped (the renderer page target still exists), which is exactly\n   * the state it must observe.\n   *\n   * @returns The sampled observation, or `undefined` when no target is reachable\n   *   or the probe failed (so the caller keeps polling rather than fast-failing).\n   */\n  private async probeRendererBootState(): Promise<RendererBootObservation | undefined> {\n    try {\n      const target = (await this.getPageTargets())[0];\n      if (!target) {\n        return undefined;\n      }\n\n      const ws = await this.connectToTarget(target);\n      try {\n        const probeExpr = `JSON.stringify({\n          bodyChildElementCount: document.body ? document.body.childElementCount : 0,\n          hasWindowApp: typeof window.app !== 'undefined',\n          isDocumentComplete: document.readyState === 'complete'\n        })`;\n        const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n          expression: probeExpr,\n          returnByValue: true\n        });\n        const value = response.result?.result?.value;\n        if (typeof value !== 'string') {\n          return undefined;\n        }\n        return JSON.parse(value) as RendererBootObservation;\n      } finally {\n        ws.close();\n      }\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Probes a target to discover which vault path it has open.\n   *\n   * Creates a temporary WebSocket connection, evaluates `getBasePath()`,\n   * and returns the result.\n   *\n   * @param target - The CDP target to probe.\n   * @returns The vault's base path.\n   */\n  private async probeVaultPath(target: CdpTarget): Promise<string> {\n    const ws = await this.connectToTarget(target);\n    try {\n      const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: 'app.vault.adapter.getBasePath()',\n        returnByValue: true\n      });\n      return String(response.result?.result?.value);\n    } finally {\n      ws.close();\n    }\n  }\n\n  /**\n   * Launches and connects to a harness-owned, isolated Obsidian instance for a\n   * vault: provisions the asar (if any), pre-seeds the isolated `obsidian.json`\n   * so the vault opens directly, launches the instance on a free CDP port, then\n   * waits until the vault window is ready and dismisses the trust dialog.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async registerVaultInOwnedInstance(vaultPath: string): Promise<void> {\n    const config = ensureNonNullable(this.ownedConfig);\n\n    if (this.ownedInstance) {\n      // A prior vault's instance is still running in this (per-worker cached)\n      // Transport. Relaunch fresh for the new vault: relaunching over the live\n      // Instance is forwarded by Electron's single-instance lock on the shared\n      // User-data dir and surfaces the vault picker, and opening a second window\n      // Via IPC leaves stale windows that break vault-target routing. So kill the\n      // Running instance, wait for it to exit (releasing the lock), then launch\n      // Again below with the new vault pre-seeded \u2014 each vault gets a pristine\n      // Single-window instance opened directly, never the selector.\n      log(`[cdp-transport] Relaunching owned instance for new vault: ${vaultPath}`);\n      this.disconnect();\n      const previousCdpUrl = this.cdpUrl;\n      this.ownedInstance.kill();\n      this.ownedInstance = undefined;\n      await this.waitForInstanceExit(previousCdpUrl);\n    } else {\n      log(`[cdp-transport] Launching owned Obsidian instance for vault: ${vaultPath}`);\n    }\n\n    mkdirSync(config.userDataDir, { recursive: true });\n    if (config.asar) {\n      copyAsarIntoUserData(config.asar.path, config.asar.version, config.userDataDir);\n    }\n\n    const vaultId = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n    const obsidianJson = {\n      updateDisabled: true,\n      vaults: { [vaultId]: { open: true, path: vaultPath, ts: Date.now() } }\n    };\n    writeFileSync(join(config.userDataDir, 'obsidian.json'), JSON.stringify(obsidianJson));\n\n    const instance = await launchOwnedObsidianInstance({\n      cdpHost: this.cdpHost,\n      exePath: config.exePath,\n      extraArgs: [\n        ...resolveOwnedHiddenLaunchArgs(this.isObsidianAppVisible),\n        ...resolveSandboxLaunchArgs(this.shouldDisableSandbox)\n      ],\n      userDataDir: config.userDataDir\n    });\n    this.ownedInstance = instance;\n    this.cdpPort = instance.port;\n    this.cdpUrl = instance.cdpUrl;\n\n    if (shouldHideObsidianApp(this.isObsidianAppVisible)) {\n      await this.moveOwnedWindowOffscreen();\n    }\n\n    await this.waitForOwnedVaultReady(vaultPath);\n  }\n\n  /**\n   * Sends a CDP command over WebSocket and waits for the response.\n   *\n   * @param ws - The WebSocket connection.\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The CDP response.\n   */\n  private async sendCommand(ws: WebSocket, method: string, params: Record<string, unknown>): Promise<CdpResponse> {\n    const id = ++this.messageId;\n\n    return new Promise<CdpResponse>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        ws.removeEventListener('message', handler);\n        reject(new Error(`CDP command timed out after ${String(this.commandTimeoutInMilliseconds)}ms: ${method}`));\n      }, this.commandTimeoutInMilliseconds);\n\n      function handler(event: MessageEvent): void {\n        const msg = JSON.parse(String(event.data)) as CdpResponse;\n        if (msg.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(msg);\n        }\n      }\n\n      ws.addEventListener('message', handler);\n      ws.send(JSON.stringify({ id, method, params }));\n    });\n  }\n\n  /**\n   * Polls a killed owned instance's CDP endpoint until it stops responding,\n   * confirming the process has exited and released Electron's single-instance\n   * lock on the shared user-data dir before a fresh instance is launched into it.\n   *\n   * @param cdpUrl - The CDP URL of the instance that was just killed.\n   */\n  private async waitForInstanceExit(cdpUrl: string): Promise<void> {\n    log(`[cdp-transport] Waiting for previous owned instance at ${cdpUrl} to exit...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        const response = await fetch(`${cdpUrl}/json`);\n        await response.body?.cancel();\n      } catch {\n        // The endpoint is gone: the process has exited and released the lock.\n        await delay(INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS);\n        return;\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    log('[cdp-transport] Previous instance still responded before timeout; relaunching anyway.');\n  }\n\n  /**\n   * Waits for the vault's `app.workspace` to reach layout-ready state.\n   *\n   * `findTargetForVault` returns as soon as `app.vault.adapter.getBasePath()`\n   * matches \u2014 which is true shortly after the `App` constructor runs, before\n   * `plugins.initialize()` (and any trust dialog) has executed. Bootstrapping\n   * the namespace and calling `pollVaultBasePath()` awaits `layoutReady`, so\n   * by the time this returns the dialog has either rendered or is not going\n   * to render.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async waitForLayoutReady(vaultPath: string): Promise<void> {\n    await ensureNamespaceBootstrapped(this, vaultPath);\n    await this.evaluate('window.__obsidianIntegrationTesting.pollVaultBasePath()', { cwd: vaultPath });\n  }\n\n  /**\n   * Polls the owned instance until the vault target exists, layout is ready, and\n   * the trust dialog (if any) has been dismissed.\n   *\n   * Between readiness attempts it also checks for a **dead boot** \u2014 the renderer\n   * loaded (`document.readyState` `'complete'`) but the app never bootstrapped\n   * (empty `<body>`, no `window.app`), the terminal state when the asar cannot\n   * run on the launched Electron shell. Once that state has held for the\n   * configured grace window it throws a {@link RendererFailedToInitializeError}\n   * immediately instead of waiting out the full readiness timeout. A grace of\n   * `0` disables the fast-fail. The grace clock starts when the renderer first\n   * reports `complete`, so a slow load before then is never counted against it.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async waitForOwnedVaultReady(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Waiting for owned vault to become ready (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    let documentCompleteSince: null | number = null;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        await this.waitForLayoutReady(vaultPath);\n        await this.dismissTrustDialog(vaultPath);\n        await this.checkRuntimeElectronCompatibility(vaultPath);\n        log('[cdp-transport] Owned vault is ready.');\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n\n      if (this.deadBootGraceInMilliseconds > 0) {\n        const observation = await this.probeRendererBootState();\n        if (observation) {\n          if (observation.isDocumentComplete && documentCompleteSince === null) {\n            documentCompleteSince = Date.now();\n          }\n          const hasGraceElapsed = documentCompleteSince !== null\n            && Date.now() - documentCompleteSince >= this.deadBootGraceInMilliseconds;\n          if (checkRendererBootState({ ...observation, hasGraceElapsed }) === 'dead') {\n            log('[cdp-transport] Owned renderer failed to initialize (dead boot); failing fast.');\n            throw new RendererFailedToInitializeError(vaultPath);\n          }\n        }\n      }\n\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Owned vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch Obsidian with remote debugging enabled.\n *\n * Resolves the actual installed Obsidian executable (covering installer-based\n * and `PATH`-based installs such as `scoop`) and verifies it exists before\n * returning a command. Throws if Obsidian is not installed.\n *\n * @param port - The CDP port to use.\n * @returns The shell command string.\n * @throws Error if Obsidian cannot be located.\n */\nasync function getObsidianLaunchCommand(port: number): Promise<string> {\n  const exePath = await resolveObsidianExecutable();\n  const flag = `--remote-debugging-port=${String(port)}`;\n\n  if (process.platform === 'win32') {\n    return `start \"\" \"${exePath}\" ${flag}`;\n  }\n\n  return `\"${exePath}\" ${flag} &`;\n}\n\n/**\n * Attempts to remove a directory recursively, returning whether it succeeded.\n *\n * @param dir - The directory to remove.\n * @returns `true` if removed, `false` if the removal threw (e.g. handles held).\n */\nfunction tryRemoveDir(dir: string): boolean {\n  try {\n    rmSync(dir, { force: true, recursive: true });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CDP transport \u2014 evaluates expressions via Chrome DevTools Protocol\n * over WebSocket and manages vaults via Electron IPC.\n *\n * Two modes:\n * - **Owned (default)**: the transport launches and owns an isolated Obsidian\n *   instance against a temporary `--user-data-dir` on a free `--remote-debugging-port`,\n *   never touching the user's Obsidian. Supports version pinning via the user-data asar.\n * - **Attach**: when an explicit CDP port is configured, the transport connects\n *   to an already-running Obsidian on that port.\n *\n * It connects to page targets, sends `Runtime.evaluate` commands, and routes to\n * the correct vault target using `getBasePath()` probing.\n *\n * Requirements: Node.js 22+ (uses built-in `WebSocket` and `fetch` globals).\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n  mkdirSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { OwnedObsidianInstance } from './obsidian-instance.cjs';\nimport type { RendererBootObservation } from './renderer-boot-detection.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { checkAsarFallback } from './asar-fallback-detection.cjs';\nimport { resolveAsarFallbackAction } from './compatibility-options.cjs';\nimport { DISMISS_TRUST_DIALOG_EXPR } from './dismiss-trust-dialog.cjs';\nimport { checkElectronCompatibility } from './electron-compatibility.cjs';\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport {\n  getVaultId,\n  isVaultRegistered,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport { launchOwnedObsidianInstance } from './obsidian-instance.cjs';\nimport { getVersionMetadata } from './obsidian-metadata.cjs';\nimport { copyAsarIntoUserData } from './obsidian-version-switch.cjs';\nimport { buildOwnedObsidianJson } from './owned-vault-seed.cjs';\nimport {\n  checkRendererBootState,\n  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS\n} from './renderer-boot-detection.cjs';\nimport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nimport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\nimport {\n  resolveOwnedHiddenLaunchArgs,\n  resolveSandboxLaunchArgs,\n  shouldHideObsidianApp\n} from './visibility.cjs';\n\n/**\n * Configuration for the CDP transport.\n */\nexport interface DesktopCdpTransportConfig {\n  /**\n   * CDP host. Defaults to `'localhost'`.\n   */\n  cdpHost?: string;\n\n  /**\n   * CDP port for **attach** mode (the `--remote-debugging-port` the running\n   * Obsidian was launched with). In owned-instance mode this is ignored \u2014 a\n   * free port is chosen at launch.\n   */\n  cdpPort?: number;\n\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to `30000`.\n   */\n  commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance (empty `<body>` with no `window.app` after the renderer reached\n   * `document.readyState` `'complete'`). Defaults to\n   * {@link DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS}. `0` disables fast-fail.\n   */\n  deadBootGraceInMilliseconds?: number;\n\n  /**\n   * When attaching (i.e. {@link cdpPort} is set), marks the target as a\n   * **harness-owned, already-prepared** instance. Suppresses the user-scope\n   * vault-registration preflight, since the owned instance's vault lives in an\n   * isolated user-data config rather than the user-scope registry.\n   */\n  isHarnessOwnedInstance?: boolean;\n\n  /**\n   * Whether the owned Obsidian window is shown on screen. When `false` (the\n   * default), the owned instance is launched with keep-alive Chromium flags and\n   * its window is moved off-screen after launch. Only meaningful in owned mode;\n   * attach mode never touches the (user's) window.\n   *\n   * @default `true`\n   */\n  isObsidianAppVisible?: boolean;\n\n  /**\n   * When set, the transport launches and owns an isolated Obsidian instance\n   * instead of attaching to a running one. This is the default desktop mode.\n   */\n  ownedInstance?: OwnedInstanceConfig;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`). Needed to boot on Linux without a correctly-configured\n   * setuid `chrome-sandbox` helper (e.g. an extracted portable shell, or CI as a\n   * non-root user); harmless on Windows/macOS. Only meaningful in owned mode.\n   *\n   * @default `false`\n   */\n  shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** (the running app version differs\n   * from the swapped-in pin) fails fast with {@link SilentAsarFallbackError}. The\n   * verdict is always computed and surfaced via\n   * {@link DesktopCdpTransport.getAsarFallback}; this gates only the throw. Only\n   * meaningful in owned mode running a swapped-in asar.\n   *\n   * @default `true`\n   */\n  shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the post-boot runtime-Electron compatibility nag warning is emitted\n   * when the live Electron is below the app's recommended minimum. The verdict is\n   * always computed and surfaced via {@link DesktopCdpTransport.getElectronCompatibility};\n   * this only gates the log. Only meaningful in owned mode.\n   *\n   * @default `true`\n   */\n  shouldWarnOnCompatibilityIssues?: boolean;\n}\n\n/**\n * An asar to provision into a harness-owned instance's user-data dir before launch.\n */\nexport interface OwnedInstanceAsar {\n  /** Absolute path to the cached/source asar file. */\n  readonly path: string;\n\n  /** The asar's `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Configuration for a harness-owned, isolated Obsidian instance.\n *\n * When present, the transport launches and owns its own Obsidian process\n * against an isolated user-data dir instead of attaching to a running instance.\n */\nexport interface OwnedInstanceConfig {\n  /** Optional asar to provision into {@link userDataDir} before launch. */\n  readonly asar?: OwnedInstanceAsar | undefined;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict, when it could be determined\n   * (an asar-swap onto a known shell version). Surfaced by\n   * {@link DesktopCdpTransport.getCompatibility}. An `'unrunnable'` verdict reaches\n   * this surface only when the proactive throw is disabled\n   * (`shouldThrowOnIncompatibleInstaller: false`); otherwise it throws\n   * `IncompatibleInstallerVersionError` before the config is built.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /** Absolute path to the Obsidian shell executable to launch. */\n  readonly exePath: string;\n\n  /**\n   * Absolute path to the isolated user-data dir. Created and owned by the\n   * transport, and deleted on dispose.\n   */\n  readonly userDataDir: string;\n}\n\ninterface CdpExceptionDetails {\n  exception?: CdpExceptionObject;\n  text: string;\n}\n\ninterface CdpExceptionObject {\n  description?: string;\n}\n\ninterface CdpResponse {\n  id: number;\n  result?: CdpResponseResult;\n}\n\ninterface CdpResponseResult {\n  readonly exceptionDetails?: CdpExceptionDetails;\n  readonly result?: CdpValue;\n}\n\ninterface CdpTarget {\n  id: string;\n  title: string;\n  type: string;\n  url: string;\n  webSocketDebuggerUrl: string;\n}\n\ninterface CdpValue {\n  type: string;\n  value?: unknown;\n}\n\n/**\n * The CDP endpoint of a launched, harness-owned instance.\n */\ninterface OwnedInstanceEndpoint {\n  /** CDP host (e.g. `'localhost'`). */\n  readonly host: string;\n\n  /** The free CDP port the owned instance was launched on. */\n  readonly port: number;\n}\n\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_ID_BYTE_LENGTH = 8;\nconst USER_DATA_RM_TIMEOUT_IN_MILLISECONDS = 10000;\nconst USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS = 500;\nconst NO_OUTPUT = '(no output)';\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\n// Old (Electron 10-era) Obsidian occasionally boots without the workspace ever\n// Initializing, so the vault never becomes ready. A fresh instance is an\n// Independent chance; relaunch up to this many times before giving up.\nconst OWNED_LAUNCH_MAX_ATTEMPTS = 3;\n// Brief settle before a relaunch so the killed instance's memory/handles are\n// Reclaimed before the next boot \u2014 improves the odds on a loaded machine.\nconst OWNED_RELAUNCH_SETTLE_IN_MILLISECONDS = 3000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\nconst INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS = 500;\nconst OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS = 200;\nconst OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS = 20000;\nconst OWNED_WINDOW_HIDE_POLL_INTERVAL_IN_MILLISECONDS = 250;\n\n/**\n * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.\n *\n * Connects to Obsidian's CDP WebSocket endpoint, sends `Runtime.evaluate`\n * commands, and routes expressions to the correct vault target.\n */\nexport class DesktopCdpTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n  private activeVaultPath: null | string = null;\n  private asarFallback: AsarFallback | undefined;\n  private readonly cdpHost: string;\n  private cdpPort: number;\n  private cdpUrl: string;\n  private readonly commandTimeoutInMilliseconds: number;\n  private readonly deadBootGraceInMilliseconds: number;\n  private electronCompatibility: ElectronCompatibility | undefined;\n  private readonly isHarnessOwnedInstance: boolean;\n  private readonly isObsidianAppVisible: boolean;\n  private messageId = 0;\n  private readonly ownedConfig: OwnedInstanceConfig | undefined;\n  private ownedInstance: OwnedObsidianInstance | undefined;\n  private readonly shouldDisableSandbox: boolean;\n  private readonly shouldThrowOnSilentAsarFallback: boolean;\n  private readonly shouldWarnOnCompatibilityIssues: boolean;\n  private ws: null | WebSocket = null;\n\n  /**\n   * Creates a new CDP transport.\n   *\n   * @param config - CDP connection configuration.\n   */\n  public constructor(config?: DesktopCdpTransportConfig) {\n    // Destructure with per-field defaults (each applies when the field is omitted,\n    // Exactly like the former `config?.x ?? default`) so the constructor stays\n    // Under the cyclomatic-complexity limit as fields are added.\n    const {\n      cdpHost = 'localhost',\n      cdpPort,\n      commandTimeoutInMilliseconds = COMMAND_TIMEOUT_IN_MILLISECONDS,\n      deadBootGraceInMilliseconds = DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,\n      isHarnessOwnedInstance = false,\n      isObsidianAppVisible = true,\n      ownedInstance,\n      shouldDisableSandbox = false,\n      shouldThrowOnSilentAsarFallback = true,\n      shouldWarnOnCompatibilityIssues = true\n    } = config ?? {};\n    this.cdpHost = cdpHost;\n    this.commandTimeoutInMilliseconds = commandTimeoutInMilliseconds;\n    this.deadBootGraceInMilliseconds = deadBootGraceInMilliseconds;\n    this.isHarnessOwnedInstance = isHarnessOwnedInstance;\n    this.isObsidianAppVisible = isObsidianAppVisible;\n    this.ownedConfig = ownedInstance;\n    this.shouldDisableSandbox = shouldDisableSandbox;\n    this.shouldThrowOnSilentAsarFallback = shouldThrowOnSilentAsarFallback;\n    this.shouldWarnOnCompatibilityIssues = shouldWarnOnCompatibilityIssues;\n    // Owned mode picks a free port at launch (assigned in registerVault).\n    // Attach mode connects to the configured port; no port is hardcoded.\n    this.cdpPort = cdpPort ?? 0;\n    this.cdpUrl = cdpPort === undefined ? '' : `http://${cdpHost}:${String(cdpPort)}`;\n  }\n\n  /**\n   * Disposes of the active WebSocket connection and, in owned-instance mode,\n   * kills the owned Obsidian process and removes its isolated user-data dir.\n   *\n   * The removal is retried because Windows briefly holds the just-killed\n   * process's file handles, which would otherwise fail `rmSync` with `EPERM`.\n   */\n  public async dispose(): Promise<void> {\n    this.disconnect();\n    if (!this.ownedConfig) {\n      return;\n    }\n\n    this.ownedInstance?.kill();\n    const { userDataDir } = this.ownedConfig;\n    const deadline = Date.now() + USER_DATA_RM_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      if (tryRemoveDir(userDataDir)) {\n        return;\n      }\n      await delay(USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS);\n    }\n    if (!tryRemoveDir(userDataDir)) {\n      log(`[cdp-transport] Could not remove owned user-data dir within ${String(USER_DATA_RM_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal): ${userDataDir}`);\n    }\n  }\n\n  /**\n   * Synchronous disposal \u2014 kills the owned instance and makes a best-effort\n   * removal of its user-data dir. Safe to call from a process `exit` handler\n   * (where async retries are impossible; a leftover temp dir is acceptable).\n   */\n  public disposeSync(): void {\n    this.disconnect();\n    if (this.ownedConfig) {\n      this.ownedInstance?.kill();\n      if (!tryRemoveDir(this.ownedConfig.userDataDir)) {\n        log(`[cdp-transport] Owned user-data dir not removed synchronously (process may still hold handles): ${this.ownedConfig.userDataDir}`);\n      }\n    }\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via CDP `Runtime.evaluate`.\n   *\n   * Routes to the correct vault target based on `options.cwd`.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const ws = await this.ensureConnection(options.cwd);\n    const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n      awaitPromise: true,\n      expression,\n      returnByValue: true\n    });\n\n    if (response.result?.exceptionDetails) {\n      const desc = response.result.exceptionDetails.exception?.description\n        ?? response.result.exceptionDetails.text;\n      throw new Error(`CDP evaluation error: ${desc}`);\n    }\n\n    const resultObj = response.result?.result;\n    if (!resultObj || resultObj.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObj.value);\n  }\n\n  /**\n   * Returns the silent-asar-fallback verdict for this owned instance \u2014 whether the\n   * app version it is actually running matches the swapped-in pin, or the installer\n   * silently reverted to its own bundled asar (read live post-boot). Returns\n   * `undefined` when this is not an owned instance, the instance has not booted\n   * yet, or the verdict could not be determined (no asar was swapped, or the live\n   * version was unreadable). A `'fallback'` verdict reaches this surface only when\n   * the throw is disabled ({@link DesktopCdpTransportConfig.shouldThrowOnSilentAsarFallback}\n   * `false`); otherwise it throws `SilentAsarFallbackError`.\n   *\n   * @returns The silent-asar-fallback verdict, or `undefined`.\n   */\n  public getAsarFallback(): AsarFallback | undefined {\n    return this.asarFallback;\n  }\n\n  /**\n   * Returns the resolved installer\u2194app compatibility verdict for this owned\n   * instance, so callers can assert on it. Returns `undefined` when this is not\n   * an owned instance, or the verdict could not be determined (e.g. an\n   * undetectable shell version, or the app version is absent from the table).\n   *\n   * @returns The compatibility verdict, or `undefined`.\n   */\n  public getCompatibility(): InstallerCompatibility | undefined {\n    return this.ownedConfig?.compatibility;\n  }\n\n  /**\n   * Returns the runtime Electron compatibility verdict for this owned instance \u2014\n   * whether the Electron version it is actually running is new enough for the\n   * running app version (read live post-boot; see {@link ObsidianVersionMetadata.minRecommendedElectronVersion}).\n   * Returns `undefined` when this is not an owned instance, the instance has not\n   * booted yet, or the verdict could not be determined (the live version was\n   * unreadable, or the app version carries no recommended Electron version).\n   *\n   * @returns The runtime Electron compatibility verdict, or `undefined`.\n   */\n  public getElectronCompatibility(): ElectronCompatibility | undefined {\n    return this.electronCompatibility;\n  }\n\n  /**\n   * Returns the CDP endpoint of the owned, launched instance so the global setup\n   * can hand it to test workers (which then **attach** to it instead of\n   * launching their own). Returns `undefined` when this transport is not an\n   * owned instance, or its instance has not been launched yet.\n   *\n   * @returns The owned instance's CDP host and port, or `undefined`.\n   */\n  public getOwnedInstanceEndpoint(): OwnedInstanceEndpoint | undefined {\n    if (!this.ownedConfig || !this.ownedInstance) {\n      return undefined;\n    }\n    return { host: this.cdpHost, port: this.cdpPort };\n  }\n\n  /**\n   * Verifies that the CDP endpoint is reachable and has Obsidian targets.\n   *\n   * If Obsidian is not running, attempts to auto-start it via URI protocol\n   * and polls until CDP becomes available.\n   *\n   * @param vaultPath - The vault path (used for vault registration check).\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    if (this.ownedConfig || this.isHarnessOwnedInstance) {\n      // Owned instance (launched here) or a worker attached to one: readiness is\n      // Guaranteed by the global setup's registerVault, and the vault lives in\n      // The isolated config \u2014 there is nothing to verify against the user-scope\n      // Registry.\n      return;\n    }\n\n    log(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    try {\n      const targets = await this.getPageTargets();\n      if (targets.length === 0) {\n        throw new Error('No page targets');\n      }\n      log(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);\n    } catch {\n      await this.ensureObsidianRunning();\n    }\n  }\n\n  /**\n   * Registers a vault via Electron IPC evaluated through CDP.\n   *\n   * Uses an existing Obsidian target to send the `vault-open` IPC command,\n   * then polls until the new vault's target appears.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    if (this.ownedConfig) {\n      await this.registerVaultInOwnedInstance(vaultPath);\n      return;\n    }\n\n    await this.openVaultInRunningInstance(vaultPath);\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    if (this.ownedConfig) {\n      // The owned instance is killed wholesale on dispose; no per-vault\n      // Unregister is needed (and the registry lives in the isolated config).\n      return;\n    }\n\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const target = await this.findTargetForVault(vaultPath);\n      const ws = await this.connectToTarget(target);\n      try {\n        const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: destroyExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } catch {\n      // Window may already be closed.\n    }\n\n    if (this.activeVaultPath === vaultPath) {\n      this.disconnect();\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const targets = await this.getPageTargets();\n    if (targets.length > 0) {\n      const ws = await this.connectToTarget(ensureNonNullable(targets[0]));\n      try {\n        await ensureNamespaceBootstrapped(this, vaultPath);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: removeExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } else {\n      log('[cdp-transport] No CDP targets for removal IPC \u2014 removing directly from obsidian.json.');\n      removeVaultFromConfig(vaultPath);\n    }\n  }\n\n  /**\n   * Computes and stores the runtime-Electron compatibility verdict (on\n   * {@link getElectronCompatibility}) from an already-read version pair, warning\n   * when the live Electron is below the app's recommended minimum. Never throws; a\n   * boot whose running app version was unreadable is skipped (nothing to judge).\n   *\n   * @param appVersion - The live running app version, or `undefined` when unreadable.\n   * @param actualElectronVersion - The live Electron version, or `undefined` when unreadable.\n   */\n  private applyElectronCompatibility(appVersion: string | undefined, actualElectronVersion: string | undefined): void {\n    if (appVersion === undefined) {\n      return;\n    }\n\n    const verdict = checkElectronCompatibility({\n      actualElectronVersion,\n      appVersion,\n      metadata: getVersionMetadata(appVersion)\n    });\n    this.electronCompatibility = verdict;\n    if (verdict.tier === 'nagged' && this.shouldWarnOnCompatibilityIssues) {\n      log(`[cdp-transport] ${ensureNonNullable(verdict.message)}`);\n    }\n  }\n\n  /**\n   * Verifies the running app (asar) version matches the swapped-in pin, storing the\n   * verdict on {@link getAsarFallback}. On a **silent fallback** (the installer ran\n   * its own bundled asar instead of the pin) it throws {@link SilentAsarFallbackError}\n   * when the throw is enabled, otherwise warns (when warnings are on) and lets the\n   * boot proceed. A boot with no swapped-in asar, or an unreadable running version,\n   * is `'unknown'` \u2014 nothing is thrown or warned. This is the healthy-UI companion to\n   * the black-screen {@link RendererFailedToInitializeError} dead-boot fast-fail.\n   *\n   * @param runningApiVersion - The live running app version, or `undefined` when unreadable.\n   */\n  private checkRuntimeAsarFallback(runningApiVersion: string | undefined): void {\n    const verdict = checkAsarFallback({\n      requestedVersion: this.ownedConfig?.asar?.version,\n      runningApiVersion\n    });\n    this.asarFallback = verdict;\n\n    const action = resolveAsarFallbackAction({\n      shouldThrowOnSilentAsarFallback: this.shouldThrowOnSilentAsarFallback,\n      shouldWarnOnCompatibilityIssues: this.shouldWarnOnCompatibilityIssues,\n      tier: verdict.tier\n    });\n    if (action === 'throw') {\n      throw new SilentAsarFallbackError({\n        requestedVersion: ensureNonNullable(verdict.requestedVersion),\n        runningApiVersion: ensureNonNullable(verdict.runningApiVersion)\n      });\n    }\n    if (action === 'warn') {\n      log(`[cdp-transport] ${ensureNonNullable(verdict.message)}`);\n    }\n  }\n\n  /**\n   * Runs the post-boot runtime compatibility checks for an owned instance, once the\n   * vault is ready. Reads the live running app version and Electron version **once**\n   * from the booted renderer's main process, then: (1) verifies the running app\n   * version matches the swapped-in pin \u2014 throwing {@link SilentAsarFallbackError} on\n   * a silent fallback (when enabled); and (2) runs the best-effort runtime-Electron\n   * nag. Only the asar-fallback check can throw, so this must run outside the\n   * readiness poll's try/catch (a swallowed throw would loop until timeout).\n   *\n   * Both are read at the renderer top level: `ipcRenderer.sendSync('version')` (the\n   * running app version, truthful even under a silent asar fallback) and\n   * `process.versions.electron` (the live shell Electron); neither uses\n   * `require('obsidian')`, which resolves only inside a plugin-load context. A read\n   * failure leaves both unknown (logged, non-fatal) \u2014 an unreadable running version\n   * cannot be judged a fallback, so the boot is not broken by a flaky read.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async checkRuntimeCompatibility(vaultPath: string): Promise<void> {\n    let appVersion: string | undefined;\n    let actualElectronVersion: string | undefined;\n    try {\n      const rawAppVersion = await this.evaluate('String(window.electron.ipcRenderer.sendSync(\\'version\\'))', { cwd: vaultPath });\n      appVersion = rawAppVersion === '' || rawAppVersion === 'undefined' ? undefined : rawAppVersion;\n      actualElectronVersion = await this.evaluate('String(process.versions.electron)', { cwd: vaultPath });\n    } catch (error) {\n      log(`[cdp-transport] Could not read runtime versions (non-fatal): ${String(error)}`);\n    }\n\n    // Fails fast (when enabled) on a silent asar fallback \u2014 MUST run before the\n    // Best-effort nag and outside any try/catch so the throw escapes the poll.\n    this.checkRuntimeAsarFallback(appVersion);\n    this.applyElectronCompatibility(appVersion, actualElectronVersion);\n  }\n\n  /**\n   * Connects to a CDP target's WebSocket endpoint.\n   *\n   * @param target - The CDP target to connect to.\n   * @returns The open WebSocket connection.\n   */\n  private async connectToTarget(target: CdpTarget): Promise<WebSocket> {\n    const ws = new WebSocket(target.webSocketDebuggerUrl);\n    await new Promise<void>((resolve, reject) => {\n      ws.onopen = (): void => {\n        resolve();\n      };\n      ws.onerror = (): void => {\n        reject(new Error(`Failed to connect to CDP target: ${target.webSocketDebuggerUrl}`));\n      };\n    });\n    return ws;\n  }\n\n  /**\n   * Disconnects the active WebSocket connection.\n   */\n  private disconnect(): void {\n    if (this.ws?.readyState === WebSocket.OPEN) {\n      this.ws.close();\n    }\n    this.ws = null;\n    this.activeVaultPath = null;\n  }\n\n  /**\n   * Dismisses the \"Do you trust the author of this vault?\" dialog if present.\n   *\n   * Acts as a safety net when `enable-plugin-<id>` is written in one renderer\n   * but not yet visible to the newly-opened vault's renderer (race observed\n   * in Obsidian 1.13.0).\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async dismissTrustDialog(vaultPath: string): Promise<void> {\n    const result = await this.evaluate(DISMISS_TRUST_DIALOG_EXPR, { cwd: vaultPath });\n    if (result === 'true') {\n      log('[cdp-transport] Dismissed \"Do you trust the author\" dialog.');\n    }\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param ws - An open WebSocket to an existing Obsidian target.\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async enablePluginsInLocalStorage(ws: WebSocket, vaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cdp-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await this.sendCommand(ws, 'Runtime.evaluate', {\n      expression: `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`,\n      returnByValue: true\n    });\n    log(`[cdp-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Ensures there is an active WebSocket connection to the correct vault target.\n   *\n   * Reuses the existing connection if it targets the requested vault.\n   * Otherwise, finds the correct target and reconnects.\n   *\n   * @param vaultPath - The vault path to target.\n   * @returns The active WebSocket connection.\n   */\n  private async ensureConnection(vaultPath: string): Promise<WebSocket> {\n    if (this.ws?.readyState === WebSocket.OPEN && this.activeVaultPath === vaultPath) {\n      return this.ws;\n    }\n\n    this.disconnect();\n\n    const target = await this.findTargetForVault(vaultPath);\n    this.ws = await this.connectToTarget(target);\n    this.activeVaultPath = vaultPath;\n    return this.ws;\n  }\n\n  /**\n   * Launches Obsidian with `--remote-debugging-port` and polls until CDP becomes available.\n   */\n  private async ensureObsidianRunning(): Promise<void> {\n    log('[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...');\n\n    const launchCommand = await getObsidianLaunchCommand(this.cdpPort);\n    try {\n      await exec(launchCommand, { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        const targets = await this.getPageTargets();\n        if (targets.length > 0) {\n          log(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);\n          return;\n        }\n      } catch {\n        log('[cdp-transport] CDP not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);\n  }\n\n  /**\n   * Finds the CDP target that has the given vault open.\n   *\n   * For a single target, returns it directly. For multiple targets,\n   * probes each by evaluating `getBasePath()` to find the match.\n   *\n   * @param vaultPath - The vault path to match.\n   * @returns The matching CDP target.\n   */\n  private async findTargetForVault(vaultPath: string): Promise<CdpTarget> {\n    const targets = await this.getPageTargets();\n\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets found');\n    }\n\n    if (targets.length === 1) {\n      return ensureNonNullable(targets[0]);\n    }\n\n    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (basePath === vaultPath) {\n          return target;\n        }\n      } catch {\n        // Not a vault target or not ready.\n      }\n    }\n\n    throw new Error(`No CDP target found for vault: ${vaultPath}`);\n  }\n\n  /**\n   * Fetches the list of page-type targets from the CDP `/json` endpoint.\n   *\n   * @returns The list of page targets.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    const response = await fetch(`${this.cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.filter((t) => t.type === 'page');\n  }\n\n  /**\n   * Kills the currently-running owned instance (if any) and waits for it to exit,\n   * so the next launch gets a pristine single-window instance.\n   *\n   * Relaunching over a live instance is forwarded by Electron's single-instance\n   * lock on the shared user-data dir and surfaces the vault picker, and opening a\n   * second window via IPC leaves stale windows that break vault-target routing \u2014\n   * hence a full kill + wait-for-exit (releasing the lock) between launches. A\n   * no-op on the first attempt, when no instance is running yet.\n   */\n  private async killRunningOwnedInstance(): Promise<void> {\n    if (!this.ownedInstance) {\n      return;\n    }\n    log('[cdp-transport] Killing running owned instance before (re)launch.');\n    this.disconnect();\n    const previousCdpUrl = this.cdpUrl;\n    this.ownedInstance.kill();\n    this.ownedInstance = undefined;\n    await this.waitForInstanceExit(previousCdpUrl);\n  }\n\n  /**\n   * Moves the owned instance's window off-screen so a hidden run never steals\n   * focus. Uses Electron's remote bridge (`window.electron.remote`) \u2014 the only\n   * cross-platform way to reposition the window \u2014 placing it just beyond the\n   * right edge of all displays. The window stays \"visible\" to Chromium (so\n   * timers, `requestAnimationFrame`, `:hover`, and trusted input keep working),\n   * unlike minimizing, which would freeze `requestAnimationFrame`.\n   *\n   * The remote bridge is not available the instant CDP starts serving, so this\n   * polls until the move succeeds. Best-effort: if the window cannot be moved\n   * within the timeout, the keep-alive launch flags still apply and the run\n   * proceeds (worst case the window is briefly visible).\n   */\n  private async moveOwnedWindowOffscreen(): Promise<void> {\n    // Resolve the Electron remote bridge two ways so BOTH modern and old Obsidian\n    // Can be moved off-screen: modern injects `window.electron.remote`; old\n    // Versions (no `window.electron`) still expose the built-in `remote` module via\n    // `require('electron')` in the node-integrated renderer (removed from Electron\n    // 14+, but present on the Electron 8-13 shells old Obsidian ships). Returning\n    // `moved` on the first success is important on Electron 10-era builds: polling\n    // On without a resolvable bridge hammers the renderer with CDP round-trips\n    // During boot and intermittently prevents the workspace from initializing.\n    const moveExpr = `(() => {\n      let remote = (window.electron && window.electron.remote) || null;\n      if (!remote) {\n        try { remote = require('electron').remote || null; } catch (requireError) { remote = null; }\n      }\n      if (!remote || typeof remote.getCurrentWindow !== 'function') {\n        return (typeof window.app === 'undefined') ? 'not-ready' : 'no-bridge';\n      }\n      const win = remote.getCurrentWindow();\n      const displays = remote.screen.getAllDisplays();\n      const maxRight = Math.max(...displays.map((display) => display.bounds.x + display.bounds.width));\n      win.setPosition(maxRight + ${String(OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS)}, 0);\n      return 'moved';\n    })()`;\n\n    const deadline = Date.now() + OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        const target = (await this.getPageTargets())[0];\n        if (target) {\n          const ws = await this.connectToTarget(target);\n          try {\n            const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n              expression: moveExpr,\n              returnByValue: true\n            });\n            if (response.result?.result?.value === 'moved') {\n              log('[cdp-transport] Moved owned Obsidian window off-screen (hidden mode).');\n              return;\n            }\n          } finally {\n            ws.close();\n          }\n        }\n      } catch {\n        // CDP endpoint / target / remote bridge not ready yet \u2014 keep polling.\n      }\n      await delay(OWNED_WINDOW_HIDE_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    log(`[cdp-transport] Could not move owned window off-screen within ${String(OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal; keep-alive flags still applied).`);\n  }\n\n  /**\n   * Opens a vault in an already-running Obsidian instance via the `vault-open`\n   * Electron IPC (evaluated through CDP on an existing target), then polls until\n   * the new vault's window target appears, is layout-ready, and its trust dialog\n   * (if any) has been dismissed.\n   *\n   * Shared by the attach-mode {@link registerVault} and the owned-mode\n   * \"instance already launched\" path, so opening an additional vault never\n   * relaunches the process (which would surface the vault picker).\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async openVaultInRunningInstance(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Registering vault: ${vaultPath}`);\n    const targets = await this.getPageTargets();\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets available. Is Obsidian running?');\n    }\n\n    const ipcWs = await this.connectToTarget(ensureNonNullable(targets[0]));\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const ipcExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpr,\n        returnByValue: true\n      });\n\n      await this.enablePluginsInLocalStorage(ipcWs, vaultPath);\n    } finally {\n      ipcWs.close();\n    }\n\n    log(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        log('[cdp-transport] Vault target found.');\n        await this.waitForLayoutReady(vaultPath);\n        await this.dismissTrustDialog(vaultPath);\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Samples the vault renderer's bootstrap state \u2014 whether the document is\n   * `complete`, whether `window.app` exists, and the `<body>` child count \u2014 from\n   * the first page target, for dead-boot detection. This works even when the app\n   * never bootstrapped (the renderer page target still exists), which is exactly\n   * the state it must observe.\n   *\n   * @returns The sampled observation, or `undefined` when no target is reachable\n   *   or the probe failed (so the caller keeps polling rather than fast-failing).\n   */\n  private async probeRendererBootState(): Promise<RendererBootObservation | undefined> {\n    try {\n      const target = (await this.getPageTargets())[0];\n      if (!target) {\n        return undefined;\n      }\n\n      const ws = await this.connectToTarget(target);\n      try {\n        const probeExpr = `JSON.stringify({\n          bodyChildElementCount: document.body ? document.body.childElementCount : 0,\n          hasWindowApp: typeof window.app !== 'undefined',\n          isDocumentComplete: document.readyState === 'complete'\n        })`;\n        const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n          expression: probeExpr,\n          returnByValue: true\n        });\n        const value = response.result?.result?.value;\n        if (typeof value !== 'string') {\n          return undefined;\n        }\n        return JSON.parse(value) as RendererBootObservation;\n      } finally {\n        ws.close();\n      }\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Probes a target to discover which vault path it has open.\n   *\n   * Creates a temporary WebSocket connection, evaluates `getBasePath()`,\n   * and returns the result.\n   *\n   * @param target - The CDP target to probe.\n   * @returns The vault's base path.\n   */\n  private async probeVaultPath(target: CdpTarget): Promise<string> {\n    const ws = await this.connectToTarget(target);\n    try {\n      const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n        // Old Obsidian versions (e.g. 0.6.x) predate the `getBasePath()` method but\n        // Expose the `basePath` property; the method exists from ~0.9.20 onward.\n        expression: 'app.vault.adapter.getBasePath ? app.vault.adapter.getBasePath() : app.vault.adapter.basePath',\n        returnByValue: true\n      });\n      return String(response.result?.result?.value);\n    } finally {\n      ws.close();\n    }\n  }\n\n  /**\n   * Launches and connects to a harness-owned, isolated Obsidian instance for a\n   * vault: provisions the asar (if any), pre-seeds the isolated `obsidian.json`\n   * so the vault opens directly, launches the instance on a free CDP port, then\n   * waits until the vault window is ready and dismisses the trust dialog.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async registerVaultInOwnedInstance(vaultPath: string): Promise<void> {\n    const config = ensureNonNullable(this.ownedConfig);\n\n    mkdirSync(config.userDataDir, { recursive: true });\n    if (config.asar) {\n      copyAsarIntoUserData(config.asar.path, config.asar.version, config.userDataDir);\n    }\n\n    const vaultId = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n    const obsidianJson = buildOwnedObsidianJson({ ts: Date.now(), vaultId, vaultPath });\n    writeFileSync(join(config.userDataDir, 'obsidian.json'), JSON.stringify(obsidianJson));\n\n    // Relaunch-retry: some old (Electron 10-era) Obsidian builds intermittently\n    // Boot with `window.app` present but the workspace never initializing, so the\n    // Vault never becomes ready. A fresh instance is an independent chance. A\n    // Deterministic failure (dead boot, silent asar fallback) is re-thrown at once \u2014\n    // Retrying it only wastes the readiness timeout.\n    let lastError: unknown;\n    for (let attempt = 1; attempt <= OWNED_LAUNCH_MAX_ATTEMPTS; attempt++) {\n      await this.killRunningOwnedInstance();\n      if (attempt > 1) {\n        await delay(OWNED_RELAUNCH_SETTLE_IN_MILLISECONDS);\n      }\n\n      const instance = await launchOwnedObsidianInstance({\n        cdpHost: this.cdpHost,\n        exePath: config.exePath,\n        extraArgs: [\n          ...resolveOwnedHiddenLaunchArgs(this.isObsidianAppVisible),\n          ...resolveSandboxLaunchArgs(this.shouldDisableSandbox)\n        ],\n        userDataDir: config.userDataDir\n      });\n      this.ownedInstance = instance;\n      this.cdpPort = instance.port;\n      this.cdpUrl = instance.cdpUrl;\n\n      if (shouldHideObsidianApp(this.isObsidianAppVisible)) {\n        await this.moveOwnedWindowOffscreen();\n      }\n\n      try {\n        await this.waitForOwnedVaultReady(vaultPath);\n        return;\n      } catch (error: unknown) {\n        if (error instanceof RendererFailedToInitializeError || error instanceof SilentAsarFallbackError) {\n          throw error;\n        }\n        lastError = error;\n        log(`[cdp-transport] Owned vault not ready (attempt ${String(attempt)}/${String(OWNED_LAUNCH_MAX_ATTEMPTS)}): ${String(error)}`);\n      }\n    }\n    throw lastError instanceof Error ? lastError : new Error(`Owned vault at ${vaultPath} did not become ready`);\n  }\n\n  /**\n   * Sends a CDP command over WebSocket and waits for the response.\n   *\n   * @param ws - The WebSocket connection.\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The CDP response.\n   */\n  private async sendCommand(ws: WebSocket, method: string, params: Record<string, unknown>): Promise<CdpResponse> {\n    const id = ++this.messageId;\n\n    return new Promise<CdpResponse>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        ws.removeEventListener('message', handler);\n        reject(new Error(`CDP command timed out after ${String(this.commandTimeoutInMilliseconds)}ms: ${method}`));\n      }, this.commandTimeoutInMilliseconds);\n\n      function handler(event: MessageEvent): void {\n        const msg = JSON.parse(String(event.data)) as CdpResponse;\n        if (msg.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(msg);\n        }\n      }\n\n      ws.addEventListener('message', handler);\n      ws.send(JSON.stringify({ id, method, params }));\n    });\n  }\n\n  /**\n   * Polls a killed owned instance's CDP endpoint until it stops responding,\n   * confirming the process has exited and released Electron's single-instance\n   * lock on the shared user-data dir before a fresh instance is launched into it.\n   *\n   * @param cdpUrl - The CDP URL of the instance that was just killed.\n   */\n  private async waitForInstanceExit(cdpUrl: string): Promise<void> {\n    log(`[cdp-transport] Waiting for previous owned instance at ${cdpUrl} to exit...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        const response = await fetch(`${cdpUrl}/json`);\n        await response.body?.cancel();\n      } catch {\n        // The endpoint is gone: the process has exited and released the lock.\n        await delay(INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS);\n        return;\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    log('[cdp-transport] Previous instance still responded before timeout; relaunching anyway.');\n  }\n\n  /**\n   * Waits for the vault's `app.workspace` to reach layout-ready state.\n   *\n   * `findTargetForVault` returns as soon as `app.vault.adapter.getBasePath()`\n   * matches \u2014 which is true shortly after the `App` constructor runs, before\n   * `plugins.initialize()` (and any trust dialog) has executed. Bootstrapping\n   * the namespace and calling `pollVaultBasePath()` awaits `layoutReady`, so\n   * by the time this returns the dialog has either rendered or is not going\n   * to render.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async waitForLayoutReady(vaultPath: string): Promise<void> {\n    await ensureNamespaceBootstrapped(this, vaultPath);\n    await this.evaluate('window.__obsidianIntegrationTesting.pollVaultBasePath()', { cwd: vaultPath });\n  }\n\n  /**\n   * Polls the owned instance until the vault target exists, layout is ready, and\n   * the trust dialog (if any) has been dismissed.\n   *\n   * Between readiness attempts it also checks for a **dead boot** \u2014 the renderer\n   * loaded (`document.readyState` `'complete'`) but the app never bootstrapped\n   * (empty `<body>`, no `window.app`), the terminal state when the asar cannot\n   * run on the launched Electron shell. Once that state has held for the\n   * configured grace window it throws a {@link RendererFailedToInitializeError}\n   * immediately instead of waiting out the full readiness timeout. A grace of\n   * `0` disables the fast-fail. The grace clock starts when the renderer first\n   * reports `complete`, so a slow load before then is never counted against it.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async waitForOwnedVaultReady(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Waiting for owned vault to become ready (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    let documentCompleteSince: null | number = null;\n    let isReady = false;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        await this.waitForLayoutReady(vaultPath);\n        await this.dismissTrustDialog(vaultPath);\n        isReady = true;\n        break;\n      } catch {\n        // The vault is not ready yet \u2014 also drop the cached CDP connection before\n        // Retrying. Old (Electron 10-era) Obsidian reloads the owned window during\n        // Boot, which can leave the cached WebSocket pinned to a stale execution\n        // Context; reconnecting each attempt re-binds to the live context.\n        this.disconnect();\n      }\n\n      if (this.deadBootGraceInMilliseconds > 0) {\n        const observation = await this.probeRendererBootState();\n        if (observation) {\n          if (observation.isDocumentComplete && documentCompleteSince === null) {\n            documentCompleteSince = Date.now();\n          }\n          const hasGraceElapsed = documentCompleteSince !== null\n            && Date.now() - documentCompleteSince >= this.deadBootGraceInMilliseconds;\n          if (checkRendererBootState({ ...observation, hasGraceElapsed }) === 'dead') {\n            log('[cdp-transport] Owned renderer failed to initialize (dead boot); failing fast.');\n            throw new RendererFailedToInitializeError(vaultPath);\n          }\n        }\n      }\n\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    if (!isReady) {\n      throw new Error(`Owned vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n    }\n\n    // The vault is ready. Run the post-boot compatibility checks here \u2014 OUTSIDE the\n    // Poll's try/catch \u2014 so a SilentAsarFallbackError fails fast instead of being\n    // Swallowed as \"not ready yet\" and looping until the readiness timeout.\n    await this.checkRuntimeCompatibility(vaultPath);\n    log('[cdp-transport] Owned vault is ready.');\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch Obsidian with remote debugging enabled.\n *\n * Resolves the actual installed Obsidian executable (covering installer-based\n * and `PATH`-based installs such as `scoop`) and verifies it exists before\n * returning a command. Throws if Obsidian is not installed.\n *\n * @param port - The CDP port to use.\n * @returns The shell command string.\n * @throws Error if Obsidian cannot be located.\n */\nasync function getObsidianLaunchCommand(port: number): Promise<string> {\n  const exePath = await resolveObsidianExecutable();\n  const flag = `--remote-debugging-port=${String(port)}`;\n\n  if (process.platform === 'win32') {\n    return `start \"\" \"${exePath}\" ${flag}`;\n  }\n\n  return `\"${exePath}\" ${flag} &`;\n}\n\n/**\n * Attempts to remove a directory recursively, returning whether it succeeded.\n *\n * @param dir - The directory to remove.\n * @returns `true` if removed, `false` if the removal threw (e.g. handles held).\n */\nfunction tryRemoveDir(dir: string): boolean {\n  try {\n    rmSync(dir, { force: true, recursive: true });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}
