obsidian-integration-testing 8.4.0 → 9.1.0

package/dist/lib/esm/demo-vault-populate.mjs

@@ -0,0 +1,57 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import { join } from "node:path";
+import { readDemoVaultTree } from "./demo-vault-tree.mjs";
+import { ensureNonNullable } from "./type-guards.mjs";
+const OBSIDIAN_CONFIG_DIR = ".obsidian";
+const PLUGINS_DIR = "plugins";
+const DATA_JSON = "data.json";
+const MANIFEST_JSON = "manifest.json";
+const MAIN_JS = "main.js";
+const DATA_JSON_INDENT = 2;
+const DEFAULT_OBSIDIAN_CONFIG_FILES = ["app.json", "appearance.json", "core-plugins.json"];
+function buildDemoVaultPopulate(params) {
+  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;
+  const map = readDemoVaultTree(excludedNames === void 0 ? { demoVaultPath } : { demoVaultPath, excludedNames });
+  for (const configFile of obsidianConfigFiles) {
+    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);
+    if (existsSync(configPath)) {
+      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);
+    }
+  }
+  for (const plugin of injectPlugins) {
+    seedPlugin(demoVaultPath, plugin, map);
+  }
+  return map;
+}
+function seedPlugin(demoVaultPath, plugin, map) {
+  const { data, pluginId } = plugin;
+  const sourceDir = plugin.sourceDir ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;
+  const fileNames = existsSync(sourceDir) ? readdirSync(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
+  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {
+    if (!fileNames.includes(requiredFile)) {
+      throw new Error(
+        `Community plugin "${pluginId}" is not installed in the demo vault (${join(sourceDir, requiredFile)} missing). Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.`
+      );
+    }
+  }
+  for (const fileName of fileNames) {
+    if (fileName === DATA_JSON && data !== void 0) {
+      continue;
+    }
+    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDir, fileName));
+  }
+  if (data !== void 0) {
+    const dataJson = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));
+    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}
+`;
+  }
+}
+export {
+  buildDemoVaultPopulate
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-populate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into\n * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two\n * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)\n * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).\n *\n * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,\n * that turns them on. It intentionally does NOT write `community-plugins.json` \u2014 the harness owns that file\n * (it lists the plugin-under-test), and enabling the extras persists them.\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\n\nimport type { PopulateFilesParams } from './temp-vault.mjs';\n\nimport { readDemoVaultTree } from './demo-vault-tree.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\n\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst DATA_JSON = 'data.json';\nconst MANIFEST_JSON = 'manifest.json';\nconst MAIN_JS = 'main.js';\nconst DATA_JSON_INDENT = 2;\n\nconst DEFAULT_OBSIDIAN_CONFIG_FILES = ['app.json', 'appearance.json', 'core-plugins.json'];\n\n/**\n * Parameters for {@link buildDemoVaultPopulate}.\n */\nexport interface BuildDemoVaultPopulateParams {\n  /**\n   * Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * Names (of files or directories, matched at any depth) to skip while reading the note tree \u2014 forwarded to\n   * {@link readDemoVaultTree}.\n   *\n   * @default `['.git', '.obsidian']`\n   */\n  readonly excludedNames?: Iterable<string>;\n\n  /**\n   * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn\n   * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.\n   */\n  readonly injectPlugins?: readonly InjectPluginParams[];\n\n  /**\n   * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole\n   * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must\n   * be re-added explicitly. Files that do not exist are skipped.\n   *\n   * @default `['app.json', 'appearance.json', 'core-plugins.json']`\n   */\n  readonly obsidianConfigFiles?: readonly string[];\n}\n\n/**\n * A community plugin to seed into the demo vault alongside the note tree.\n */\nexport interface InjectPluginParams {\n  /**\n   * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever\n   * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.\n   */\n  readonly data?: unknown;\n\n  /**\n   * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).\n   */\n  readonly pluginId: string;\n\n  /**\n   * Directory to read the plugin's built files from. Every file directly inside it is copied into\n   * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.\n   *\n   * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`\n   */\n  readonly sourceDir?: string;\n}\n\n/**\n * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config\n * files, and every injected plugin's binaries (+ optional `data.json`).\n *\n * @param params - The {@link BuildDemoVaultPopulateParams}.\n * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.\n */\nexport function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams {\n  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;\n\n  const map = readDemoVaultTree(excludedNames === undefined ? { demoVaultPath } : { demoVaultPath, excludedNames });\n\n  for (const configFile of obsidianConfigFiles) {\n    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);\n    if (existsSync(configPath)) {\n      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);\n    }\n  }\n\n  for (const plugin of injectPlugins) {\n    seedPlugin(demoVaultPath, plugin, map);\n  }\n\n  return map;\n}\n\n/**\n * Seeds one injected plugin's binaries (and optional `data.json`) into the populate map.\n *\n * @param demoVaultPath - The demo vault root, used to resolve the default source directory.\n * @param plugin - The plugin to seed.\n * @param map - The populate map to write into.\n */\nfunction seedPlugin(demoVaultPath: string, plugin: InjectPluginParams, map: PopulateFilesParams): void {\n  const { data, pluginId } = plugin;\n  const sourceDir = plugin.sourceDir ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = existsSync(sourceDir)\n    ? readdirSync(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name)\n    : [];\n\n  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {\n    if (!fileNames.includes(requiredFile)) {\n      throw new Error(\n        `Community plugin \"${pluginId}\" is not installed in the demo vault (${join(sourceDir, requiredFile)} missing). `\n          + 'Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.'\n      );\n    }\n  }\n\n  for (const fileName of fileNames) {\n    // `data.json` is regenerated from `data` below (when provided); skip the on-disk copy to avoid seeding it twice.\n    if (fileName === DATA_JSON && data !== undefined) {\n      continue;\n    }\n    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDir, fileName));\n  }\n\n  if (data !== undefined) {\n    const dataJson: string = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));\n    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}\\n`;\n  }\n}\n"],
  "mappings": "AAaA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AAIrB,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAElC,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,YAAY;AAClB,MAAM,gBAAgB;AACtB,MAAM,UAAU;AAChB,MAAM,mBAAmB;AAEzB,MAAM,gCAAgC,CAAC,YAAY,mBAAmB,mBAAmB;AAkElF,SAAS,uBAAuB,QAA2D;AAChG,QAAM,EAAE,eAAe,eAAe,gBAAgB,CAAC,GAAG,sBAAsB,8BAA8B,IAAI;AAElH,QAAM,MAAM,kBAAkB,kBAAkB,SAAY,EAAE,cAAc,IAAI,EAAE,eAAe,cAAc,CAAC;AAEhH,aAAW,cAAc,qBAAqB;AAC5C,UAAM,aAAa,KAAK,eAAe,qBAAqB,UAAU;AACtE,QAAI,WAAW,UAAU,GAAG;AAC1B,UAAI,GAAG,mBAAmB,IAAI,UAAU,EAAE,IAAI,aAAa,UAAU;AAAA,IACvE;AAAA,EACF;AAEA,aAAW,UAAU,eAAe;AAClC,eAAW,eAAe,QAAQ,GAAG;AAAA,EACvC;AAEA,SAAO;AACT;AASA,SAAS,WAAW,eAAuB,QAA4B,KAAgC;AACrG,QAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,QAAM,YAAY,OAAO,aAAa,KAAK,eAAe,qBAAqB,aAAa,QAAQ;AACpG,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,YAAY,WAAW,SAAS,IAClC,YAAY,WAAW,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IAC3G,CAAC;AAEL,aAAW,gBAAgB,CAAC,SAAS,aAAa,GAAG;AACnD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,yCAAyC,KAAK,WAAW,YAAY,CAAC;AAAA,MAErG;AAAA,IACF;AAAA,EACF;AAEA,aAAW,YAAY,WAAW;AAEhC,QAAI,aAAa,aAAa,SAAS,QAAW;AAChD;AAAA,IACF;AACA,QAAI,GAAG,YAAY,IAAI,QAAQ,EAAE,IAAI,aAAa,KAAK,WAAW,QAAQ,CAAC;AAAA,EAC7E;AAEA,MAAI,SAAS,QAAW;AACtB,UAAM,WAAmB,kBAAkB,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACvF,QAAI,GAAG,YAAY,IAAI,SAAS,EAAE,IAAI,GAAG,QAAQ;AAAA;AAAA,EACnD;AACF;",
  "names": []
}


package/dist/lib/esm/demo-vault-tree.d.mts

@@ -0,0 +1,34 @@
+/**
+ * @file
+ *
+ * Reads a plugin's in-repo `demo-vault/` tree into a populate map so a Vitest/Jest global setup can
+ * seed it into the temp vault BEFORE Obsidian opens it. Seeding pre-launch lets Obsidian's startup scan
+ * index every note in one pass, avoiding the file-watcher race that silently drops events under a bulk
+ * post-launch {@link TempVault.populate}.
+ */
+import type { PopulateFilesParams } from './temp-vault.mjs';
+/**
+ * Parameters for {@link readDemoVaultTree}.
+ */
+export interface ReadDemoVaultTreeParams {
+    /**
+     * Absolute path to the demo vault directory to read.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * Names (of files or directories, matched at any depth) to skip. Defaults to `.git` and `.obsidian`:
+     * the harness provisions `.obsidian/plugins/<id>` itself, so the vault's own `.obsidian` must not be
+     * copied over it.
+     *
+     * @default `['.git', '.obsidian']`
+     */
+    readonly excludedNames?: Iterable<string>;
+}
+/**
+ * Reads a demo vault directory tree recursively into a {@link PopulateFilesParams} map (vault-relative
+ * POSIX path to file bytes), skipping {@link ReadDemoVaultTreeParams.excludedNames}.
+ *
+ * @param params - The {@link ReadDemoVaultTreeParams}.
+ * @returns The populate map, ready to hand to {@link TempVault.populate} or a global setup's `populate`.
+ */
+export declare function readDemoVaultTree(params: ReadDemoVaultTreeParams): PopulateFilesParams;

package/dist/lib/esm/demo-vault-tree.mjs

@@ -0,0 +1,35 @@
+import {
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import {
+  join,
+  relative,
+  sep
+} from "node:path";
+const DEFAULT_EXCLUDED_NAMES = [".git", ".obsidian"];
+function readDemoVaultTree(params) {
+  const { demoVaultPath } = params;
+  const excludedNames = new Set(params.excludedNames ?? DEFAULT_EXCLUDED_NAMES);
+  const map = {};
+  collect(demoVaultPath, demoVaultPath, excludedNames, map);
+  return map;
+}
+function collect(root, dir, excludedNames, map) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (excludedNames.has(entry.name)) {
+      continue;
+    }
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collect(root, absolutePath, excludedNames, map);
+      continue;
+    }
+    const relativePath = relative(root, absolutePath).split(sep).join("/");
+    map[relativePath] = readFileSync(absolutePath);
+  }
+}
+export {
+  readDemoVaultTree
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/enable-plugin.d.mts

@@ -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/esm/enable-plugin.mjs

@@ -2,6 +2,9 @@ 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) {
@@ -15,22 +18,69 @@ 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.`;
+}
 export {
-  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.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": []
}


package/dist/lib/esm/global-setup-core.d.mts

@@ -13,6 +13,25 @@ import { TempVault } from './temp-vault.mjs';
  * 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.