obsidian-integration-testing 11.0.0 → 12.0.0

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

@@ -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.cjs';
 /**
@@ -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/cjs/eval-in-obsidian.cjs

@@ -79,4 +79,4 @@ ${sanitizedDetail}`);
 0 && (module.exports = {
   evalInObsidian
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor,\n  Modifier,\n  TFile\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArguments,\n  ContextId\n} from './context-id.cjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { generateNamespaceCall } from './generate-function-call.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `callback` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `callback` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `callback` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Parameters for {@link CommonArguments.clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to press.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArguments.clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to press.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArguments {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The shared library bag injected into every callback \u2014 see {@link Lib}.\n   *\n   * Never empty: the harness pre-populates a **base** set of renderer-driving\n   * helpers (trusted input \u2014 `typeIntoEditor` / `pressKey` / `moveMouse` /\n   * `clickMouse` / `hoverElement` / `unhoverElement` / `clickElement` \u2014 plus\n   * `waitUntil`, `createNote` and `openSettingsTab`), and provider packages\n   * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe\n   * library on top via {@link registerLibResolver}. A serialized closure reaches\n   * every shared helper through `lib` \u2014 `lib.typeIntoEditor({ editor, text })`,\n   * `lib.getFileOrNull({ app, \u2026 })` \u2014 instead of importing or hand-rolling them.\n   */\n  lib: Lib;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link CommonArguments.createNote}.\n */\nexport interface CreateNoteParams {\n  /**\n   * The note's content. This exact string is what the created note is read back\n   * against, so it is the definition of a successful write.\n   */\n  readonly content: string;\n\n  /**\n   * The vault-relative path to create, extension included.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  callback(input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<Result>;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly input?: Input;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArguments.hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The shared library bag injected into every {@link evalInObsidian} callback as\n * {@link CommonArguments.lib}.\n *\n * Two layers compose into this one bag. The **base** \u2014 the harness-provided\n * renderer-driving helpers declared below (the trusted-input primitives and\n * {@link Lib.waitUntil}) \u2014 is always present. On top, provider packages register\n * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`\n * their whole renderer-safe library at runtime, and augment this **augmentable**\n * interface (the `i18next` `CustomTypeOptions` idiom) via\n * `declare module 'obsidian-integration-testing'` to type it. Multiple providers\n * compose: their exports merge at runtime and their augmentations merge in the\n * type system (`interface Lib extends \u2026`).\n *\n * @example\n * ```ts\n * declare module 'obsidian-integration-testing' {\n *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}\n * }\n * ```\n */\nexport interface Lib {\n  /**\n   * Clicks the center of an element using **trusted** Electron pointer input.\n   *\n   * The element-relative counterpart of {@link Lib.clickMouse}, mirroring the\n   * {@link Lib.moveMouse} / {@link Lib.hoverElement} split. Use\n   * {@link Lib.clickMouse} directly when the point to click is **not** the\n   * element's center \u2014 the markdown editor's margin, for instance, lies inside\n   * `cm.scrollDOM` but outside `.cm-sizer`, so no element's center lands on it.\n   *\n   * Synchronous: injecting the trusted click does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The element to click, the button to press and any modifiers\n   *   to hold.\n   */\n  clickElement(this: void, params: ClickElementParams): void;\n\n  /**\n   * Clicks at the given web-contents coordinates using **trusted** Electron\n   * pointer input, so Chromium synthesizes a real `click` (or `contextmenu`,\n   * for the right button) with `isTrusted === true`.\n   *\n   * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do:\n   * Obsidian and CodeMirror gate on `isTrusted`, so a dispatched event silently\n   * exercises nothing while the test still passes whatever weaker assertion it\n   * makes. Obsidian 1.13.7's markdown viewport (margin) menu, for example,\n   * opens from a `cm.scrollDOM` `contextmenu` listener guarded by\n   * `e.isTrusted`, which a dispatched event never gets past.\n   *\n   * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192\n   * `mouseUp` at one point, with no waiting for any effect (callers poll their\n   * own readiness signal). The leading move is what puts the pointer over the\n   * hit-test target before the button goes down. Prefer\n   * {@link Lib.clickElement} for element-relative clicks.\n   *\n   * A real context menu actually opens, so a suite driving a right click must\n   * close it (or remove the leftover `.menu` element) before the next test.\n   *\n   * Synchronous: injecting the trusted click does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to click at, the button to\n   *   press and any modifiers to hold.\n   */\n  clickMouse(this: void, params: ClickMouseParams): void;\n\n  /**\n   * Creates a note and does not return until its content is verifiably on\n   * disk, rewriting it if it is not.\n   *\n   * Use this instead of `app.vault.create` in any suite that may run on\n   * Android. The emulator transport loses roughly **0.9 %** of `vault.create`\n   * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on\n   * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,\n   * and it does not heal on its own. A suite doing ~34 creates per run\n   * therefore has a ~26 % chance of at least one lost write, and whichever test\n   * loses that lottery fails on a `waitUntil` for content that was never\n   * written \u2014 which is why it reads as an unrelated per-test flake rather than\n   * one shared cause.\n   *\n   * Verification is by **reading the note back**, never by inspecting\n   * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through\n   * `vault.modify` with the same content lands correctly (also measured), so a\n   * lost write costs a retry rather than a failure. A note whose content still\n   * does not match after the bounded retries throws, naming the path and both\n   * lengths, so a genuinely broken write fails loudly instead of spinning.\n   *\n   * Harmless everywhere else \u2014 on a transport that does not lose writes the\n   * read-back matches first time and nothing is rewritten.\n   *\n   * @param params - The note path and content.\n   * @returns A {@link Promise} resolving to the created file, once its content\n   *   is confirmed.\n   */\n  createNote(this: void, params: CreateNoteParams): Promise<TFile>;\n\n  /**\n   * Moves the mouse pointer to the center of an element using **trusted**\n   * Electron pointer input, then polls until the element actually matches\n   * `:hover`.\n   *\n   * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`\n   * state takes effect in the CSS engine \u2014 real theme `var()` values and real\n   * compositing \u2014 instead of a hand-simulated cascade. It polls the live\n   * `element.matches(':hover')` state (not a fixed delay), so it is robust under\n   * shared-instance load. It targets the single shared window's **global**\n   * pointer, so only one element is hovered at a time.\n   *\n   * @param params - The element to hover.\n   * @returns A {@link Promise} that resolves once the element matches `:hover`.\n   */\n  hoverElement(this: void, params: HoverElementParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to the given web-contents coordinates using a\n   * **trusted** Electron pointer move.\n   *\n   * A trusted move (injected via Electron's `webContents.sendInputEvent`)\n   * updates the real pointer state in the CSS engine, so `:hover` rules\n   * genuinely apply \u2014 unlike `dispatchEvent(new MouseEvent('mouseover'))`,\n   * which is untrusted and never sets `:hover`. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time.\n   *\n   * This is the low-level primitive: it performs a single move and does **not**\n   * wait for any state to settle (callers poll their own readiness signal).\n   * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for\n   * element-relative moves; use `moveMouse` directly when an element-relative\n   * target does not fit (e.g. an element spanning the full viewport width).\n   *\n   * Synchronous: injecting the trusted move does no real awaiting, so the caller\n   * does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   */\n  moveMouse(this: void, params: MoveMouseParams): void;\n\n  /**\n   * Opens Obsidian's settings modal on a given tab, and does not return until\n   * that tab has actually rendered.\n   *\n   * **This exists because `app.setting.open()` on its own does not work from a\n   * test.** `app.setting.containerEl` is built at startup but is never in the\n   * document, and `open()` does not attach it \u2014 so the modal builds into a\n   * detached tree, `open()` returns without throwing, and a screenshot taken\n   * afterwards shows the untouched document. That is what made the settings tab\n   * look impossible to capture, and got recorded as such in two plugins.\n   *\n   * The fix is one step, and its **order is load-bearing**: the container is\n   * appended to `document.body` **before** `open()`. Attaching afterwards is too\n   * late \u2014 whatever the modal drew on open has already gone into the detached\n   * container, so it ends up on screen showing the wrong thing. That failure\n   * looks like success until the captured frame is examined, which is the trap\n   * this helper exists to remove.\n   *\n   * Re-attaching is idempotent, so a tab closed with `app.setting.close()` can\n   * simply be re-opened.\n   *\n   * @param params - The tab to open and how long to wait for it to render.\n   * @returns A {@link Promise} resolving to the names of the setting rows the\n   *   tab rendered \u2014 both the proof it rendered and what a caller asserts on. A\n   *   tab that legitimately renders no `.setting-item-name` rows (Hotkeys, say)\n   *   resolves to an empty array.\n   * @throws Error if no tab carries {@link OpenSettingsTabParams.tabId}, or if\n   *   the tab does not render within the timeout.\n   */\n  openSettingsTab(this: void, params: OpenSettingsTabParams): Promise<string[]>;\n\n  /**\n   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a\n   * trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types\n   * printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link Lib.waitUntil}. It targets the single shared\n   * window's **global** focus, so only the DOM-focused element receives the key.\n   *\n   * Synchronous: injecting the trusted key press does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   */\n  pressKey(this: void, params: PressKeyParams): void;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link Lib.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp` a real\n   * user produces. Each keystroke is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to a point just outside an element's bounding box\n   * using a **trusted** Electron pointer move, then polls until the element no\n   * longer matches `:hover`.\n   *\n   * The inverse of {@link Lib.hoverElement}. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time. When\n   * an element spans the full viewport (no point outside its box is reachable),\n   * use {@link Lib.moveMouse} directly to move the pointer to a known empty\n   * coordinate instead.\n   *\n   * @param params - The element to move the pointer away from.\n   * @returns A {@link Promise} that resolves once the element no longer matches\n   *   `:hover`.\n   */\n  unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;\n\n  /**\n   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected\n   * replacement for the per-closure poll loops consumers would otherwise\n   * hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): Promise<void>;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent`\n * spelling.\n */\nexport type MouseButton = 'left' | 'middle' | 'right';\n\n/**\n * Parameters for {@link CommonArguments.moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link Lib.openSettingsTab}.\n */\nexport interface OpenSettingsTabParams {\n  /**\n   * The id of the settings tab to open \u2014 a plugin id for a plugin's own tab, or\n   * a core tab id (`'editor'`, `'hotkeys'`, \u2026).\n   *\n   * Required, because opening the modal without naming a tab renders **nothing**\n   * on a harness-owned instance: the modal restores the last tab the profile\n   * used, and an isolated profile has never opened one, so `activeTab` stays\n   * `null` and no row is drawn. An unknown id is rejected immediately, listing\n   * the ids that do exist.\n   */\n  readonly tabId: string;\n\n  /**\n   * The maximum time to wait for the modal to open and for the requested tab to\n   * render its content.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link CommonArguments.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArguments.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArguments.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link CommonArguments.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link CommonArguments.unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point\n   * just outside its bounding box. This is a live renderer DOM node \u2014 the\n   * callback runs in-renderer, so no cross-process serialization is needed\n   * (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link CommonArguments.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an input object that includes `app`, `obsidianModule`,\n * `context`, and any additional `input` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `input` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `callback`.\n */\nexport async function evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Input, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `callback` can be unbound.\n  const { callback, contextId, input = {}, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    callback,\n    input,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultString = await transport.evaluate(expression, { cwd });\n\n  if (resultString === '' || resultString === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultString) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultString}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replaceAll(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AAmkBlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,UAAU,WAAW,QAAQ,CAAC,GAAG,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACxH,QAAM,MAAM,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,KAAC,2BAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,YAAM,wDAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,iBAAa,qDAAsB,mBAAmB;AAE5D,QAAM,eAAe,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAEjE,MAAI,iBAAiB,MAAM,iBAAiB,WAAW;AACrD,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,YAAY;AAAA,EACpC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,YAAY,EAAE;AAAA,EACtF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,WAAW,yCAAyC,2BAA2B;AAClF,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor,\n  Modifier,\n  TFile\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArguments,\n  ContextId\n} from './context-id.cjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { generateNamespaceCall } from './generate-function-call.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `callback` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `callback` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `callback` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Parameters for {@link CommonArguments.clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to press.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArguments.clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to press.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArguments {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The shared library bag injected into every callback \u2014 see {@link Lib}.\n   *\n   * Never empty: the harness pre-populates a **base** set of renderer-driving\n   * helpers (trusted input \u2014 `typeIntoEditor` / `pressKey` / `moveMouse` /\n   * `clickMouse` / `hoverElement` / `unhoverElement` / `clickElement` \u2014 plus\n   * `waitUntil`, `createNote` and `openSettingsTab`), and provider packages\n   * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe\n   * library on top via {@link registerLibResolver}. A serialized closure reaches\n   * every shared helper through `lib` \u2014 `lib.typeIntoEditor({ editor, text })`,\n   * `lib.getFileOrNull({ app, \u2026 })` \u2014 instead of importing or hand-rolling them.\n   */\n  lib: Lib;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link CommonArguments.createNote}.\n */\nexport interface CreateNoteParams {\n  /**\n   * The note's content. This exact string is what the created note is read back\n   * against, so it is the definition of a successful write.\n   */\n  readonly content: string;\n\n  /**\n   * The vault-relative path to create, extension included.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  callback(input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<Result>;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly input?: Input;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArguments.hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The shared library bag injected into every {@link evalInObsidian} callback as\n * {@link CommonArguments.lib}.\n *\n * Two layers compose into this one bag. The **base** \u2014 the harness-provided\n * renderer-driving helpers declared below (the trusted-input primitives and\n * {@link Lib.waitUntil}) \u2014 is always present. On top, provider packages register\n * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`\n * their whole renderer-safe library at runtime, and augment this **augmentable**\n * interface (the `i18next` `CustomTypeOptions` idiom) via\n * `declare module 'obsidian-integration-testing'` to type it. Multiple providers\n * compose: their exports merge at runtime and their augmentations merge in the\n * type system (`interface Lib extends \u2026`).\n *\n * @example\n * ```ts\n * declare module 'obsidian-integration-testing' {\n *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}\n * }\n * ```\n */\nexport interface Lib {\n  /**\n   * Clicks the center of an element using **trusted** pointer input \u2014 Electron's\n   * `sendInputEvent` on desktop, a CDP touch tap in the WebView on mobile.\n   *\n   * The element-relative counterpart of {@link Lib.clickMouse}, mirroring the\n   * {@link Lib.moveMouse} / {@link Lib.hoverElement} split. Use\n   * {@link Lib.clickMouse} directly when the point to click is **not** the\n   * element's center \u2014 the markdown editor's margin, for instance, lies inside\n   * `cm.scrollDOM` but outside `.cm-sizer`, so no element's center lands on it.\n   *\n   * **Must be awaited.** On mobile the injection is a round-trip to the host \u2014\n   * the renderer cannot produce a trusted event itself \u2014 so a missing `await`\n   * would let the assertion run before the click landed.\n   *\n   * @param params - The element to click, the button to press and any modifiers\n   *   to hold.\n   * @returns A {@link Promise} that resolves once the click has been injected.\n   */\n  clickElement(this: void, params: ClickElementParams): Promise<void>;\n\n  /**\n   * Clicks at the given web-contents coordinates using **trusted** Electron\n   * pointer input, so Chromium synthesizes a real `click` (or `contextmenu`,\n   * for the right button) with `isTrusted === true`.\n   *\n   * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do:\n   * Obsidian and CodeMirror gate on `isTrusted`, so a dispatched event silently\n   * exercises nothing while the test still passes whatever weaker assertion it\n   * makes. Obsidian 1.13.7's markdown viewport (margin) menu, for example,\n   * opens from a `cm.scrollDOM` `contextmenu` listener guarded by\n   * `e.isTrusted`, which a dispatched event never gets past.\n   *\n   * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192\n   * `mouseUp` at one point, with no waiting for any effect (callers poll their\n   * own readiness signal). The leading move is what puts the pointer over the\n   * hit-test target before the button goes down. Prefer\n   * {@link Lib.clickElement} for element-relative clicks.\n   *\n   * A real context menu actually opens, so a suite driving a right click must\n   * close it (or remove the leftover `.menu` element) before the next test.\n   *\n   * **On mobile** the button model does not survive the port: touch has no\n   * buttons, so `'left'` (the default) is a **tap**, `'right'` is the\n   * **long-press** that opens Obsidian Mobile's context menu, and `'middle'`\n   * throws \u2014 there is no gesture for it, and inventing one would be worse than\n   * saying so. The coordinates are CSS pixels in the WebView's own viewport,\n   * which is what CDP takes, so `devicePixelRatio` never enters the picture.\n   *\n   * **Must be awaited** \u2014 see {@link Lib.clickElement}.\n   *\n   * @param params - The web-contents DIP coordinates to click at, the button to\n   *   press and any modifiers to hold.\n   * @returns A {@link Promise} that resolves once the click has been injected.\n   */\n  clickMouse(this: void, params: ClickMouseParams): Promise<void>;\n\n  /**\n   * Creates a note and does not return until its content is verifiably on\n   * disk, rewriting it if it is not.\n   *\n   * Use this instead of `app.vault.create` in any suite that may run on\n   * Android. The emulator transport loses roughly **0.9 %** of `vault.create`\n   * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on\n   * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,\n   * and it does not heal on its own. A suite doing ~34 creates per run\n   * therefore has a ~26 % chance of at least one lost write, and whichever test\n   * loses that lottery fails on a `waitUntil` for content that was never\n   * written \u2014 which is why it reads as an unrelated per-test flake rather than\n   * one shared cause.\n   *\n   * Verification is by **reading the note back**, never by inspecting\n   * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through\n   * `vault.modify` with the same content lands correctly (also measured), so a\n   * lost write costs a retry rather than a failure. A note whose content still\n   * does not match after the bounded retries throws, naming the path and both\n   * lengths, so a genuinely broken write fails loudly instead of spinning.\n   *\n   * Harmless everywhere else \u2014 on a transport that does not lose writes the\n   * read-back matches first time and nothing is rewritten.\n   *\n   * @param params - The note path and content.\n   * @returns A {@link Promise} resolving to the created file, once its content\n   *   is confirmed.\n   */\n  createNote(this: void, params: CreateNoteParams): Promise<TFile>;\n\n  /**\n   * Moves the mouse pointer to the center of an element using **trusted**\n   * Electron pointer input, then polls until the element actually matches\n   * `:hover`.\n   *\n   * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`\n   * state takes effect in the CSS engine \u2014 real theme `var()` values and real\n   * compositing \u2014 instead of a hand-simulated cascade. It polls the live\n   * `element.matches(':hover')` state (not a fixed delay), so it is robust under\n   * shared-instance load. It targets the single shared window's **global**\n   * pointer, so only one element is hovered at a time.\n   *\n   * **Desktop only \u2014 it throws on mobile**, deliberately: touch input has no\n   * hover state, so there is nothing faithful to inject. A silent no-op would\n   * leave a test asserting against a hover that never happened, which is the\n   * exact false-confidence failure trusted input exists to prevent. Branch on\n   * `Platform.isDesktopApp`, or drive the element with {@link Lib.clickElement}.\n   *\n   * @param params - The element to hover.\n   * @returns A {@link Promise} that resolves once the element matches `:hover`.\n   */\n  hoverElement(this: void, params: HoverElementParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to the given web-contents coordinates using a\n   * **trusted** Electron pointer move.\n   *\n   * A trusted move (injected via Electron's `webContents.sendInputEvent`)\n   * updates the real pointer state in the CSS engine, so `:hover` rules\n   * genuinely apply \u2014 unlike `dispatchEvent(new MouseEvent('mouseover'))`,\n   * which is untrusted and never sets `:hover`. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time.\n   *\n   * This is the low-level primitive: it performs a single move and does **not**\n   * wait for any state to settle (callers poll their own readiness signal).\n   * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for\n   * element-relative moves; use `moveMouse` directly when an element-relative\n   * target does not fit (e.g. an element spanning the full viewport width).\n   *\n   * **Desktop only \u2014 it throws on mobile**, for the same reason as\n   * {@link Lib.hoverElement}: there is no touch pointer to move.\n   *\n   * **Must be awaited** \u2014 see {@link Lib.clickElement}.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   * @returns A {@link Promise} that resolves once the move has been injected.\n   */\n  moveMouse(this: void, params: MoveMouseParams): Promise<void>;\n\n  /**\n   * Opens Obsidian's settings modal on a given tab, and does not return until\n   * that tab has actually rendered.\n   *\n   * **This exists because `app.setting.open()` on its own does not work from a\n   * test.** `app.setting.containerEl` is built at startup but is never in the\n   * document, and `open()` does not attach it \u2014 so the modal builds into a\n   * detached tree, `open()` returns without throwing, and a screenshot taken\n   * afterwards shows the untouched document. That is what made the settings tab\n   * look impossible to capture, and got recorded as such in two plugins.\n   *\n   * The fix is one step, and its **order is load-bearing**: the container is\n   * appended to `document.body` **before** `open()`. Attaching afterwards is too\n   * late \u2014 whatever the modal drew on open has already gone into the detached\n   * container, so it ends up on screen showing the wrong thing. That failure\n   * looks like success until the captured frame is examined, which is the trap\n   * this helper exists to remove.\n   *\n   * Re-attaching is idempotent, so a tab closed with `app.setting.close()` can\n   * simply be re-opened.\n   *\n   * @param params - The tab to open and how long to wait for it to render.\n   * @returns A {@link Promise} resolving to the names of the setting rows the\n   *   tab rendered \u2014 both the proof it rendered and what a caller asserts on. A\n   *   tab that legitimately renders no `.setting-item-name` rows (Hotkeys, say)\n   *   resolves to an empty array.\n   * @throws Error if no tab carries {@link OpenSettingsTabParams.tabId}, or if\n   *   the tab does not render within the timeout.\n   */\n  openSettingsTab(this: void, params: OpenSettingsTabParams): Promise<string[]>;\n\n  /**\n   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a\n   * trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types\n   * printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link Lib.waitUntil}. It targets the single shared\n   * window's **global** focus, so only the DOM-focused element receives the key.\n   *\n   * **On mobile** the same sequence is injected through the WebView's debugger\n   * (`Input.dispatchKeyEvent`), which is equally trusted. Named keys (`'Enter'`,\n   * `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single\n   * printable characters are supported; any other multi-character name throws\n   * rather than pressing nothing.\n   *\n   * **Must be awaited** \u2014 see {@link Lib.clickElement}.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   * @returns A {@link Promise} that resolves once the key press has been\n   *   injected.\n   */\n  pressKey(this: void, params: PressKeyParams): Promise<void>;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link Lib.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp` a real\n   * user produces. Each keystroke is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to a point just outside an element's bounding box\n   * using a **trusted** Electron pointer move, then polls until the element no\n   * longer matches `:hover`.\n   *\n   * The inverse of {@link Lib.hoverElement}. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time. When\n   * an element spans the full viewport (no point outside its box is reachable),\n   * use {@link Lib.moveMouse} directly to move the pointer to a known empty\n   * coordinate instead.\n   *\n   * **Desktop only \u2014 it throws on mobile**, for the same reason as\n   * {@link Lib.hoverElement}.\n   *\n   * @param params - The element to move the pointer away from.\n   * @returns A {@link Promise} that resolves once the element no longer matches\n   *   `:hover`.\n   */\n  unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;\n\n  /**\n   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected\n   * replacement for the per-closure poll loops consumers would otherwise\n   * hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): Promise<void>;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent`\n * spelling.\n */\nexport type MouseButton = 'left' | 'middle' | 'right';\n\n/**\n * Parameters for {@link CommonArguments.moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link Lib.openSettingsTab}.\n */\nexport interface OpenSettingsTabParams {\n  /**\n   * The id of the settings tab to open \u2014 a plugin id for a plugin's own tab, or\n   * a core tab id (`'editor'`, `'hotkeys'`, \u2026).\n   *\n   * Required, because opening the modal without naming a tab renders **nothing**\n   * on a harness-owned instance: the modal restores the last tab the profile\n   * used, and an isolated profile has never opened one, so `activeTab` stays\n   * `null` and no row is drawn. An unknown id is rejected immediately, listing\n   * the ids that do exist.\n   */\n  readonly tabId: string;\n\n  /**\n   * The maximum time to wait for the modal to open and for the requested tab to\n   * render its content.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link CommonArguments.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArguments.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArguments.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link CommonArguments.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link CommonArguments.unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point\n   * just outside its bounding box. This is a live renderer DOM node \u2014 the\n   * callback runs in-renderer, so no cross-process serialization is needed\n   * (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link CommonArguments.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an input object that includes `app`, `obsidianModule`,\n * `context`, and any additional `input` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `input` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `callback`.\n */\nexport async function evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Input, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `callback` can be unbound.\n  const { callback, contextId, input = {}, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    callback,\n    input,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultString = await transport.evaluate(expression, { cwd });\n\n  if (resultString === '' || resultString === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultString) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultString}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replaceAll(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,qBAA2B;AAC3B,0BAAoB;AASpB,8BAGO;AACP,oCAAsC;AACtC,iCAA4C;AAC5C,+BAAqC;AA2BrC,MAAM,YAAY;AAgmBlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,UAAU,WAAW,QAAQ,CAAC,GAAG,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACxH,QAAM,MAAM,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,KAAC,2BAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,YAAM,wDAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,iBAAa,qDAAsB,mBAAmB;AAE5D,QAAM,eAAe,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAEjE,MAAI,iBAAiB,MAAM,iBAAiB,WAAW;AACrD,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,YAAY;AAAA,EACpC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,YAAY,EAAE;AAAA,EACtF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,WAAW,yCAAyC,2BAA2B;AAClF,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": ["process"]
}


package/dist/lib/cjs/eval-in-obsidian.d.cts

@@ -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,15 @@ 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.
@@ -336,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.
@@ -376,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`.

package/dist/lib/cjs/index.cjs

@@ -25,11 +25,14 @@ __export(index_exports, {
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
   DesktopOnlyPluginSkipError: () => import_desktop_only_plugin_skip_error.DesktopOnlyPluginSkipError,
   IncompatibleInstallerVersionError: () => import_incompatible_installer_version_error.IncompatibleInstallerVersionError,
+  IntegrationSetupFailedError: () => import_integration_setup_failed_error.IntegrationSetupFailedError,
   PUBLIC_LATEST: () => import_obsidian_version.PUBLIC_LATEST,
   RendererFailedToInitializeError: () => import_renderer_failed_to_initialize_error.RendererFailedToInitializeError,
   SilentAsarFallbackError: () => import_silent_asar_fallback_error.SilentAsarFallbackError,
   TemporaryVault: () => import_temporary_vault.TemporaryVault,
+  bootstrapDemoVaultPlugins: () => import_demo_vault_bootstrap.bootstrapDemoVaultPlugins,
   buildDemoVaultPopulate: () => import_demo_vault_populate.buildDemoVaultPopulate,
+  buildDemoVaultPopulateAsync: () => import_demo_vault_bootstrap.buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride: () => import_capture_screenshot.buildDeviceMetricsOverride,
   buildLabelSvg: () => import_label_screenshot.buildLabelSvg,
   captureObsidianScreenshot: () => import_capture_obsidian_screenshot.captureObsidianScreenshot,
@@ -54,7 +57,9 @@ __export(index_exports, {
   resolveAsarFallback: () => import_asar_fallback_detection.resolveAsarFallback,
   resolveElectronCompatibility: () => import_electron_compatibility.resolveElectronCompatibility,
   resolveInstallerCompatibility: () => import_installer_compatibility.resolveInstallerCompatibility,
+  resolveMissingInjectedPlugins: () => import_demo_vault_populate.resolveMissingInjectedPlugins,
   runObsidianVersionMatrix: () => import_run_version_matrix.runObsidianVersionMatrix,
+  setSetupErrorResolver: () => import_context_provider.setSetupErrorResolver,
   setTransportOptionsResolver: () => import_context_provider.setTransportOptionsResolver,
   setVaultPathResolver: () => import_context_provider.setVaultPathResolver,
   unregisterVault: () => import_vault_registry.unregisterVault
@@ -66,6 +71,7 @@ var import_capture_screenshot = require("./capture-screenshot.cjs");
 var import_connect_to_cdp = require("./connect-to-cdp.cjs");
 var import_context_id = require("./context-id.cjs");
 var import_context_provider = require("./context-provider.cjs");
+var import_demo_vault_bootstrap = require("./demo-vault-bootstrap.cjs");
 var import_demo_vault_populate = require("./demo-vault-populate.cjs");
 var import_demo_vault_tree = require("./demo-vault-tree.cjs");
 var import_desktop_only_plugin_skip_error = require("./desktop-only-plugin-skip-error.cjs");
@@ -74,6 +80,7 @@ var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_fit_screenshot = require("./fit-screenshot.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
 var import_installer_compatibility = require("./installer-compatibility.cjs");
+var import_integration_setup_failed_error = require("./integration-setup-failed-error.cjs");
 var import_label_screenshot = require("./label-screenshot.cjs");
 var import_lib_registry = require("./lib-registry.cjs");
 var import_obsidian_metadata = require("./obsidian-metadata.cjs");
@@ -99,11 +106,14 @@ var import_version_matrix = require("./version-matrix.cjs");
   DesktopCdpTransport,
   DesktopOnlyPluginSkipError,
   IncompatibleInstallerVersionError,
+  IntegrationSetupFailedError,
   PUBLIC_LATEST,
   RendererFailedToInitializeError,
   SilentAsarFallbackError,
   TemporaryVault,
+  bootstrapDemoVaultPlugins,
   buildDemoVaultPopulate,
+  buildDemoVaultPopulateAsync,
   buildDeviceMetricsOverride,
   buildLabelSvg,
   captureObsidianScreenshot,
@@ -128,9 +138,11 @@ var import_version_matrix = require("./version-matrix.cjs");
   resolveAsarFallback,
   resolveElectronCompatibility,
   resolveInstallerCompatibility,
+  resolveMissingInjectedPlugins,
   runObsidianVersionMatrix,
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams\n} from './demo-vault-populate.cjs';\nexport { buildDemoVaultPopulate } from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAKP,4BAA6B;AAK7B,wBAA0B;AAK1B,8BAGO;AAKP,iCAAuC;AAEvC,6BAAkC;AAClC,4CAA2C;AAM3C,oCAA6C;AAkB7C,8BAA+B;AAM/B,4BAGO;AAEP,kDAAkD;AAMlD,qCAA8C;AAM9C,8BAKO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,8BAA+B;AAC/B,iDAAgD;AAEhD,gCAAyC;AAEzC,wCAAwC;AAKxC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains the entry point for the integration testing module.\n */\n\nexport type {\n  AsarFallback,\n  AsarFallbackTier,\n  ResolveAsarFallbackParams\n} from './asar-fallback-detection.cjs';\nexport { resolveAsarFallback } from './asar-fallback-detection.cjs';\nexport type { CaptureObsidianScreenshotOptions } from './capture-obsidian-screenshot.cjs';\nexport { captureObsidianScreenshot } from './capture-obsidian-screenshot.cjs';\nexport type {\n  CaptureScreenshotParams,\n  PngDimensions\n} from './capture-screenshot.cjs';\nexport {\n  buildDeviceMetricsOverride,\n  decodeBase64Png,\n  isPng,\n  readPngDimensions\n} from './capture-screenshot.cjs';\nexport type {\n  CdpConnection,\n  ConnectToCdpOptions\n} from './connect-to-cdp.cjs';\nexport { connectToCdp } from './connect-to-cdp.cjs';\nexport type {\n  ContextArguments,\n  ContextOf\n} from './context-id.cjs';\nexport { ContextId } from './context-id.cjs';\nexport type {\n  SetupErrorResolver,\n  TransportOptionsResolver,\n  VaultPathResolver\n} from './context-provider.cjs';\nexport {\n  setSetupErrorResolver,\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from './context-provider.cjs';\nexport type {\n  BootstrapDemoVaultPluginsParams,\n  BootstrapDemoVaultPluginsResult,\n  InstalledPluginInfo\n} from './demo-vault-bootstrap.cjs';\nexport {\n  bootstrapDemoVaultPlugins,\n  buildDemoVaultPopulateAsync\n} from './demo-vault-bootstrap.cjs';\nexport type {\n  BuildDemoVaultPopulateParams,\n  InjectPluginParams,\n  ResolveMissingInjectedPluginsParams\n} from './demo-vault-populate.cjs';\nexport {\n  buildDemoVaultPopulate,\n  resolveMissingInjectedPlugins\n} from './demo-vault-populate.cjs';\nexport type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';\nexport { readDemoVaultTree } from './demo-vault-tree.cjs';\nexport { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  CommonArguments,\n  CreateNoteParams,\n  EvalInObsidianParams,\n  GenericObject,\n  HoverElementParams,\n  Lib,\n  MouseButton,\n  MoveMouseParams,\n  OpenSettingsTabParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams,\n  WaitUntilParams\n} from './eval-in-obsidian.cjs';\nexport { evalInObsidian } from './eval-in-obsidian.cjs';\nexport type {\n  ComputeFitToCanvasParams,\n  FitScreenshotToCanvasOptions,\n  FitToCanvasGeometry\n} from './fit-screenshot.cjs';\nexport {\n  computeFitToCanvas,\n  fitScreenshotToCanvas\n} from './fit-screenshot.cjs';\nexport type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';\nexport { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';\nexport type {\n  InstallerCompatibility,\n  InstallerCompatibilityTier,\n  ResolveInstallerCompatibilityParams\n} from './installer-compatibility.cjs';\nexport { resolveInstallerCompatibility } from './installer-compatibility.cjs';\nexport type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';\nexport { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';\nexport type {\n  ComputeLabelBandParams,\n  LabelBandGeometry,\n  LabelScreenshotOptions\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot\n} from './label-screenshot.cjs';\nexport type { LibResolver } from './lib-registry.cjs';\nexport { registerLibResolver } from './lib-registry.cjs';\nexport type {\n  ObsidianRuntimeVersions,\n  ObsidianVersionChangelogUrls,\n  ObsidianVersionDownloads,\n  ObsidianVersionMetadata\n} from './obsidian-metadata.cjs';\nexport { getVersionMetadata } from './obsidian-metadata.cjs';\nexport {\n  CATALYST_LATEST,\n  PUBLIC_LATEST\n} from './obsidian-version.cjs';\nexport type { OpenObsidianSettingsTabOptions } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { PollInObsidianParams } from './poll-in-obsidian.cjs';\nexport { pollInObsidian } from './poll-in-obsidian.cjs';\nexport { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';\nexport type { RunObsidianVersionMatrixParams } from './run-version-matrix.cjs';\nexport { runObsidianVersionMatrix } from './run-version-matrix.cjs';\nexport type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';\nexport { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams\n} from './temporary-vault.cjs';\nexport { TemporaryVault } from './temporary-vault.cjs';\nexport type {\n  AppiumSessionInfo,\n  AppiumTransportConfig\n} from './transport-appium.cjs';\nexport { AppiumTransport } from './transport-appium.cjs';\nexport type {\n  DesktopCdpTransportConfig,\n  OwnedInstanceAsar,\n  OwnedInstanceConfig,\n  OwnedInstanceEndpoint\n} from './transport-desktop-cdp.cjs';\nexport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nexport { createTransportFromOptions } from './transport-factory.cjs';\nexport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianCdpTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.cjs';\nexport { checkIsMobileTransport } from './transport-options.cjs';\nexport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\nexport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\nexport type { ObsidianVersionMatrixEntry } from './version-matrix.cjs';\nexport { DEFAULT_OBSIDIAN_VERSION_SPECS } from './version-matrix.cjs';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAMP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAM3C,oCAA6C;AAkB7C,8BAA+B;AAM/B,4BAGO;AAEP,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAM5C,8BAKO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,8BAA+B;AAC/B,iDAAgD;AAEhD,gCAAyC;AAEzC,wCAAwC;AAKxC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}


package/dist/lib/cjs/index.d.cts

@@ -13,10 +13,12 @@ export type { CdpConnection, ConnectToCdpOptions } from './connect-to-cdp.cjs';
 export { connectToCdp } from './connect-to-cdp.cjs';
 export type { ContextArguments, ContextOf } from './context-id.cjs';
 export { ContextId } from './context-id.cjs';
-export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
-export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
-export type { BuildDemoVaultPopulateParams, InjectPluginParams } from './demo-vault-populate.cjs';
-export { buildDemoVaultPopulate } from './demo-vault-populate.cjs';
+export type { SetupErrorResolver, TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
+export { setSetupErrorResolver, setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
+export type { BootstrapDemoVaultPluginsParams, BootstrapDemoVaultPluginsResult, InstalledPluginInfo } from './demo-vault-bootstrap.cjs';
+export { bootstrapDemoVaultPlugins, buildDemoVaultPopulateAsync } from './demo-vault-bootstrap.cjs';
+export type { BuildDemoVaultPopulateParams, InjectPluginParams, ResolveMissingInjectedPluginsParams } from './demo-vault-populate.cjs';
+export { buildDemoVaultPopulate, resolveMissingInjectedPlugins } from './demo-vault-populate.cjs';
 export type { ReadDemoVaultTreeParams } from './demo-vault-tree.cjs';
 export { readDemoVaultTree } from './demo-vault-tree.cjs';
 export { DesktopOnlyPluginSkipError } from './desktop-only-plugin-skip-error.cjs';
@@ -30,6 +32,8 @@ export type { IncompatibleInstallerVersionErrorConstructorParams } from './incom
 export { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';
 export type { InstallerCompatibility, InstallerCompatibilityTier, ResolveInstallerCompatibilityParams } from './installer-compatibility.cjs';
 export { resolveInstallerCompatibility } from './installer-compatibility.cjs';
+export type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.cjs';
+export { IntegrationSetupFailedError } from './integration-setup-failed-error.cjs';
 export type { ComputeLabelBandParams, LabelBandGeometry, LabelScreenshotOptions } from './label-screenshot.cjs';
 export { buildLabelSvg, computeLabelBand, escapeSvgText, labelScreenshot } from './label-screenshot.cjs';
 export type { LibResolver } from './lib-registry.cjs';

package/dist/lib/cjs/installer-asset.cjs

@@ -91,4 +91,4 @@ function getPlatformAssetShape(platform) {
   selectInstallerAssetName,
   selectInstallerDownloadUrl
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n *\n * When the version is present in the baked `metadata.json` catalog (from\n * upstream `obsidian-versions.json`), its exact installer URL is already known;\n * {@link selectInstallerDownloadUrl} picks the platform-correct one and the\n * downloader uses it directly, skipping the release-API lookup and the\n * name-templating fallback entirely.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /**\n  Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux).\n   */\n  readonly baseName: string;\n\n  /**\n  File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`.\n   */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/**\nSeparator forms tried, hyphen (newer) first, when falling back to templated names.\n */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /**\n  The platform to build candidate names for.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /**\n  The release's asset names (e.g. from the GitHub release API).\n   */\n  readonly assetNames: readonly string[];\n\n  /**\n  The platform whose installer asset to select.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerDownloadUrl}.\n */\nexport interface SelectInstallerDownloadUrlParams {\n  /**\n  The version's baked download URLs, or `undefined` when it is absent from the catalog.\n   */\n  readonly downloads: ObsidianVersionDownloads | undefined;\n\n  /**\n  The platform whose installer URL to select.\n   */\n  readonly platform: NodeJS.Platform;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Selects the platform-correct x64 installer download URL from a version's\n * baked catalog entry.\n *\n * @param params - The baked download URLs and the platform.\n * @returns The installer URL for the platform, or `undefined` when the version\n *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst\n *   build, or a Linux `.tar.gz` that was never published).\n */\nexport function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined {\n  const { downloads } = params;\n  if (!downloads) {\n    return undefined;\n  }\n\n  if (params.platform === 'win32') {\n    return downloads.exe;\n  }\n\n  if (params.platform === 'darwin') {\n    return downloads.dmg;\n  }\n\n  return downloads.tar;\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map((infix) => escapeRegExp(infix)).join('|')})?`\n    : '';\n  return new RegExp(\n    String.raw`^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyDA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAKA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AA4DhC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAWO,SAAS,2BAA2B,QAA8D;AACvG,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,aAAa,SAAS;AAC/B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,UAAU;AACnB;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,CAAC,UAAU,aAAa,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,OACzE;AACJ,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,KAAK,aAAa,MAAM,SAAS,CAAC;AAAA,EACvH;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,WAAW,uBAAuB,OAAO,QAAQ;AAChE;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n *\n * When the version is present in the baked `metadata.json` catalog (from\n * the `obsidianmd/obsidian-releases` release assets), its exact installer URL is already known;\n * {@link selectInstallerDownloadUrl} picks the platform-correct one and the\n * downloader uses it directly, skipping the release-API lookup and the\n * name-templating fallback entirely.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /**\n  Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux).\n   */\n  readonly baseName: string;\n\n  /**\n  File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`.\n   */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/**\nSeparator forms tried, hyphen (newer) first, when falling back to templated names.\n */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /**\n  The platform to build candidate names for.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /**\n  The release's asset names (e.g. from the GitHub release API).\n   */\n  readonly assetNames: readonly string[];\n\n  /**\n  The platform whose installer asset to select.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerDownloadUrl}.\n */\nexport interface SelectInstallerDownloadUrlParams {\n  /**\n  The version's baked download URLs, or `undefined` when it is absent from the catalog.\n   */\n  readonly downloads: ObsidianVersionDownloads | undefined;\n\n  /**\n  The platform whose installer URL to select.\n   */\n  readonly platform: NodeJS.Platform;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Selects the platform-correct x64 installer download URL from a version's\n * baked catalog entry.\n *\n * @param params - The baked download URLs and the platform.\n * @returns The installer URL for the platform, or `undefined` when the version\n *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst\n *   build, or a Linux `.tar.gz` that was never published).\n */\nexport function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined {\n  const { downloads } = params;\n  if (!downloads) {\n    return undefined;\n  }\n\n  if (params.platform === 'win32') {\n    return downloads.exe;\n  }\n\n  if (params.platform === 'darwin') {\n    return downloads.dmg;\n  }\n\n  return downloads.tar;\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map((infix) => escapeRegExp(infix)).join('|')})?`\n    : '';\n  return new RegExp(\n    String.raw`^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyDA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAKA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AA4DhC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAWO,SAAS,2BAA2B,QAA8D;AACvG,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,aAAa,SAAS;AAC/B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,UAAU;AACnB;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,CAAC,UAAU,aAAa,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,OACzE;AACJ,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,KAAK,aAAa,MAAM,SAAS,CAAC;AAAA,EACvH;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,WAAW,uBAAuB,OAAO,QAAQ;AAChE;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/installer-asset.d.cts

@@ -25,7 +25,7 @@
  * 32-bit / arm64 / all-users sibling assets are deliberately rejected.
  *
  * When the version is present in the baked `metadata.json` catalog (from
- * upstream `obsidian-versions.json`), its exact installer URL is already known;
+ * the `obsidianmd/obsidian-releases` release assets), its exact installer URL is already known;
  * {@link selectInstallerDownloadUrl} picks the platform-correct one and the
  * downloader uses it directly, skipping the release-API lookup and the
  * name-templating fallback entirely.