obsidian-integration-testing 8.4.0 → 9.1.0

package/dist/lib/cjs/enable-plugin.cjs

@@ -18,13 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var enable_plugin_exports = {};
 __export(enable_plugin_exports, {
-  enablePluginWithErrorCapture: () => enablePluginWithErrorCapture
+  enablePluginWithErrorCapture: () => enablePluginWithErrorCapture,
+  getGenericPluginLoadFailureMessage: () => getGenericPluginLoadFailureMessage
 });
 module.exports = __toCommonJS(enable_plugin_exports);
 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)) {
+    await app.plugins.disablePluginAndSave(pluginId);
+  }
   let errorMessage;
   const origLoadPlugin = app.plugins.loadPlugin;
   app.plugins.loadPlugin = async function loadPlugin(id, isUserEnabled) {
@@ -38,23 +42,70 @@ async function enablePluginWithErrorCapture({ app, pluginId }) {
       throw error;
     }
   };
+  const capturedConsole = [];
+  const formatHolder = window;
+  function formatArg(arg) {
+    if (arg instanceof Error) {
+      return formatHolder.__obsidianIntegrationTesting?.errorToString(arg) ?? String(arg);
+    }
+    if (typeof arg === "string") {
+      return arg;
+    }
+    if (arg === void 0 || arg === null) {
+      return String(arg);
+    }
+    const json = JSON.stringify(arg);
+    return json ?? Object.prototype.toString.call(arg);
+  }
+  function recordConsole(...args) {
+    capturedConsole.push(args.map(formatArg).join(" "));
+  }
+  const origConsoleError = console.error;
+  const origConsoleWarn = console.warn;
+  console.error = (...args) => {
+    recordConsole(...args);
+    origConsoleError.apply(console, args);
+  };
+  console.warn = (...args) => {
+    recordConsole(...args);
+    origConsoleWarn.apply(console, args);
+  };
+  function onWindowError(event) {
+    capturedConsole.push(event.error instanceof Error ? formatArg(event.error) : event.message);
+  }
+  function onUnhandledRejection(event) {
+    capturedConsole.push(formatArg(event.reason));
+  }
+  window.addEventListener("error", onWindowError);
+  window.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);
   }
   const isLoaded = pluginId in app.plugins.plugins;
+  let rendererConsoleErrors;
   if (!errorMessage && !isLoaded) {
-    errorMessage = `Plugin "${pluginId}" is in the enabled set but not loaded. Obsidian may have caught the error before the monkey-patch. Check the Obsidian console for details.`;
+    const joined = capturedConsole.join("\n").trim();
+    rendererConsoleErrors = joined ? joined : void 0;
   }
   return {
     errorMessage,
     isEnabled: app.plugins.enabledPlugins.has(pluginId),
-    isLoaded
+    isLoaded,
+    rendererConsoleErrors
   };
 }
+function getGenericPluginLoadFailureMessage(pluginId) {
+  return `Plugin "${pluginId}" is in the enabled set but not loaded. Obsidian may have caught the error before the monkey-patch. Check the Obsidian console for details.`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  enablePluginWithErrorCapture
+  enablePluginWithErrorCapture,
+  getGenericPluginLoadFailureMessage
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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.cjs';\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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": []
}


package/dist/lib/cjs/enable-plugin.d.cts

@@ -19,7 +19,10 @@ export interface EnablePluginParams {
  */
 export interface EnablePluginResult {
     /**
-     * The error message if the plugin failed to load, or `undefined` if it loaded successfully.
+     * The error message captured by the `loadPlugin` monkey-patch, or `undefined`
+     * when the patch saw no throw. When Obsidian swallows the error *before* the
+     * patch (leaving this empty) but the plugin still failed to load, the real
+     * cause — if it reached the renderer console — is in {@link EnablePluginResult.rendererConsoleErrors}.
      */
     readonly errorMessage: string | undefined;
     /**
@@ -32,6 +35,14 @@ export interface EnablePluginResult {
      * This is the definitive check — a plugin that is enabled but not loaded has failed.
      */
     readonly isLoaded: boolean;
+    /**
+     * Console/error output captured in the renderer during the enable window —
+     * populated **only** when the plugin failed to load and the monkey-patch saw
+     * no throw (`!errorMessage && !isLoaded`), i.e. exactly the case that would
+     * otherwise surface the generic {@link getGenericPluginLoadFailureMessage} text.
+     * `undefined` otherwise (including on success and when {@link EnablePluginResult.errorMessage} already has the error).
+     */
+    readonly rendererConsoleErrors: string | undefined;
 }
 /**
  * Enables a plugin inside Obsidian and captures any load error.
@@ -48,3 +59,17 @@ export interface EnablePluginResult {
  * @returns The enable result with error message and enabled status.
  */
 export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult>;
+/**
+ * The generic last-resort message shown when a plugin is in the enabled set but
+ * not loaded and no real error could be captured (neither the `loadPlugin`
+ * monkey-patch nor the renderer console nor, on Android, `adb logcat` surfaced a
+ * cause).
+ *
+ * Host-side helper — used by the setup orchestration to compose the final
+ * failure message, so the renderer-injected {@link enablePluginWithErrorCapture}
+ * stays self-contained.
+ *
+ * @param pluginId - The ID of the plugin that failed to load.
+ * @returns The generic failure message.
+ */
+export declare function getGenericPluginLoadFailureMessage(pluginId: string): string;

package/dist/lib/cjs/global-setup-core.cjs

@@ -37,10 +37,12 @@ var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
+var import_promises2 = require("node:timers/promises");
 var import_enable_plugin = require("./enable-plugin.cjs");
 var import_error_to_string = require("./error-to-string.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_log = require("./log.cjs");
+var import_plugin_enable_retry = require("./plugin-enable-retry.cjs");
 var import_setup_lock = require("./setup-lock.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
@@ -80,23 +82,15 @@ async function coreSetup(params) {
     transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
     (0, import_log.log)(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);
     (0, import_log.log)(`[integration-setup:${label}] Project root: ${projectRoot}`);
-    const distPath = await resolveDistPath(projectRoot);
-    const manifestJson = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(distPath, "manifest.json"), "utf-8"));
-    const pluginId = manifestJson.id;
-    if (transport.isMobile && manifestJson.isDesktopOnly) {
-      throw new Error(
-        `Plugin "${pluginId}" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`
-      );
-    }
-    const mainJs = (0, import_node_path.join)(distPath, MAIN_JS);
-    const buildStat = await (0, import_promises.stat)(mainJs);
-    (0, import_log.log)(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);
+    const shouldInstallPlugin = params?.installPlugin !== false;
     tempVault = new import_temp_vault.TempVault();
     (0, import_log.log)(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);
-    const pluginDir = (0, import_node_path.join)(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
-    await (0, import_promises.mkdir)(pluginDir, { recursive: true });
-    await (0, import_promises.cp)(distPath, pluginDir, { recursive: true });
-    await (0, import_promises.writeFile)((0, import_node_path.join)(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+    let pluginId;
+    if (shouldInstallPlugin) {
+      pluginId = await copyPluginIntoVault({ label, projectRoot, tempVault, transport });
+    } else {
+      (0, import_log.log)(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);
+    }
     if (params?.populate) {
       const entryCount = Object.keys(params.populate).length;
       (0, import_log.log)(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);
@@ -107,18 +101,16 @@ async function coreSetup(params) {
     (0, import_log.log)(`[integration-setup:${label}] Registering vault...`);
     await tempVault.register(transport);
     (0, import_log.log)(`[integration-setup:${label}] Vault registered.`);
-    (0, import_log.log)(`[integration-setup:${label}] Enabling plugin "${pluginId}"...`);
-    const { errorMessage } = await (0, import_eval_in_obsidian.evalInObsidian)({
-      args: { pluginId },
-      fn: import_enable_plugin.enablePluginWithErrorCapture,
-      shouldSkipPreflightChecks: true,
+    if (pluginId !== void 0) {
+      await enablePluginInVault({ label, pluginId, tempVault, transport, transportOptions });
+    }
+    await enableExtraCommunityPlugins({
+      label,
+      pluginIds: params?.enableCommunityPlugins ?? [],
+      tempVault,
       transport,
-      vaultPath: tempVault.path
+      transportOptions
     });
-    if (errorMessage) {
-      throw new Error(`Plugin "${pluginId}" failed to load: ${errorMessage}`);
-    }
-    (0, import_log.log)(`[integration-setup:${label}] Plugin "${pluginId}" enabled successfully.`);
     const augmentedOptions = augmentTransportOptions(transportOptions, transport);
     const result = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };
     activeSetups.add(result);
@@ -196,6 +188,80 @@ function augmentTransportOptions(options, transport) {
   }
   return options;
 }
+async function copyPluginIntoVault(params) {
+  const { label, projectRoot, tempVault, transport } = params;
+  const distPath = await resolveDistPath(projectRoot);
+  const manifestJson = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(distPath, "manifest.json"), "utf-8"));
+  const pluginId = manifestJson.id;
+  if (transport.isMobile && manifestJson.isDesktopOnly) {
+    throw new Error(
+      `Plugin "${pluginId}" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`
+    );
+  }
+  const mainJs = (0, import_node_path.join)(distPath, MAIN_JS);
+  const buildStat = await (0, import_promises.stat)(mainJs);
+  (0, import_log.log)(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);
+  const pluginDir = (0, import_node_path.join)(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  await (0, import_promises.mkdir)(pluginDir, { recursive: true });
+  await (0, import_promises.cp)(distPath, pluginDir, { recursive: true });
+  await (0, import_promises.writeFile)((0, import_node_path.join)(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+  return pluginId;
+}
+async function enableExtraCommunityPlugins(params) {
+  const { label, pluginIds, tempVault, transport, transportOptions } = params;
+  for (const pluginId of pluginIds) {
+    (0, import_log.log)(`[integration-setup:${label}] Enabling extra community plugin "${pluginId}"...`);
+    await enablePluginInVault({ label, pluginId, tempVault, transport, transportOptions });
+  }
+}
+async function enablePluginInVault(params) {
+  const { label, pluginId, tempVault, transport, transportOptions } = params;
+  (0, import_log.log)(`[integration-setup:${label}] Enabling plugin "${pluginId}"...`);
+  const captureHandle = await transport.beginConsoleCapture?.();
+  const maxAttempts = 1 + (0, import_plugin_enable_retry.resolvePluginEnableRetryCount)(transportOptions);
+  const baseDelayInMilliseconds = (0, import_plugin_enable_retry.resolvePluginEnableRetryDelayInMilliseconds)(transportOptions);
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    let result;
+    try {
+      result = await (0, import_eval_in_obsidian.evalInObsidian)({
+        args: { pluginId },
+        fn: import_enable_plugin.enablePluginWithErrorCapture,
+        shouldSkipPreflightChecks: true,
+        transport,
+        vaultPath: tempVault.path
+      });
+    } catch (error) {
+      if (attempt < maxAttempts) {
+        const delayInMilliseconds = (0, import_plugin_enable_retry.computeBackoffDelayInMilliseconds)(baseDelayInMilliseconds, attempt - 1);
+        (0, import_log.log)(
+          `[integration-setup:${label}] Enable attempt ${String(attempt)}/${String(maxAttempts)} threw (${(0, import_error_to_string.errorToString)(error)}); retrying in ${String(delayInMilliseconds)}ms...`
+        );
+        await (0, import_promises2.setTimeout)(delayInMilliseconds);
+        continue;
+      }
+      throw error;
+    }
+    const realError = result.errorMessage ?? result.rendererConsoleErrors;
+    if (result.isLoaded && !realError) {
+      const attemptSuffix = attempt > 1 ? ` (attempt ${String(attempt)}/${String(maxAttempts)})` : "";
+      (0, import_log.log)(`[integration-setup:${label}] Plugin "${pluginId}" enabled successfully${attemptSuffix}.`);
+      return;
+    }
+    if (!(0, import_plugin_enable_retry.shouldRetryPluginEnable)(result)) {
+      throw new Error(`Plugin "${pluginId}" failed to load: ${realError ?? (0, import_enable_plugin.getGenericPluginLoadFailureMessage)(pluginId)}`);
+    }
+    if (attempt < maxAttempts) {
+      const delayInMilliseconds = (0, import_plugin_enable_retry.computeBackoffDelayInMilliseconds)(baseDelayInMilliseconds, attempt - 1);
+      (0, import_log.log)(
+        `[integration-setup:${label}] Plugin "${pluginId}" enabled but not loaded (attempt ${String(attempt)}/${String(maxAttempts)}); retrying in ${String(delayInMilliseconds)}ms...`
+      );
+      await (0, import_promises2.setTimeout)(delayInMilliseconds);
+    }
+  }
+  const logcatTail = await transport.readConsoleCaptureSince?.(captureHandle);
+  const detail = logcatTail ?? (0, import_enable_plugin.getGenericPluginLoadFailureMessage)(pluginId);
+  throw new Error(`Plugin "${pluginId}" failed to load: ${detail}`);
+}
 function findProjectRoot() {
   let dir = import_node_process.default.cwd();
   while (true) {
@@ -303,4 +369,4 @@ async function teardownAsync(result) {
   coreTeardown,
   resolveIntegrationTransportOptions
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\n\nimport type { SetupLock } from './setup-lock.cjs';\nimport type { PopulateFilesParams } from './temp-vault.cjs';\nimport type { ObsidianTransportOptions } from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { enablePluginWithErrorCapture } from './enable-plugin.cjs';\nimport { errorToString } from './error-to-string.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { log } from './log.cjs';\nimport { acquireSetupLock } from './setup-lock.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, uses an off-screen owned desktop instance. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, copies the built\n * plugin into a temporary vault, registers the vault with Obsidian, and\n * enables the plugin.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);\n  const label = transportOptions.type;\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  let transport: ObsidianTransport | undefined;\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const distPath = await resolveDistPath(projectRoot);\n    const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n    const pluginId = manifestJson.id;\n\n    if (transport.isMobile && manifestJson.isDesktopOnly) {\n      throw new Error(\n        `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n      );\n    }\n\n    const mainJs = join(distPath, MAIN_JS);\n    const buildStat = await stat(mainJs);\n\n    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n    await mkdir(pluginDir, { recursive: true });\n    await cp(distPath, pluginDir, { recursive: true });\n    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    // Enable the plugin and verify it loaded. Obsidian's enablePlugin() wraps\n    // LoadPlugin() in a try-catch that swallows errors and returns false.\n    // We monkey-patch loadPlugin() to capture the error before it's swallowed.\n    log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n    const { errorMessage } = await evalInObsidian({\n      args: { pluginId },\n      fn: enablePluginWithErrorCapture,\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath: tempVault.path\n    });\n\n    if (errorMessage) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${errorMessage}`);\n    }\n\n    log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully.`);\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault && transport) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n}\n\n/**\n * Resolves transport options for an integration run.\n *\n * Desktop launches are normally visible, but test setup explicitly keeps its\n * owned instance off-screen so it does not interrupt the developer.\n *\n * @param options - Consumer-provided transport options.\n * @returns Options with the desktop integration visibility default applied.\n */\nexport function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions {\n  if (options?.type === 'obsidian-android-appium') {\n    return options;\n  }\n\n  return {\n    ...options,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,\n    type: 'obsidian-cdp'\n  };\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { EnablePluginResult } from './enable-plugin.cjs';\nimport type { SetupLock } from './setup-lock.cjs';\nimport type { PopulateFilesParams } from './temp-vault.cjs';\nimport type { ObsidianTransportOptions } from './transport-options.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  enablePluginWithErrorCapture,\n  getGenericPluginLoadFailureMessage\n} from './enable-plugin.cjs';\nimport { errorToString } from './error-to-string.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { log } from './log.cjs';\nimport {\n  computeBackoffDelayInMilliseconds,\n  resolvePluginEnableRetryCount,\n  resolvePluginEnableRetryDelayInMilliseconds,\n  shouldRetryPluginEnable\n} from './plugin-enable-retry.cjs';\nimport { acquireSetupLock } from './setup-lock.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Community-plugin ids to enable in the vault **in addition to** the\n   * plugin-under-test, after it is enabled. Each id's built files must already be\n   * present under `.obsidian/plugins/<id>/` \u2014 seed them via {@link CoreSetupParams.populate}\n   * (e.g. with `buildDemoVaultPopulate`). Enabling goes through the same\n   * retry/load-verify path as the plugin-under-test. Composes with\n   * `installPlugin: false` (enable extras into an otherwise plugin-less vault).\n   */\n  readonly enableCommunityPlugins?: readonly string[] | undefined;\n\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer (e.g. a typings\n   * crawler) that only needs a registered, empty vault to `evalInObsidian`\n   * against: the plugin `dist`/`manifest.json` read, the copy into\n   * `.obsidian/plugins`, the `community-plugins.json` write, and the enable step\n   * are all skipped, while the transport, temp vault, registration, and\n   * worker-facing endpoint provisioning still run unchanged.\n   */\n  readonly installPlugin?: boolean | undefined;\n\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, uses an off-screen owned desktop instance. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Parameters for {@link copyPluginIntoVault}.\n */\ninterface CopyPluginIntoVaultParams {\n  /** Short label for log messages. */\n  readonly label: string;\n\n  /** The project root to resolve the built plugin from. */\n  readonly projectRoot: string;\n\n  /** The temp vault to copy the plugin into. */\n  readonly tempVault: TempVault;\n\n  /** The transport (used for the mobile/desktop-only compatibility check). */\n  readonly transport: ObsidianTransport;\n}\n\n/**\n * Parameters for {@link enableExtraCommunityPlugins}.\n */\ninterface EnableExtraCommunityPluginsParams {\n  /** Short label for log messages. */\n  readonly label: string;\n\n  /** The ids of the extra community plugins to enable (their binaries must already be in the vault). */\n  readonly pluginIds: readonly string[];\n\n  /** The temp vault the plugins were seeded into. */\n  readonly tempVault: TempVault;\n\n  /** The transport to evaluate against. */\n  readonly transport: ObsidianTransport;\n\n  /** The resolved transport options (source of the plugin-enable retry knobs). */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Parameters for {@link enablePluginInVault}.\n */\ninterface EnablePluginInVaultParams {\n  /** Short label for log messages. */\n  readonly label: string;\n\n  /** The id of the plugin to enable. */\n  readonly pluginId: string;\n\n  /** The temp vault the plugin was copied into. */\n  readonly tempVault: TempVault;\n\n  /** The transport to evaluate against. */\n  readonly transport: ObsidianTransport;\n\n  /** The resolved transport options (source of the plugin-enable retry knobs). */\n  readonly transportOptions: null | ObsidianTransportOptions;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, creates and registers\n * a temporary vault with Obsidian, and \u2014 unless {@link CoreSetupParams.installPlugin}\n * is `false` \u2014 copies the built plugin into the vault and enables it. The\n * plugin-less mode still launches the owned instance and publishes its\n * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);\n  const label = transportOptions.type;\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  let transport: ObsidianTransport | undefined;\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const shouldInstallPlugin = params?.installPlugin !== false;\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n\n    let pluginId: string | undefined;\n\n    if (shouldInstallPlugin) {\n      pluginId = await copyPluginIntoVault({ label, projectRoot, tempVault, transport });\n    } else {\n      log(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);\n    }\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    if (pluginId !== undefined) {\n      await enablePluginInVault({ label, pluginId, tempVault, transport, transportOptions });\n    }\n\n    await enableExtraCommunityPlugins({\n      label,\n      pluginIds: params?.enableCommunityPlugins ?? [],\n      tempVault,\n      transport,\n      transportOptions\n    });\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault && transport) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n}\n\n/**\n * Resolves transport options for an integration run.\n *\n * Desktop launches are normally visible, but test setup explicitly keeps its\n * owned instance off-screen so it does not interrupt the developer.\n *\n * @param options - Consumer-provided transport options.\n * @returns Options with the desktop integration visibility default applied.\n */\nexport function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions {\n  if (options?.type === 'obsidian-android-appium') {\n    return options;\n  }\n\n  return {\n    ...options,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,\n    type: 'obsidian-cdp'\n  };\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Copies the built plugin into the temp vault and marks it as a community plugin.\n *\n * Reads `manifest.json` from the newer of `dist/dev`/`dist/build`, rejects a\n * desktop-only plugin on a mobile transport, copies the build into\n * `.obsidian/plugins/<id>`, and writes `.obsidian/community-plugins.json`.\n *\n * @param params - The copy parameters.\n * @returns The plugin id read from the manifest.\n */\nasync function copyPluginIntoVault(params: CopyPluginIntoVaultParams): Promise<string> {\n  const { label, projectRoot, tempVault, transport } = params;\n  const distPath = await resolveDistPath(projectRoot);\n  const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n  const pluginId = manifestJson.id;\n\n  if (transport.isMobile && manifestJson.isDesktopOnly) {\n    throw new Error(\n      `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n    );\n  }\n\n  const mainJs = join(distPath, MAIN_JS);\n  const buildStat = await stat(mainJs);\n  log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n  const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  await mkdir(pluginDir, { recursive: true });\n  await cp(distPath, pluginDir, { recursive: true });\n  await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n  return pluginId;\n}\n\n/**\n * Enables extra community plugins (beyond the plugin-under-test) in the registered vault, each through the\n * same {@link enablePluginInVault} path. Each plugin's built files must already be present in the vault (seed\n * them via {@link CoreSetupParams.populate}). A no-op when the list is empty.\n *\n * @param params - The enable parameters.\n */\nasync function enableExtraCommunityPlugins(params: EnableExtraCommunityPluginsParams): Promise<void> {\n  const { label, pluginIds, tempVault, transport, transportOptions } = params;\n  for (const pluginId of pluginIds) {\n    log(`[integration-setup:${label}] Enabling extra community plugin \"${pluginId}\"...`);\n    await enablePluginInVault({ label, pluginId, tempVault, transport, transportOptions });\n  }\n}\n\n/**\n * Enables the plugin in the registered vault and verifies it loaded.\n *\n * Obsidian's `enablePlugin()` wraps `loadPlugin()` in a try-catch that swallows\n * errors and returns false, so {@link enablePluginWithErrorCapture} monkey-patches\n * `loadPlugin()` to capture the error before it's swallowed.\n *\n * @param params - The enable parameters.\n */\nasync function enablePluginInVault(params: EnablePluginInVaultParams): Promise<void> {\n  const { label, pluginId, tempVault, transport, transportOptions } = params;\n  log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n\n  /*\n   * Open a native console-capture window (Layer 2, Android only) around the\n   * enable so that if Obsidian swallows the load error before the monkey-patch\n   * and the renderer console (Layer 1) came up empty, we can still recover the\n   * real cause from `adb logcat`. No-op (undefined) on transports that don't\n   * implement it (e.g. desktop).\n   */\n  const captureHandle = await transport.beginConsoleCapture?.();\n\n  /*\n   * On a freshly cold-booted emulator the plugin subsystem can still be settling\n   * when we enable the plugin, so a single-shot enable races the load and loses\n   * (the plugin lands in the enabled set but never loads). Retry the enable +\n   * load-verification a few times with exponential backoff, which recovers the\n   * transient race. A captured load error (`realError`) is a deterministic bug \u2014\n   * retrying cannot fix it, so we fail fast. Non-Android transports resolve to\n   * the same defaults but never enter the retry path: their load either succeeds\n   * on the first attempt or throws a captured error.\n   */\n  const maxAttempts = 1 + resolvePluginEnableRetryCount(transportOptions);\n  const baseDelayInMilliseconds = resolvePluginEnableRetryDelayInMilliseconds(transportOptions);\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    let result: EnablePluginResult;\n    try {\n      result = await evalInObsidian({\n        args: { pluginId },\n        fn: enablePluginWithErrorCapture,\n        shouldSkipPreflightChecks: true,\n        transport,\n        vaultPath: tempVault.path\n      });\n    } catch (error) {\n      /*\n       * The eval itself threw (e.g. the WebView context was lost mid-execution on\n       * a churning guest) \u2014 a transport-level transient. Retry if attempts remain.\n       */\n      if (attempt < maxAttempts) {\n        const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n        log(\n          `[integration-setup:${label}] Enable attempt ${String(attempt)}/${String(maxAttempts)} threw `\n            + `(${errorToString(error)}); retrying in ${String(delayInMilliseconds)}ms...`\n        );\n        await sleep(delayInMilliseconds);\n        continue;\n      }\n      throw error;\n    }\n\n    /*\n     * `errorMessage` is the real throw seen by the monkey-patch;\n     * `rendererConsoleErrors` (Layer 1) is the real cause console-logged in the renderer.\n     */\n    const realError = result.errorMessage ?? result.rendererConsoleErrors;\n\n    if (result.isLoaded && !realError) {\n      const attemptSuffix = attempt > 1 ? ` (attempt ${String(attempt)}/${String(maxAttempts)})` : '';\n      log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully${attemptSuffix}.`);\n      return;\n    }\n\n    // A captured load error is deterministic \u2014 fail fast rather than retry.\n    if (!shouldRetryPluginEnable(result)) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${realError ?? getGenericPluginLoadFailureMessage(pluginId)}`);\n    }\n\n    // Transient cold-boot race (enabled but not loaded, no cause captured): retry.\n    if (attempt < maxAttempts) {\n      const delayInMilliseconds = computeBackoffDelayInMilliseconds(baseDelayInMilliseconds, attempt - 1);\n      log(\n        `[integration-setup:${label}] Plugin \"${pluginId}\" enabled but not loaded `\n          + `(attempt ${String(attempt)}/${String(maxAttempts)}); retrying in ${String(delayInMilliseconds)}ms...`\n      );\n      await sleep(delayInMilliseconds);\n    }\n  }\n\n  /*\n   * Exhausted every attempt on the transient signature: compose the most\n   * specific detail available (`adb logcat` tail on Android, else the generic\n   * message) \u2014 unchanged from the pre-retry single-shot failure.\n   */\n  const logcatTail = await transport.readConsoleCaptureSince?.(captureHandle);\n  const detail = logcatTail ?? getGenericPluginLoadFailureMessage(pluginId);\n  throw new Error(`Plugin \"${pluginId}\" failed to load: ${detail}`);\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": ["import_promises", "sleep", "process"]
}


package/dist/lib/cjs/global-setup-core.d.cts

@@ -13,6 +13,25 @@ import { TempVault } from './temp-vault.cjs';
  * Parameters for {@link coreSetup}.
  */
 export interface CoreSetupParams {
+    /**
+     * Community-plugin ids to enable in the vault **in addition to** the
+     * plugin-under-test, after it is enabled. Each id's built files must already be
+     * present under `.obsidian/plugins/<id>/` — seed them via {@link CoreSetupParams.populate}
+     * (e.g. with `buildDemoVaultPopulate`). Enabling goes through the same
+     * retry/load-verify path as the plugin-under-test. Composes with
+     * `installPlugin: false` (enable extras into an otherwise plugin-less vault).
+     */
+    readonly enableCommunityPlugins?: readonly string[] | undefined;
+    /**
+     * Whether to install and enable the built plugin in the temp vault. Defaults
+     * to `true`. Set to `false` for a **non-plugin** consumer (e.g. a typings
+     * crawler) that only needs a registered, empty vault to `evalInObsidian`
+     * against: the plugin `dist`/`manifest.json` read, the copy into
+     * `.obsidian/plugins`, the `community-plugins.json` write, and the enable step
+     * are all skipped, while the transport, temp vault, registration, and
+     * worker-facing endpoint provisioning still run unchanged.
+     */
+    readonly installPlugin?: boolean | undefined;
     /**
      * Files and folders to write into the vault **before** Obsidian opens it, so
      * its startup scan indexes them in one pass (see {@link TempVault.populate}).
@@ -40,9 +59,11 @@ export interface CoreSetupResult {
 /**
  * Framework-agnostic global setup logic.
  *
- * Loads `.env` from the project root, creates a transport, copies the built
- * plugin into a temporary vault, registers the vault with Obsidian, and
- * enables the plugin.
+ * Loads `.env` from the project root, creates a transport, creates and registers
+ * a temporary vault with Obsidian, and — unless {@link CoreSetupParams.installPlugin}
+ * is `false` — copies the built plugin into the vault and enables it. The
+ * plugin-less mode still launches the owned instance and publishes its
+ * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.
  *
  * @param params - Setup parameters.
  * @returns The setup result containing the temp vault, transport, and resolved options.