obsidian-integration-testing 12.0.0 → 12.1.1

package/dist/lib/esm/transport-desktop-cdp.mjs

@@ -13,6 +13,7 @@ import {
   isPng
 } from "./capture-screenshot.mjs";
 import { resolveAsarFallbackAction } from "./compatibility-options.mjs";
+import { ConfigDirectoryFallbackError } from "./config-directory-fallback-error.mjs";
 import { DISMISS_TRUST_DIALOG_EXPR } from "./dismiss-trust-dialog.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
 import { exec } from "./exec.mjs";
@@ -27,6 +28,11 @@ import { resolveObsidianExecutable } from "./obsidian-executable.mjs";
 import { launchOwnedObsidianInstance } from "./obsidian-instance.mjs";
 import { getVersionMetadata } from "./obsidian-metadata.mjs";
 import { copyAsarIntoUserData } from "./obsidian-version-switch.mjs";
+import { readOwnedInstanceExitMarker } from "./owned-instance-exit-marker.mjs";
+import {
+  buildOwnedInstanceExitedErrorFromMarker,
+  OwnedInstanceExitedError
+} from "./owned-instance-exited-error.mjs";
 import { buildOwnedObsidianJson } from "./owned-vault-seed.mjs";
 import { buildParentLivenessWatchdogExpression } from "./parent-liveness.mjs";
 import {
@@ -36,7 +42,11 @@ import {
 import { RendererFailedToInitializeError } from "./renderer-failed-to-initialize-error.mjs";
 import { SilentAsarFallbackError } from "./silent-asar-fallback-error.mjs";
 import { ensureNonNullable } from "./type-guards.mjs";
-import { areVaultPathsMatching } from "./vault-path-match.mjs";
+import {
+  areVaultPathsMatching,
+  normalizeVaultPathForComparison
+} from "./vault-path-match.mjs";
+import { shouldTearDownVaultWindow } from "./vault-teardown-verdict.mjs";
 import {
   resolveOwnedHiddenLaunchArguments,
   resolveSandboxLaunchArguments,
@@ -55,6 +65,8 @@ const VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1e3;
 const AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
 const AUTO_START_TIMEOUT_IN_MILLISECONDS = 3e4;
 const INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS = 500;
+const STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS = 3e4;
+const STARTER_SCREEN_POLL_INTERVAL_IN_MILLISECONDS = 250;
 const OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS = 200;
 const OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS = 2e4;
 const OWNED_WINDOW_HIDE_POLL_INTERVAL_IN_MILLISECONDS = 250;
@@ -69,6 +81,7 @@ class DesktopCdpTransport {
   cdpPort;
   cdpUrl;
   commandTimeoutInMilliseconds;
+  configDirectory;
   deadBootGraceInMilliseconds;
   electronCompatibility;
   isHarnessOwnedInstance;
@@ -76,6 +89,14 @@ class DesktopCdpTransport {
   messageId = 0;
   ownedConfig;
   ownedInstance;
+  /**
+   * Vault paths THIS transport opened via {@link registerVault}, normalized by
+   * {@link normalizeVaultPathForComparison}. A worker attached to a
+   * harness-owned instance may tear down only these — every other vault in that
+   * instance belongs to the global setup that launched it (see
+   * {@link shouldTearDownVaultWindow}).
+   */
+  selfRegisteredVaultPaths = /* @__PURE__ */ new Set();
   shouldDisableSandbox;
   shouldThrowOnSilentAsarFallback;
   shouldWarnOnCompatibilityIssues;
@@ -90,6 +111,7 @@ class DesktopCdpTransport {
       cdpHost = "localhost",
       cdpPort,
       commandTimeoutInMilliseconds = COMMAND_TIMEOUT_IN_MILLISECONDS,
+      configDirectory,
       deadBootGraceInMilliseconds = DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
       isHarnessOwnedInstance = false,
       isObsidianAppVisible = true,
@@ -100,6 +122,7 @@ class DesktopCdpTransport {
     } = config ?? {};
     this.cdpHost = cdpHost;
     this.commandTimeoutInMilliseconds = commandTimeoutInMilliseconds;
+    this.configDirectory = configDirectory;
     this.deadBootGraceInMilliseconds = deadBootGraceInMilliseconds;
     this.isHarnessOwnedInstance = isHarnessOwnedInstance;
     this.isObsidianAppVisible = isObsidianAppVisible;
@@ -311,16 +334,30 @@ class DesktopCdpTransport {
       return;
     }
     await this.openVaultInRunningInstance(vaultPath);
+    this.selfRegisteredVaultPaths.add(normalizeVaultPathForComparison(vaultPath));
   }
   /**
    * Unregisters a vault by destroying its window and removing it from the registry.
    *
+   * Refuses when this transport does not own what it would be tearing down —
+   * see {@link shouldTearDownVaultWindow} for which of the two ownership flags
+   * means what, and why they are not interchangeable.
+   *
    * @param vaultPath - The absolute path to the vault folder.
    */
   async unregisterVault(vaultPath) {
-    if (this.ownedConfig) {
+    const normalizedVaultPath = normalizeVaultPathForComparison(vaultPath);
+    if (!shouldTearDownVaultWindow({
+      isHarnessOwnedInstance: this.isHarnessOwnedInstance,
+      isOwnedInstance: Boolean(this.ownedConfig),
+      isSelfRegistered: this.selfRegisteredVaultPaths.has(normalizedVaultPath)
+    })) {
+      log(
+        this.ownedConfig ? `[cdp-transport] Skipping per-vault teardown; the owned instance is killed wholesale on dispose: ${vaultPath}` : `[cdp-transport] Skipping per-vault teardown; this worker did not register the vault it was asked to unregister: ${vaultPath}`
+      );
       return;
     }
+    this.selfRegisteredVaultPaths.delete(normalizedVaultPath);
     try {
       await ensureNamespaceBootstrapped(this, vaultPath);
       const target = await this.findTargetForVault(vaultPath);
@@ -404,6 +441,65 @@ class DesktopCdpTransport {
       log(`[cdp-transport] Could not arm the parent-liveness watchdog (instance may outlive a killed harness): ${String(error)}`);
     }
   }
+  /**
+   * Verifies the ready vault is actually using the requested config folder,
+   * throwing {@link ConfigDirectoryFallbackError} when it is not.
+   *
+   * Obsidian applies the override with `setConfigDir`, which substitutes
+   * `.obsidian` for any value its own `validateConfigDir` rejects — without a
+   * word, and without failing the boot. The resulting vault opens, reaches
+   * layout-ready, and reports success; what it lacks is the settings and enabled
+   * plugins of the folder that was asked for. Reading the live
+   * `app.vault.configDir` back is the only way to tell the two apart, and it
+   * covers every cause at once: a name Obsidian rejected (including its
+   * unrecoverable character blacklist, which `assertValidConfigDirectory` deliberately
+   * does not guess at), and a write that never reached the vault's renderer.
+   *
+   * A no-op when no override was requested.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   */
+  async assertRequestedConfigDirectory(vaultPath) {
+    if (this.configDirectory === void 0) {
+      return;
+    }
+    const actualConfigDirectory = await this.evaluate("app.vault.configDir", { cwd: vaultPath });
+    if (actualConfigDirectory === this.configDirectory) {
+      log(`[cdp-transport] Vault opened with the requested config folder ${this.configDirectory}.`);
+      return;
+    }
+    throw new ConfigDirectoryFallbackError({
+      actualConfigDirectory,
+      requestedConfigDirectory: this.configDirectory,
+      vaultPath
+    });
+  }
+  /**
+   * Builds the error for a harness-owned instance that is no longer serving CDP,
+   * from the best evidence this process has.
+   *
+   * Two processes see two different halves of the death. The one that launched
+   * the instance holds the child and can read the exit code straight off it; a
+   * test worker holds nothing but the port, and reads the same facts from the
+   * exit marker the owner wrote (`owned-instance-exit-marker.ts`). With neither
+   * — the marker lost, or a kill so abrupt nothing recorded it — the error still
+   * names the instance as the cause, which is the whole point of it.
+   *
+   * @returns The error to throw in place of a refused connection.
+   */
+  buildOwnedInstanceExitedError() {
+    const exitInfo = this.ownedInstance?.readExitInfo();
+    if (exitInfo) {
+      return new OwnedInstanceExitedError({
+        cdpUrl: this.cdpUrl,
+        code: exitInfo.code,
+        outputTail: this.ownedInstance?.readOutput(),
+        signal: exitInfo.signal,
+        spawnError: exitInfo.spawnError
+      });
+    }
+    return buildOwnedInstanceExitedErrorFromMarker(this.cdpUrl, readOwnedInstanceExitMarker(this.cdpPort));
+  }
   /**
    * Verifies the running app (asar) version matches the swapped-in pin, storing the
    * verdict on {@link getAsarFallback}. On a **silent fallback** (the installer ran
@@ -622,7 +718,15 @@ class DesktopCdpTransport {
         "No CDP endpoint configured: the owned Obsidian instance has not been launched yet, and no `port` was given to attach to a running one. A test worker in this state usually means its global setup failed, or the project is missing the per-worker setup file in `setupFiles`."
       );
     }
-    const response = await fetch(`${this.cdpUrl}/json`);
+    let response;
+    try {
+      response = await fetch(`${this.cdpUrl}/json`);
+    } catch (error) {
+      if (this.ownedConfig || this.isHarnessOwnedInstance) {
+        throw this.buildOwnedInstanceExitedError();
+      }
+      throw error;
+    }
     const targets = await response.json();
     return targets.filter((t) => t.type === "page");
   }
@@ -700,6 +804,54 @@ class DesktopCdpTransport {
     }
     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).`);
   }
+  /**
+   * Writes the config-folder override into the starter screen's `localStorage`
+   * and then opens the vault from there over the `vault-open` IPC.
+   *
+   * Obsidian reads the override exactly once, in the vault's own renderer, during
+   * `Vault.setup` — `getOverrideConfigDir(appId)` is `localStorage.getItem(appId +
+   * '-config')`. So there is no writing it into the vault's window: by the time
+   * that window exists the read has happened. The starter screen is the earlier
+   * renderer the write needs, and it qualifies because it has `localStorage` and
+   * `window.electron.ipcRenderer` but no `app` (verified on 1.13.7).
+   *
+   * That missing `app` is also why this talks raw CDP rather than going through
+   * {@link ensureNamespaceBootstrapped} / the `ipcSendSync` helper as
+   * {@link DesktopCdpTransport.openVaultInRunningInstance} does: every one of
+   * those paths probes `app.vault.adapter` to identify its target, and would fail
+   * on the very renderer this needs.
+   *
+   * The key name is known ahead of the write because the harness registered the
+   * vault under an id it generated itself, and `vault-open` reuses that entry
+   * rather than minting a new one.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   * @param vaultId - The harness-generated vault id the vault is registered under.
+   * @param configDirectory - The config folder to override to.
+   */
+  async openVaultFromStarterScreen(vaultPath, vaultId, configDirectory) {
+    log(`[cdp-transport] Seeding config folder override ${configDirectory} on the starter screen...`);
+    const target = await this.waitForStarterScreenTarget();
+    const ws = await this.connectToTarget(target);
+    try {
+      await this.sendCommand(ws, "Runtime.evaluate", {
+        expression: `localStorage.setItem(${JSON.stringify(`${vaultId}-config`)}, ${JSON.stringify(configDirectory)});`,
+        returnByValue: true
+      });
+      await this.sendCommand(ws, "Runtime.evaluate", {
+        expression: `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`,
+        returnByValue: true
+      });
+      log(`[cdp-transport] Set ${vaultId}-config and enable-plugin-${vaultId} in localStorage.`);
+      await this.sendCommand(ws, "Runtime.evaluate", {
+        expression: `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false)`,
+        returnByValue: true
+      });
+      log(`[cdp-transport] Sent vault-open for ${vaultPath} from the starter screen.`);
+    } finally {
+      ws.close();
+    }
+  }
   /**
    * Opens a vault in an already-running Obsidian instance via the `vault-open`
    * Electron IPC (evaluated through CDP on an existing target), then polls until
@@ -825,14 +977,15 @@ class DesktopCdpTransport {
       copyAsarIntoUserData(config.asar.path, config.asar.version, config.userDataDirectory);
     }
     const vaultId = randomBytes(VAULT_ID_BYTE_LENGTH).toString("hex");
-    const obsidianJson = buildOwnedObsidianJson({ ts: Date.now(), vaultId, vaultPath });
-    writeFileSync(join(config.userDataDirectory, "obsidian.json"), JSON.stringify(obsidianJson));
+    const shouldAutoOpenVault = this.configDirectory === void 0;
     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 obsidianJson = buildOwnedObsidianJson({ shouldAutoOpenVault, ts: Date.now(), vaultId, vaultPath });
+      writeFileSync(join(config.userDataDirectory, "obsidian.json"), JSON.stringify(obsidianJson));
       const instance = await launchOwnedObsidianInstance({
         cdpHost: this.cdpHost,
         exePath: config.exePath,
@@ -849,11 +1002,15 @@ class DesktopCdpTransport {
         await this.moveOwnedWindowOffscreen();
       }
       try {
+        if (!shouldAutoOpenVault) {
+          await this.openVaultFromStarterScreen(vaultPath, vaultId, this.configDirectory);
+        }
         await this.waitForOwnedVaultReady(vaultPath);
+        await this.assertRequestedConfigDirectory(vaultPath);
         await this.armParentLivenessWatchdog(vaultPath, instance.parentLivenessPort);
         return;
       } catch (error) {
-        if (error instanceof RendererFailedToInitializeError || error instanceof SilentAsarFallbackError) {
+        if (error instanceof RendererFailedToInitializeError || error instanceof SilentAsarFallbackError || error instanceof ConfigDirectoryFallbackError) {
           throw error;
         }
         lastError = error;
@@ -978,6 +1135,44 @@ class DesktopCdpTransport {
     await this.checkRuntimeCompatibility(vaultPath);
     log("[cdp-transport] Owned vault is ready.");
   }
+  /**
+   * Polls until the starter screen's renderer can accept the config-folder
+   * override — that is, until it exposes both `localStorage` and
+   * `window.electron.ipcRenderer.sendSync`.
+   *
+   * A page target exists as soon as the launch resolves, so this is not waiting
+   * for a window; it is waiting for that window's own scripts to finish. Writing
+   * before then would either throw or, worse, land in a renderer that is about to
+   * be replaced.
+   *
+   * @returns The starter screen's CDP target.
+   * @throws {Error} When no renderer becomes writable within the timeout.
+   */
+  async waitForStarterScreenTarget() {
+    const deadline = Date.now() + STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
+      const [target] = await this.getPageTargets();
+      if (target) {
+        const ws = await this.connectToTarget(target);
+        try {
+          const response = await this.sendCommand(ws, "Runtime.evaluate", {
+            expression: 'typeof localStorage !== "undefined" && !!(window.electron && window.electron.ipcRenderer && window.electron.ipcRenderer.sendSync)',
+            returnByValue: true
+          });
+          if (response.result?.result?.value === true) {
+            return target;
+          }
+        } catch {
+        } finally {
+          ws.close();
+        }
+      }
+      await delay(STARTER_SCREEN_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+    throw new Error(
+      `The starter screen did not expose localStorage and the Electron IPC bridge within ${String(STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS)}ms, so the config folder override could not be written.`
+    );
+  }
 }
 function delay(ms) {
   return new Promise((resolve) => {
@@ -1003,4 +1198,4 @@ async function getObsidianLaunchCommand(port) {
 export {
   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-directory` 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.mjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { OwnedObsidianInstance } from './obsidian-instance.mjs';\nimport type { RendererBootObservation } from './renderer-boot-detection.mjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\n\nimport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nimport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng\n} from './capture-screenshot.mjs';\nimport { resolveAsarFallbackAction } from './compatibility-options.mjs';\nimport { DISMISS_TRUST_DIALOG_EXPR } from './dismiss-trust-dialog.mjs';\nimport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport {\n  didRemoveVaultFromConfig,\n  getVaultId,\n  isVaultRegistered\n} from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport { launchOwnedObsidianInstance } from './obsidian-instance.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport { copyAsarIntoUserData } from './obsidian-version-switch.mjs';\nimport { buildOwnedObsidianJson } from './owned-vault-seed.mjs';\nimport { buildParentLivenessWatchdogExpression } from './parent-liveness.mjs';\nimport {\n  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,\n  resolveRendererBootState\n} from './renderer-boot-detection.mjs';\nimport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nimport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\nimport { areVaultPathsMatching } from './vault-path-match.mjs';\nimport {\n  resolveOwnedHiddenLaunchArguments,\n  resolveSandboxLaunchArguments,\n  shouldHideObsidianApp\n} from './visibility.mjs';\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 directory before launch.\n */\nexport interface OwnedInstanceAsar {\n  /**\n  Absolute path to the cached/source asar file.\n   */\n  readonly path: string;\n\n  /**\n  The asar's `x.y.z` version.\n   */\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 directory instead of attaching to a running instance.\n */\nexport interface OwnedInstanceConfig {\n  /**\n  Optional asar to provision into {@link userDataDirectory} before launch.\n   */\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  /**\n  Absolute path to the Obsidian shell executable to launch.\n   */\n  readonly exePath: string;\n\n  /**\n   * Absolute path to the isolated user-data directory. Created and owned by the\n   * transport, and deleted on dispose.\n   */\n\n  readonly userDataDirectory: string;\n}\n\n/**\n * The CDP endpoint of a launched, harness-owned instance.\n */\nexport interface OwnedInstanceEndpoint {\n  /**\n  CDP host (e.g. `'localhost'`).\n   */\n  readonly host: string;\n\n  /**\n  The free CDP port the owned instance was launched on.\n   */\n  readonly port: number;\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  /**\n   * The base64-encoded image returned by `Page.captureScreenshot`.\n   */\n  readonly data?: string;\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\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst VAULT_ID_BYTE_LENGTH = 8;\nconst USER_DATA_RM_TIMEOUT_IN_MILLISECONDS = 10_000;\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 = 30_000;\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 = 30_000;\nconst INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS = 500;\nconst OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS = 200;\nconst OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS = 20_000;\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   * Captures a PNG screenshot of the Obsidian window showing the given vault.\n   *\n   * When a size is requested the viewport is pinned to it with\n   * `Emulation.setDeviceMetricsOverride` for the duration of the capture, so the\n   * emitted PNG is exactly that size whatever size the window happens to be \u2014\n   * and the override is always cleared afterwards, including when the capture\n   * throws, so a failed capture cannot leave the window stuck at the override.\n   *\n   * @param params - Which vault window to capture, and the exact size to capture it at.\n   * @returns The raw PNG bytes.\n   * @throws Error if CDP returns no image data, or data that is not a PNG.\n   */\n  public async captureScreenshot(params: CaptureScreenshotParams): Promise<Uint8Array> {\n    const ws = await this.ensureConnection(params.cwd);\n    const deviceMetricsOverride = buildDeviceMetricsOverride(params);\n    if (deviceMetricsOverride) {\n      await this.sendCommand(ws, 'Emulation.setDeviceMetricsOverride', deviceMetricsOverride);\n    }\n\n    try {\n      const response = await this.sendCommand(ws, 'Page.captureScreenshot', {\n        // The override already sizes the viewport, so capturing beyond it would\n        // Re-introduce the scroll height the override exists to pin down.\n        captureBeyondViewport: false,\n        format: 'png'\n      });\n\n      const data = response.result?.data;\n      if (data === undefined) {\n        throw new Error('CDP screenshot error: Page.captureScreenshot returned no image data.');\n      }\n\n      const bytes = decodeBase64Png(data);\n      if (!isPng(bytes)) {\n        throw new Error('CDP screenshot error: Page.captureScreenshot returned data that is not a PNG.');\n      }\n\n      return bytes;\n    } finally {\n      if (deviceMetricsOverride) {\n        await this.sendCommand(ws, 'Emulation.clearDeviceMetricsOverride', {});\n      }\n    }\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 directory.\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 { userDataDirectory } = this.ownedConfig;\n    const deadline = Date.now() + USER_DATA_RM_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      if (didRemoveDirectory(userDataDirectory)) {\n        return;\n      }\n      await delay(USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS);\n    }\n    if (!didRemoveDirectory(userDataDirectory)) {\n      log(`[cdp-transport] Could not remove owned user-data directory within ${String(USER_DATA_RM_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal): ${userDataDirectory}`);\n    }\n  }\n\n  /**\n   * Synchronous disposal \u2014 kills the owned instance and makes a best-effort\n   * removal of its user-data directory. Safe to call from a process `exit` handler\n   * (where async retries are impossible; a leftover temp directory is acceptable).\n   */\n  public disposeSync(): void {\n    this.disconnect();\n    if (this.ownedConfig) {\n      this.ownedInstance?.kill();\n      if (!didRemoveDirectory(this.ownedConfig.userDataDirectory)) {\n        log(`[cdp-transport] Owned user-data directory not removed synchronously (process may still hold handles): ${this.ownedConfig.userDataDirectory}`);\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 resultObject = response.result?.result;\n    if (!resultObject || resultObject.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObject.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 TemporaryVault.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 windowDestroyExpression = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: windowDestroyExpression,\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      // The `vault-remove` IPC is sent through a still-open window (`targets[0]`) \u2014\n      // `vaultPath`'s own window was just destroyed above, so bootstrap the namespace\n      // On the existing window's OWN base path, not on `vaultPath` (which no longer has\n      // A live target to match).\n      const removalTarget = ensureNonNullable(targets[0]);\n      const removalBasePath = await this.probeVaultPath(removalTarget);\n      const ws = await this.connectToTarget(removalTarget);\n      try {\n        await ensureNamespaceBootstrapped(this, removalBasePath);\n        const vaultRemoveExpression = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ channel: 'vault-remove', channelArguments: [vaultPath] })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: vaultRemoveExpression,\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      didRemoveVaultFromConfig(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 = resolveElectronCompatibility({\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   * Points the owned instance's renderer at this process's liveness socket so it\n   * destroys itself if we die without running teardown (see `parent-liveness.ts`).\n   *\n   * Best-effort by design. A renderer without Node access reports `'unavailable'`\n   * and an evaluation failure is logged and swallowed: the watchdog is a backstop\n   * for an already-abnormal exit, never a reason to fail an otherwise good launch.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   * @param parentLivenessPort - The loopback port the renderer should connect back to.\n   */\n  private async armParentLivenessWatchdog(vaultPath: string, parentLivenessPort: number): Promise<void> {\n    try {\n      const result = await this.evaluate(buildParentLivenessWatchdogExpression(parentLivenessPort), { cwd: vaultPath });\n      log(`[cdp-transport] Parent-liveness watchdog on port ${String(parentLivenessPort)}: ${result}.`);\n    } catch (error: unknown) {\n      log(`[cdp-transport] Could not arm the parent-liveness watchdog (instance may outlive a killed harness): ${String(error)}`);\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 = resolveAsarFallback({\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.addEventListener('open', (): void => {\n        resolve();\n      });\n      ws.addEventListener('error', (): 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   * Probes every target by evaluating `getBasePath()` and returns the one whose\n   * base path matches `vaultPath` (via {@link areVaultPathsMatching}, tolerant of\n   * separator/case differences). A single target is **not** returned blindly: with\n   * more than one vault open (attach mode's shared instance), the sole-target\n   * shortcut would return whichever window happens to be open regardless of which\n   * vault was requested \u2014 the exact mis-routing this method must avoid. A target\n   * whose probe throws is treated as not-ready and skipped (the caller's readiness\n   * poll retries); a target whose probe succeeds but does not match is never\n   * returned. When nothing matches, throw so the caller keeps polling.\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    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (areVaultPathsMatching(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   * @throws {Error} When no CDP endpoint is configured yet.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    if (!this.cdpUrl) {\n      // An owned instance picks its port at launch, so before `registerVault` there is no endpoint and\n      // `this.cdpUrl` is still empty -- which used to make this a `fetch('/json')` and fail with\n      // `Failed to parse URL from /json`, an error naming neither the transport nor what went wrong.\n      // A transport in this state is always a symptom of something upstream (a failed global setup, a\n      // Worker with no registered resolvers -- L9), so say so rather than report a malformed URL.\n      throw new Error(\n        'No CDP endpoint configured: the owned Obsidian instance has not been launched yet, and no `port` '\n          + 'was given to attach to a running one. A test worker in this state usually means its global setup '\n          + 'failed, or the project is missing the per-worker setup file in `setupFiles`.'\n      );\n    }\n\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 directory 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 moveExpression = `(() => {\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();\n        if (target) {\n          const ws = await this.connectToTarget(target);\n          try {\n            const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n              expression: moveExpression,\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    // The `vault-open` IPC is sent through an EXISTING window (`targets[0]`), so the\n    // Helper namespace must be bootstrapped on THAT window \u2014 not on `vaultPath`, whose\n    // Window does not exist yet. Bootstrapping against `vaultPath` here would route\n    // Through `findTargetForVault(vaultPath)` with only the existing window present and\n    // Poison the connection cache (label `vaultPath`, socket \u2192 the existing window), so\n    // Every later eval for `vaultPath` would mis-route to the existing window. Probe the\n    // Existing window's own base path and bootstrap against that instead.\n    const existingTarget = ensureNonNullable(targets[0]);\n    const existingVaultPath = await this.probeVaultPath(existingTarget);\n    const ipcWs = await this.connectToTarget(existingTarget);\n    try {\n      await ensureNamespaceBootstrapped(this, existingVaultPath);\n      const ipcExpression = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ channel: 'vault-open', channelArguments: [vaultPath, false] })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpression,\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();\n      if (!target) {\n        return undefined;\n      }\n\n      const ws = await this.connectToTarget(target);\n      try {\n        const probeExpression = `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: probeExpression,\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.userDataDirectory, { recursive: true });\n    if (config.asar) {\n      copyAsarIntoUserData(config.asar.path, config.asar.version, config.userDataDirectory);\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.userDataDirectory, '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        extraArguments: [\n          ...resolveOwnedHiddenLaunchArguments(this.isObsidianAppVisible),\n          ...resolveSandboxLaunchArguments(this.shouldDisableSandbox)\n        ],\n\n        userDataDirectory: config.userDataDirectory\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        await this.armParentLivenessWatchdog(vaultPath, instance.parentLivenessPort);\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 message = JSON.parse(String(event.data)) as CdpResponse;\n        if (message.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(message);\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 directory 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 (resolveRendererBootState({ ...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 * Attempts to remove a directory recursively, returning whether it succeeded.\n *\n * @param directory - The directory to remove.\n * @returns `true` if removed, `false` if the removal threw (e.g. handles held).\n */\nfunction didRemoveDirectory(directory: string): boolean {\n  try {\n    rmSync(directory, { force: true, recursive: true });\n    return true;\n  } catch {\n    return false;\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/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# 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-directory` 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.mjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { OwnedObsidianInstance } from './obsidian-instance.mjs';\nimport type { RendererBootObservation } from './renderer-boot-detection.mjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\n\nimport { resolveAsarFallback } from './asar-fallback-detection.mjs';\nimport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng\n} from './capture-screenshot.mjs';\nimport { resolveAsarFallbackAction } from './compatibility-options.mjs';\nimport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.mjs';\nimport { DISMISS_TRUST_DIALOG_EXPR } from './dismiss-trust-dialog.mjs';\nimport { resolveElectronCompatibility } from './electron-compatibility.mjs';\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport {\n  didRemoveVaultFromConfig,\n  getVaultId,\n  isVaultRegistered\n} from './obsidian-config.mjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.mjs';\nimport { launchOwnedObsidianInstance } from './obsidian-instance.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport { copyAsarIntoUserData } from './obsidian-version-switch.mjs';\nimport { readOwnedInstanceExitMarker } from './owned-instance-exit-marker.mjs';\nimport {\n  buildOwnedInstanceExitedErrorFromMarker,\n  OwnedInstanceExitedError\n} from './owned-instance-exited-error.mjs';\nimport { buildOwnedObsidianJson } from './owned-vault-seed.mjs';\nimport { buildParentLivenessWatchdogExpression } from './parent-liveness.mjs';\nimport {\n  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,\n  resolveRendererBootState\n} from './renderer-boot-detection.mjs';\nimport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.mjs';\nimport { SilentAsarFallbackError } from './silent-asar-fallback-error.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\nimport {\n  areVaultPathsMatching,\n  normalizeVaultPathForComparison\n} from './vault-path-match.mjs';\nimport { shouldTearDownVaultWindow } from './vault-teardown-verdict.mjs';\nimport {\n  resolveOwnedHiddenLaunchArguments,\n  resolveSandboxLaunchArguments,\n  shouldHideObsidianApp\n} from './visibility.mjs';\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   * The vault's config folder override (Obsidian's *Override config folder*),\n   * e.g. `'.obsidian-desktop'`. When set, the owned instance boots to the\n   * starter screen, writes `<vaultId>-config` into that renderer's\n   * `localStorage`, and only then opens the vault over the `vault-open` IPC \u2014\n   * the override is read once, during the vault renderer's own setup, so it has\n   * to exist before that window is created. The opened vault's actual\n   * `app.vault.configDir` is then read back, and a mismatch throws\n   * {@link ConfigDirectoryFallbackError}. Only meaningful in owned mode.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  configDirectory?: string;\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 directory before launch.\n */\nexport interface OwnedInstanceAsar {\n  /**\n  Absolute path to the cached/source asar file.\n   */\n  readonly path: string;\n\n  /**\n  The asar's `x.y.z` version.\n   */\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 directory instead of attaching to a running instance.\n */\nexport interface OwnedInstanceConfig {\n  /**\n  Optional asar to provision into {@link userDataDirectory} before launch.\n   */\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  /**\n  Absolute path to the Obsidian shell executable to launch.\n   */\n  readonly exePath: string;\n\n  /**\n   * Absolute path to the isolated user-data directory. Created and owned by the\n   * transport, and deleted on dispose.\n   */\n\n  readonly userDataDirectory: string;\n}\n\n/**\n * The CDP endpoint of a launched, harness-owned instance.\n */\nexport interface OwnedInstanceEndpoint {\n  /**\n  CDP host (e.g. `'localhost'`).\n   */\n  readonly host: string;\n\n  /**\n  The free CDP port the owned instance was launched on.\n   */\n  readonly port: number;\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  /**\n   * The base64-encoded image returned by `Page.captureScreenshot`.\n   */\n  readonly data?: string;\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\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst VAULT_ID_BYTE_LENGTH = 8;\nconst USER_DATA_RM_TIMEOUT_IN_MILLISECONDS = 10_000;\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 = 30_000;\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 = 30_000;\nconst INSTANCE_EXIT_SETTLE_DELAY_IN_MILLISECONDS = 500;\n// How long to wait for the starter screen's renderer to expose `localStorage`\n// And `window.electron.ipcRenderer` \u2014 the two things the config-folder override\n// Needs. CDP already serves a page target by the time the launch resolves, so\n// This only covers the renderer finishing its own script evaluation.\nconst STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst STARTER_SCREEN_POLL_INTERVAL_IN_MILLISECONDS = 250;\nconst OWNED_WINDOW_OFFSCREEN_MARGIN_IN_PIXELS = 200;\nconst OWNED_WINDOW_HIDE_TIMEOUT_IN_MILLISECONDS = 20_000;\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 configDirectory: string | undefined;\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  /**\n   * Vault paths THIS transport opened via {@link registerVault}, normalized by\n   * {@link normalizeVaultPathForComparison}. A worker attached to a\n   * harness-owned instance may tear down only these \u2014 every other vault in that\n   * instance belongs to the global setup that launched it (see\n   * {@link shouldTearDownVaultWindow}).\n   */\n  private readonly selfRegisteredVaultPaths = new Set<string>();\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      configDirectory,\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.configDirectory = configDirectory;\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   * Captures a PNG screenshot of the Obsidian window showing the given vault.\n   *\n   * When a size is requested the viewport is pinned to it with\n   * `Emulation.setDeviceMetricsOverride` for the duration of the capture, so the\n   * emitted PNG is exactly that size whatever size the window happens to be \u2014\n   * and the override is always cleared afterwards, including when the capture\n   * throws, so a failed capture cannot leave the window stuck at the override.\n   *\n   * @param params - Which vault window to capture, and the exact size to capture it at.\n   * @returns The raw PNG bytes.\n   * @throws Error if CDP returns no image data, or data that is not a PNG.\n   */\n  public async captureScreenshot(params: CaptureScreenshotParams): Promise<Uint8Array> {\n    const ws = await this.ensureConnection(params.cwd);\n    const deviceMetricsOverride = buildDeviceMetricsOverride(params);\n    if (deviceMetricsOverride) {\n      await this.sendCommand(ws, 'Emulation.setDeviceMetricsOverride', deviceMetricsOverride);\n    }\n\n    try {\n      const response = await this.sendCommand(ws, 'Page.captureScreenshot', {\n        // The override already sizes the viewport, so capturing beyond it would\n        // Re-introduce the scroll height the override exists to pin down.\n        captureBeyondViewport: false,\n        format: 'png'\n      });\n\n      const data = response.result?.data;\n      if (data === undefined) {\n        throw new Error('CDP screenshot error: Page.captureScreenshot returned no image data.');\n      }\n\n      const bytes = decodeBase64Png(data);\n      if (!isPng(bytes)) {\n        throw new Error('CDP screenshot error: Page.captureScreenshot returned data that is not a PNG.');\n      }\n\n      return bytes;\n    } finally {\n      if (deviceMetricsOverride) {\n        await this.sendCommand(ws, 'Emulation.clearDeviceMetricsOverride', {});\n      }\n    }\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 directory.\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 { userDataDirectory } = this.ownedConfig;\n    const deadline = Date.now() + USER_DATA_RM_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      if (didRemoveDirectory(userDataDirectory)) {\n        return;\n      }\n      await delay(USER_DATA_RM_RETRY_INTERVAL_IN_MILLISECONDS);\n    }\n    if (!didRemoveDirectory(userDataDirectory)) {\n      log(`[cdp-transport] Could not remove owned user-data directory within ${String(USER_DATA_RM_TIMEOUT_IN_MILLISECONDS)}ms (non-fatal): ${userDataDirectory}`);\n    }\n  }\n\n  /**\n   * Synchronous disposal \u2014 kills the owned instance and makes a best-effort\n   * removal of its user-data directory. Safe to call from a process `exit` handler\n   * (where async retries are impossible; a leftover temp directory is acceptable).\n   */\n  public disposeSync(): void {\n    this.disconnect();\n    if (this.ownedConfig) {\n      this.ownedInstance?.kill();\n      if (!didRemoveDirectory(this.ownedConfig.userDataDirectory)) {\n        log(`[cdp-transport] Owned user-data directory not removed synchronously (process may still hold handles): ${this.ownedConfig.userDataDirectory}`);\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 resultObject = response.result?.result;\n    if (!resultObject || resultObject.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObject.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 TemporaryVault.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    // Recorded only on success, and only here: this is the one branch that opens\n    // A window in an instance this transport did not launch, so it is the one\n    // Branch that earns the right to close one (see `unregisterVault`).\n    this.selfRegisteredVaultPaths.add(normalizeVaultPathForComparison(vaultPath));\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * Refuses when this transport does not own what it would be tearing down \u2014\n   * see {@link shouldTearDownVaultWindow} for which of the two ownership flags\n   * means what, and why they are not interchangeable.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    const normalizedVaultPath = normalizeVaultPathForComparison(vaultPath);\n    if (\n      !shouldTearDownVaultWindow({\n        isHarnessOwnedInstance: this.isHarnessOwnedInstance,\n        isOwnedInstance: Boolean(this.ownedConfig),\n        isSelfRegistered: this.selfRegisteredVaultPaths.has(normalizedVaultPath)\n      })\n    ) {\n      log(\n        this.ownedConfig\n          ? `[cdp-transport] Skipping per-vault teardown; the owned instance is killed wholesale on dispose: ${vaultPath}`\n          : `[cdp-transport] Skipping per-vault teardown; this worker did not register the vault it was asked to unregister: ${vaultPath}`\n      );\n      return;\n    }\n\n    this.selfRegisteredVaultPaths.delete(normalizedVaultPath);\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 windowDestroyExpression = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: windowDestroyExpression,\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      // The `vault-remove` IPC is sent through a still-open window (`targets[0]`) \u2014\n      // `vaultPath`'s own window was just destroyed above, so bootstrap the namespace\n      // On the existing window's OWN base path, not on `vaultPath` (which no longer has\n      // A live target to match).\n      const removalTarget = ensureNonNullable(targets[0]);\n      const removalBasePath = await this.probeVaultPath(removalTarget);\n      const ws = await this.connectToTarget(removalTarget);\n      try {\n        await ensureNamespaceBootstrapped(this, removalBasePath);\n        const vaultRemoveExpression = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ channel: 'vault-remove', channelArguments: [vaultPath] })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: vaultRemoveExpression,\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      didRemoveVaultFromConfig(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 = resolveElectronCompatibility({\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   * Points the owned instance's renderer at this process's liveness socket so it\n   * destroys itself if we die without running teardown (see `parent-liveness.ts`).\n   *\n   * Best-effort by design. A renderer without Node access reports `'unavailable'`\n   * and an evaluation failure is logged and swallowed: the watchdog is a backstop\n   * for an already-abnormal exit, never a reason to fail an otherwise good launch.\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   * @param parentLivenessPort - The loopback port the renderer should connect back to.\n   */\n  private async armParentLivenessWatchdog(vaultPath: string, parentLivenessPort: number): Promise<void> {\n    try {\n      const result = await this.evaluate(buildParentLivenessWatchdogExpression(parentLivenessPort), { cwd: vaultPath });\n      log(`[cdp-transport] Parent-liveness watchdog on port ${String(parentLivenessPort)}: ${result}.`);\n    } catch (error: unknown) {\n      log(`[cdp-transport] Could not arm the parent-liveness watchdog (instance may outlive a killed harness): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Verifies the ready vault is actually using the requested config folder,\n   * throwing {@link ConfigDirectoryFallbackError} when it is not.\n   *\n   * Obsidian applies the override with `setConfigDir`, which substitutes\n   * `.obsidian` for any value its own `validateConfigDir` rejects \u2014 without a\n   * word, and without failing the boot. The resulting vault opens, reaches\n   * layout-ready, and reports success; what it lacks is the settings and enabled\n   * plugins of the folder that was asked for. Reading the live\n   * `app.vault.configDir` back is the only way to tell the two apart, and it\n   * covers every cause at once: a name Obsidian rejected (including its\n   * unrecoverable character blacklist, which `assertValidConfigDirectory` deliberately\n   * does not guess at), and a write that never reached the vault's renderer.\n   *\n   * A no-op when no override was requested.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async assertRequestedConfigDirectory(vaultPath: string): Promise<void> {\n    if (this.configDirectory === undefined) {\n      return;\n    }\n\n    const actualConfigDirectory = await this.evaluate('app.vault.configDir', { cwd: vaultPath });\n    if (actualConfigDirectory === this.configDirectory) {\n      log(`[cdp-transport] Vault opened with the requested config folder ${this.configDirectory}.`);\n      return;\n    }\n\n    throw new ConfigDirectoryFallbackError({\n      actualConfigDirectory,\n      requestedConfigDirectory: this.configDirectory,\n      vaultPath\n    });\n  }\n\n  /**\n   * Builds the error for a harness-owned instance that is no longer serving CDP,\n   * from the best evidence this process has.\n   *\n   * Two processes see two different halves of the death. The one that launched\n   * the instance holds the child and can read the exit code straight off it; a\n   * test worker holds nothing but the port, and reads the same facts from the\n   * exit marker the owner wrote (`owned-instance-exit-marker.ts`). With neither\n   * \u2014 the marker lost, or a kill so abrupt nothing recorded it \u2014 the error still\n   * names the instance as the cause, which is the whole point of it.\n   *\n   * @returns The error to throw in place of a refused connection.\n   */\n  private buildOwnedInstanceExitedError(): OwnedInstanceExitedError {\n    const exitInfo = this.ownedInstance?.readExitInfo();\n    if (exitInfo) {\n      return new OwnedInstanceExitedError({\n        cdpUrl: this.cdpUrl,\n        code: exitInfo.code,\n        outputTail: this.ownedInstance?.readOutput(),\n        signal: exitInfo.signal,\n        spawnError: exitInfo.spawnError\n      });\n    }\n\n    return buildOwnedInstanceExitedErrorFromMarker(this.cdpUrl, readOwnedInstanceExitMarker(this.cdpPort));\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 = resolveAsarFallback({\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.addEventListener('open', (): void => {\n        resolve();\n      });\n      ws.addEventListener('error', (): 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   * Probes every target by evaluating `getBasePath()` and returns the one whose\n   * base path matches `vaultPath` (via {@link areVaultPathsMatching}, tolerant of\n   * separator/case differences). A single target is **not** returned blindly: with\n   * more than one vault open (attach mode's shared instance), the sole-target\n   * shortcut would return whichever window happens to be open regardless of which\n   * vault was requested \u2014 the exact mis-routing this method must avoid. A target\n   * whose probe throws is treated as not-ready and skipped (the caller's readiness\n   * poll retries); a target whose probe succeeds but does not match is never\n   * returned. When nothing matches, throw so the caller keeps polling.\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    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (areVaultPathsMatching(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   * @throws {Error} When no CDP endpoint is configured yet.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    if (!this.cdpUrl) {\n      // An owned instance picks its port at launch, so before `registerVault` there is no endpoint and\n      // `this.cdpUrl` is still empty -- which used to make this a `fetch('/json')` and fail with\n      // `Failed to parse URL from /json`, an error naming neither the transport nor what went wrong.\n      // A transport in this state is always a symptom of something upstream (a failed global setup, a\n      // Worker with no registered resolvers -- L9), so say so rather than report a malformed URL.\n      throw new Error(\n        'No CDP endpoint configured: the owned Obsidian instance has not been launched yet, and no `port` '\n          + 'was given to attach to a running one. A test worker in this state usually means its global setup '\n          + 'failed, or the project is missing the per-worker setup file in `setupFiles`.'\n      );\n    }\n\n    let response: Response;\n    try {\n      response = await fetch(`${this.cdpUrl}/json`);\n    } catch (error: unknown) {\n      /*\n       * An unreachable endpoint means different things in the two modes, and\n       * conflating them is what produced the `ECONNREFUSED` cascades. The\n       * harness owns this port and nothing else may hold it, so nothing\n       * answering means OUR instance is gone \u2014 say that, with its exit code\n       * when it is known. In plain attach mode the endpoint belongs to a\n       * foreign Obsidian that is simply not running, which `ensureObsidianRunning`\n       * handles by starting one; that path must keep seeing the raw failure.\n       */\n      if (this.ownedConfig || this.isHarnessOwnedInstance) {\n        throw this.buildOwnedInstanceExitedError();\n      }\n      throw error;\n    }\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 directory 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 moveExpression = `(() => {\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();\n        if (target) {\n          const ws = await this.connectToTarget(target);\n          try {\n            const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n              expression: moveExpression,\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   * Writes the config-folder override into the starter screen's `localStorage`\n   * and then opens the vault from there over the `vault-open` IPC.\n   *\n   * Obsidian reads the override exactly once, in the vault's own renderer, during\n   * `Vault.setup` \u2014 `getOverrideConfigDir(appId)` is `localStorage.getItem(appId +\n   * '-config')`. So there is no writing it into the vault's window: by the time\n   * that window exists the read has happened. The starter screen is the earlier\n   * renderer the write needs, and it qualifies because it has `localStorage` and\n   * `window.electron.ipcRenderer` but no `app` (verified on 1.13.7).\n   *\n   * That missing `app` is also why this talks raw CDP rather than going through\n   * {@link ensureNamespaceBootstrapped} / the `ipcSendSync` helper as\n   * {@link DesktopCdpTransport.openVaultInRunningInstance} does: every one of\n   * those paths probes `app.vault.adapter` to identify its target, and would fail\n   * on the very renderer this needs.\n   *\n   * The key name is known ahead of the write because the harness registered the\n   * vault under an id it generated itself, and `vault-open` reuses that entry\n   * rather than minting a new one.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   * @param vaultId - The harness-generated vault id the vault is registered under.\n   * @param configDirectory - The config folder to override to.\n   */\n  private async openVaultFromStarterScreen(vaultPath: string, vaultId: string, configDirectory: string): Promise<void> {\n    log(`[cdp-transport] Seeding config folder override ${configDirectory} on the starter screen...`);\n    const target = await this.waitForStarterScreenTarget();\n    const ws = await this.connectToTarget(target);\n    try {\n      await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: `localStorage.setItem(${JSON.stringify(`${vaultId}-config`)}, ${JSON.stringify(configDirectory)});`,\n        returnByValue: true\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 ${vaultId}-config and enable-plugin-${vaultId} in localStorage.`);\n\n      await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false)`,\n        returnByValue: true\n      });\n      log(`[cdp-transport] Sent vault-open for ${vaultPath} from the starter screen.`);\n    } finally {\n      ws.close();\n    }\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    // The `vault-open` IPC is sent through an EXISTING window (`targets[0]`), so the\n    // Helper namespace must be bootstrapped on THAT window \u2014 not on `vaultPath`, whose\n    // Window does not exist yet. Bootstrapping against `vaultPath` here would route\n    // Through `findTargetForVault(vaultPath)` with only the existing window present and\n    // Poison the connection cache (label `vaultPath`, socket \u2192 the existing window), so\n    // Every later eval for `vaultPath` would mis-route to the existing window. Probe the\n    // Existing window's own base path and bootstrap against that instead.\n    const existingTarget = ensureNonNullable(targets[0]);\n    const existingVaultPath = await this.probeVaultPath(existingTarget);\n    const ipcWs = await this.connectToTarget(existingTarget);\n    try {\n      await ensureNamespaceBootstrapped(this, existingVaultPath);\n      const ipcExpression = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ channel: 'vault-open', channelArguments: [vaultPath, false] })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpression,\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();\n      if (!target) {\n        return undefined;\n      }\n\n      const ws = await this.connectToTarget(target);\n      try {\n        const probeExpression = `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: probeExpression,\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.userDataDirectory, { recursive: true });\n    if (config.asar) {\n      copyAsarIntoUserData(config.asar.path, config.asar.version, config.userDataDirectory);\n    }\n\n    const vaultId = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n\n    // A config-folder override is a `localStorage` entry, and `localStorage` needs a\n    // Renderer, so the vault must NOT auto-open: the instance boots to the starter\n    // Screen, the override is written there, and the vault is opened from it over\n    // IPC. Obsidian reuses the pre-registered id for that open (verified on 1.13.7),\n    // Which is what makes the `<vaultId>-config` key name knowable before launch.\n    const shouldAutoOpenVault = this.configDirectory === undefined;\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      // Re-seeded every attempt rather than once before the loop: Obsidian rewrites\n      // `obsidian.json` as it opens a vault (it stamps the entry `open: true`), so a\n      // Relaunch that inherited the previous attempt's file would sail past the\n      // Starter screen the override needs.\n      const obsidianJson = buildOwnedObsidianJson({ shouldAutoOpenVault, ts: Date.now(), vaultId, vaultPath });\n      writeFileSync(join(config.userDataDirectory, 'obsidian.json'), JSON.stringify(obsidianJson));\n\n      const instance = await launchOwnedObsidianInstance({\n        cdpHost: this.cdpHost,\n        exePath: config.exePath,\n        extraArguments: [\n          ...resolveOwnedHiddenLaunchArguments(this.isObsidianAppVisible),\n          ...resolveSandboxLaunchArguments(this.shouldDisableSandbox)\n        ],\n\n        userDataDirectory: config.userDataDirectory\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        if (!shouldAutoOpenVault) {\n          // `shouldAutoOpenVault` is a `const` derived from `this.configDirectory === undefined`,\n          // So TypeScript narrows the field to `string` in this branch on its own.\n          await this.openVaultFromStarterScreen(vaultPath, vaultId, this.configDirectory);\n        }\n        await this.waitForOwnedVaultReady(vaultPath);\n        await this.assertRequestedConfigDirectory(vaultPath);\n        await this.armParentLivenessWatchdog(vaultPath, instance.parentLivenessPort);\n        return;\n      } catch (error: unknown) {\n        // A config-folder fallback is deterministic \u2014 the name is either one Obsidian\n        // Accepts or it is not \u2014 so relaunching only burns another boot.\n        if (\n          error instanceof RendererFailedToInitializeError\n          || error instanceof SilentAsarFallbackError\n          || error instanceof ConfigDirectoryFallbackError\n        ) {\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 message = JSON.parse(String(event.data)) as CdpResponse;\n        if (message.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(message);\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 directory 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 (resolveRendererBootState({ ...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   * Polls until the starter screen's renderer can accept the config-folder\n   * override \u2014 that is, until it exposes both `localStorage` and\n   * `window.electron.ipcRenderer.sendSync`.\n   *\n   * A page target exists as soon as the launch resolves, so this is not waiting\n   * for a window; it is waiting for that window's own scripts to finish. Writing\n   * before then would either throw or, worse, land in a renderer that is about to\n   * be replaced.\n   *\n   * @returns The starter screen's CDP target.\n   * @throws {Error} When no renderer becomes writable within the timeout.\n   */\n  private async waitForStarterScreenTarget(): Promise<CdpTarget> {\n    const deadline = Date.now() + STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      const [target] = await this.getPageTargets();\n      if (target) {\n        const ws = await this.connectToTarget(target);\n        try {\n          const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n            expression: 'typeof localStorage !== \"undefined\" && !!(window.electron && window.electron.ipcRenderer && window.electron.ipcRenderer.sendSync)',\n            returnByValue: true\n          });\n          if (response.result?.result?.value === true) {\n            return target;\n          }\n        } catch {\n          // The renderer is not evaluating yet \u2014 keep polling.\n        } finally {\n          ws.close();\n        }\n      }\n      await delay(STARTER_SCREEN_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(\n      `The starter screen did not expose localStorage and the Electron IPC bridge within ${String(STARTER_SCREEN_TIMEOUT_IN_MILLISECONDS)}ms, `\n        + 'so the config folder override could not be written.'\n    );\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 * Attempts to remove a directory recursively, returning whether it succeeded.\n *\n * @param directory - The directory to remove.\n * @returns `true` if removed, `false` if the removal threw (e.g. handles held).\n */\nfunction didRemoveDirectory(directory: string): boolean {\n  try {\n    rmSync(directory, { force: true, recursive: true });\n    return true;\n  } catch {\n    return false;\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/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
