obsidian-integration-testing 5.2.0 → 5.4.0

package/README.md

@@ -109,6 +109,97 @@ 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`.
+
+### Wait for an async condition (`waitUntil`)
+
+Every callback also receives 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
+otherwise hand-roll in every closure.
+
+The `predicate` may be synchronous or asynchronous (it is `await`ed on each poll). It is
+checked immediately, then re-checked every `intervalInMilliseconds` until it returns truthy or
+`timeoutInMilliseconds` elapses, at which point the returned promise **rejects** (the error
+includes `message` when given).
+
+| Option                   | Purpose                                               | Default |
+|--------------------------|-------------------------------------------------------|---------|
+| `predicate`              | Condition to poll; sync or async, awaited each check. | —       |
+| `intervalInMilliseconds` | Delay between polls.                                  | `50`    |
+| `timeoutInMilliseconds`  | Max time to wait before rejecting.                    | `5000`  |
+| `message`                | Detail appended to the timeout error message.         | —       |
+
+```ts
+// Wait until the plugin has opened a Markdown view, then read its editor.
+const value = await evalInObsidian({
+  fn: async ({ app, obsidianModule, waitUntil }) => {
+    await waitUntil({
+      message: 'no active Markdown view',
+      predicate: () => Boolean(app.workspace.getActiveViewOfType(obsidianModule.MarkdownView))
+    });
+    return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView)?.editor.getValue() ?? null;
+  }
+});
+```
+
 ### Pass complex arguments
 
 Arguments are JSON-serialized. You can even pass functions — they are serialized via `toString()`:

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   * 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.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 * 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;AAcA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AAiRlB,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"]
}


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

@@ -16,6 +16,43 @@ export interface CommonArgs {
      * The Obsidian {@link App} instance.
      */
     app: App;
+    /**
+     * Moves the mouse pointer to the center of an element using **trusted**
+     * Electron pointer input, then polls until the element actually matches
+     * `:hover`.
+     *
+     * Because the move is trusted (see {@link CommonArgs.moveMouse}), the real
+     * `:hover` state takes effect in the CSS engine — real theme `var()` values
+     * and real compositing — instead of a hand-simulated cascade. It polls the
+     * live `element.matches(':hover')` state (not a fixed delay), so it is robust
+     * under shared-instance load. It targets the single shared window's
+     * **global** pointer, so only one element is hovered at a time.
+     *
+     * @param params - The element to hover.
+     * @returns A {@link Promise} that resolves once the element matches `:hover`.
+     */
+    hoverElement(this: void, params: HoverElementParams): Promise<void>;
+    /**
+     * Moves the mouse pointer to the given web-contents coordinates using a
+     * **trusted** Electron pointer move.
+     *
+     * A trusted move (injected via Electron's `webContents.sendInputEvent`)
+     * updates the real pointer state in the CSS engine, so `:hover` rules
+     * genuinely apply — unlike `dispatchEvent(new MouseEvent('mouseover'))`,
+     * which is untrusted and never sets `:hover`. It targets the single shared
+     * window's **global** pointer, so only one element is hovered at a time.
+     *
+     * This is the low-level primitive: it performs a single move and does **not**
+     * wait for any state to settle (callers poll their own readiness signal).
+     * Prefer {@link CommonArgs.hoverElement} / {@link CommonArgs.unhoverElement}
+     * for element-relative moves; use `moveMouse` directly when an
+     * element-relative target does not fit (e.g. an element spanning the full
+     * viewport width).
+     *
+     * @param params - The web-contents DIP coordinates to move to.
+     * @returns A {@link Promise} that resolves once the move has been injected.
+     */
+    moveMouse(this: void, params: MoveMouseParams): Promise<void>;
     /**
      * The `obsidian` module, resolved at runtime inside the Obsidian process.
      */
@@ -41,6 +78,45 @@ export interface CommonArgs {
      * @returns A {@link Promise} that resolves once the keystrokes have settled.
      */
     typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;
+    /**
+     * Moves the mouse pointer to a point just outside an element's bounding box
+     * using a **trusted** Electron pointer move, then polls until the element no
+     * longer matches `:hover`.
+     *
+     * The inverse of {@link CommonArgs.hoverElement}. It targets the single
+     * shared window's **global** pointer, so only one element is hovered at a
+     * time. When an element spans the full viewport (no point outside its box is
+     * reachable), use {@link CommonArgs.moveMouse} directly to move the pointer
+     * to a known empty coordinate instead.
+     *
+     * @param params - The element to move the pointer away from.
+     * @returns A {@link Promise} that resolves once the element no longer matches
+     *   `:hover`.
+     */
+    unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;
+    /**
+     * Polls a predicate until it becomes truthy, or rejects once a bounded
+     * timeout elapses.
+     *
+     * Integration-test `evalInObsidian` callbacks routinely need to wait for an
+     * asynchronous effect to settle (a view to open, a DOM node to appear, a
+     * setting to apply). Because the callback is serialized via `toString()` and
+     * cannot import modules, it can't reuse `obsidian-dev-utils`'
+     * `retryWithTimeout` / `runWithTimeout`. This helper is the shared,
+     * injected replacement for the per-closure poll loops consumers would
+     * otherwise hand-roll.
+     *
+     * The `predicate` may be synchronous or asynchronous — it is awaited on every
+     * poll. It is checked immediately, then re-checked every
+     * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`
+     * elapses, at which point the returned {@link Promise} rejects (the error
+     * includes `message` when provided).
+     *
+     * @param params - The predicate to poll plus optional timeout, interval, and
+     *   timeout message.
+     * @returns A {@link Promise} that resolves once the predicate is truthy.
+     */
+    waitUntil(this: void, params: WaitUntilParams): Promise<void>;
 }
 /**
  * Parameters for {@link evalInObsidian}.
@@ -84,6 +160,30 @@ export interface EvalInObsidianParams<Args extends GenericObject, Result, TConte
  * A plain object with string keys.
  */
 export type GenericObject = Record<string, unknown>;
+/**
+ * Parameters for {@link CommonArgs.hoverElement}.
+ */
+export interface HoverElementParams {
+    /**
+     * The element to hover. The pointer is moved to its center. This is a live
+     * renderer DOM node — the callback runs in-renderer, so no cross-process
+     * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * Parameters for {@link CommonArgs.moveMouse}.
+ */
+export interface MoveMouseParams {
+    /**
+     * The x coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly x: number;
+    /**
+     * The y coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly y: number;
+}
 /**
  * Parameters for {@link CommonArgs.typeIntoEditor}.
  */
@@ -98,6 +198,48 @@ export interface TypeIntoEditorParams {
      */
     readonly text: string;
 }
+/**
+ * Parameters for {@link CommonArgs.unhoverElement}.
+ */
+export interface UnhoverElementParams {
+    /**
+     * The element to move the pointer away from. The pointer is moved to a point
+     * just outside its bounding box. This is a live renderer DOM node — the
+     * callback runs in-renderer, so no cross-process serialization is needed
+     * (same as {@link TypeIntoEditorParams.editor}).
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * Parameters for {@link CommonArgs.waitUntil}.
+ */
+export interface WaitUntilParams {
+    /**
+     * The polling interval between predicate checks.
+     *
+     * @default `50`
+     */
+    readonly intervalInMilliseconds?: number;
+    /**
+     * An optional detail appended to the timeout error message, describing what
+     * was being waited for.
+     */
+    readonly message?: string;
+    /**
+     * The condition to wait for. Polled immediately, then on every interval until
+     * it returns a truthy value. May be synchronous or asynchronous — it is
+     * awaited on each poll.
+     *
+     * @returns Whether the awaited condition has been met.
+     */
+    predicate(this: void): boolean | Promise<boolean>;
+    /**
+     * The maximum time to wait before rejecting.
+     *
+     * @default `5000`
+     */
+    readonly timeoutInMilliseconds?: number;
+}
 /**
  * Evaluates a function inside the running Obsidian instance
  * via the active transport and returns the parsed result.

package/dist/lib/cjs/index.cjs

@@ -54,4 +54,4 @@ var import_vault_registry = require("./vault-registry.cjs");
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -8,7 +8,7 @@ export { connectToCdp } from './connect-to-cdp.cjs';
 export { ContextId } from './context-id.cjs';
 export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
 export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
-export type { EvalInObsidianParams, TypeIntoEditorParams } from './eval-in-obsidian.cjs';
+export type { EvalInObsidianParams, HoverElementParams, MoveMouseParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
 export type { PopulateFileContent, PopulateFilesParams } from './temp-vault.cjs';
 export { TempVault } from './temp-vault.cjs';

package/dist/lib/cjs/library.cjs

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

package/dist/lib/cjs/namespace-bootstrap.cjs

@@ -41,6 +41,10 @@ async function ensureNamespaceBootstrapped(transport, cwd, timeoutInMilliseconds
 }
 function bootstrapNamespace(bootstrapParams) {
   const DESTROY_DELAY_IN_MILLISECONDS = 50;
+  const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
+  const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
+  const WAIT_UNTIL_POLL_INTERVAL_IN_MILLISECONDS = 50;
+  const WAIT_UNTIL_TIMEOUT_IN_MILLISECONDS = 5e3;
   const holder = window;
   const existingContexts = holder.__obsidianIntegrationTesting?.contexts ?? {};
   const existingObsidianModule = holder.__obsidianIntegrationTesting?.obsidianModule;
@@ -68,7 +72,7 @@ function bootstrapNamespace(bootstrapParams) {
       }
       const obsidianModule = await this.getObsidianModule();
       const context = params.contextId ? this.contexts[params.contextId] ??= {} : {};
-      const fullArgs = { ...params.args, app: this.app, context, obsidianModule, typeIntoEditor };
+      const fullArgs = { ...params.args, app: this.app, context, hoverElement, moveMouse, obsidianModule, typeIntoEditor, unhoverElement, waitUntil };
       try {
         const result = await params.fn(fullArgs);
         if (result === void 0) {
@@ -141,8 +145,6 @@ ${this.serializeError(error.cause, depth + 1)}`;
   window.__obsidianIntegrationTesting = ns;
   async function typeIntoEditor(typeParams) {
     const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;
-    const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
-    const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
     const { editor, text } = typeParams;
     const valueBeforeTyping = editor.getValue();
     editor.focus();
@@ -158,9 +160,56 @@ ${this.serializeError(error.cause, depth + 1)}`;
       await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
     }
   }
+  async function hoverElement(hoverParams) {
+    const CENTER_DIVISOR = 2;
+    const { element } = hoverParams;
+    const rect = element.getBoundingClientRect();
+    moveMouseTo(Math.round(rect.left + rect.width / CENTER_DIVISOR), Math.round(rect.top + rect.height / CENTER_DIVISOR));
+    const startTime = Date.now();
+    while (!element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+  }
+  function moveMouse(moveParams) {
+    moveMouseTo(Math.round(moveParams.x), Math.round(moveParams.y));
+    return Promise.resolve();
+  }
+  function moveMouseTo(x, y) {
+    const webContents = window.electron.remote.getCurrentWebContents();
+    webContents.sendInputEvent({ type: "mouseMove", x, y });
+  }
+  async function unhoverElement(unhoverParams) {
+    const CENTER_DIVISOR = 2;
+    const OUTSIDE_OFFSET_IN_PIXELS = 1;
+    const { element } = unhoverParams;
+    const rect = element.getBoundingClientRect();
+    const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;
+    const y = rect.top + rect.height / CENTER_DIVISOR;
+    moveMouseTo(Math.round(x), Math.round(y));
+    const startTime = Date.now();
+    while (element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+  }
+  async function waitUntil(waitParams) {
+    const {
+      intervalInMilliseconds = WAIT_UNTIL_POLL_INTERVAL_IN_MILLISECONDS,
+      message,
+      predicate,
+      timeoutInMilliseconds = WAIT_UNTIL_TIMEOUT_IN_MILLISECONDS
+    } = waitParams;
+    const startTime = Date.now();
+    while (!await predicate()) {
+      if (Date.now() - startTime >= timeoutInMilliseconds) {
+        const suffix = message === void 0 ? "" : `: ${message}`;
+        throw new Error(`waitUntil timed out after ${String(timeoutInMilliseconds)} milliseconds${suffix}`);
+      }
+      await sleep(intervalInMilliseconds);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ensureNamespaceBootstrapped
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/namespace-bootstrap.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Bootstraps the `window.__obsidianIntegrationTesting` namespace in the\n * Obsidian process. Extracted to its own module to avoid dependency cycles\n * between `eval-in-obsidian.ts` and the transport modules.\n */\n\nimport type {\n  App,\n  Editor\n} from 'obsidian';\n\nimport type { GenerateFunctionCallParams } from './generate-function-call.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { generateFunctionCall } from './generate-function-call.cjs';\nimport { LIBRARY_VERSION } from './library.cjs';\n\ninterface BootstrapNamespaceParams {\n  readonly version: string;\n}\n\n/**\n * Ensures the `window.__obsidianIntegrationTesting` namespace is bootstrapped\n * in the Obsidian process with the current library version.\n *\n * Performs a lightweight version check via the transport. If the namespace\n * doesn't exist or has a different version, sends the full bootstrap expression\n * to register all helper functions.\n *\n * @param transport - The transport to use for evaluation.\n * @param cwd - The working directory (vault path).\n * @param timeoutInMilliseconds - Optional per-eval timeout. Forwarded to both\n *   the version check and the bootstrap eval so a hung `obsidian eval` rejects\n *   instead of blocking the caller indefinitely.\n */\nexport async function ensureNamespaceBootstrapped(transport: ObsidianTransport, cwd: string, timeoutInMilliseconds?: number): Promise<void> {\n  const evalOptions: TransportEvalOptions = {\n    cwd,\n    ...(timeoutInMilliseconds !== undefined && { timeoutInMilliseconds })\n  };\n  const versionJson = JSON.stringify(LIBRARY_VERSION);\n  const checkResult = await transport.evaluate(\n    `JSON.stringify(window.__obsidianIntegrationTesting?.version === ${versionJson})`,\n    evalOptions\n  );\n\n  if (checkResult === 'true') {\n    return;\n  }\n\n  const bootstrapExpr = generateFunctionCall(bootstrapNamespace, { version: LIBRARY_VERSION });\n  await transport.evaluate(bootstrapExpr, evalOptions);\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Bootstraps the `window.__obsidianIntegrationTesting` namespace with all\n * helper functions. Serialized via `toString()` and sent to Obsidian once\n * per library version.\n *\n * Preserves `contexts` across version upgrades so live {@link ContextId}\n * references survive.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n *\n * @param bootstrapParams - The parameters including the library version.\n */\nfunction bootstrapNamespace(bootstrapParams: GenerateFunctionCallParams<BootstrapNamespaceParams>): void {\n  interface IntegrationTestingHolder {\n    __obsidianIntegrationTesting: IntegrationTestingNamespaceState;\n  }\n\n  interface IntegrationTestingNamespaceState {\n    contexts: Record<string, Record<string, unknown>>;\n    obsidianModule?: unknown;\n    version: string;\n  }\n\n  interface IntegrationTestingNamespace extends IntegrationTestingNamespaceState {\n    readonly app: App;\n    destroyCurrentWindow(): Promise<void>;\n    ensureLayoutReady(): Promise<void>;\n    evalWrapper(nsParams: EvalWrapperParams): Promise<string>;\n    getObsidianModule(): Promise<unknown>;\n    ipcSendSync(nsParams: IpcSendSyncParams): Promise<void>;\n    pollVaultBasePath(): Promise<string>;\n    serializeError(error: unknown, depth?: number): string;\n    setLocalStorageItem(nsParams: SetLocalStorageItemParams): Promise<void>;\n  }\n\n  interface EvalWrapperParams {\n    readonly args: Record<string, unknown>;\n    readonly contextId?: string;\n    fn(fnArgs: Record<string, unknown>): unknown;\n  }\n\n  interface FileSystemAdapterLike {\n    getBasePath(): string;\n  }\n\n  interface IpcSendSyncParams {\n    readonly args: unknown[];\n    readonly channel: string;\n  }\n\n  interface SetLocalStorageItemParams {\n    readonly key: string;\n    readonly value: string;\n  }\n\n  interface TypeIntoEditorNsParams {\n    readonly editor: Editor;\n    readonly text: string;\n  }\n\n  interface ElectronWebContentsWithSendInputEvent {\n    sendInputEvent(inputEvent: SendInputEventKeyboardInput): void;\n  }\n\n  interface SendInputEventKeyboardInput {\n    keyCode: string;\n    type: 'char' | 'keyDown' | 'keyUp';\n  }\n\n  /**\n   * Delay (in ms) before invoking `electronWindow.destroy()` so the eval that\n   * triggered the call has time to return its result to the caller. Without\n   * it the renderer dies before the IPC reply ships, the caller waits for the\n   * full eval timeout, and stale `BrowserWindow` entries pile up.\n   */\n  const DESTROY_DELAY_IN_MILLISECONDS = 50;\n\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n  const holder = window as unknown as Partial<IntegrationTestingHolder>;\n  const existingContexts = holder.__obsidianIntegrationTesting?.contexts ?? {};\n  const existingObsidianModule = holder.__obsidianIntegrationTesting?.obsidianModule;\n\n  const ns: IntegrationTestingNamespace = {\n    get app() {\n      // eslint-disable-next-line @typescript-eslint/no-deprecated -- `app` getter reads `window.app` which is set by Obsidian.\n      return window.app;\n    },\n\n    contexts: existingContexts,\n\n    async destroyCurrentWindow(this: IntegrationTestingNamespace): Promise<void> {\n      await this.ensureLayoutReady();\n      await sleep(0);\n      const electronWindow = window.electronWindow;\n      window.setTimeout(() => {\n        electronWindow.destroy();\n      }, DESTROY_DELAY_IN_MILLISECONDS);\n    },\n\n    async ensureLayoutReady(this: IntegrationTestingNamespace): Promise<void> {\n      await new Promise<void>((resolve) => {\n        this.app.workspace.onLayoutReady(resolve);\n      });\n    },\n\n    async evalWrapper(this: IntegrationTestingNamespace, params): Promise<string> {\n      if (!this.app.plugins.isEnabled()) {\n        await this.app.plugins.setEnable(true);\n      }\n      const obsidianModule = await this.getObsidianModule();\n      const context = params.contextId\n        ? (this.contexts[params.contextId] ??= {})\n        : {};\n      const fullArgs = { ...params.args, app: this.app, context, obsidianModule, typeIntoEditor };\n      try {\n        const result = await params.fn(fullArgs);\n        if (result === undefined) {\n          return JSON.stringify({ type: 'undefined' });\n        }\n        return JSON.stringify({ value: result });\n      } catch (evalError) {\n        return JSON.stringify({ type: 'error', value: this.serializeError(evalError) });\n      }\n    },\n\n    async getObsidianModule(this: IntegrationTestingNamespace): Promise<unknown> {\n      if (this.obsidianModule) {\n        return this.obsidianModule;\n      }\n\n      const SLICE_START = 2;\n      const randomSuffix = String(Math.random()).slice(SLICE_START);\n      const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n      const dir = `${this.app.vault.configDir}/plugins/${tempModuleName}`;\n      this.app.plugins.manifests[tempModuleName] = {\n        author: '',\n        description: '',\n        dir,\n        id: tempModuleName,\n        isDesktopOnly: false,\n        minAppVersion: '',\n        name: tempModuleName,\n        version: ''\n      };\n      await this.app.vault.adapter.mkdir(dir);\n\n      const pluginFnBody = 'const r=require,e=exports;const m=r(\\'obsidian\\');window.__obsidianIntegrationTesting.obsidianModule=m;e.default=m.Plugin;';\n      await this.app.vault.adapter.write(`${dir}/main.js`, pluginFnBody);\n\n      await this.app.plugins.loadPlugin(tempModuleName);\n      await this.app.plugins.uninstallPlugin(tempModuleName);\n\n      if (this.obsidianModule) {\n        return this.obsidianModule;\n      }\n\n      throw new Error('Failed to load obsidian module');\n    },\n\n    async ipcSendSync(this: IntegrationTestingNamespace, params): Promise<void> {\n      await this.ensureLayoutReady();\n      window.electron.ipcRenderer.sendSync(params.channel, ...params.args);\n    },\n\n    obsidianModule: existingObsidianModule,\n\n    async pollVaultBasePath(this: IntegrationTestingNamespace): Promise<string> {\n      await this.ensureLayoutReady();\n\n      // eslint-disable-next-line no-restricted-syntax -- DataAdapter is actually FileSystemAdapter at runtime on desktop.\n      return JSON.stringify((this.app.vault.adapter as unknown as FileSystemAdapterLike).getBasePath());\n    },\n\n    serializeError(this: IntegrationTestingNamespace, error: unknown, depth = 0): string {\n      const CAUSE_INDENT_SIZE = 2;\n      const indent = ' '.repeat(depth * CAUSE_INDENT_SIZE);\n\n      if (!(error instanceof Error)) {\n        return `${indent}${String(error)}`;\n      }\n\n      const stackOrMessage = error.stack ?? `${error.name}: ${error.message}`;\n      let result = stackOrMessage.split('\\n').map((line) => `${indent}${line}`).join('\\n');\n\n      if (error.cause !== undefined) {\n        result += `\\n${indent}[cause]:`;\n        result += `\\n${this.serializeError(error.cause, depth + 1)}`;\n      }\n\n      return result;\n    },\n\n    async setLocalStorageItem(this: IntegrationTestingNamespace, params): Promise<void> {\n      await this.ensureLayoutReady();\n      localStorage.setItem(params.key, params.value);\n    },\n\n    version: bootstrapParams.version\n  };\n\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n  (window as unknown as Partial<IntegrationTestingHolder>).__obsidianIntegrationTesting = ns;\n\n  async function typeIntoEditor(typeParams: TypeIntoEditorNsParams): Promise<void> {\n    const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n    const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n    const INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n    const { editor, text } = typeParams;\n    const valueBeforeTyping = editor.getValue();\n\n    // Focus the editor and place the caret at the end of the document.\n    editor.focus();\n    const lastLine = editor.lastLine();\n    editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n    // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n    await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n    // eslint-disable-next-line no-restricted-syntax -- Approved double cast: obsidian-typings' `ElectronWebContents` omits the stable `sendInputEvent`, which is what injects a trusted (real) keypress.\n    const webContents = window.electron.remote.getCurrentWebContents() as unknown as ElectronWebContentsWithSendInputEvent;\n    for (const char of text) {\n      webContents.sendInputEvent({ keyCode: char, type: 'char' });\n    }\n\n    // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n    const startTime = Date.now();\n    while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/namespace-bootstrap.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Bootstraps the `window.__obsidianIntegrationTesting` namespace in the\n * Obsidian process. Extracted to its own module to avoid dependency cycles\n * between `eval-in-obsidian.ts` and the transport modules.\n */\n\nimport type { App } from 'obsidian';\n\nimport type {\n  HoverElementParams,\n  MoveMouseParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nimport type { GenerateFunctionCallParams } from './generate-function-call.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { generateFunctionCall } from './generate-function-call.cjs';\nimport { LIBRARY_VERSION } from './library.cjs';\n\ninterface BootstrapNamespaceParams {\n  readonly version: string;\n}\n\n/**\n * Ensures the `window.__obsidianIntegrationTesting` namespace is bootstrapped\n * in the Obsidian process with the current library version.\n *\n * Performs a lightweight version check via the transport. If the namespace\n * doesn't exist or has a different version, sends the full bootstrap expression\n * to register all helper functions.\n *\n * @param transport - The transport to use for evaluation.\n * @param cwd - The working directory (vault path).\n * @param timeoutInMilliseconds - Optional per-eval timeout. Forwarded to both\n *   the version check and the bootstrap eval so a hung `obsidian eval` rejects\n *   instead of blocking the caller indefinitely.\n */\nexport async function ensureNamespaceBootstrapped(transport: ObsidianTransport, cwd: string, timeoutInMilliseconds?: number): Promise<void> {\n  const evalOptions: TransportEvalOptions = {\n    cwd,\n    ...(timeoutInMilliseconds !== undefined && { timeoutInMilliseconds })\n  };\n  const versionJson = JSON.stringify(LIBRARY_VERSION);\n  const checkResult = await transport.evaluate(\n    `JSON.stringify(window.__obsidianIntegrationTesting?.version === ${versionJson})`,\n    evalOptions\n  );\n\n  if (checkResult === 'true') {\n    return;\n  }\n\n  const bootstrapExpr = generateFunctionCall(bootstrapNamespace, { version: LIBRARY_VERSION });\n  await transport.evaluate(bootstrapExpr, evalOptions);\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Bootstraps the `window.__obsidianIntegrationTesting` namespace with all\n * helper functions. Serialized via `toString()` and sent to Obsidian once\n * per library version.\n *\n * Preserves `contexts` across version upgrades so live {@link ContextId}\n * references survive.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n *\n * @param bootstrapParams - The parameters including the library version.\n */\nfunction bootstrapNamespace(bootstrapParams: GenerateFunctionCallParams<BootstrapNamespaceParams>): void {\n  interface IntegrationTestingHolder {\n    __obsidianIntegrationTesting: IntegrationTestingNamespaceState;\n  }\n\n  interface IntegrationTestingNamespaceState {\n    contexts: Record<string, Record<string, unknown>>;\n    obsidianModule?: unknown;\n    version: string;\n  }\n\n  interface IntegrationTestingNamespace extends IntegrationTestingNamespaceState {\n    readonly app: App;\n    destroyCurrentWindow(): Promise<void>;\n    ensureLayoutReady(): Promise<void>;\n    evalWrapper(nsParams: EvalWrapperParams): Promise<string>;\n    getObsidianModule(): Promise<unknown>;\n    ipcSendSync(nsParams: IpcSendSyncParams): Promise<void>;\n    pollVaultBasePath(): Promise<string>;\n    serializeError(error: unknown, depth?: number): string;\n    setLocalStorageItem(nsParams: SetLocalStorageItemParams): Promise<void>;\n  }\n\n  interface EvalWrapperParams {\n    readonly args: Record<string, unknown>;\n    readonly contextId?: string;\n    fn(fnArgs: Record<string, unknown>): unknown;\n  }\n\n  interface FileSystemAdapterLike {\n    getBasePath(): string;\n  }\n\n  interface IpcSendSyncParams {\n    readonly args: unknown[];\n    readonly channel: string;\n  }\n\n  interface SetLocalStorageItemParams {\n    readonly key: string;\n    readonly value: string;\n  }\n\n  interface ElectronWebContentsWithSendInputEvent {\n    sendInputEvent(inputEvent: SendInputEventKeyboardInput | SendInputEventMouseInput): void;\n  }\n\n  interface SendInputEventKeyboardInput {\n    keyCode: string;\n    type: 'char' | 'keyDown' | 'keyUp';\n  }\n\n  interface SendInputEventMouseInput {\n    type: 'mouseMove';\n    x: number;\n    y: number;\n  }\n\n  /**\n   * Delay (in ms) before invoking `electronWindow.destroy()` so the eval that\n   * triggered the call has time to return its result to the caller. Without\n   * it the renderer dies before the IPC reply ships, the caller waits for the\n   * full eval timeout, and stale `BrowserWindow` entries pile up.\n   */\n  const DESTROY_DELAY_IN_MILLISECONDS = 50;\n\n  /**\n   * Interval (in ms) between polls while waiting for a trusted input event to\n   * take effect (the editor document updates, or an element's `:hover` state\n   * flips). Shared by every trusted-input helper.\n   */\n  const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n  /**\n   * Maximum time (in ms) to wait for a trusted input event to take effect\n   * before giving up (the expected outcome when the input is rejected \u2014 e.g. a\n   * read-only editor, or a pointer move that never lands on the element).\n   */\n  const INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n  /**\n   * Default interval (in ms) between {@link waitUntil} predicate checks when the\n   * caller does not override it.\n   */\n  const WAIT_UNTIL_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n  /**\n   * Default maximum time (in ms) {@link waitUntil} waits for its predicate to\n   * become truthy before rejecting, when the caller does not override it.\n   */\n  const WAIT_UNTIL_TIMEOUT_IN_MILLISECONDS = 5000;\n\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n  const holder = window as unknown as Partial<IntegrationTestingHolder>;\n  const existingContexts = holder.__obsidianIntegrationTesting?.contexts ?? {};\n  const existingObsidianModule = holder.__obsidianIntegrationTesting?.obsidianModule;\n\n  const ns: IntegrationTestingNamespace = {\n    get app() {\n      // eslint-disable-next-line @typescript-eslint/no-deprecated -- `app` getter reads `window.app` which is set by Obsidian.\n      return window.app;\n    },\n\n    contexts: existingContexts,\n\n    async destroyCurrentWindow(this: IntegrationTestingNamespace): Promise<void> {\n      await this.ensureLayoutReady();\n      await sleep(0);\n      const electronWindow = window.electronWindow;\n      window.setTimeout(() => {\n        electronWindow.destroy();\n      }, DESTROY_DELAY_IN_MILLISECONDS);\n    },\n\n    async ensureLayoutReady(this: IntegrationTestingNamespace): Promise<void> {\n      await new Promise<void>((resolve) => {\n        this.app.workspace.onLayoutReady(resolve);\n      });\n    },\n\n    async evalWrapper(this: IntegrationTestingNamespace, params): Promise<string> {\n      if (!this.app.plugins.isEnabled()) {\n        await this.app.plugins.setEnable(true);\n      }\n      const obsidianModule = await this.getObsidianModule();\n      const context = params.contextId\n        ? (this.contexts[params.contextId] ??= {})\n        : {};\n      const fullArgs = { ...params.args, app: this.app, context, hoverElement, moveMouse, obsidianModule, typeIntoEditor, unhoverElement, waitUntil };\n      try {\n        const result = await params.fn(fullArgs);\n        if (result === undefined) {\n          return JSON.stringify({ type: 'undefined' });\n        }\n        return JSON.stringify({ value: result });\n      } catch (evalError) {\n        return JSON.stringify({ type: 'error', value: this.serializeError(evalError) });\n      }\n    },\n\n    async getObsidianModule(this: IntegrationTestingNamespace): Promise<unknown> {\n      if (this.obsidianModule) {\n        return this.obsidianModule;\n      }\n\n      const SLICE_START = 2;\n      const randomSuffix = String(Math.random()).slice(SLICE_START);\n      const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n      const dir = `${this.app.vault.configDir}/plugins/${tempModuleName}`;\n      this.app.plugins.manifests[tempModuleName] = {\n        author: '',\n        description: '',\n        dir,\n        id: tempModuleName,\n        isDesktopOnly: false,\n        minAppVersion: '',\n        name: tempModuleName,\n        version: ''\n      };\n      await this.app.vault.adapter.mkdir(dir);\n\n      const pluginFnBody = 'const r=require,e=exports;const m=r(\\'obsidian\\');window.__obsidianIntegrationTesting.obsidianModule=m;e.default=m.Plugin;';\n      await this.app.vault.adapter.write(`${dir}/main.js`, pluginFnBody);\n\n      await this.app.plugins.loadPlugin(tempModuleName);\n      await this.app.plugins.uninstallPlugin(tempModuleName);\n\n      if (this.obsidianModule) {\n        return this.obsidianModule;\n      }\n\n      throw new Error('Failed to load obsidian module');\n    },\n\n    async ipcSendSync(this: IntegrationTestingNamespace, params): Promise<void> {\n      await this.ensureLayoutReady();\n      window.electron.ipcRenderer.sendSync(params.channel, ...params.args);\n    },\n\n    obsidianModule: existingObsidianModule,\n\n    async pollVaultBasePath(this: IntegrationTestingNamespace): Promise<string> {\n      await this.ensureLayoutReady();\n\n      // eslint-disable-next-line no-restricted-syntax -- DataAdapter is actually FileSystemAdapter at runtime on desktop.\n      return JSON.stringify((this.app.vault.adapter as unknown as FileSystemAdapterLike).getBasePath());\n    },\n\n    serializeError(this: IntegrationTestingNamespace, error: unknown, depth = 0): string {\n      const CAUSE_INDENT_SIZE = 2;\n      const indent = ' '.repeat(depth * CAUSE_INDENT_SIZE);\n\n      if (!(error instanceof Error)) {\n        return `${indent}${String(error)}`;\n      }\n\n      const stackOrMessage = error.stack ?? `${error.name}: ${error.message}`;\n      let result = stackOrMessage.split('\\n').map((line) => `${indent}${line}`).join('\\n');\n\n      if (error.cause !== undefined) {\n        result += `\\n${indent}[cause]:`;\n        result += `\\n${this.serializeError(error.cause, depth + 1)}`;\n      }\n\n      return result;\n    },\n\n    async setLocalStorageItem(this: IntegrationTestingNamespace, params): Promise<void> {\n      await this.ensureLayoutReady();\n      localStorage.setItem(params.key, params.value);\n    },\n\n    version: bootstrapParams.version\n  };\n\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `__obsidianIntegrationTesting` is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n  (window as unknown as Partial<IntegrationTestingHolder>).__obsidianIntegrationTesting = ns;\n\n  async function typeIntoEditor(typeParams: TypeIntoEditorParams): Promise<void> {\n    const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n\n    const { editor, text } = typeParams;\n    const valueBeforeTyping = editor.getValue();\n\n    // Focus the editor and place the caret at the end of the document.\n    editor.focus();\n    const lastLine = editor.lastLine();\n    editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n    // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n    await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n    // eslint-disable-next-line no-restricted-syntax -- Approved double cast: obsidian-typings' `ElectronWebContents` omits the stable `sendInputEvent`, which is what injects a trusted (real) keypress.\n    const webContents = window.electron.remote.getCurrentWebContents() as unknown as ElectronWebContentsWithSendInputEvent;\n    for (const char of text) {\n      webContents.sendInputEvent({ keyCode: char, type: 'char' });\n    }\n\n    // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n    const startTime = Date.now();\n    while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n  }\n\n  async function hoverElement(hoverParams: HoverElementParams): Promise<void> {\n    const CENTER_DIVISOR = 2;\n\n    const { element } = hoverParams;\n\n    // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n    const rect = element.getBoundingClientRect();\n    moveMouseTo(Math.round(rect.left + rect.width / CENTER_DIVISOR), Math.round(rect.top + rect.height / CENTER_DIVISOR));\n\n    // Poll until the real `:hover` state has actually taken, instead of a fixed settle.\n    const startTime = Date.now();\n    while (!element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n  }\n\n  function moveMouse(moveParams: MoveMouseParams): Promise<void> {\n    moveMouseTo(Math.round(moveParams.x), Math.round(moveParams.y));\n    return Promise.resolve();\n  }\n\n  function moveMouseTo(x: number, y: number): void {\n    // eslint-disable-next-line no-restricted-syntax -- Approved double cast: obsidian-typings' `ElectronWebContents` omits the stable `sendInputEvent`, which is what injects a trusted (real) pointer move.\n    const webContents = window.electron.remote.getCurrentWebContents() as unknown as ElectronWebContentsWithSendInputEvent;\n    webContents.sendInputEvent({ type: 'mouseMove', x, y });\n  }\n\n  async function unhoverElement(unhoverParams: UnhoverElementParams): Promise<void> {\n    const CENTER_DIVISOR = 2;\n    const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n    const { element } = unhoverParams;\n\n    // Move to a point just outside the element's box.\n    // When flush against the viewport's left edge, use just past the right edge.\n    // A full-viewport-width element should use `moveMouse` directly instead.\n    const rect = element.getBoundingClientRect();\n    const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;\n    const y = rect.top + rect.height / CENTER_DIVISOR;\n    moveMouseTo(Math.round(x), Math.round(y));\n\n    // Poll until the real `:hover` state has actually cleared, instead of a fixed settle.\n    const startTime = Date.now();\n    while (element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n      await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n  }\n\n  async function waitUntil(waitParams: WaitUntilParams): Promise<void> {\n    const {\n      intervalInMilliseconds = WAIT_UNTIL_POLL_INTERVAL_IN_MILLISECONDS,\n      message,\n      predicate,\n      timeoutInMilliseconds = WAIT_UNTIL_TIMEOUT_IN_MILLISECONDS\n    } = waitParams;\n\n    const startTime = Date.now();\n    while (!(await predicate())) {\n      if (Date.now() - startTime >= timeoutInMilliseconds) {\n        const suffix = message === undefined ? '' : `: ${message}`;\n        throw new Error(`waitUntil timed out after ${String(timeoutInMilliseconds)} milliseconds${suffix}`);\n      }\n      await sleep(intervalInMilliseconds);\n    }\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
