obsidian-integration-testing 9.0.0 → 9.1.1

package/README.md

@@ -500,6 +500,36 @@ Both files share the same `createSetup` instance (via the common module), so `te
 
 **Manual** — when wiring `TempVault` yourself (without a framework global setup), call `vault.populate()` before `vault.register()`, as shown in [Create a temporary vault](#create-a-temporary-vault).
 
+### Seed a plugin's `demo-vault/` and enable extra community plugins
+
+A plugin's committed `demo-vault/` often needs more than the plugin-under-test — e.g. **CodeScript Toolkit** (`fix-require-modules`) to run its `code-button` blocks, or the `demo-vault-helper` bootstrap. Two pieces make this a one-liner:
+
+- **`enableCommunityPlugins`** — a `createSetup` option listing community-plugin ids to enable **in addition to** the plugin-under-test, after it is enabled. Each id's built files must already be in the vault (seed them below). This replaces the hand-rolled `beforeAll` that turned off restricted mode and called `enablePlugin(...)` in every demo-vault test.
+- **`buildDemoVaultPopulate`** — reads the repo's `demo-vault/` tree, carries over selected `.obsidian/*` config (`app.json`, `appearance.json`, `core-plugins.json` by default), and seeds each injected plugin's binaries (+ optional `data.json`) — returning a `populate` map. It complements the release-time demo-vault archiving in `obsidian-dev-utils`.
+
+```ts
+// integration-global-setup.ts
+import { buildDemoVaultPopulate } from 'obsidian-integration-testing';
+import { createSetup } from 'obsidian-integration-testing/vitest-global-setup-plugin';
+import { getRootFolder } from 'obsidian-dev-utils/script-utils/root';
+import { join } from 'node:path';
+
+const CST_ID = 'fix-require-modules';
+
+export const { setup, teardown } = createSetup({
+  // Turn on the seeded extra plugins (the plugin-under-test is enabled automatically).
+  enableCommunityPlugins: [CST_ID],
+  populate: () =>
+    buildDemoVaultPopulate({
+      demoVaultPath: join(getRootFolder() ?? process.cwd(), 'demo-vault'),
+      // CST binaries come from the demo vault's local (gitignored) install; `data` writes its data.json.
+      injectPlugins: [{ pluginId: CST_ID, data: { modulesRoot: '_assets' } }]
+    })
+});
+```
+
+`buildDemoVaultPopulate` throws an actionable error if an injected plugin's `main.js`/`manifest.json` is missing from the demo vault — open `demo-vault/` in Obsidian once so `demo-vault-helper` installs it, then re-run. `enableCommunityPlugins` also composes with `installPlugin: false` (enable extras into an otherwise plugin-less vault).
+
 ### Non-plugin consumers
 
 If your project is **not** a plugin — a tool that only needs a registered, empty vault to `evalInObsidian` against (e.g. a typings crawler) — point `globalSetup` at the **`-no-plugin`** entry point instead of `-plugin`. It still launches one owned, off-screen Obsidian instance and publishes its endpoint to workers so each worker **attaches** to it, but skips reading `dist/manifest.json`, copying a plugin, writing `community-plugins.json`, and enabling a plugin. No wrapper module needed:

package/dist/lib/cjs/demo-vault-populate.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var demo_vault_populate_exports = {};
+__export(demo_vault_populate_exports, {
+  buildDemoVaultPopulate: () => buildDemoVaultPopulate
+});
+module.exports = __toCommonJS(demo_vault_populate_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_demo_vault_tree = require("./demo-vault-tree.cjs");
+var import_type_guards = require("./type-guards.cjs");
+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 = (0, import_demo_vault_tree.readDemoVaultTree)(excludedNames === void 0 ? { demoVaultPath } : { demoVaultPath, excludedNames });
+  for (const configFile of obsidianConfigFiles) {
+    const configPath = (0, import_node_path.join)(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);
+    if ((0, import_node_fs.existsSync)(configPath)) {
+      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = (0, import_node_fs.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 ?? (0, import_node_path.join)(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;
+  const fileNames = (0, import_node_fs.existsSync)(sourceDir) ? (0, import_node_fs.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 (${(0, import_node_path.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}`] = (0, import_node_fs.readFileSync)((0, import_node_path.join)(sourceDir, fileName));
+  }
+  if (data !== void 0) {
+    const dataJson = (0, import_type_guards.ensureNonNullable)(JSON.stringify(data, null, DATA_JSON_INDENT));
+    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}
+`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\n\nimport { readDemoVaultTree } from './demo-vault-tree.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\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;AAAA;AAAA;AAAA;AAaA,qBAIO;AACP,uBAAqB;AAIrB,6BAAkC;AAClC,yBAAkC;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,UAAM,0CAAkB,kBAAkB,SAAY,EAAE,cAAc,IAAI,EAAE,eAAe,cAAc,CAAC;AAEhH,aAAW,cAAc,qBAAqB;AAC5C,UAAM,iBAAa,uBAAK,eAAe,qBAAqB,UAAU;AACtE,YAAI,2BAAW,UAAU,GAAG;AAC1B,UAAI,GAAG,mBAAmB,IAAI,UAAU,EAAE,QAAI,6BAAa,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,iBAAa,uBAAK,eAAe,qBAAqB,aAAa,QAAQ;AACpG,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,gBAAY,2BAAW,SAAS,QAClC,4BAAY,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,6CAAyC,uBAAK,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,QAAI,iCAAa,uBAAK,WAAW,QAAQ,CAAC;AAAA,EAC7E;AAEA,MAAI,SAAS,QAAW;AACtB,UAAM,eAAmB,sCAAkB,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACvF,QAAI,GAAG,YAAY,IAAI,SAAS,EAAE,IAAI,GAAG,QAAQ;AAAA;AAAA,EACnD;AACF;",
  "names": []
}


package/dist/lib/cjs/demo-vault-populate.d.cts

@@ -0,0 +1,71 @@
+/**
+ * @file
+ *
+ * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into
+ * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two
+ * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)
+ * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).
+ *
+ * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,
+ * that turns them on. It intentionally does NOT write `community-plugins.json` — the harness owns that file
+ * (it lists the plugin-under-test), and enabling the extras persists them.
+ */
+import type { PopulateFilesParams } from './temp-vault.cjs';
+/**
+ * Parameters for {@link buildDemoVaultPopulate}.
+ */
+export interface BuildDemoVaultPopulateParams {
+    /**
+     * Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * Names (of files or directories, matched at any depth) to skip while reading the note tree — forwarded to
+     * {@link readDemoVaultTree}.
+     *
+     * @default `['.git', '.obsidian']`
+     */
+    readonly excludedNames?: Iterable<string>;
+    /**
+     * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn
+     * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.
+     */
+    readonly injectPlugins?: readonly InjectPluginParams[];
+    /**
+     * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole
+     * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must
+     * be re-added explicitly. Files that do not exist are skipped.
+     *
+     * @default `['app.json', 'appearance.json', 'core-plugins.json']`
+     */
+    readonly obsidianConfigFiles?: readonly string[];
+}
+/**
+ * A community plugin to seed into the demo vault alongside the note tree.
+ */
+export interface InjectPluginParams {
+    /**
+     * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever
+     * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.
+     */
+    readonly data?: unknown;
+    /**
+     * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).
+     */
+    readonly pluginId: string;
+    /**
+     * Directory to read the plugin's built files from. Every file directly inside it is copied into
+     * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.
+     *
+     * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`
+     */
+    readonly sourceDir?: string;
+}
+/**
+ * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config
+ * files, and every injected plugin's binaries (+ optional `data.json`).
+ *
+ * @param params - The {@link BuildDemoVaultPopulateParams}.
+ * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.
+ */
+export declare function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams;

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;