obsidian-integration-testing 5.1.2 → 5.3.0

package/README.md

@@ -109,6 +109,64 @@ const title = await evalInObsidian({
 });
 ```
 
+### Simulate real user input (trusted keyboard & pointer)
+
+Every callback also receives helpers that inject **trusted** input at the Chromium level
+(via Electron's `webContents.sendInputEvent`) — the kind of event only the browser/OS
+normally produces. This matters because the in-page alternatives give false results:
+`dispatchEvent(new KeyboardEvent(...))` / `new MouseEvent(...)` are untrusted
+(`isTrusted: false`), so CodeMirror ignores the keystroke and `:hover` never takes effect;
+`execCommand('insertText')` mutates the selection even when the editor is not focused,
+masking focus bugs as false passes. The trusted helpers flow through the real input
+pipeline, so text lands **only if the editor genuinely holds focus** and `:hover` rules
+genuinely apply.
+
+The element/editor arguments are live renderer DOM nodes — the callback runs in the Obsidian
+renderer, so no cross-process serialization is needed.
+
+| Helper                             | Purpose                                                                                                              |
+|------------------------------------|----------------------------------------------------------------------------------------------------------------------|
+| `typeIntoEditor({ editor, text })` | Focuses `editor` (caret to end), types `text` as trusted key events, then polls until the document reflects it.      |
+| `hoverElement({ element })`        | Moves the pointer to `element`'s center, then polls until `element.matches(':hover')`.                               |
+| `unhoverElement({ element })`      | Moves the pointer just outside `element`'s bounding box, then polls until it no longer matches `:hover`.             |
+| `moveMouse({ x, y })`              | Low-level primitive: injects one trusted pointer move at the given web-contents DIP coordinates (does **not** poll). |
+
+```ts
+// Type into the active editor — only succeeds if the editor truly holds focus.
+const typed = await evalInObsidian({
+  fn: async ({ app, obsidianModule, typeIntoEditor }) => {
+    const view = app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
+    const editor = view?.editor;
+    if (!editor) {
+      return null;
+    }
+
+    await typeIntoEditor({ editor, text: 'Hello, world!' });
+    return editor.getValue();
+  }
+});
+
+// Observe a genuine :hover state (real theme var() values, real compositing).
+await evalInObsidian({
+  fn: async ({ hoverElement, unhoverElement }) => {
+    const bar = document.querySelector<HTMLElement>('.minimized-modal-bar');
+    if (!bar) {
+      return;
+    }
+
+    await hoverElement({ element: bar });
+    // ...assert the hovered appearance...
+    await unhoverElement({ element: bar });
+  }
+});
+```
+
+> **Serialize focus/pointer-dependent test files.** Trusted input targets the single shared
+> window's **global** focus and pointer, so test files that depend on either must not run in
+> parallel against the one shared Obsidian instance (they race for focus, and a
+> `detachLeavesOfType('markdown')` in one file wipes another's editor). Run your
+> obsidian-integration Vitest project serially — `fileParallelism: false` and `maxWorkers: 1`.
+
 ### Pass complex arguments
 
 Arguments are JSON-serialized. You can even pass functions — they are serialized via `toString()`:
@@ -636,6 +694,45 @@ npx vitest run --project integration-tests:android-appium
 npx vitest run --project integration-tests:*
 ```
 
+## Ad-hoc debugging (`connectToCdp` and the CLI)
+
+Outside of a test framework, `connectToCdp()` launches (or attaches to) a `CDP` Obsidian instance, opens a vault, bootstraps the runtime helpers, and returns a disposable connection — handy for reproducing behavior in a real Obsidian from a throwaway script or the REPL.
+
+```ts
+import { connectToCdp } from 'obsidian-integration-testing';
+
+// Owns an isolated instance + an empty temp vault (both cleaned up on dispose).
+await using conn = await connectToCdp();
+
+console.log(conn.port, conn.cdpUrl); // the free CDP port the instance was launched on
+
+// Raw expression → normalized string result:
+await conn.invoke('app.vault.getName()');
+
+// Rich, typed path — `fn` runs in the Obsidian renderer with { app, obsidianModule, typeIntoEditor, context }:
+await conn.evalInObsidian({ fn: ({ app }) => app.workspace.getActiveFile()?.path ?? null });
+```
+
+`connectToCdp` accepts the same version knobs as the transport (`obsidianVersion`, `obsidianInstallerVersion`, `host`, `commandTimeoutInMilliseconds`, both defaulting to your installed Obsidian), plus:
+
+- **`vault`** — path to an existing vault to open. When omitted, an empty temporary vault is created.
+- **`port`** — attach to an already-running Obsidian on this `CDP` port instead of owning an instance (as in [Attaching to a running Obsidian](#attaching-to-a-running-obsidian)).
+- **`shouldRemoveVaultOnDispose`** — whether `dispose()` removes the vault directory. Defaults to `true` for an implicit temp vault and `false` when a `vault` path is given, so a **real vault is never auto-deleted**. Set it explicitly to override.
+
+> [!WARNING]
+>
+> Opening a **real** vault in the owned instance may write to that vault's `.obsidian` config (normal Obsidian behavior). The vault directory itself is never deleted unless `shouldRemoveVaultOnDispose` is `true`.
+
+### CLI
+
+The package ships an `obsidian-integration-testing` bin that wraps `connectToCdp`, prints the chosen port/URL, and stays alive until `Ctrl+C` — useful when an external tool (raw `CDP` `ws`, DevTools) needs to attach to a printed port:
+
+```bash
+npx obsidian-integration-testing --vault F:/path/to/vault --obsidian-version 1.8.10
+```
+
+Flags mirror the options above: `--vault`, `--obsidian-version`, `--obsidian-installer-version`, `--port`, `--host`, `--command-timeout`, and `--no-remove-vault` (keep the temp vault on exit).
+
 ## Support
 
 <!-- markdownlint-disable MD033 -->

package/bin/obsidian-integration-testing.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from '../dist/lib/esm/cli.mjs';
+
+await main();

package/dist/lib/cjs/cli.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_util = require("node:util");
+var import_connect_to_cdp = require("./connect-to-cdp.cjs");
+async function main() {
+  const { values } = (0, import_node_util.parseArgs)({
+    options: {
+      "command-timeout": { type: "string" },
+      "host": { type: "string" },
+      "no-remove-vault": { type: "boolean" },
+      "obsidian-installer-version": { type: "string" },
+      "obsidian-version": { type: "string" },
+      "port": { type: "string" },
+      "vault": { type: "string" }
+    }
+  });
+  const connection = await (0, import_connect_to_cdp.connectToCdp)(buildOptions(values));
+  import_node_process.default.stdout.write(
+    `Obsidian CDP ready.
+  port:   ${String(connection.port)}
+  cdpUrl: ${connection.cdpUrl}
+  vault:  ${connection.vault.path}
+Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.
+Press Ctrl+C to stop.
+`
+  );
+  await waitForShutdownSignal();
+  import_node_process.default.stdout.write("\nShutting down\u2026\n");
+  await connection.dispose();
+}
+function buildOptions(values) {
+  return {
+    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
+    ...values.host !== void 0 && { host: values.host },
+    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
+    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
+    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
+    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
+    ...values.vault !== void 0 && { vault: values.vault }
+  };
+}
+function parseNumber(flag, raw) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new Error(`--${flag} must be a number, got: ${raw}`);
+  }
+  return value;
+}
+function waitForShutdownSignal() {
+  return new Promise((resolve) => {
+    import_node_process.default.once("SIGINT", () => {
+      resolve();
+    });
+    import_node_process.default.once("SIGTERM", () => {
+      resolve();
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+/**
+ * @file
+ *
+ * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled
+ * Obsidian instance with the runtime helper namespace bootstrapped, prints the
+ * chosen CDP port/URL, and stays alive until interrupted so an external tool
+ * (raw CDP `ws`, DevTools, …) can attach.
+ */
+/**
+ * Parses CLI arguments, opens the connection, prints its endpoint, and blocks
+ * until `SIGINT`/`SIGTERM`, disposing the connection on shutdown.
+ *
+ * @returns A {@link Promise} that resolves once the connection has been disposed.
+ */
+export declare function main(): Promise<void>;

package/dist/lib/cjs/connect-to-cdp.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var connect_to_cdp_exports = {};
+__export(connect_to_cdp_exports, {
+  connectToCdp: () => connectToCdp
+});
+module.exports = __toCommonJS(connect_to_cdp_exports);
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_temp_vault = require("./temp-vault.cjs");
+var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
+var import_transport_factory = require("./transport-factory.cjs");
+const DEFAULT_CDP_HOST = "localhost";
+async function connectToCdp(options) {
+  const transportOptions = {
+    type: "obsidian-cdp",
+    ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
+    ...options?.host !== void 0 && { host: options.host },
+    ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
+    ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
+    ...options?.port !== void 0 && { port: options.port }
+  };
+  const transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
+  const vault = new import_temp_vault.TempVault(options?.vault);
+  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
+  await vault.register(transport);
+  const { host, port } = resolveEndpoint(transport, options);
+  const cdpUrl = `http://${host}:${String(port)}`;
+  const connection = {
+    cdpUrl,
+    async dispose() {
+      try {
+        if (shouldRemoveVaultOnDispose) {
+          await vault.dispose(transport);
+        } else {
+          await transport.unregisterVault(vault.path);
+        }
+      } finally {
+        await transport.dispose?.();
+      }
+    },
+    async evalInObsidian(params) {
+      return (0, import_eval_in_obsidian.evalInObsidian)({ ...params, transport, vaultPath: vault.path });
+    },
+    async invoke(expression) {
+      return transport.evaluate(expression, { cwd: vault.path });
+    },
+    port,
+    async [Symbol.asyncDispose]() {
+      await connection.dispose();
+    },
+    vault
+  };
+  return connection;
+}
+function resolveEndpoint(transport, options) {
+  if (transport instanceof import_transport_desktop_cdp.DesktopCdpTransport) {
+    const endpoint = transport.getOwnedInstanceEndpoint();
+    if (endpoint) {
+      return { host: endpoint.host, port: endpoint.port };
+    }
+  }
+  if (options?.port !== void 0) {
+    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };
+  }
+  throw new Error("connectToCdp: could not determine the CDP port.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectToCdp
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * `typeIntoEditor`, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any\n   * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault\n   * path pre-bound to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,8BAA+B;AAC/B,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AA0IzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,UAAM,qDAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,4BAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,iBAAO,wCAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,kDAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/cjs/connect-to-cdp.d.cts

@@ -0,0 +1,130 @@
+/**
+ * @file
+ *
+ * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance
+ * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.
+ *
+ * A single {@link connectToCdp} call resolves the owned-instance config, opens a
+ * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,
+ * `typeIntoEditor`, `serializeError`, `getObsidianModule`, … are available), then
+ * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a
+ * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
+ */
+import type { Except } from 'type-fest';
+import type { ContextId } from './context-id.cjs';
+import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.cjs';
+import { TempVault } from './temp-vault.cjs';
+/**
+ * A live connection to a CDP-enabled Obsidian instance with the runtime helper
+ * namespace bootstrapped.
+ *
+ * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(…)`
+ * disposes it (killing an owned instance and — for a throw-away temp vault —
+ * removing its directory) automatically.
+ */
+export interface CdpConnection extends AsyncDisposable {
+    /**
+     * The base CDP URL, e.g. `http://localhost:51888`.
+     */
+    readonly cdpUrl: string;
+    /**
+     * Disposes the connection: kills an owned instance and removes its isolated
+     * user-data dir. The vault directory is removed only when it is a throw-away
+     * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a
+     * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.
+     *
+     * @returns A {@link Promise} that resolves once disposal completes.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Evaluates a self-contained function inside Obsidian via the rich helper
+     * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any
+     * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault
+     * path pre-bound to this connection.
+     *
+     * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).
+     * @returns A {@link Promise} that resolves to the return value of `fn`.
+     */
+    evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
+    /**
+     * Evaluates a raw JavaScript expression inside Obsidian and returns the
+     * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).
+     *
+     * @param expression - A self-contained JavaScript expression.
+     * @returns A {@link Promise} that resolves to the raw result string.
+     */
+    invoke(expression: string): Promise<string>;
+    /**
+     * The CDP port the instance is reachable on (the free port chosen for an
+     * owned instance, or the attached {@link ConnectToCdpOptions.port}).
+     */
+    readonly port: number;
+    /**
+     * The opened vault. Exposes `path` and `populate(...)` for seeding files.
+     */
+    readonly vault: TempVault;
+}
+/**
+ * Options for {@link connectToCdp}.
+ */
+export interface ConnectToCdpOptions {
+    /**
+     * Timeout in milliseconds for individual CDP commands.
+     *
+     * @default `30000`
+     */
+    readonly commandTimeoutInMilliseconds?: number;
+    /**
+     * CDP host.
+     *
+     * @default `'localhost'`
+     */
+    readonly host?: string;
+    /**
+     * Pins the Electron shell (installer build) the owned instance runs. Accepts
+     * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when
+     * {@link port} (attach mode) is set. When omitted, the installed shell is used.
+     *
+     * @default `undefined`
+     */
+    readonly obsidianInstallerVersion?: string;
+    /**
+     * Pins the Obsidian app version (asar) the owned instance runs. Accepts
+     * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when
+     * {@link port} (attach mode) is set. When omitted, the installed version is used.
+     *
+     * @default `undefined`
+     */
+    readonly obsidianVersion?: string;
+    /**
+     * CDP port of an already-running Obsidian to **attach** to. When omitted, an
+     * isolated instance is launched on an automatically chosen free port.
+     *
+     * @default `undefined`
+     */
+    readonly port?: number;
+    /**
+     * Whether to remove the vault directory on {@link CdpConnection.dispose}.
+     *
+     * When omitted, defaults to `true` for an implicit throw-away temp vault
+     * ({@link vault} not given) and `false` when a {@link vault} path is given, so
+     * a real vault is never deleted. Set explicitly to override.
+     */
+    readonly shouldRemoveVaultOnDispose?: boolean;
+    /**
+     * Absolute path to an existing vault to open. When omitted, an empty temporary
+     * vault is created (and removed on dispose unless
+     * {@link shouldRemoveVaultOnDispose} says otherwise).
+     *
+     * @default `undefined`
+     */
+    readonly vault?: string;
+}
+/**
+ * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and
+ * bootstraps the runtime helper namespace, returning a disposable connection.
+ *
+ * @param options - Connection options.
+ * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.
+ */
+export declare function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection>;

package/dist/lib/cjs/eval-in-obsidian.cjs

@@ -79,4 +79,4 @@ ${sanitizedDetail}`);
 0 && (module.exports = {
   evalInObsidian
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.cjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { generateNamespaceCall } from './generate-function-call.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `fn` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `fn` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * A trusted event (injected via Electron's `webContents.sendInputEvent`)\n   * behaves like a real keypress: it is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArgs.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type, one trusted character event per code point.\n   */\n  readonly text: string;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    args,\n    fn,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AAuHlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,OAAO,CAAC,GAAG,WAAW,IAAI,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACjH,QAAM,MAAM,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,KAAC,2BAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,YAAM,wDAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,iBAAa,qDAAsB,mBAAmB;AAE5D,QAAM,YAAY,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAE9D,MAAI,cAAc,MAAM,cAAc,WAAW;AAC/C,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,SAAS;AAAA,EACjC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,SAAS,EAAE;AAAA,EACnF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,QAAQ,yCAAyC,2BAA2B;AAC/E,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.cjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { generateNamespaceCall } from './generate-function-call.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `fn` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `fn` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * Moves the mouse pointer to the center of an element using **trusted**\n   * Electron pointer input, then polls until the element actually matches\n   * `:hover`.\n   *\n   * Because the move is trusted (see {@link CommonArgs.moveMouse}), the real\n   * `:hover` state takes effect in the CSS engine \u2014 real theme `var()` values\n   * and real compositing \u2014 instead of a hand-simulated cascade. It polls the\n   * live `element.matches(':hover')` state (not a fixed delay), so it is robust\n   * under shared-instance load. It targets the single shared window's\n   * **global** pointer, so only one element is hovered at a time.\n   *\n   * @param params - The element to hover.\n   * @returns A {@link Promise} that resolves once the element matches `:hover`.\n   */\n  hoverElement(this: void, params: HoverElementParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to the given web-contents coordinates using a\n   * **trusted** Electron pointer move.\n   *\n   * A trusted move (injected via Electron's `webContents.sendInputEvent`)\n   * updates the real pointer state in the CSS engine, so `:hover` rules\n   * genuinely apply \u2014 unlike `dispatchEvent(new MouseEvent('mouseover'))`,\n   * which is untrusted and never sets `:hover`. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time.\n   *\n   * This is the low-level primitive: it performs a single move and does **not**\n   * wait for any state to settle (callers poll their own readiness signal).\n   * Prefer {@link CommonArgs.hoverElement} / {@link CommonArgs.unhoverElement}\n   * for element-relative moves; use `moveMouse` directly when an\n   * element-relative target does not fit (e.g. an element spanning the full\n   * viewport width).\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   * @returns A {@link Promise} that resolves once the move has been injected.\n   */\n  moveMouse(this: void, params: MoveMouseParams): Promise<void>;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * A trusted event (injected via Electron's `webContents.sendInputEvent`)\n   * behaves like a real keypress: it is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to a point just outside an element's bounding box\n   * using a **trusted** Electron pointer move, then polls until the element no\n   * longer matches `:hover`.\n   *\n   * The inverse of {@link CommonArgs.hoverElement}. It targets the single\n   * shared window's **global** pointer, so only one element is hovered at a\n   * time. When an element spans the full viewport (no point outside its box is\n   * reachable), use {@link CommonArgs.moveMouse} directly to move the pointer\n   * to a known empty coordinate instead.\n   *\n   * @param params - The element to move the pointer away from.\n   * @returns A {@link Promise} that resolves once the element no longer matches\n   *   `:hover`.\n   */\n  unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArgs.hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link CommonArgs.moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link CommonArgs.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type, one trusted character event per code point.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link CommonArgs.unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point\n   * just outside its bounding box. This is a live renderer DOM node \u2014 the\n   * callback runs in-renderer, so no cross-process serialization is needed\n   * (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    args,\n    fn,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AAuNlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,OAAO,CAAC,GAAG,WAAW,IAAI,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACjH,QAAM,MAAM,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,KAAC,2BAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,YAAM,wDAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,iBAAa,qDAAsB,mBAAmB;AAE5D,QAAM,YAAY,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAE9D,MAAI,cAAc,MAAM,cAAc,WAAW;AAC/C,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,SAAS;AAAA,EACjC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,SAAS,EAAE;AAAA,EACnF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,QAAQ,yCAAyC,2BAA2B;AAC/E,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": ["process"]
}
