obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/esm/context-provider.mjs

@@ -1,11 +1,18 @@
+let setupErrorResolver;
 let transportOptionsResolver;
 let vaultPathResolver;
+function getSetupError() {
+  return setupErrorResolver?.();
+}
 function getTransportOptions() {
   return transportOptionsResolver?.();
 }
 function getVaultPath() {
   return vaultPathResolver?.();
 }
+function setSetupErrorResolver(callback) {
+  setupErrorResolver = callback;
+}
 function setTransportOptionsResolver(callback) {
   transportOptionsResolver = callback;
 }
@@ -13,9 +20,11 @@ function setVaultPathResolver(callback) {
   vaultPathResolver = callback;
 }
 export {
+  getSetupError,
   getTransportOptions,
   getVaultPath,
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,114 @@
+/**
+ * @file
+ *
+ * Installs a demo vault's **injected community plugins** headlessly, by downloading
+ * their published GitHub release assets straight into
+ * `demo-vault/.obsidian/plugins/<id>/`.
+ *
+ * `buildDemoVaultPopulate` requires each injected plugin's `main.js` /
+ * `manifest.json` to already be on disk, and throws when they are not. Until this
+ * module existed the only documented remedy was a **GUI step** — open `demo-vault/`
+ * in Obsidian once and let `demo-vault-helper` install the plugin at runtime.
+ * `.obsidian/plugins/*` is gitignored in a plugin repo, so that state
+ * exists on exactly the one machine that did it and is invisible to a fresh clone,
+ * a new machine, or CI. Since a plugin repo's release preflight runs its
+ * integration tests, that made *cutting a release from a clean clone* impossible
+ * without a human opening a GUI.
+ *
+ * Downloading the release assets is the exact headless equivalent: the resulting
+ * folder is what Obsidian itself would have installed, so the shipped
+ * `*-demo-vault.zip` — which unzips into a single `*-demo-vault-<version>` folder —
+ * stays the standard demo-vault artifact.
+ *
+ * Two entry points, plus the `bootstrap-demo-vault` CLI subcommand:
+ *
+ * - {@link bootstrapDemoVaultPlugins} — install the missing ones, explicitly.
+ * - {@link buildDemoVaultPopulateAsync} — do that and then build the populate map,
+ *   so a global setup self-heals with no manual step at all.
+ *
+ * The sync `buildDemoVaultPopulate` deliberately keeps throwing: `fetch` has no
+ * synchronous form, so auto-healing can only live on an async sibling. Its message
+ * now names both remedies above instead of the GUI step.
+ */
+import type { BuildDemoVaultPopulateParams, InjectPluginParams } from './demo-vault-populate.mjs';
+import type { PopulateFilesParams } from './temporary-vault.mjs';
+/**
+ * Parameters for {@link bootstrapDemoVaultPlugins}.
+ */
+export interface BootstrapDemoVaultPluginsParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * The injected plugins to install — the same list passed to `buildDemoVaultPopulate`. Plugins whose
+     * binaries are already present are skipped (unless {@link BootstrapDemoVaultPluginsParams.shouldForce}),
+     * as are plugins carrying an explicit `sourceDirectory`.
+     */
+    readonly injectPlugins: readonly InjectPluginParams[];
+    /**
+     * Whether to re-download plugins that are already installed, replacing them with the current release.
+     * Defaults to `false` — the normal path installs only what is missing, so a warm checkout does no
+     * network I/O at all.
+     */
+    readonly shouldForce?: boolean | undefined;
+}
+/**
+ * The outcome of a {@link bootstrapDemoVaultPlugins} run.
+ */
+export interface BootstrapDemoVaultPluginsResult {
+    /**
+    The plugins that were downloaded and written, in the order they were installed.
+     */
+    readonly installed: readonly InstalledPluginInfo[];
+    /**
+    The ids of plugins left untouched — already installed, or opted out via an explicit `sourceDirectory`.
+     */
+    readonly skippedPluginIds: readonly string[];
+}
+/**
+ * One plugin installed by {@link bootstrapDemoVaultPlugins}.
+ */
+export interface InstalledPluginInfo {
+    /**
+    The asset file names actually written, e.g. `['main.js', 'manifest.json', 'styles.css']`.
+     */
+    readonly assetNames: readonly string[];
+    /**
+    The plugin's id.
+     */
+    readonly pluginId: string;
+    /**
+    The GitHub repository the assets came from, as `owner/name`.
+     */
+    readonly repo: string;
+    /**
+    The release tag downloaded from, or `undefined` when the repository's latest release was used.
+     */
+    readonly version: string | undefined;
+}
+/**
+ * Installs every injected community plugin whose built files are missing from the demo vault, by
+ * downloading its published release assets into `demo-vault/.obsidian/plugins/<id>/`.
+ *
+ * Each plugin's repository comes from its {@link InjectPluginParams.repo} when given, otherwise from
+ * Obsidian's own community plugin registry — the same `id` → `repo` table the in-app community browser
+ * installs from, so no plugin-specific mapping is hardcoded.
+ *
+ * @param params - The {@link BootstrapDemoVaultPluginsParams}.
+ * @returns What was installed and what was skipped.
+ * @throws Error if a plugin's repository cannot be resolved, or a required asset cannot be downloaded.
+ */
+export declare function bootstrapDemoVaultPlugins(params: BootstrapDemoVaultPluginsParams): Promise<BootstrapDemoVaultPluginsResult>;
+/**
+ * The self-healing counterpart of `buildDemoVaultPopulate`: installs any injected community plugin whose
+ * binaries are missing (see {@link bootstrapDemoVaultPlugins}), then builds the populate map exactly as the
+ * synchronous builder does.
+ *
+ * Use this from a global setup's `populate` thunk — both the Vitest and Jest adapters accept a thunk
+ * returning a promise — so a fresh clone, a new machine, or CI needs no manual install step.
+ *
+ * @param params - The same `BuildDemoVaultPopulateParams` the synchronous builder takes.
+ * @returns The populate map, ready to hand to a global setup's `populate` or `TemporaryVault.populate`.
+ */
+export declare function buildDemoVaultPopulateAsync(params: BuildDemoVaultPopulateParams): Promise<PopulateFilesParams>;

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 a 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.zip` \u2014 which unzips into a single `*-demo-vault-<version>` folder \u2014\n * stays the standard demo-vault 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,13 @@ import {
   readFileSync
 } from "node:fs";
 import { join } from "node:path";
+import { REQUIRED_PLUGIN_ASSET_NAMES } from "./community-plugin-registry.mjs";
+import { DEFAULT_CONFIG_DIRECTORY } from "./config-directory.mjs";
 import { readDemoVaultTree } from "./demo-vault-tree.mjs";
 import { ensureNonNullable } from "./type-guards.mjs";
-const OBSIDIAN_CONFIG_DIR = ".obsidian";
+const OBSIDIAN_CONFIG_DIR = DEFAULT_CONFIG_DIRECTORY;
 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 +27,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 +76,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 { DEFAULT_CONFIG_DIRECTORY } from './config-directory.mjs';\nimport { readDemoVaultTree } from './demo-vault-tree.mjs';\nimport { ensureNonNullable } from './type-guards.mjs';\n\n/*\n * Both the folder the demo vault's own committed config sits in on disk, and the destination the map\n * names for it. The two coincide by construction: the source is a repo folder Obsidian created under its\n * default, and a `configDirectory` override on the run is applied to the destination keys later, by\n * `remapConfigDirectoryKeys` in `global-setup-core`, which is where the override is actually known.\n */\nconst OBSIDIAN_CONFIG_DIR = DEFAULT_CONFIG_DIRECTORY;\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,gCAAgC;AACzC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAQlC,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": []
}
