obsidian-integration-testing 6.0.0 → 7.0.0

package/README.md

@@ -111,7 +111,7 @@ const title = await evalInObsidian({
 
 ### Simulate real user input (trusted keyboard & pointer)
 
-Every callback also receives helpers that inject **trusted** input at the Chromium level
+The callback's `lib` bag provides 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
@@ -135,7 +135,7 @@ renderer, so no cross-process serialization is needed.
 ```ts
 // Type into the active editor — only succeeds if the editor truly holds focus.
 const typed = await evalInObsidian({
-  fn: async ({ app, obsidianModule, typeIntoEditor }) => {
+  fn: async ({ app, lib: { typeIntoEditor }, obsidianModule }) => {
     const view = app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
     const editor = view?.editor;
     if (!editor) {
@@ -150,7 +150,7 @@ const typed = await evalInObsidian({
 // Press special keys / shortcuts (Obsidian `Modifier` names; `'Mod'` = Cmd on macOS, Ctrl elsewhere).
 // A key press has no universal effect, so pair it with `waitUntil` to await the outcome.
 await evalInObsidian({
-  fn: async ({ app, obsidianModule, pressKey, waitUntil }) => {
+  fn: async ({ app, lib: { pressKey, waitUntil }, obsidianModule }) => {
     const editor = app.workspace.getActiveViewOfType(obsidianModule.MarkdownView)?.editor;
     editor?.focus();
 
@@ -161,7 +161,7 @@ await evalInObsidian({
 
 // Observe a genuine :hover state (real theme var() values, real compositing).
 await evalInObsidian({
-  fn: async ({ hoverElement, unhoverElement }) => {
+  fn: async ({ lib: { hoverElement, unhoverElement } }) => {
     const bar = document.querySelector<HTMLElement>('.minimized-modal-bar');
     if (!bar) {
       return;
@@ -182,7 +182,7 @@ await evalInObsidian({
 
 ### Wait for an async condition (`waitUntil`)
 
-Every callback also receives a `waitUntil({ predicate })` helper for polling until an
+The `lib` bag also provides a `waitUntil({ predicate })` helper for polling until an
 asynchronous effect settles (a view opens, a DOM node appears, a setting applies). Because
 the callback is serialized via `toString()` and **cannot import modules**, it can't reuse a
 library poll helper — `waitUntil` is the shared, injected replacement for the loops you would
@@ -203,7 +203,7 @@ includes `message` when given).
 ```ts
 // Wait until the plugin has opened a Markdown view, then read its editor.
 const value = await evalInObsidian({
-  fn: async ({ app, obsidianModule, waitUntil }) => {
+  fn: async ({ app, lib: { waitUntil }, obsidianModule }) => {
     await waitUntil({
       message: 'no active Markdown view',
       predicate: () => Boolean(app.workspace.getActiveViewOfType(obsidianModule.MarkdownView))
@@ -213,6 +213,41 @@ const value = await evalInObsidian({
 });
 ```
 
+### Inject a shared library (`lib`)
+
+Because a callback is serialized via `toString()` and **cannot import modules**, it can't reuse
+your utility library directly. Every callback receives a `lib` argument — a single bag that
+**provider packages populate** with their whole (renderer-safe) library, so closures can call
+shared helpers instead of hand-rolling them. `lib` is `{}` until a provider registers a resolver.
+
+A provider registers a **renderer-side resolver** with `registerLibResolver` from its per-worker
+test setup (a `setupFiles` entry, the same place the context resolvers are registered). The
+resolver runs inside Obsidian and returns an object; every registered resolver's result is merged
+(`Object.assign`) into the one `lib` bag, so multiple providers compose. The resolver is
+serialized, so it must be self-contained — read a value a fixture plugin published on `window`:
+
+```ts
+// provider's setup file (registered via setupFiles)
+import { registerLibResolver } from 'obsidian-integration-testing';
+
+registerLibResolver(() => window.__myLibraryModule__);
+```
+
+Make `lib` type-safe by augmenting the `Lib` interface (multiple augmentations merge, mirroring
+the runtime merge):
+
+```ts
+declare module 'obsidian-integration-testing' {
+  interface Lib {
+    getThing(id: string): Thing;
+  }
+}
+
+const name = await evalInObsidian({
+  fn: ({ lib: { getThing } }) => getThing('a').name
+});
+```
+
 ### Pass complex arguments
 
 Arguments are JSON-serialized. You can even pass functions — they are serialized via `toString()`:
@@ -685,6 +720,8 @@ Besides the required `appiumUrl` and `avdName`, the transport accepts these opti
 | Option                                        | Purpose                                                                                                         | Default                |
 | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------- |
 | `appId`                                       | App package (Android) or bundle ID (iOS).                                                                       | `'md.obsidian'`        |
+| `appiumStartTimeoutInMilliseconds`            | Max wait for the auto-started Appium server to become ready; only when the harness auto-starts it.              | `180000`               |
+| `deviceIdleTimeoutInMilliseconds`             | Max wait after boot for a started emulator to go idle before the session; avoids inflated cold setup. 0 skips.  | `60000`                |
 | `isAppiumConsoleVisible`                      | Show the auto-started Appium server console window. Hidden (`windowsHide`) by default so it never steals focus. | `false`                |
 | `isEmulatorVisible`                           | Show the auto-started emulator window. Hidden (`-no-window`, headless) by default so it never steals focus.     | `false`                |
 | `layoutReadyTimeoutInMilliseconds`            | Max wait for `app.workspace.layoutReady` after the vault (re)opens; raise on slow emulators.                    | `90000`                |

package/dist/lib/cjs/appium-session-config.cjs

@@ -18,17 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var appium_session_config_exports = {};
 __export(appium_session_config_exports, {
+  DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
+  resolveAppiumStartTimeoutInMilliseconds: () => resolveAppiumStartTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds: () => resolveSessionConnectionRetryTimeoutInMilliseconds
 });
 module.exports = __toCommonJS(appium_session_config_exports);
+const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
 const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 18e4;
+function resolveAppiumStartTimeoutInMilliseconds(options) {
+  return options.appiumStartTimeoutInMilliseconds ?? DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS;
+}
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
+  resolveAppiumStartTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/appium-session-config.d.cts

@@ -1,16 +1,34 @@
 /**
  * @file
  *
- * Resolves tunable Appium session-establishment timeouts from the transport
- * options, applying defaults. Kept separate from the integration-only
- * `transport-factory` so the default resolution stays unit-testable (the
- * factory itself needs a real Appium server and is excluded from unit tests).
+ * Resolves tunable Appium server-start and session-establishment timeouts from
+ * the transport options, applying defaults. Kept separate from the
+ * integration-only `transport-factory` so the default resolution stays
+ * unit-testable (the factory itself needs a real Appium server and is excluded
+ * from unit tests).
  */
 import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.cjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.appiumStartTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 180000;
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.sessionConnectionRetryTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 180000;
+/**
+ * Resolves the auto-started Appium server readiness timeout, applying the
+ * default when the option is omitted.
+ *
+ * This governs how long the factory polls the auto-started Appium server's
+ * `/status` endpoint before giving up. Only relevant when the harness
+ * auto-starts the server; when attaching to an already-running server the wait
+ * is skipped entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveAppiumStartTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
 /**
  * Resolves the Appium session connection retry timeout, applying the default
  * when the option is omitted.

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

@@ -85,4 +85,4 @@ function resolveEndpoint(transport, options) {
 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   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\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    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\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;AAoJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,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": []
}

+//# 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 * the base `lib` helpers, `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, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * 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   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\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    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\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;AAqJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,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

@@ -6,7 +6,7 @@
  *
  * 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
+ * the base `lib` helpers, `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}.
  */
@@ -38,9 +38,10 @@ export interface CdpConnection extends AsyncDisposable {
     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.
+     * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`
+     * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). 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`.

package/dist/lib/cjs/device-readiness.cjs

@@ -0,0 +1,43 @@
+"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 device_readiness_exports = {};
+__export(device_readiness_exports, {
+  DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  checkDeviceIdle: () => checkDeviceIdle,
+  resolveDeviceIdleTimeoutInMilliseconds: () => resolveDeviceIdleTimeoutInMilliseconds
+});
+module.exports = __toCommonJS(device_readiness_exports);
+const BOOT_ANIMATION_STOPPED_STATE = "stopped";
+const PACKAGE_LINE_PREFIX = "package:";
+const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 6e4;
+function checkDeviceIdle(params) {
+  const isBootAnimationStopped = params.bootAnimationProp.trim() === BOOT_ANIMATION_STOPPED_STATE;
+  const isPackageManagerReady = params.packageListOutput.split("\n").some((line) => line.trim().startsWith(PACKAGE_LINE_PREFIX));
+  return isBootAnimationStopped && isPackageManagerReady;
+}
+function resolveDeviceIdleTimeoutInMilliseconds(options) {
+  return options.deviceIdleTimeoutInMilliseconds ?? DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS,
+  checkDeviceIdle,
+  resolveDeviceIdleTimeoutInMilliseconds
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/device-readiness.d.cts

@@ -0,0 +1,55 @@
+/**
+ * @file
+ *
+ * Pure helpers for deciding when a freshly-booted Android emulator is idle
+ * enough to establish an Appium session, plus resolving the idle-wait timeout
+ * from the transport options. Kept separate from the integration-only
+ * `transport-factory` so the parsing and default resolution stay unit-testable
+ * (the factory itself needs a real emulator and is excluded from unit tests).
+ *
+ * `sys.boot_completed` fires *before* the guest is actually idle: package
+ * optimization (`dex2oat`) and system services keep churning after it, so a
+ * session established the instant it fires makes every one of UiAutomator2's
+ * serialized `adb` round-trips contend with that work and inflate ~3x. Gating
+ * the session on a later, quieter signal (the boot animation has stopped and
+ * the package manager is serving) lets it run against an idle guest instead.
+ */
+import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.cjs';
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.deviceIdleTimeoutInMilliseconds}.
+ */
+export declare const DEFAULT_DEVICE_IDLE_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * Parameters for {@link checkDeviceIdle}.
+ */
+export interface CheckDeviceIdleParams {
+    /** Raw stdout of `adb shell getprop init.svc.bootanim`. */
+    readonly bootAnimationProp: string;
+    /** Raw stdout of `adb shell cmd package list packages`. */
+    readonly packageListOutput: string;
+}
+/**
+ * Decides whether a booted emulator is idle enough to start an Appium session,
+ * from the raw output of the two probe commands.
+ *
+ * The guest is considered idle once the boot animation has stopped **and** the
+ * package manager is serving (it lists at least one package). Both are binary,
+ * later-than-`sys.boot_completed` signals, so this returns `true` well after the
+ * premature boot-completed flag but without any latency thresholds.
+ *
+ * @param params - The sampled probe outputs.
+ * @returns `true` when the guest is idle enough to proceed.
+ */
+export declare function checkDeviceIdle(params: CheckDeviceIdleParams): boolean;
+/**
+ * Resolves the post-boot device-idle wait timeout, applying the default when
+ * the option is omitted.
+ *
+ * This bounds how long the factory waits for a freshly-started emulator to
+ * become idle (see {@link checkDeviceIdle}) before establishing the session. A
+ * value of `0` skips the wait entirely.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveDeviceIdleTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;

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  Modifier\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   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link CommonArgs.typeIntoEditor}: it\n   * injects a trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link CommonArgs.typeIntoEditor} (which\n   * types printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link CommonArgs.waitUntil}. It targets the single\n   * shared window's **global** focus, so only the DOM-focused element receives\n   * the key.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   * @returns A {@link Promise} that resolves once the key press has been\n   *   injected.\n   */\n  pressKey(this: void, params: PressKeyParams): Promise<void>;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link CommonArgs.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp`\n   * a real user produces. Each keystroke is delivered to the window's\n   * DOM-focused element and flows through CodeMirror's real input pipeline, so\n   * the typed text reaches the document **only if the editor genuinely holds\n   * 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   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared,\n   * injected replacement for the per-closure poll loops consumers would\n   * otherwise hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): 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.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\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. Each code point is pressed via {@link CommonArgs.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\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 * Parameters for {@link CommonArgs.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\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;AAeA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AA2UlB,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  Modifier\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 shared library bag injected into every callback \u2014 see {@link Lib}.\n   *\n   * Never empty: the harness pre-populates a **base** set of renderer-driving\n   * helpers (trusted input \u2014 `typeIntoEditor` / `pressKey` / `moveMouse` /\n   * `hoverElement` / `unhoverElement` \u2014 and `waitUntil`), and provider packages\n   * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe\n   * library on top via {@link registerLibResolver}. A serialized closure reaches\n   * every shared helper through `lib` \u2014 `lib.typeIntoEditor({ editor, text })`,\n   * `lib.getFileOrNull({ app, \u2026 })` \u2014 instead of importing or hand-rolling them.\n   */\n  lib: Lib;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\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 * The shared library bag injected into every {@link evalInObsidian} callback as\n * {@link CommonArgs.lib}.\n *\n * Two layers compose into this one bag. The **base** \u2014 the harness-provided\n * renderer-driving helpers declared below (the trusted-input primitives and\n * {@link Lib.waitUntil}) \u2014 is always present. On top, provider packages register\n * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`\n * their whole renderer-safe library at runtime, and augment this **augmentable**\n * interface (the `i18next` `CustomTypeOptions` idiom) via\n * `declare module 'obsidian-integration-testing'` to type it. Multiple providers\n * compose: their exports merge at runtime and their augmentations merge in the\n * type system (`interface Lib extends \u2026`).\n *\n * @example\n * ```ts\n * declare module 'obsidian-integration-testing' {\n *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}\n * }\n * ```\n */\nexport interface Lib {\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 Lib.moveMouse}), the real `:hover`\n   * state takes effect in the CSS engine \u2014 real theme `var()` values and real\n   * compositing \u2014 instead of a hand-simulated cascade. It polls the live\n   * `element.matches(':hover')` state (not a fixed delay), so it is robust under\n   * shared-instance load. It targets the single shared window's **global**\n   * 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 Lib.hoverElement} / {@link Lib.unhoverElement} for\n   * element-relative moves; use `moveMouse` directly when an element-relative\n   * target does not fit (e.g. an element spanning the full 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   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a\n   * trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types\n   * printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link Lib.waitUntil}. It targets the single shared\n   * window's **global** focus, so only the DOM-focused element receives the key.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   * @returns A {@link Promise} that resolves once the key press has been\n   *   injected.\n   */\n  pressKey(this: void, params: PressKeyParams): Promise<void>;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link Lib.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp` a real\n   * user produces. Each keystroke 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 Lib.hoverElement}. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time. When\n   * an element spans the full viewport (no point outside its box is reachable),\n   * use {@link Lib.moveMouse} directly to move the pointer to a known empty\n   * 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   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected\n   * replacement for the per-closure poll loops consumers would otherwise\n   * hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): Promise<void>;\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.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\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. Each code point is pressed via {@link CommonArgs.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\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 * Parameters for {@link CommonArgs.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\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;AAeA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AA4WlB,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"]
}
