obsidian-integration-testing 10.4.0 → 12.0.0

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

@@ -0,0 +1,127 @@
+import {
+  mkdirSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import {
+  buildPluginAssetUrl,
+  COMMUNITY_PLUGINS_REGISTRY_URL,
+  isValidRepoReference,
+  OPTIONAL_PLUGIN_ASSET_NAMES,
+  REQUIRED_PLUGIN_ASSET_NAMES,
+  selectPluginRepo
+} from "./community-plugin-registry.mjs";
+import {
+  buildDemoVaultPopulate,
+  resolveInjectedPluginSourceDirectory,
+  resolveMissingInjectedPlugins
+} from "./demo-vault-populate.mjs";
+import { log } from "./log.mjs";
+const DOWNLOAD_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+const HTTP_NOT_FOUND = 404;
+let registryPromise;
+async function bootstrapDemoVaultPlugins(params) {
+  const { demoVaultPath, injectPlugins, shouldForce = false } = params;
+  const bootstrappable = injectPlugins.filter((plugin) => plugin.sourceDirectory === void 0);
+  const targets = shouldForce ? bootstrappable : resolveMissingInjectedPlugins({ demoVaultPath, injectPlugins });
+  const targetPluginIds = new Set(targets.map((plugin) => plugin.pluginId));
+  const installed = [];
+  for (const plugin of targets) {
+    installed.push(await installPlugin(demoVaultPath, plugin));
+  }
+  return {
+    installed,
+    skippedPluginIds: injectPlugins.map((plugin) => plugin.pluginId).filter((pluginId) => !targetPluginIds.has(pluginId))
+  };
+}
+async function buildDemoVaultPopulateAsync(params) {
+  if (params.injectPlugins !== void 0) {
+    await bootstrapDemoVaultPlugins({ demoVaultPath: params.demoVaultPath, injectPlugins: params.injectPlugins });
+  }
+  return buildDemoVaultPopulate(params);
+}
+function buildGitHubHeaders() {
+  const headers = new Headers({ "User-Agent": DOWNLOAD_USER_AGENT });
+  const token = process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"];
+  if (token) {
+    headers.set("Authorization", `Bearer ${token}`);
+  }
+  return headers;
+}
+async function downloadAsset(url, isRequired) {
+  const response = await fetch(url, { headers: buildGitHubHeaders() });
+  if (!response.ok) {
+    if (!isRequired && response.status === HTTP_NOT_FOUND) {
+      return void 0;
+    }
+    throw new Error(`Failed to download ${url}: HTTP ${String(response.status)} ${response.statusText}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+async function fetchCommunityPluginRegistry() {
+  registryPromise ??= (async () => {
+    log(`[demo-vault-bootstrap] Fetching Obsidian's community plugin registry from ${COMMUNITY_PLUGINS_REGISTRY_URL}...`);
+    const response = await fetch(COMMUNITY_PLUGINS_REGISTRY_URL, { headers: buildGitHubHeaders() });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch Obsidian's community plugin registry (${COMMUNITY_PLUGINS_REGISTRY_URL}): HTTP ${String(response.status)} ${response.statusText}. Pass an explicit \`repo\` on the injected plugin to skip the registry lookup.`
+      );
+    }
+    return await response.json();
+  })();
+  try {
+    return await registryPromise;
+  } catch (error) {
+    registryPromise = void 0;
+    throw error;
+  }
+}
+async function installPlugin(demoVaultPath, plugin) {
+  const { pluginId, version } = plugin;
+  const repo = await resolvePluginRepo(plugin);
+  const targetDirectory = resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin });
+  log(`[demo-vault-bootstrap] Installing "${pluginId}" from ${repo}@${version ?? "latest"} into ${targetDirectory}...`);
+  const downloads = await Promise.all([
+    ...REQUIRED_PLUGIN_ASSET_NAMES.map(async (assetName) => ({
+      assetName,
+      content: await downloadAsset(buildPluginAssetUrl({ assetName, repo, version }), true)
+    })),
+    ...OPTIONAL_PLUGIN_ASSET_NAMES.map(async (assetName) => ({
+      assetName,
+      content: await downloadAsset(buildPluginAssetUrl({ assetName, repo, version }), false)
+    }))
+  ]);
+  mkdirSync(targetDirectory, { recursive: true });
+  const assetNames = [];
+  for (const { assetName, content } of downloads) {
+    if (content === void 0) {
+      continue;
+    }
+    writeFileSync(join(targetDirectory, assetName), content);
+    assetNames.push(assetName);
+  }
+  log(`[demo-vault-bootstrap] Installed "${pluginId}": ${assetNames.join(", ")}.`);
+  return { assetNames, pluginId, repo, version };
+}
+async function resolvePluginRepo(plugin) {
+  const { pluginId, repo } = plugin;
+  if (repo !== void 0) {
+    if (!isValidRepoReference(repo)) {
+      throw new Error(`Invalid \`repo\` for community plugin "${pluginId}": ${repo}. Expected an \`owner/name\` reference.`);
+    }
+    return repo;
+  }
+  const registryRepo = selectPluginRepo({ entries: await fetchCommunityPluginRegistry(), pluginId });
+  if (registryRepo === void 0) {
+    throw new Error(
+      `Community plugin "${pluginId}" is not listed in Obsidian's community plugin registry, so its GitHub repository cannot be resolved. Pass an explicit \`repo\` (\`owner/name\`) on the injected plugin.`
+    );
+  }
+  return registryRepo;
+}
+export {
+  bootstrapDemoVaultPlugins,
+  buildDemoVaultPopulateAsync
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-bootstrap.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Installs a demo vault's **injected community plugins** headlessly, by downloading\n * their published GitHub release assets straight into\n * `demo-vault/.obsidian/plugins/<id>/`.\n *\n * `buildDemoVaultPopulate` requires each injected plugin's `main.js` /\n * `manifest.json` to already be on disk, and throws when they are not. Until this\n * module existed the only documented remedy was a **GUI step** \u2014 open `demo-vault/`\n * in Obsidian once and let `demo-vault-helper` install the plugin at runtime.\n * `.obsidian/plugins/*` is gitignored in every fleet plugin repo, so that state\n * exists on exactly the one machine that did it and is invisible to a fresh clone,\n * a new machine, or CI. Since a plugin repo's release preflight runs its\n * integration tests, that made *cutting a release from a clean clone* impossible\n * without a human opening a GUI.\n *\n * Downloading the release assets is the exact headless equivalent: the resulting\n * folder is what Obsidian itself would have installed, so the shipped\n * `*-demo-vault-<version>.zip` stays the fleet-standard artifact.\n *\n * Two entry points, plus the `bootstrap-demo-vault` CLI subcommand:\n *\n * - {@link bootstrapDemoVaultPlugins} \u2014 install the missing ones, explicitly.\n * - {@link buildDemoVaultPopulateAsync} \u2014 do that and then build the populate map,\n *   so a global setup self-heals with no manual step at all.\n *\n * The sync `buildDemoVaultPopulate` deliberately keeps throwing: `fetch` has no\n * synchronous form, so auto-healing can only live on an async sibling. Its message\n * now names both remedies above instead of the GUI step.\n */\n\nimport {\n  mkdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { CommunityPluginRegistryEntry } from './community-plugin-registry.mjs';\nimport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams\n} from './demo-vault-populate.mjs';\nimport type { PopulateFilesParams } from './temporary-vault.mjs';\n\nimport {\n  buildPluginAssetUrl,\n  COMMUNITY_PLUGINS_REGISTRY_URL,\n  isValidRepoReference,\n  OPTIONAL_PLUGIN_ASSET_NAMES,\n  REQUIRED_PLUGIN_ASSET_NAMES,\n  selectPluginRepo\n} from './community-plugin-registry.mjs';\nimport {\n  buildDemoVaultPopulate,\n  resolveInjectedPluginSourceDirectory,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.mjs';\nimport { log } from './log.mjs';\n\n/**\n * Browser `User-Agent` for the asset downloads, matching `obsidian-installer.ts` \u2014\n * a plain Node fetch is rejected by some CDN edges.\n */\nconst DOWNLOAD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';\n\nconst HTTP_NOT_FOUND = 404;\n\n/**\n * The community plugin registry, fetched at most once per process. Every injected\n * plugin of every demo-vault project in a run resolves against the same table, and\n * it is a multi-megabyte document.\n */\nlet registryPromise: Promise<readonly CommunityPluginRegistryEntry[]> | undefined;\n\n/**\n * Parameters for {@link bootstrapDemoVaultPlugins}.\n */\nexport interface BootstrapDemoVaultPluginsParams {\n  /**\n  Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * The injected plugins to install \u2014 the same list passed to `buildDemoVaultPopulate`. Plugins whose\n   * binaries are already present are skipped (unless {@link BootstrapDemoVaultPluginsParams.shouldForce}),\n   * as are plugins carrying an explicit `sourceDirectory`.\n   */\n  readonly injectPlugins: readonly InjectPluginParams[];\n\n  /**\n   * Whether to re-download plugins that are already installed, replacing them with the current release.\n   * Defaults to `false` \u2014 the normal path installs only what is missing, so a warm checkout does no\n   * network I/O at all.\n   */\n  readonly shouldForce?: boolean | undefined;\n}\n\n/**\n * The outcome of a {@link bootstrapDemoVaultPlugins} run.\n */\nexport interface BootstrapDemoVaultPluginsResult {\n  /**\n  The plugins that were downloaded and written, in the order they were installed.\n   */\n  readonly installed: readonly InstalledPluginInfo[];\n\n  /**\n  The ids of plugins left untouched \u2014 already installed, or opted out via an explicit `sourceDirectory`.\n   */\n  readonly skippedPluginIds: readonly string[];\n}\n\n/**\n * One plugin installed by {@link bootstrapDemoVaultPlugins}.\n */\nexport interface InstalledPluginInfo {\n  /**\n  The asset file names actually written, e.g. `['main.js', 'manifest.json', 'styles.css']`.\n   */\n  readonly assetNames: readonly string[];\n\n  /**\n  The plugin's id.\n   */\n  readonly pluginId: string;\n\n  /**\n  The GitHub repository the assets came from, as `owner/name`.\n   */\n  readonly repo: string;\n\n  /**\n  The release tag downloaded from, or `undefined` when the repository's latest release was used.\n   */\n  readonly version: string | undefined;\n}\n\n/**\n * Installs every injected community plugin whose built files are missing from the demo vault, by\n * downloading its published release assets into `demo-vault/.obsidian/plugins/<id>/`.\n *\n * Each plugin's repository comes from its {@link InjectPluginParams.repo} when given, otherwise from\n * Obsidian's own community plugin registry \u2014 the same `id` \u2192 `repo` table the in-app community browser\n * installs from, so no plugin-specific mapping is hardcoded.\n *\n * @param params - The {@link BootstrapDemoVaultPluginsParams}.\n * @returns What was installed and what was skipped.\n * @throws Error if a plugin's repository cannot be resolved, or a required asset cannot be downloaded.\n */\nexport async function bootstrapDemoVaultPlugins(params: BootstrapDemoVaultPluginsParams): Promise<BootstrapDemoVaultPluginsResult> {\n  const { demoVaultPath, injectPlugins, shouldForce = false } = params;\n\n  const bootstrappable = injectPlugins.filter((plugin) => plugin.sourceDirectory === undefined);\n  const targets = shouldForce ? bootstrappable : resolveMissingInjectedPlugins({ demoVaultPath, injectPlugins });\n  const targetPluginIds = new Set(targets.map((plugin) => plugin.pluginId));\n\n  const installed: InstalledPluginInfo[] = [];\n  for (const plugin of targets) {\n    // Sequential on purpose: the installs share one memoised registry fetch.\n    // Parallelism would buy nothing but interleaved logs for the handful of plugins a demo vault injects.\n    installed.push(await installPlugin(demoVaultPath, plugin));\n  }\n\n  return {\n    installed,\n    skippedPluginIds: injectPlugins.map((plugin) => plugin.pluginId).filter((pluginId) => !targetPluginIds.has(pluginId))\n  };\n}\n\n/**\n * The self-healing counterpart of `buildDemoVaultPopulate`: installs any injected community plugin whose\n * binaries are missing (see {@link bootstrapDemoVaultPlugins}), then builds the populate map exactly as the\n * synchronous builder does.\n *\n * Use this from a global setup's `populate` thunk \u2014 both the Vitest and Jest adapters accept a thunk\n * returning a promise \u2014 so a fresh clone, a new machine, or CI needs no manual install step.\n *\n * @param params - The same `BuildDemoVaultPopulateParams` the synchronous builder takes.\n * @returns The populate map, ready to hand to a global setup's `populate` or `TemporaryVault.populate`.\n */\nexport async function buildDemoVaultPopulateAsync(params: BuildDemoVaultPopulateParams): Promise<PopulateFilesParams> {\n  if (params.injectPlugins !== undefined) {\n    await bootstrapDemoVaultPlugins({ demoVaultPath: params.demoVaultPath, injectPlugins: params.injectPlugins });\n  }\n\n  return buildDemoVaultPopulate(params);\n}\n\n/* v8 ignore start -- Network download glue, covered by integration tests, not unit tests. */\n\n/**\n * Builds the request headers for a GitHub download, sending a `GITHUB_TOKEN` / `GH_TOKEN` bearer when one\n * is in the environment \u2014 without it the anonymous quota returns HTTP 403 on shared CI runner IPs.\n *\n * @returns The headers to send.\n */\nfunction buildGitHubHeaders(): Headers {\n  const headers = new Headers({ 'User-Agent': DOWNLOAD_USER_AGENT });\n  const token = process.env['GITHUB_TOKEN'] ?? process.env['GH_TOKEN'];\n  if (token) {\n    headers.set('Authorization', `Bearer ${token}`);\n  }\n  return headers;\n}\n\n/**\n * Downloads one release asset.\n *\n * @param url - The asset's download URL.\n * @param isRequired - Whether a missing asset (HTTP 404) is an error rather than an absent optional file.\n * @returns The asset's bytes, or `undefined` when an optional asset is not published.\n * @throws Error if the download fails and the asset is required.\n */\nasync function downloadAsset(url: string, isRequired: boolean): Promise<Buffer | undefined> {\n  const response = await fetch(url, { headers: buildGitHubHeaders() });\n  if (!response.ok) {\n    if (!isRequired && response.status === HTTP_NOT_FOUND) {\n      return undefined;\n    }\n    throw new Error(`Failed to download ${url}: HTTP ${String(response.status)} ${response.statusText}`);\n  }\n  return Buffer.from(await response.arrayBuffer());\n}\n\n/**\n * Fetches Obsidian's community plugin registry, memoised for the lifetime of the process.\n *\n * @returns The registry rows.\n * @throws Error if the registry cannot be fetched or parsed.\n */\nasync function fetchCommunityPluginRegistry(): Promise<readonly CommunityPluginRegistryEntry[]> {\n  registryPromise ??= (async (): Promise<readonly CommunityPluginRegistryEntry[]> => {\n    log(`[demo-vault-bootstrap] Fetching Obsidian's community plugin registry from ${COMMUNITY_PLUGINS_REGISTRY_URL}...`);\n    const response = await fetch(COMMUNITY_PLUGINS_REGISTRY_URL, { headers: buildGitHubHeaders() });\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch Obsidian's community plugin registry (${COMMUNITY_PLUGINS_REGISTRY_URL}): `\n          + `HTTP ${String(response.status)} ${response.statusText}. `\n          + 'Pass an explicit `repo` on the injected plugin to skip the registry lookup.'\n      );\n    }\n    return await response.json() as readonly CommunityPluginRegistryEntry[];\n  })();\n\n  try {\n    return await registryPromise;\n  } catch (error: unknown) {\n    // Do not memoise a failure: a transient network error must not poison every later lookup.\n    registryPromise = undefined;\n    throw error;\n  }\n}\n\n/**\n * Downloads one plugin's release assets and writes them into the demo vault.\n *\n * @param demoVaultPath - The demo vault root.\n * @param plugin - The plugin to install.\n * @returns What was installed.\n * @throws Error if the repository cannot be resolved or a required asset cannot be downloaded.\n */\nasync function installPlugin(demoVaultPath: string, plugin: InjectPluginParams): Promise<InstalledPluginInfo> {\n  const { pluginId, version } = plugin;\n  const repo = await resolvePluginRepo(plugin);\n  const targetDirectory = resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin });\n\n  log(`[demo-vault-bootstrap] Installing \"${pluginId}\" from ${repo}@${version ?? 'latest'} into ${targetDirectory}...`);\n\n  const downloads = await Promise.all([\n    ...REQUIRED_PLUGIN_ASSET_NAMES.map(async (assetName) => ({\n      assetName,\n      content: await downloadAsset(buildPluginAssetUrl({ assetName, repo, version }), true)\n    })),\n    ...OPTIONAL_PLUGIN_ASSET_NAMES.map(async (assetName) => ({\n      assetName,\n      content: await downloadAsset(buildPluginAssetUrl({ assetName, repo, version }), false)\n    }))\n  ]);\n\n  mkdirSync(targetDirectory, { recursive: true });\n\n  const assetNames: string[] = [];\n  for (const { assetName, content } of downloads) {\n    if (content === undefined) {\n      continue;\n    }\n    writeFileSync(join(targetDirectory, assetName), content);\n    assetNames.push(assetName);\n  }\n\n  log(`[demo-vault-bootstrap] Installed \"${pluginId}\": ${assetNames.join(', ')}.`);\n\n  return { assetNames, pluginId, repo, version };\n}\n\n/**\n * Resolves the GitHub repository publishing a plugin \u2014 the explicit override when given, otherwise\n * Obsidian's community plugin registry.\n *\n * @param plugin - The plugin to resolve.\n * @returns The `owner/name` repository reference.\n * @throws Error if an explicit override is malformed, or the id is not a registered community plugin.\n */\nasync function resolvePluginRepo(plugin: InjectPluginParams): Promise<string> {\n  const { pluginId, repo } = plugin;\n\n  if (repo !== undefined) {\n    if (!isValidRepoReference(repo)) {\n      throw new Error(`Invalid \\`repo\\` for community plugin \"${pluginId}\": ${repo}. Expected an \\`owner/name\\` reference.`);\n    }\n    return repo;\n  }\n\n  const registryRepo = selectPluginRepo({ entries: await fetchCommunityPluginRegistry(), pluginId });\n  if (registryRepo === undefined) {\n    throw new Error(\n      `Community plugin \"${pluginId}\" is not listed in Obsidian's community plugin registry, so its GitHub `\n        + 'repository cannot be resolved. Pass an explicit `repo` (`owner/name`) on the injected plugin.'\n    );\n  }\n\n  return registryRepo;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -9,6 +9,12 @@
  * 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.
+ *
+ * Stays **synchronous**, so an injected plugin whose binaries are absent is a throw rather than a download.
+ * `demo-vault-bootstrap.ts` owns the headless install the throw's message points at — including
+ * `buildDemoVaultPopulateAsync`, the self-healing sibling of {@link buildDemoVaultPopulate}. The
+ * missing-plugin detection ({@link resolveMissingInjectedPlugins}) lives here and is shared with it, so the
+ * two paths cannot disagree about what "not installed" means.
  */
 import type { PopulateFilesParams } from './temporary-vault.mjs';
 /**
@@ -53,13 +59,56 @@ export interface InjectPluginParams {
      * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).
      */
     readonly pluginId: string;
+    /**
+     * The GitHub repository (`owner/name`) publishing this plugin, consulted **only** by the headless
+     * bootstrap (`bootstrapDemoVaultPlugins` / `buildDemoVaultPopulateAsync` / the
+     * `bootstrap-demo-vault` CLI) when the binaries are missing from the demo vault. Supplying it skips
+     * the lookup in Obsidian's community plugin registry, which is also the way to bootstrap a plugin
+     * that is not listed there at all. Never used when the files are already on disk.
+     */
+    readonly repo?: string | undefined;
     /**
      * 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.
      *
+     * Setting this also opts the plugin **out** of the headless bootstrap: an explicit source directory
+     * names a local build output, not somewhere to download a published release into.
+     *
      * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`
      */
     readonly sourceDirectory?: string;
+    /**
+     * The release tag the headless bootstrap downloads from, pinning the installed version. Omit for the
+     * repository's latest release — what the in-app community browser installs. Like
+     * {@link InjectPluginParams.repo}, consulted only while bootstrapping missing binaries.
+     */
+    readonly version?: string | undefined;
+}
+/**
+ * Parameters for {@link resolveInjectedPluginSourceDirectory}.
+ */
+export interface ResolveInjectedPluginSourceDirectoryParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+    The injected plugin whose source directory to resolve.
+     */
+    readonly plugin: InjectPluginParams;
+}
+/**
+ * Parameters for {@link resolveMissingInjectedPlugins}.
+ */
+export interface ResolveMissingInjectedPluginsParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+    The injected plugins to check.
+     */
+    readonly injectPlugins: readonly InjectPluginParams[];
 }
 /**
  * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config
@@ -69,3 +118,24 @@ export interface InjectPluginParams {
  * @returns The populate map, ready to hand to a global setup's `populate` or {@link TemporaryVault.populate}.
  */
 export declare function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams;
+/**
+ * Resolves the directory an injected plugin's built files are read from.
+ *
+ * @param params - The {@link ResolveInjectedPluginSourceDirectoryParams}.
+ * @returns The explicit {@link InjectPluginParams.sourceDirectory} when set, otherwise the plugin's folder
+ *   inside the demo vault.
+ */
+export declare function resolveInjectedPluginSourceDirectory(params: ResolveInjectedPluginSourceDirectoryParams): string;
+/**
+ * Selects the injected plugins whose binaries are missing from the demo vault and can therefore be
+ * installed headlessly — the exact set {@link buildDemoVaultPopulate} would otherwise throw on.
+ *
+ * Plugins carrying an explicit {@link InjectPluginParams.sourceDirectory} are excluded: that names a local
+ * build output, not somewhere to download a published release into.
+ *
+ * Shared with the bootstrap so "missing" has one definition rather than two that can drift apart.
+ *
+ * @param params - The {@link ResolveMissingInjectedPluginsParams}.
+ * @returns The plugins to bootstrap, in the order given.
+ */
+export declare function resolveMissingInjectedPlugins(params: ResolveMissingInjectedPluginsParams): InjectPluginParams[];

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

@@ -4,13 +4,12 @@ import {
   readFileSync
 } from "node:fs";
 import { join } from "node:path";
+import { REQUIRED_PLUGIN_ASSET_NAMES } from "./community-plugin-registry.mjs";
 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) {
@@ -27,15 +26,39 @@ function buildDemoVaultPopulate(params) {
   }
   return map;
 }
+function resolveInjectedPluginSourceDirectory(params) {
+  const { demoVaultPath, plugin } = params;
+  return plugin.sourceDirectory ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, plugin.pluginId);
+}
+function resolveMissingInjectedPlugins(params) {
+  const { demoVaultPath } = params;
+  return params.injectPlugins.filter((plugin) => {
+    if (plugin.sourceDirectory !== void 0) {
+      return false;
+    }
+    const fileNames = readPluginFileNames(resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin }));
+    return REQUIRED_PLUGIN_ASSET_NAMES.some((assetName) => !fileNames.includes(assetName));
+  });
+}
+function buildMissingPluginRemedy(demoVaultPath, plugin) {
+  if (plugin.sourceDirectory !== void 0) {
+    return "It was read from an explicit `sourceDirectory`, which opts it out of the headless bootstrap \u2014 build it into that directory, or drop `sourceDirectory` to install it from its published release.";
+  }
+  return `Install it headlessly with \`npx obsidian-integration-testing bootstrap-demo-vault --demo-vault "${demoVaultPath}"\`, or switch this setup to \`buildDemoVaultPopulateAsync\`, which installs missing plugins itself. Opening demo-vault/ in Obsidian once so demo-vault-helper installs it also works.`;
+}
+function readPluginFileNames(sourceDirectory) {
+  return existsSync(sourceDirectory) ? readdirSync(sourceDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
+}
 function seedPlugin(demoVaultPath, plugin, map) {
   const { data, pluginId } = plugin;
-  const sourceDirectory = plugin.sourceDirectory ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  const sourceDirectory = resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin });
   const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;
-  const fileNames = existsSync(sourceDirectory) ? readdirSync(sourceDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
-  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {
+  const fileNames = readPluginFileNames(sourceDirectory);
+  for (const requiredFile of REQUIRED_PLUGIN_ASSET_NAMES) {
     if (!fileNames.includes(requiredFile)) {
+      const remedy = buildMissingPluginRemedy(demoVaultPath, plugin);
       throw new Error(
-        `Community plugin "${pluginId}" is not installed in the demo vault (${join(sourceDirectory, requiredFile)} missing). Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.`
+        `Community plugin "${pluginId}" is not installed in the demo vault (${join(sourceDirectory, requiredFile)} missing). ${remedy}`
       );
     }
   }
@@ -52,6 +75,8 @@ function seedPlugin(demoVaultPath, plugin, map) {
   }
 }
 export {
-  buildDemoVaultPopulate
+  buildDemoVaultPopulate,
+  resolveInjectedPluginSourceDirectory,
+  resolveMissingInjectedPlugins
 };
-//# 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 './temporary-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.sourceDirectory}.\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\n  readonly sourceDirectory?: 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 TemporaryVault.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 sourceDirectory = plugin.sourceDirectory ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = existsSync(sourceDirectory)\n    ? readdirSync(sourceDirectory, { 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(sourceDirectory, 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(sourceDirectory, 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;AAmElF,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,kBAAkB,OAAO,mBAAmB,KAAK,eAAe,qBAAqB,aAAa,QAAQ;AAChH,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,YAAY,WAAW,eAAe,IACxC,YAAY,iBAAiB,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IACjH,CAAC;AAEL,aAAW,gBAAgB,CAAC,SAAS,aAAa,GAAG;AACnD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,yCAAyC,KAAK,iBAAiB,YAAY,CAAC;AAAA,MAE3G;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,iBAAiB,QAAQ,CAAC;AAAA,EACnF;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": []
}

+//# 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 * Stays **synchronous**, so an injected plugin whose binaries are absent is a throw rather than a download.\n * `demo-vault-bootstrap.ts` owns the headless install the throw's message points at \u2014 including\n * `buildDemoVaultPopulateAsync`, the self-healing sibling of {@link buildDemoVaultPopulate}. The\n * missing-plugin detection ({@link resolveMissingInjectedPlugins}) lives here and is shared with it, so the\n * two paths cannot disagree about what \"not installed\" means.\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\n\nimport type { PopulateFilesParams } from './temporary-vault.mjs';\n\nimport { REQUIRED_PLUGIN_ASSET_NAMES } from './community-plugin-registry.mjs';\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 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.sourceDirectory}.\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   * The GitHub repository (`owner/name`) publishing this plugin, consulted **only** by the headless\n   * bootstrap (`bootstrapDemoVaultPlugins` / `buildDemoVaultPopulateAsync` / the\n   * `bootstrap-demo-vault` CLI) when the binaries are missing from the demo vault. Supplying it skips\n   * the lookup in Obsidian's community plugin registry, which is also the way to bootstrap a plugin\n   * that is not listed there at all. Never used when the files are already on disk.\n   */\n  readonly repo?: string | undefined;\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   * Setting this also opts the plugin **out** of the headless bootstrap: an explicit source directory\n   * names a local build output, not somewhere to download a published release into.\n   *\n   * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`\n   */\n\n  readonly sourceDirectory?: string;\n\n  /**\n   * The release tag the headless bootstrap downloads from, pinning the installed version. Omit for the\n   * repository's latest release \u2014 what the in-app community browser installs. Like\n   * {@link InjectPluginParams.repo}, consulted only while bootstrapping missing binaries.\n   */\n  readonly version?: string | undefined;\n}\n\n/**\n * Parameters for {@link resolveInjectedPluginSourceDirectory}.\n */\nexport interface ResolveInjectedPluginSourceDirectoryParams {\n  /**\n  Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n  The injected plugin whose source directory to resolve.\n   */\n  readonly plugin: InjectPluginParams;\n}\n\n/**\n * Parameters for {@link resolveMissingInjectedPlugins}.\n */\nexport interface ResolveMissingInjectedPluginsParams {\n  /**\n  Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n  The injected plugins to check.\n   */\n  readonly injectPlugins: readonly InjectPluginParams[];\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 TemporaryVault.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 * Resolves the directory an injected plugin's built files are read from.\n *\n * @param params - The {@link ResolveInjectedPluginSourceDirectoryParams}.\n * @returns The explicit {@link InjectPluginParams.sourceDirectory} when set, otherwise the plugin's folder\n *   inside the demo vault.\n */\nexport function resolveInjectedPluginSourceDirectory(params: ResolveInjectedPluginSourceDirectoryParams): string {\n  const { demoVaultPath, plugin } = params;\n  return plugin.sourceDirectory ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, plugin.pluginId);\n}\n\n/**\n * Selects the injected plugins whose binaries are missing from the demo vault and can therefore be\n * installed headlessly \u2014 the exact set {@link buildDemoVaultPopulate} would otherwise throw on.\n *\n * Plugins carrying an explicit {@link InjectPluginParams.sourceDirectory} are excluded: that names a local\n * build output, not somewhere to download a published release into.\n *\n * Shared with the bootstrap so \"missing\" has one definition rather than two that can drift apart.\n *\n * @param params - The {@link ResolveMissingInjectedPluginsParams}.\n * @returns The plugins to bootstrap, in the order given.\n */\nexport function resolveMissingInjectedPlugins(params: ResolveMissingInjectedPluginsParams): InjectPluginParams[] {\n  const { demoVaultPath } = params;\n  return params.injectPlugins.filter((plugin) => {\n    if (plugin.sourceDirectory !== undefined) {\n      return false;\n    }\n    const fileNames = readPluginFileNames(resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin }));\n    return REQUIRED_PLUGIN_ASSET_NAMES.some((assetName) => !fileNames.includes(assetName));\n  });\n}\n\n/**\n * Builds the \"how to fix this\" half of the missing-binaries error.\n *\n * The remedy differs by opt-out: a plugin read from the demo vault can be installed headlessly, while one\n * read from an explicit `sourceDirectory` names a local build output the bootstrap must never overwrite.\n *\n * @param demoVaultPath - The demo vault root, named in the CLI hint so the command is copy-pasteable.\n * @param plugin - The plugin whose binaries are missing.\n * @returns The remedy sentence(s).\n */\nfunction buildMissingPluginRemedy(demoVaultPath: string, plugin: InjectPluginParams): string {\n  if (plugin.sourceDirectory !== undefined) {\n    return 'It was read from an explicit `sourceDirectory`, which opts it out of the headless bootstrap \u2014 '\n      + 'build it into that directory, or drop `sourceDirectory` to install it from its published release.';\n  }\n\n  return `Install it headlessly with \\`npx obsidian-integration-testing bootstrap-demo-vault --demo-vault \"${demoVaultPath}\"\\`, `\n    + 'or switch this setup to `buildDemoVaultPopulateAsync`, which installs missing plugins itself. '\n    + 'Opening demo-vault/ in Obsidian once so demo-vault-helper installs it also works.';\n}\n\n/**\n * Lists the file names directly inside a plugin's source directory.\n *\n * @param sourceDirectory - The directory to list.\n * @returns The file names, or an empty array when the directory does not exist.\n */\nfunction readPluginFileNames(sourceDirectory: string): string[] {\n  return existsSync(sourceDirectory)\n    ? readdirSync(sourceDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name)\n    : [];\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 * @throws Error if the plugin's `main.js` / `manifest.json` are not on disk, naming the headless remedies.\n */\nfunction seedPlugin(demoVaultPath: string, plugin: InjectPluginParams, map: PopulateFilesParams): void {\n  const { data, pluginId } = plugin;\n  const sourceDirectory = resolveInjectedPluginSourceDirectory({ demoVaultPath, plugin });\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = readPluginFileNames(sourceDirectory);\n\n  for (const requiredFile of REQUIRED_PLUGIN_ASSET_NAMES) {\n    if (!fileNames.includes(requiredFile)) {\n      const remedy = buildMissingPluginRemedy(demoVaultPath, plugin);\n      throw new Error(\n        `Community plugin \"${pluginId}\" is not installed in the demo vault (${join(sourceDirectory, requiredFile)} missing). ${remedy}`\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(sourceDirectory, 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": "AAmBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AAIrB,SAAS,mCAAmC;AAC5C,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAElC,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,YAAY;AAClB,MAAM,mBAAmB;AAEzB,MAAM,gCAAgC,CAAC,YAAY,mBAAmB,mBAAmB;AAoHlF,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;AASO,SAAS,qCAAqC,QAA4D;AAC/G,QAAM,EAAE,eAAe,OAAO,IAAI;AAClC,SAAO,OAAO,mBAAmB,KAAK,eAAe,qBAAqB,aAAa,OAAO,QAAQ;AACxG;AAcO,SAAS,8BAA8B,QAAmE;AAC/G,QAAM,EAAE,cAAc,IAAI;AAC1B,SAAO,OAAO,cAAc,OAAO,CAAC,WAAW;AAC7C,QAAI,OAAO,oBAAoB,QAAW;AACxC,aAAO;AAAA,IACT;AACA,UAAM,YAAY,oBAAoB,qCAAqC,EAAE,eAAe,OAAO,CAAC,CAAC;AACrG,WAAO,4BAA4B,KAAK,CAAC,cAAc,CAAC,UAAU,SAAS,SAAS,CAAC;AAAA,EACvF,CAAC;AACH;AAYA,SAAS,yBAAyB,eAAuB,QAAoC;AAC3F,MAAI,OAAO,oBAAoB,QAAW;AACxC,WAAO;AAAA,EAET;AAEA,SAAO,oGAAoG,aAAa;AAG1H;AAQA,SAAS,oBAAoB,iBAAmC;AAC9D,SAAO,WAAW,eAAe,IAC7B,YAAY,iBAAiB,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IACjH,CAAC;AACP;AAUA,SAAS,WAAW,eAAuB,QAA4B,KAAgC;AACrG,QAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,QAAM,kBAAkB,qCAAqC,EAAE,eAAe,OAAO,CAAC;AACtF,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,YAAY,oBAAoB,eAAe;AAErD,aAAW,gBAAgB,6BAA6B;AACtD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,SAAS,yBAAyB,eAAe,MAAM;AAC7D,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,yCAAyC,KAAK,iBAAiB,YAAY,CAAC,cAAc,MAAM;AAAA,MAC/H;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,iBAAiB,QAAQ,CAAC;AAAA,EACnF;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/eval-in-obsidian.d.mts

@@ -71,8 +71,8 @@ export interface CommonArguments {
      *
      * Never empty: the harness pre-populates a **base** set of renderer-driving
      * helpers (trusted input — `typeIntoEditor` / `pressKey` / `moveMouse` /
-     * `clickMouse` / `hoverElement` / `unhoverElement` / `clickElement` — and
-     * `waitUntil`), and provider packages
+     * `clickMouse` / `hoverElement` / `unhoverElement` / `clickElement` — plus
+     * `waitUntil`, `createNote` and `openSettingsTab`), and provider packages
      * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe
      * library on top via {@link registerLibResolver}. A serialized closure reaches
      * every shared helper through `lib` — `lib.typeIntoEditor({ editor, text })`,
@@ -174,7 +174,8 @@ export interface HoverElementParams {
  */
 export interface Lib {
     /**
-     * Clicks the center of an element using **trusted** Electron pointer input.
+     * Clicks the center of an element using **trusted** pointer input — Electron's
+     * `sendInputEvent` on desktop, a CDP touch tap in the WebView on mobile.
      *
      * The element-relative counterpart of {@link Lib.clickMouse}, mirroring the
      * {@link Lib.moveMouse} / {@link Lib.hoverElement} split. Use
@@ -182,13 +183,15 @@ export interface Lib {
      * element's center — the markdown editor's margin, for instance, lies inside
      * `cm.scrollDOM` but outside `.cm-sizer`, so no element's center lands on it.
      *
-     * Synchronous: injecting the trusted click does no real awaiting, so the
-     * caller does not need to `await` it.
+     * **Must be awaited.** On mobile the injection is a round-trip to the host —
+     * the renderer cannot produce a trusted event itself — so a missing `await`
+     * would let the assertion run before the click landed.
      *
      * @param params - The element to click, the button to press and any modifiers
      *   to hold.
+     * @returns A {@link Promise} that resolves once the click has been injected.
      */
-    clickElement(this: void, params: ClickElementParams): void;
+    clickElement(this: void, params: ClickElementParams): Promise<void>;
     /**
      * Clicks at the given web-contents coordinates using **trusted** Electron
      * pointer input, so Chromium synthesizes a real `click` (or `contextmenu`,
@@ -210,13 +213,20 @@ export interface Lib {
      * A real context menu actually opens, so a suite driving a right click must
      * close it (or remove the leftover `.menu` element) before the next test.
      *
-     * Synchronous: injecting the trusted click does no real awaiting, so the
-     * caller does not need to `await` it.
+     * **On mobile** the button model does not survive the port: touch has no
+     * buttons, so `'left'` (the default) is a **tap**, `'right'` is the
+     * **long-press** that opens Obsidian Mobile's context menu, and `'middle'`
+     * throws — there is no gesture for it, and inventing one would be worse than
+     * saying so. The coordinates are CSS pixels in the WebView's own viewport,
+     * which is what CDP takes, so `devicePixelRatio` never enters the picture.
+     *
+     * **Must be awaited** — see {@link Lib.clickElement}.
      *
      * @param params - The web-contents DIP coordinates to click at, the button to
      *   press and any modifiers to hold.
+     * @returns A {@link Promise} that resolves once the click has been injected.
      */
-    clickMouse(this: void, params: ClickMouseParams): void;
+    clickMouse(this: void, params: ClickMouseParams): Promise<void>;
     /**
      * Creates a note and does not return until its content is verifiably on
      * disk, rewriting it if it is not.
@@ -258,6 +268,12 @@ export interface Lib {
      * shared-instance load. It targets the single shared window's **global**
      * pointer, so only one element is hovered at a time.
      *
+     * **Desktop only — it throws on mobile**, deliberately: touch input has no
+     * hover state, so there is nothing faithful to inject. A silent no-op would
+     * leave a test asserting against a hover that never happened, which is the
+     * exact false-confidence failure trusted input exists to prevent. Branch on
+     * `Platform.isDesktopApp`, or drive the element with {@link Lib.clickElement}.
+     *
      * @param params - The element to hover.
      * @returns A {@link Promise} that resolves once the element matches `:hover`.
      */
@@ -278,12 +294,45 @@ export interface Lib {
      * element-relative moves; use `moveMouse` directly when an element-relative
      * target does not fit (e.g. an element spanning the full viewport width).
      *
-     * Synchronous: injecting the trusted move does no real awaiting, so the caller
-     * does not need to `await` it.
+     * **Desktop only — it throws on mobile**, for the same reason as
+     * {@link Lib.hoverElement}: there is no touch pointer to move.
+     *
+     * **Must be awaited** — see {@link Lib.clickElement}.
      *
      * @param params - The web-contents DIP coordinates to move to.
+     * @returns A {@link Promise} that resolves once the move has been injected.
      */
-    moveMouse(this: void, params: MoveMouseParams): void;
+    moveMouse(this: void, params: MoveMouseParams): Promise<void>;
+    /**
+     * Opens Obsidian's settings modal on a given tab, and does not return until
+     * that tab has actually rendered.
+     *
+     * **This exists because `app.setting.open()` on its own does not work from a
+     * test.** `app.setting.containerEl` is built at startup but is never in the
+     * document, and `open()` does not attach it — so the modal builds into a
+     * detached tree, `open()` returns without throwing, and a screenshot taken
+     * afterwards shows the untouched document. That is what made the settings tab
+     * look impossible to capture, and got recorded as such in two plugins.
+     *
+     * The fix is one step, and its **order is load-bearing**: the container is
+     * appended to `document.body` **before** `open()`. Attaching afterwards is too
+     * late — whatever the modal drew on open has already gone into the detached
+     * container, so it ends up on screen showing the wrong thing. That failure
+     * looks like success until the captured frame is examined, which is the trap
+     * this helper exists to remove.
+     *
+     * Re-attaching is idempotent, so a tab closed with `app.setting.close()` can
+     * simply be re-opened.
+     *
+     * @param params - The tab to open and how long to wait for it to render.
+     * @returns A {@link Promise} resolving to the names of the setting rows the
+     *   tab rendered — both the proof it rendered and what a caller asserts on. A
+     *   tab that legitimately renders no `.setting-item-name` rows (Hotkeys, say)
+     *   resolves to an empty array.
+     * @throws Error if no tab carries {@link OpenSettingsTabParams.tabId}, or if
+     *   the tab does not render within the timeout.
+     */
+    openSettingsTab(this: void, params: OpenSettingsTabParams): Promise<string[]>;
     /**
      * Presses a single key (optionally with modifiers) using **trusted** Electron
      * keyboard input, firing the full real key pipeline —
@@ -306,12 +355,19 @@ export interface Lib {
      * expected effect via {@link Lib.waitUntil}. It targets the single shared
      * window's **global** focus, so only the DOM-focused element receives the key.
      *
-     * Synchronous: injecting the trusted key press does no real awaiting, so the
-     * caller does not need to `await` it.
+     * **On mobile** the same sequence is injected through the WebView's debugger
+     * (`Input.dispatchKeyEvent`), which is equally trusted. Named keys (`'Enter'`,
+     * `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single
+     * printable characters are supported; any other multi-character name throws
+     * rather than pressing nothing.
+     *
+     * **Must be awaited** — see {@link Lib.clickElement}.
      *
      * @param params - The key to press and any modifiers to hold.
+     * @returns A {@link Promise} that resolves once the key press has been
+     *   injected.
      */
-    pressKey(this: void, params: PressKeyParams): void;
+    pressKey(this: void, params: PressKeyParams): Promise<void>;
     /**
      * Types text into a CodeMirror {@link Editor} using **trusted** Electron
      * keyboard input.
@@ -346,6 +402,9 @@ export interface Lib {
      * use {@link Lib.moveMouse} directly to move the pointer to a known empty
      * coordinate instead.
      *
+     * **Desktop only — it throws on mobile**, for the same reason as
+     * {@link Lib.hoverElement}.
+     *
      * @param params - The element to move the pointer away from.
      * @returns A {@link Promise} that resolves once the element no longer matches
      *   `:hover`.
@@ -393,6 +452,29 @@ export interface MoveMouseParams {
      */
     readonly y: number;
 }
+/**
+ * Parameters for {@link Lib.openSettingsTab}.
+ */
+export interface OpenSettingsTabParams {
+    /**
+     * The id of the settings tab to open — a plugin id for a plugin's own tab, or
+     * a core tab id (`'editor'`, `'hotkeys'`, …).
+     *
+     * Required, because opening the modal without naming a tab renders **nothing**
+     * on a harness-owned instance: the modal restores the last tab the profile
+     * used, and an isolated profile has never opened one, so `activeTab` stays
+     * `null` and no row is drawn. An unknown id is rejected immediately, listing
+     * the ids that do exist.
+     */
+    readonly tabId: string;
+    /**
+     * The maximum time to wait for the modal to open and for the requested tab to
+     * render its content.
+     *
+     * @default `5000`
+     */
+    readonly timeoutInMilliseconds?: number;
+}
 /**
  * Parameters for {@link CommonArguments.pressKey}.
  */