obsidian-integration-testing 9.2.2 → 10.1.0

package/dist/lib/esm/enable-plugin.mjs

@@ -2,7 +2,7 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
   if (!app.plugins.isEnabled()) {
     await app.plugins.setEnable(true);
   }
-  if (app.plugins.enabledPlugins.has(pluginId) && !(pluginId in app.plugins.plugins)) {
+  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {
     await app.plugins.disablePluginAndSave(pluginId);
   }
   let errorMessage;
@@ -13,61 +13,61 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
       errorMessage = void 0;
       return result;
     } catch (error) {
-      const holder = window;
+      const holder = globalThis;
       errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);
       throw error;
     }
   };
   const capturedConsole = [];
-  const formatHolder = window;
-  function formatArg(arg) {
-    if (arg instanceof Error) {
-      return formatHolder.__obsidianIntegrationTesting?.errorToString(arg) ?? String(arg);
+  const formatHolder = globalThis;
+  function formatArgument(argument) {
+    if (argument instanceof Error) {
+      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);
     }
-    if (typeof arg === "string") {
-      return arg;
+    if (typeof argument === "string") {
+      return argument;
     }
-    if (arg === void 0 || arg === null) {
-      return String(arg);
+    if (argument === void 0 || argument === null) {
+      return String(argument);
     }
-    const json = JSON.stringify(arg);
-    return json ?? Object.prototype.toString.call(arg);
+    const json = JSON.stringify(argument);
+    return json ?? Object.prototype.toString.call(argument);
   }
-  function recordConsole(...args) {
-    capturedConsole.push(args.map(formatArg).join(" "));
+  function recordConsole(...input) {
+    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(" "));
   }
   const origConsoleError = console.error;
   const origConsoleWarn = console.warn;
-  console.error = (...args) => {
-    recordConsole(...args);
-    origConsoleError.apply(console, args);
+  console.error = (...input) => {
+    recordConsole(...input);
+    origConsoleError.apply(console, input);
   };
-  console.warn = (...args) => {
-    recordConsole(...args);
-    origConsoleWarn.apply(console, args);
+  console.warn = (...input) => {
+    recordConsole(...input);
+    origConsoleWarn.apply(console, input);
   };
   function onWindowError(event) {
-    capturedConsole.push(event.error instanceof Error ? formatArg(event.error) : event.message);
+    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);
   }
   function onUnhandledRejection(event) {
-    capturedConsole.push(formatArg(event.reason));
+    capturedConsole.push(formatArgument(event.reason));
   }
-  window.addEventListener("error", onWindowError);
-  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  globalThis.addEventListener("error", onWindowError);
+  globalThis.addEventListener("unhandledrejection", onUnhandledRejection);
   try {
     await app.plugins.enablePluginAndSave(pluginId);
   } finally {
     app.plugins.loadPlugin = origLoadPlugin;
     console.error = origConsoleError;
     console.warn = origConsoleWarn;
-    window.removeEventListener("error", onWindowError);
-    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+    globalThis.removeEventListener("error", onWindowError);
+    globalThis.removeEventListener("unhandledrejection", onUnhandledRejection);
   }
-  const isLoaded = pluginId in app.plugins.plugins;
+  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);
   let rendererConsoleErrors;
   if (!errorMessage && !isLoaded) {
     const joined = capturedConsole.join("\n").trim();
-    rendererConsoleErrors = joined ? joined : void 0;
+    rendererConsoleErrors = joined || void 0;
   }
   return {
     errorMessage,
@@ -83,4 +83,4 @@ export {
   enablePluginWithErrorCapture,
   getGenericPluginLoadFailureMessage
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArgs } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString(error: unknown): string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is always restored in a `finally` block.\n *\n * Designed to be passed as the `fn` argument to {@link evalInObsidian}.\n *\n * @param args - The common args plus the plugin ID.\n * @param args.app - The Obsidian app instance.\n * @param args.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !(pluginId in app.plugins.plugins)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\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      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = window as unknown as Partial<IntegrationTestingHolder>;\n  function formatArg(arg: unknown): string {\n    if (arg instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(arg) ?? String(arg);\n    }\n    if (typeof arg === 'string') {\n      return arg;\n    }\n    if (arg === undefined || arg === null) {\n      return String(arg);\n    }\n    const json = JSON.stringify(arg);\n    return json ?? Object.prototype.toString.call(arg);\n  }\n  function recordConsole(...args: unknown[]): void {\n    capturedConsole.push(args.map(formatArg).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  console.error = (...args: unknown[]): void => {\n    recordConsole(...args);\n    origConsoleError.apply(console, args);\n  };\n  console.warn = (...args: unknown[]): void => {\n    recordConsole(...args);\n    origConsoleWarn.apply(console, args);\n  };\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArg(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArg(event.reason));\n  }\n  window.addEventListener('error', onWindowError);\n  window.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Intentional restore of monkey-patch.\n    app.plugins.loadPlugin = origLoadPlugin;\n    console.error = origConsoleError;\n    console.warn = origConsoleWarn;\n    window.removeEventListener('error', onWindowError);\n    window.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = pluginId in app.plugins.plugins;\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined ? joined : undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA+EA,eAAsB,6BAA6B,EAAE,KAAK,SAAS,GAAiE;AAClI,MAAI,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5B,UAAM,IAAI,QAAQ,UAAU,IAAI;AAAA,EAClC;AASA,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,KAAK,EAAE,YAAY,IAAI,QAAQ,UAAU;AAClF,UAAM,IAAI,QAAQ,qBAAqB,QAAQ;AAAA,EACjD;AAEA,MAAI;AAEJ,QAAM,iBAAiB,IAAI,QAAQ;AACnC,MAAI,QAAQ,aAAa,eAAe,WAAW,IAAY,eAA0C;AACvG,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,KAAK,MAAM,IAAI,aAAa;AAChE,qBAAe;AACf,aAAO;AAAA,IACT,SAAS,OAAO;AAEd,YAAM,SAAS;AACf,qBAAe,OAAO,8BAA8B,cAAc,KAAK,KAAK,OAAO,KAAK;AACxF,YAAM;AAAA,IACR;AAAA,EACF;AAUA,QAAM,kBAA4B,CAAC;AAEnC,QAAM,eAAe;AACrB,WAAS,UAAU,KAAsB;AACvC,QAAI,eAAe,OAAO;AACxB,aAAO,aAAa,8BAA8B,cAAc,GAAG,KAAK,OAAO,GAAG;AAAA,IACpF;AACA,QAAI,OAAO,QAAQ,UAAU;AAC3B,aAAO;AAAA,IACT;AACA,QAAI,QAAQ,UAAa,QAAQ,MAAM;AACrC,aAAO,OAAO,GAAG;AAAA,IACnB;AACA,UAAM,OAAO,KAAK,UAAU,GAAG;AAC/B,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,GAAG;AAAA,EACnD;AACA,WAAS,iBAAiB,MAAuB;AAC/C,oBAAgB,KAAK,KAAK,IAAI,SAAS,EAAE,KAAK,GAAG,CAAC;AAAA,EACpD;AACA,QAAM,mBAAmB,QAAQ;AACjC,QAAM,kBAAkB,QAAQ;AAChC,UAAQ,QAAQ,IAAI,SAA0B;AAC5C,kBAAc,GAAG,IAAI;AACrB,qBAAiB,MAAM,SAAS,IAAI;AAAA,EACtC;AACA,UAAQ,OAAO,IAAI,SAA0B;AAC3C,kBAAc,GAAG,IAAI;AACrB,oBAAgB,MAAM,SAAS,IAAI;AAAA,EACrC;AACA,WAAS,cAAc,OAAyB;AAC9C,oBAAgB,KAAK,MAAM,iBAAiB,QAAQ,UAAU,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EAC5F;AACA,WAAS,qBAAqB,OAAoC;AAChE,oBAAgB,KAAK,UAAU,MAAM,MAAM,CAAC;AAAA,EAC9C;AACA,SAAO,iBAAiB,SAAS,aAAa;AAC9C,SAAO,iBAAiB,sBAAsB,oBAAoB;AAElE,MAAI;AACF,UAAM,IAAI,QAAQ,oBAAoB,QAAQ;AAAA,EAChD,UAAE;AAEA,QAAI,QAAQ,aAAa;AACzB,YAAQ,QAAQ;AAChB,YAAQ,OAAO;AACf,WAAO,oBAAoB,SAAS,aAAa;AACjD,WAAO,oBAAoB,sBAAsB,oBAAoB;AAAA,EACvE;AAEA,QAAM,WAAW,YAAY,IAAI,QAAQ;AAEzC,MAAI;AACJ,MAAI,CAAC,gBAAgB,CAAC,UAAU;AAC9B,UAAM,SAAS,gBAAgB,KAAK,IAAI,EAAE,KAAK;AAC/C,4BAAwB,SAAS,SAAS;AAAA,EAC5C;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAW,IAAI,QAAQ,eAAe,IAAI,QAAQ;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAeO,SAAS,mCAAmC,UAA0B;AAC3E,SAAO,WAAW,QAAQ;AAG5B;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/enable-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared helper for enabling an Obsidian plugin with error capture.\n * Used by both the global setup and integration tests.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Plugin } from 'obsidian';\n\nimport type { CommonArguments } from './eval-in-obsidian.mjs';\n\n/**\n * Parameters for {@link enablePluginWithErrorCapture}.\n */\nexport interface EnablePluginParams {\n  /**\n   * The ID of the plugin to enable.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Result of enabling a plugin with error capture.\n */\nexport interface EnablePluginResult {\n  /**\n   * The error message captured by the `loadPlugin` monkey-patch, or `undefined`\n   * when the patch saw no throw. When Obsidian swallows the error *before* the\n   * patch (leaving this empty) but the plugin still failed to load, the real\n   * cause \u2014 if it reached the renderer console \u2014 is in {@link EnablePluginResult.rendererConsoleErrors}.\n   */\n  readonly errorMessage: string | undefined;\n\n  /**\n   * Whether the plugin is in the enabled set after the enable attempt.\n   * A plugin can be \"enabled\" (configured) but not \"loaded\" (failed to initialize).\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Whether the plugin instance actually exists in `app.plugins.plugins`.\n   * This is the definitive check \u2014 a plugin that is enabled but not loaded has failed.\n   */\n  readonly isLoaded: boolean;\n\n  /**\n   * Console/error output captured in the renderer during the enable window \u2014\n   * populated **only** when the plugin failed to load and the monkey-patch saw\n   * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would\n   * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.\n   * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).\n   */\n  readonly rendererConsoleErrors: string | undefined;\n}\n\ninterface IntegrationTestingErrorToString {\n  errorToString(error: unknown): string;\n}\n\ninterface IntegrationTestingHolder {\n  __obsidianIntegrationTesting: IntegrationTestingErrorToString;\n}\n\n/**\n * Enables a plugin inside Obsidian and captures any load error.\n *\n * Monkey-patches `app.plugins.loadPlugin` to intercept errors before\n * Obsidian's `enablePlugin` try-catch swallows them. The original method\n * is always restored in a `finally` block.\n *\n * Designed to be passed as the `callback` argument to {@link evalInObsidian}.\n *\n * @param input - The common input plus the plugin ID.\n * @param input.app - The Obsidian app instance.\n * @param input.pluginId - The ID of the plugin to enable.\n * @returns The enable result with error message and enabled status.\n */\nexport async function enablePluginWithErrorCapture({ app, pluginId }: CommonArguments & EnablePluginParams): Promise<EnablePluginResult> {\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n\n  /*\n   * Force a genuine reload when retrying. If a prior attempt left the plugin in\n   * the enabled set but not loaded (the cold-boot race), a plain re-enable can\n   * short-circuit on some Obsidian versions without re-attempting the load.\n   * Fully reset the enabled state first so the `enablePluginAndSave` below is a\n   * real fresh enable + load. No-op on the first attempt (not yet enabled).\n   */\n  if (app.plugins.enabledPlugins.has(pluginId) && !Object.hasOwn(app.plugins.plugins, pluginId)) {\n    await app.plugins.disablePluginAndSave(pluginId);\n  }\n\n  let errorMessage: string | undefined;\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- Intentional monkey-patch; restored in finally.\n  const origLoadPlugin = app.plugins.loadPlugin;\n  app.plugins.loadPlugin = async function loadPlugin(id: string, isUserEnabled?: boolean): Promise<Plugin> {\n    try {\n      const result = await origLoadPlugin.call(this, id, isUserEnabled);\n      errorMessage = undefined;\n      return result;\n    } catch (error) {\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 = globalThis as unknown as Partial<IntegrationTestingHolder>;\n      errorMessage = holder.__obsidianIntegrationTesting?.errorToString(error) ?? String(error);\n      throw error;\n    }\n  };\n\n  /*\n   * Layer 1 \u2014 capture the renderer console + uncaught errors for the duration of\n   * the enable. If Obsidian swallows the load error before the monkey-patch above\n   * sees it (leaving `errorMessage` empty), the real cause is typically still\n   * `console.error`'d, so capturing it here surfaces it in place of the generic\n   * fallback. Works on desktop and Android alike since this whole function is\n   * serialized and injected into the renderer.\n   */\n  const capturedConsole: string[] = [];\n  // eslint-disable-next-line no-restricted-syntax -- Approved double cast, same rationale as above.\n  const formatHolder = globalThis as unknown as Partial<IntegrationTestingHolder>;\n  function formatArgument(argument: unknown): string {\n    if (argument instanceof Error) {\n      return formatHolder.__obsidianIntegrationTesting?.errorToString(argument) ?? String(argument);\n    }\n    if (typeof argument === 'string') {\n      return argument;\n    }\n    if (argument === undefined || argument === null) {\n      return String(argument);\n    }\n    const json = JSON.stringify(argument);\n    return json ?? Object.prototype.toString.call(argument);\n  }\n  function recordConsole(...input: unknown[]): void {\n    capturedConsole.push(input.map((argument) => formatArgument(argument)).join(' '));\n  }\n  const origConsoleError = console.error;\n  const origConsoleWarn = console.warn;\n  console.error = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleError.apply(console, input);\n  };\n  console.warn = (...input: unknown[]): void => {\n    recordConsole(...input);\n    origConsoleWarn.apply(console, input);\n  };\n  function onWindowError(event: ErrorEvent): void {\n    capturedConsole.push(event.error instanceof Error ? formatArgument(event.error) : event.message);\n  }\n  function onUnhandledRejection(event: PromiseRejectionEvent): void {\n    capturedConsole.push(formatArgument(event.reason));\n  }\n  globalThis.addEventListener('error', onWindowError);\n  globalThis.addEventListener('unhandledrejection', onUnhandledRejection);\n\n  try {\n    await app.plugins.enablePluginAndSave(pluginId);\n  } finally {\n    // eslint-disable-next-line require-atomic-updates -- Intentional restore of monkey-patch.\n    app.plugins.loadPlugin = origLoadPlugin;\n    console.error = origConsoleError;\n    console.warn = origConsoleWarn;\n    globalThis.removeEventListener('error', onWindowError);\n    globalThis.removeEventListener('unhandledrejection', onUnhandledRejection);\n  }\n\n  const isLoaded = Object.hasOwn(app.plugins.plugins, pluginId);\n\n  let rendererConsoleErrors: string | undefined;\n  if (!errorMessage && !isLoaded) {\n    const joined = capturedConsole.join('\\n').trim();\n    rendererConsoleErrors = joined || undefined;\n  }\n\n  return {\n    errorMessage,\n    isEnabled: app.plugins.enabledPlugins.has(pluginId),\n    isLoaded,\n    rendererConsoleErrors\n  };\n}\n\n/**\n * The generic last-resort message shown when a plugin is in the enabled set but\n * not loaded and no real error could be captured (neither the `loadPlugin`\n * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a\n * cause).\n *\n * Host-side helper \u2014 used by the setup orchestration to compose the final\n * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}\n * stays self-contained.\n *\n * @param pluginId - The ID of the plugin that failed to load.\n * @returns The generic failure message.\n */\nexport function getGenericPluginLoadFailureMessage(pluginId: string): string {\n  return `Plugin \"${pluginId}\" is in the enabled set but not loaded. `\n    + 'Obsidian may have caught the error before the monkey-patch. '\n    + 'Check the Obsidian console for details.';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA+EA,eAAsB,6BAA6B,EAAE,KAAK,SAAS,GAAsE;AACvI,MAAI,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5B,UAAM,IAAI,QAAQ,UAAU,IAAI;AAAA,EAClC;AASA,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,KAAK,CAAC,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ,GAAG;AAC7F,UAAM,IAAI,QAAQ,qBAAqB,QAAQ;AAAA,EACjD;AAEA,MAAI;AAEJ,QAAM,iBAAiB,IAAI,QAAQ;AACnC,MAAI,QAAQ,aAAa,eAAe,WAAW,IAAY,eAA0C;AACvG,QAAI;AACF,YAAM,SAAS,MAAM,eAAe,KAAK,MAAM,IAAI,aAAa;AAChE,qBAAe;AACf,aAAO;AAAA,IACT,SAAS,OAAO;AAEd,YAAM,SAAS;AACf,qBAAe,OAAO,8BAA8B,cAAc,KAAK,KAAK,OAAO,KAAK;AACxF,YAAM;AAAA,IACR;AAAA,EACF;AAUA,QAAM,kBAA4B,CAAC;AAEnC,QAAM,eAAe;AACrB,WAAS,eAAe,UAA2B;AACjD,QAAI,oBAAoB,OAAO;AAC7B,aAAO,aAAa,8BAA8B,cAAc,QAAQ,KAAK,OAAO,QAAQ;AAAA,IAC9F;AACA,QAAI,OAAO,aAAa,UAAU;AAChC,aAAO;AAAA,IACT;AACA,QAAI,aAAa,UAAa,aAAa,MAAM;AAC/C,aAAO,OAAO,QAAQ;AAAA,IACxB;AACA,UAAM,OAAO,KAAK,UAAU,QAAQ;AACpC,WAAO,QAAQ,OAAO,UAAU,SAAS,KAAK,QAAQ;AAAA,EACxD;AACA,WAAS,iBAAiB,OAAwB;AAChD,oBAAgB,KAAK,MAAM,IAAI,CAAC,aAAa,eAAe,QAAQ,CAAC,EAAE,KAAK,GAAG,CAAC;AAAA,EAClF;AACA,QAAM,mBAAmB,QAAQ;AACjC,QAAM,kBAAkB,QAAQ;AAChC,UAAQ,QAAQ,IAAI,UAA2B;AAC7C,kBAAc,GAAG,KAAK;AACtB,qBAAiB,MAAM,SAAS,KAAK;AAAA,EACvC;AACA,UAAQ,OAAO,IAAI,UAA2B;AAC5C,kBAAc,GAAG,KAAK;AACtB,oBAAgB,MAAM,SAAS,KAAK;AAAA,EACtC;AACA,WAAS,cAAc,OAAyB;AAC9C,oBAAgB,KAAK,MAAM,iBAAiB,QAAQ,eAAe,MAAM,KAAK,IAAI,MAAM,OAAO;AAAA,EACjG;AACA,WAAS,qBAAqB,OAAoC;AAChE,oBAAgB,KAAK,eAAe,MAAM,MAAM,CAAC;AAAA,EACnD;AACA,aAAW,iBAAiB,SAAS,aAAa;AAClD,aAAW,iBAAiB,sBAAsB,oBAAoB;AAEtE,MAAI;AACF,UAAM,IAAI,QAAQ,oBAAoB,QAAQ;AAAA,EAChD,UAAE;AAEA,QAAI,QAAQ,aAAa;AACzB,YAAQ,QAAQ;AAChB,YAAQ,OAAO;AACf,eAAW,oBAAoB,SAAS,aAAa;AACrD,eAAW,oBAAoB,sBAAsB,oBAAoB;AAAA,EAC3E;AAEA,QAAM,WAAW,OAAO,OAAO,IAAI,QAAQ,SAAS,QAAQ;AAE5D,MAAI;AACJ,MAAI,CAAC,gBAAgB,CAAC,UAAU;AAC9B,UAAM,SAAS,gBAAgB,KAAK,IAAI,EAAE,KAAK;AAC/C,4BAAwB,UAAU;AAAA,EACpC;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAW,IAAI,QAAQ,eAAe,IAAI,QAAQ;AAAA,IAClD;AAAA,IACA;AAAA,EACF;AACF;AAeO,SAAS,mCAAmC,UAA0B;AAC3E,SAAO,WAAW,QAAQ;AAG5B;",
  "names": []
}


package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -6,12 +6,12 @@
 import type { App, Editor, Modifier, TFile } from 'obsidian';
 import type * as obsidian from 'obsidian';
 import type { Promisable } from 'type-fest';
-import type { ContextArgs, ContextId } from './context-id.mjs';
+import type { ContextArguments, ContextId } from './context-id.mjs';
 import type { ObsidianTransport } from './transport.mjs';
 /**
  * Common arguments automatically provided to every {@link evalInObsidian} callback.
  */
-export interface CommonArgs {
+export interface CommonArguments {
     /**
      * The Obsidian {@link App} instance.
      */
@@ -34,7 +34,7 @@ export interface CommonArgs {
     obsidianModule: typeof obsidian;
 }
 /**
- * Parameters for {@link CommonArgs.createNote}.
+ * Parameters for {@link CommonArguments.createNote}.
  */
 export interface CreateNoteParams {
     /**
@@ -50,12 +50,11 @@ export interface CreateNoteParams {
 /**
  * Parameters for {@link evalInObsidian}.
  */
-export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
+export interface EvalInObsidianParams<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
     /**
-     * Additional arguments to pass to the function. Values may include functions —
-     * they are serialized via `toString()`.
+     * The function to evaluate in the Obsidian context.
      */
-    readonly args?: Args;
+    callback(input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<Result>;
     /**
      * A {@link ContextId} linking this call to a persistent store on `window`
      * in the Obsidian process. The callback receives a typed `context` object
@@ -65,9 +64,10 @@ export interface EvalInObsidianParams<Args extends GenericObject, Result, TConte
      */
     readonly contextId?: TContextId;
     /**
-     * The function to evaluate in the Obsidian context.
+     * Additional arguments to pass to the function. Values may include functions —
+     * they are serialized via `toString()`.
      */
-    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
+    readonly input?: Input;
     /**
      * Skips pre-flight checks (vault registration, CLI availability).
      * Used internally by vault registration functions.
@@ -90,7 +90,7 @@ export interface EvalInObsidianParams<Args extends GenericObject, Result, TConte
  */
 export type GenericObject = Record<string, unknown>;
 /**
- * Parameters for {@link CommonArgs.hoverElement}.
+ * Parameters for {@link CommonArguments.hoverElement}.
  */
 export interface HoverElementParams {
     /**
@@ -102,7 +102,7 @@ export interface HoverElementParams {
 }
 /**
  * The shared library bag injected into every {@link evalInObsidian} callback as
- * {@link CommonArgs.lib}.
+ * {@link CommonArguments.lib}.
  *
  * Two layers compose into this one bag. The **base** — the harness-provided
  * renderer-driving helpers declared below (the trusted-input primitives and
@@ -281,7 +281,7 @@ export interface Lib {
     waitUntil(this: void, params: WaitUntilParams): Promise<void>;
 }
 /**
- * Parameters for {@link CommonArgs.moveMouse}.
+ * Parameters for {@link CommonArguments.moveMouse}.
  */
 export interface MoveMouseParams {
     /**
@@ -294,7 +294,7 @@ export interface MoveMouseParams {
     readonly y: number;
 }
 /**
- * Parameters for {@link CommonArgs.pressKey}.
+ * Parameters for {@link CommonArguments.pressKey}.
  */
 export interface PressKeyParams {
     /**
@@ -303,7 +303,7 @@ export interface PressKeyParams {
      * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character
      * (`'a'`, `'1'`). The produced character (when the key inserts text) is the
      * literal `key` value; case-correct text belongs to
-     * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.
+     * {@link CommonArguments.typeIntoEditor}, not a key-press primitive.
      */
     readonly key: string;
     /**
@@ -317,7 +317,7 @@ export interface PressKeyParams {
     readonly modifiers?: readonly Modifier[];
 }
 /**
- * Parameters for {@link CommonArgs.typeIntoEditor}.
+ * Parameters for {@link CommonArguments.typeIntoEditor}.
  */
 export interface TypeIntoEditorParams {
     /**
@@ -326,13 +326,13 @@ export interface TypeIntoEditorParams {
      */
     readonly editor: Editor;
     /**
-     * The text to type. Each code point is pressed via {@link CommonArgs.pressKey}
+     * The text to type. Each code point is pressed via {@link CommonArguments.pressKey}
      * (a trusted `keyDown` → `char` → `keyUp`), exactly as a real user typing.
      */
     readonly text: string;
 }
 /**
- * Parameters for {@link CommonArgs.unhoverElement}.
+ * Parameters for {@link CommonArguments.unhoverElement}.
  */
 export interface UnhoverElementParams {
     /**
@@ -344,7 +344,7 @@ export interface UnhoverElementParams {
     readonly element: HTMLElement;
 }
 /**
- * Parameters for {@link CommonArgs.waitUntil}.
+ * Parameters for {@link CommonArguments.waitUntil}.
  */
 export interface WaitUntilParams {
     /**
@@ -377,15 +377,15 @@ export interface WaitUntilParams {
  * Evaluates a function inside the running Obsidian instance
  * via the active transport and returns the parsed result.
  *
- * The function receives an args object that includes `app`, `obsidianModule`,
- * `context`, and any additional `args` passed by the caller.
+ * The function receives an input object that includes `app`, `obsidianModule`,
+ * `context`, and any additional `input` passed by the caller.
  * It is serialized via `toString()` and invoked as an IIFE.
  * The function must be self-contained — closures over local variables will not work.
- * Pass any needed values as `args` — they are JSON-serialized and deserialized on the Obsidian side.
+ * Pass any needed values as `input` — they are JSON-serialized and deserialized on the Obsidian side.
  *
  * The result is `JSON.stringify`'d on the Obsidian side and parsed back.
  *
  * @param params - The parameters for the function to evaluate.
- * @returns A {@link Promise} that resolves to the return value of `fn`.
+ * @returns A {@link Promise} that resolves to the return value of `callback`.
  */
-export declare function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: EvalInObsidianParams<Args, Result, TContextId>): Promise<Result>;
+export declare function evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: EvalInObsidianParams<Input, Result, TContextId>): Promise<Result>;

package/dist/lib/esm/eval-in-obsidian.mjs

@@ -9,7 +9,7 @@ import { ensureNamespaceBootstrapped } from "./namespace-bootstrap.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
 const NO_OUTPUT = "(no output)";
 async function evalInObsidian(params) {
-  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;
+  const { callback, contextId, input = {}, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;
   const cwd = vaultPath ?? getVaultPath() ?? process.cwd();
   if (vaultPath !== void 0 && !existsSync(vaultPath)) {
     throw new Error(`Vault path does not exist: ${vaultPath}`);
@@ -20,24 +20,24 @@ async function evalInObsidian(params) {
   }
   await ensureNamespaceBootstrapped(transport, cwd);
   const namespaceCallParams = {
-    args,
-    fn,
+    callback,
+    input,
     ...contextId !== void 0 && { contextId: String(contextId) }
   };
   const expression = generateNamespaceCall(namespaceCallParams);
-  const resultStr = await transport.evaluate(expression, { cwd });
-  if (resultStr === "" || resultStr === NO_OUTPUT) {
+  const resultString = await transport.evaluate(expression, { cwd });
+  if (resultString === "" || resultString === NO_OUTPUT) {
     return void 0;
   }
   let envelope;
   try {
-    envelope = JSON.parse(resultStr);
+    envelope = JSON.parse(resultString);
   } catch {
-    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);
+    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultString}`);
   }
   if ("type" in envelope) {
     if (envelope.type === "error") {
-      const sanitizedDetail = envelope.value.replace(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
+      const sanitizedDetail = envelope.value.replaceAll(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
       throw new Error(`evalInObsidian: Error inside Obsidian:
 ${sanitizedDetail}`);
     }
@@ -48,4 +48,4 @@ ${sanitizedDetail}`);
 export {
   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  TFile\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.mjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { generateNamespaceCall } from './generate-function-call.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\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 CommonArgs.createNote}.\n */\nexport interface CreateNoteParams {\n  /**\n   * The note's content. This exact string is what the created note is read back\n   * against, so it is the definition of a successful write.\n   */\n  readonly content: string;\n\n  /**\n   * The vault-relative path to create, extension included.\n   */\n  readonly path: string;\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   * Creates a note and does not return until its content is verifiably on\n   * disk, rewriting it if it is not.\n   *\n   * Use this instead of `app.vault.create` in any suite that may run on\n   * Android. The emulator transport loses roughly **0.9 %** of `vault.create`\n   * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on\n   * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,\n   * and it does not heal on its own. A suite doing ~34 creates per run\n   * therefore has a ~26 % chance of at least one lost write, and whichever test\n   * loses that lottery fails on a `waitUntil` for content that was never\n   * written \u2014 which is why it reads as an unrelated per-test flake rather than\n   * one shared cause.\n   *\n   * Verification is by **reading the note back**, never by inspecting\n   * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through\n   * `vault.modify` with the same content lands correctly (also measured), so a\n   * lost write costs a retry rather than a failure. A note whose content still\n   * does not match after the bounded retries throws, naming the path and both\n   * lengths, so a genuinely broken write fails loudly instead of spinning.\n   *\n   * Harmless everywhere else \u2014 on a transport that does not lose writes the\n   * read-back matches first time and nothing is rewritten.\n   *\n   * @param params - The note path and content.\n   * @returns A {@link Promise} resolving to the created file, once its content\n   *   is confirmed.\n   */\n  createNote(this: void, params: CreateNoteParams): Promise<TFile>;\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 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   * Synchronous: injecting the trusted move does no real awaiting, so the caller\n   * does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   */\n  moveMouse(this: void, params: MoveMouseParams): 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   * Synchronous: injecting the trusted key press does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   */\n  pressKey(this: void, params: PressKeyParams): 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": "AAgBA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AASpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA2BrC,MAAM,YAAY;AA6ZlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,OAAO,CAAC,GAAG,WAAW,IAAI,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACjH,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,CAAC,WAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,QAAM,4BAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,aAAa,sBAAsB,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": []
}

+//# 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  TFile\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  ContextArguments,\n  ContextId\n} from './context-id.mjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { generateNamespaceCall } from './generate-function-call.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\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 `callback` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `callback` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `callback` 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 CommonArguments {\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 CommonArguments.createNote}.\n */\nexport interface CreateNoteParams {\n  /**\n   * The note's content. This exact string is what the created note is read back\n   * against, so it is the definition of a successful write.\n   */\n  readonly content: string;\n\n  /**\n   * The vault-relative path to create, extension included.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  callback(input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<Result>;\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   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly input?: Input;\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 CommonArguments.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 CommonArguments.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   * Creates a note and does not return until its content is verifiably on\n   * disk, rewriting it if it is not.\n   *\n   * Use this instead of `app.vault.create` in any suite that may run on\n   * Android. The emulator transport loses roughly **0.9 %** of `vault.create`\n   * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on\n   * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,\n   * and it does not heal on its own. A suite doing ~34 creates per run\n   * therefore has a ~26 % chance of at least one lost write, and whichever test\n   * loses that lottery fails on a `waitUntil` for content that was never\n   * written \u2014 which is why it reads as an unrelated per-test flake rather than\n   * one shared cause.\n   *\n   * Verification is by **reading the note back**, never by inspecting\n   * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through\n   * `vault.modify` with the same content lands correctly (also measured), so a\n   * lost write costs a retry rather than a failure. A note whose content still\n   * does not match after the bounded retries throws, naming the path and both\n   * lengths, so a genuinely broken write fails loudly instead of spinning.\n   *\n   * Harmless everywhere else \u2014 on a transport that does not lose writes the\n   * read-back matches first time and nothing is rewritten.\n   *\n   * @param params - The note path and content.\n   * @returns A {@link Promise} resolving to the created file, once its content\n   *   is confirmed.\n   */\n  createNote(this: void, params: CreateNoteParams): Promise<TFile>;\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 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   * Synchronous: injecting the trusted move does no real awaiting, so the caller\n   * does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   */\n  moveMouse(this: void, params: MoveMouseParams): 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   * Synchronous: injecting the trusted key press does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   */\n  pressKey(this: void, params: PressKeyParams): 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 CommonArguments.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 CommonArguments.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 CommonArguments.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 CommonArguments.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 CommonArguments.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 CommonArguments.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 CommonArguments.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 input object that includes `app`, `obsidianModule`,\n * `context`, and any additional `input` 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 `input` \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 `callback`.\n */\nexport async function evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Input, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `callback` can be unbound.\n  const { callback, contextId, input = {}, 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    callback,\n    input,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultString = await transport.evaluate(expression, { cwd });\n\n  if (resultString === '' || resultString === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultString) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultString}`);\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        .replaceAll(/\\(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": "AAgBA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AASpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA2BrC,MAAM,YAAY;AA6ZlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,UAAU,WAAW,QAAQ,CAAC,GAAG,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACxH,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,CAAC,WAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,QAAM,4BAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,aAAa,sBAAsB,mBAAmB;AAE5D,QAAM,eAAe,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAEjE,MAAI,iBAAiB,MAAM,iBAAiB,WAAW;AACrD,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,YAAY;AAAA,EACpC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,YAAY,EAAE;AAAA,EACtF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,WAAW,yCAAyC,2BAA2B;AAClF,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": []
}


package/dist/lib/esm/exec.d.mts

@@ -4,19 +4,19 @@
  * Contains utility functions for executing commands.
  */
 /**
- * A command part: either a plain string or an {@link ExecArg} with batched arguments.
+ * A command part: either a plain string or an {@link ExecArgument} with batched arguments.
  */
-export type CommandPart = ExecArg | string;
+export type CommandPart = ExecArgument | string;
 /**
- * A command argument that contains a list of args to be batched.
+ * A command argument that contains a list of commandArguments to be batched.
  * If the expanded command exceeds the platform's max command length,
- * the batched args are split into sequential executions.
+ * the batched commandArguments are split into sequential executions.
  */
-export interface ExecArg {
+export interface ExecArgument {
     /**
      * The arguments to batch.
      */
-    readonly batchedArgs: readonly string[];
+    readonly batchedArguments: readonly string[];
 }
 /**
  * Options for {@link exec} that return detailed results.
@@ -48,7 +48,7 @@ export interface ExecOption {
      */
     readonly shouldIncludeDetails?: boolean;
     /**
-     * An input to be passed to the command.
+     * An argument to be passed to the command.
      */
     readonly stdin?: string;
     /**
@@ -106,7 +106,7 @@ export declare function exec(command: CommandPart[] | string, options: ExecDetai
  * Converts an array of command-line arguments into a single command-line string
  * using the `CommandLineToArgvW` convention.
  *
- * @param args - The array of command-line arguments to convert.
+ * @param commandArguments - The array of command-line arguments to convert.
  * @returns A string representing the command-line invocation.
  */
-export declare function toCommandLine(args: string[]): string;
+export declare function toCommandLine(commandArguments: string[]): string;