obsidian-integration-testing 17.2.0 → 17.3.0

package/dist/lib/esm/apply-obsidian-theme.d.mts

@@ -0,0 +1,99 @@
+/**
+ * @file
+ *
+ * Switches the driven Obsidian to its dark or light theme, and makes the switch
+ * survive a config reload.
+ *
+ * `app.changeTheme` only sets the theme in the in-memory config and SCHEDULES
+ * the save, a second later (`requestSaveConfig` is debounced). Until that save
+ * lands, any file-watcher event on `.obsidian/app.json` or
+ * `.obsidian/appearance.json` makes Obsidian run `vault.reloadConfig`, which
+ * re-reads both files and deletes every in-memory key the disk does not have —
+ * `theme` included. The body then falls back to the light theme, and a capture
+ * suite that set the dark theme shoots every frame light, silently writing over
+ * the frames it has committed. Read from the 1.14.2 `app.js`, and reproduced in a
+ * plugin's capture suite: one external rewrite of `app.json` straight after
+ * `changeTheme` turned all five of its desktop frames light.
+ *
+ * {@link applyObsidianTheme} saves the config at once, so a reload finds the
+ * theme on disk and has nothing to drop, and waits until the body carries the
+ * theme's class and `appearance.json` carries its name. It also records the
+ * theme it applied, so `captureObsidianScreenshot` can refuse a frame the theme
+ * has left since.
+ */
+import type { ObsidianTransport } from './transport.mjs';
+/**
+ * Parameters for {@link applyObsidianTheme}.
+ */
+export interface ApplyObsidianThemeParams {
+    /**
+     * The theme to switch to.
+     */
+    readonly theme: ObsidianTheme;
+    /**
+     * How long to wait for the theme to be applied and saved.
+     *
+     * @default 10000
+     */
+    readonly timeoutInMilliseconds?: number;
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian window to switch. When omitted, the current test
+     * context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Parameters for {@link assertObsidianThemeUnchanged}.
+ */
+export interface AssertObsidianThemeUnchangedParams {
+    /**
+     * What the refusal is refusing, for its message, e.g. `capture a screenshot`.
+     */
+    readonly action: string;
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian window to check. When omitted, the current test
+     * context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * One of Obsidian's two built-in base themes.
+ */
+export type ObsidianTheme = 'dark' | 'light';
+/**
+ * Switches Obsidian to its dark or light theme, saves the config at once, and
+ * waits until the theme is both on screen and on disk.
+ *
+ * Use it instead of `app.changeTheme` in a capture suite: see the module
+ * comment for the reload that silently undoes a bare `changeTheme`. The theme
+ * is recorded, and `captureObsidianScreenshot` then refuses any frame whose body
+ * is no longer in it, so a theme lost after this call fails the capture by name
+ * instead of rewriting a committed frame.
+ *
+ * @param params - The theme, how long to wait, and transport / vault overrides.
+ * @returns A {@link Promise} that resolves once the theme is applied and saved.
+ * @throws Error if the theme is not applied and saved within the timeout.
+ */
+export declare function applyObsidianTheme(params: ApplyObsidianThemeParams): Promise<void>;
+/**
+ * Throws when the body has left the theme {@link applyObsidianTheme} applied.
+ *
+ * Nothing is checked when no theme was applied through it, since there is then
+ * no expectation to hold the frame to.
+ *
+ * @param params - What is being refused, and transport / vault overrides.
+ * @returns A {@link Promise} that resolves when the theme still holds, or none
+ *   was applied.
+ * @throws Error naming the applied theme and the one on screen, if they differ.
+ */
+export declare function assertObsidianThemeUnchanged(params: AssertObsidianThemeUnchangedParams): Promise<void>;

package/dist/lib/esm/apply-obsidian-theme.mjs

@@ -0,0 +1,70 @@
+import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
+const DEFAULT_TIMEOUT_IN_MILLISECONDS = 1e4;
+async function applyObsidianTheme(params) {
+  const {
+    theme,
+    timeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MILLISECONDS,
+    transport,
+    vaultPath
+  } = params;
+  await evalInObsidian(normalizeOptionalProperties({
+    async callback({ app, lib: { waitUntil }, theme: requestedTheme, timeoutInMilliseconds: timeout }) {
+      const themeName = requestedTheme === "dark" ? "obsidian" : "moonstone";
+      const bodyClass = `theme-${requestedTheme}`;
+      app.changeTheme(themeName);
+      await app.vault.saveConfig();
+      await waitUntil({
+        message: `the ${requestedTheme} theme to be applied and saved to appearance.json`,
+        async predicate() {
+          const appearance = await app.vault.readConfigJson("appearance");
+          return document.body.classList.contains(bodyClass) && appearance?.theme === themeName;
+        },
+        timeoutInMilliseconds: timeout
+      });
+      globalThis.__obsidianIntegrationTestingAppliedTheme = requestedTheme;
+      return void 0;
+    },
+    input: {
+      theme,
+      timeoutInMilliseconds
+    },
+    transport,
+    vaultPath
+  }));
+}
+async function assertObsidianThemeUnchanged(params) {
+  const {
+    action,
+    transport,
+    vaultPath
+  } = params;
+  const mismatch = await evalInObsidian(normalizeOptionalProperties({
+    callback() {
+      const appliedTheme = globalThis.__obsidianIntegrationTestingAppliedTheme;
+      if (appliedTheme === void 0 || document.body.classList.contains(`theme-${appliedTheme}`)) {
+        return null;
+      }
+      let shownTheme = "neither dark nor light";
+      if (document.body.classList.contains("theme-dark")) {
+        shownTheme = "dark";
+      } else if (document.body.classList.contains("theme-light")) {
+        shownTheme = "light";
+      }
+      return `applyObsidianTheme applied the ${appliedTheme} theme, but the body is now ${shownTheme}`;
+    },
+    input: {},
+    transport,
+    vaultPath
+  }));
+  if (mismatch !== null) {
+    throw new Error(
+      `Refusing to ${action}: ${mismatch}. Something reset the theme after it was applied - typically a bare app.changeTheme, or a config reload. Call applyObsidianTheme again, or pass shouldVerifyTheme: false to capture the frame as it is.`
+    );
+  }
+}
+export {
+  applyObsidianTheme,
+  assertObsidianThemeUnchanged
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/apply-obsidian-theme.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Switches the driven Obsidian to its dark or light theme, and makes the switch\n * survive a config reload.\n *\n * `app.changeTheme` only sets the theme in the in-memory config and SCHEDULES\n * the save, a second later (`requestSaveConfig` is debounced). Until that save\n * lands, any file-watcher event on `.obsidian/app.json` or\n * `.obsidian/appearance.json` makes Obsidian run `vault.reloadConfig`, which\n * re-reads both files and deletes every in-memory key the disk does not have \u2014\n * `theme` included. The body then falls back to the light theme, and a capture\n * suite that set the dark theme shoots every frame light, silently writing over\n * the frames it has committed. Read from the 1.14.2 `app.js`, and reproduced in a\n * plugin's capture suite: one external rewrite of `app.json` straight after\n * `changeTheme` turned all five of its desktop frames light.\n *\n * {@link applyObsidianTheme} saves the config at once, so a reload finds the\n * theme on disk and has nothing to drop, and waits until the body carries the\n * theme's class and `appearance.json` carries its name. It also records the\n * theme it applied, so `captureObsidianScreenshot` can refuse a frame the theme\n * has left since.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian) covered by integration tests, not unit tests. */\n\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\n\n/**\n * Parameters for {@link applyObsidianTheme}.\n */\nexport interface ApplyObsidianThemeParams {\n  /**\n   * The theme to switch to.\n   */\n  readonly theme: ObsidianTheme;\n\n  /**\n   * How long to wait for the theme to be applied and saved.\n   *\n   * @default 10000\n   */\n  readonly timeoutInMilliseconds?: number;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian window to switch. When omitted, the current test\n   * context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link assertObsidianThemeUnchanged}.\n */\nexport interface AssertObsidianThemeUnchangedParams {\n  /**\n   * What the refusal is refusing, for its message, e.g. `capture a screenshot`.\n   */\n  readonly action: string;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian window to check. When omitted, the current test\n   * context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * One of Obsidian's two built-in base themes.\n */\nexport type ObsidianTheme = 'dark' | 'light';\n\ninterface AppearanceConfig {\n  readonly theme?: unknown;\n}\n\n// A `window` property rather than a closure variable: the apply and the check\n// are separate evaluations. Spelled out in the holder rather than shared through\n// a constant, because a closure is serialized and cannot reach module scope.\n//\n// Kept local rather than declared globally, like every other holder of a\n// harness `window` property, so it never leaks into consumer types.\ninterface AppliedThemeHolder {\n  __obsidianIntegrationTestingAppliedTheme?: ObsidianTheme | undefined;\n}\n\ninterface ApplyThemeInput extends GenericObject {\n  readonly theme: ObsidianTheme;\n  readonly timeoutInMilliseconds: number;\n}\n\nconst DEFAULT_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * Switches Obsidian to its dark or light theme, saves the config at once, and\n * waits until the theme is both on screen and on disk.\n *\n * Use it instead of `app.changeTheme` in a capture suite: see the module\n * comment for the reload that silently undoes a bare `changeTheme`. The theme\n * is recorded, and `captureObsidianScreenshot` then refuses any frame whose body\n * is no longer in it, so a theme lost after this call fails the capture by name\n * instead of rewriting a committed frame.\n *\n * @param params - The theme, how long to wait, and transport / vault overrides.\n * @returns A {@link Promise} that resolves once the theme is applied and saved.\n * @throws Error if the theme is not applied and saved within the timeout.\n */\nexport async function applyObsidianTheme(params: ApplyObsidianThemeParams): Promise<void> {\n  const {\n    theme,\n    timeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MILLISECONDS,\n    transport,\n    vaultPath\n  } = params;\n\n  await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<ApplyThemeInput, undefined>>({\n    async callback({ app, lib: { waitUntil }, theme: requestedTheme, timeoutInMilliseconds: timeout }): Promise<undefined> {\n      const themeName = requestedTheme === 'dark' ? 'obsidian' : 'moonstone';\n      const bodyClass = `theme-${requestedTheme}`;\n\n      app.changeTheme(themeName);\n      // Saving now, rather than on `changeTheme`'s own debounced schedule, is the\n      // whole fix: a reload that finds the theme on disk has nothing to drop.\n      await app.vault.saveConfig();\n\n      await waitUntil({\n        message: `the ${requestedTheme} theme to be applied and saved to appearance.json`,\n        async predicate(): Promise<boolean> {\n          const appearance = await app.vault.readConfigJson('appearance') as AppearanceConfig | null;\n          return document.body.classList.contains(bodyClass) && appearance?.theme === themeName;\n        },\n        timeoutInMilliseconds: timeout\n      });\n\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: the applied theme is this helper's own Window property, kept local rather than declared globally.\n      (globalThis as unknown as AppliedThemeHolder).__obsidianIntegrationTestingAppliedTheme = requestedTheme;\n      return undefined;\n    },\n    input: {\n      theme,\n      timeoutInMilliseconds\n    },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Throws when the body has left the theme {@link applyObsidianTheme} applied.\n *\n * Nothing is checked when no theme was applied through it, since there is then\n * no expectation to hold the frame to.\n *\n * @param params - What is being refused, and transport / vault overrides.\n * @returns A {@link Promise} that resolves when the theme still holds, or none\n *   was applied.\n * @throws Error naming the applied theme and the one on screen, if they differ.\n */\nexport async function assertObsidianThemeUnchanged(params: AssertObsidianThemeUnchangedParams): Promise<void> {\n  const {\n    action,\n    transport,\n    vaultPath\n  } = params;\n\n  const mismatch = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<Record<string, never>, null | string>>({\n    callback(): null | string {\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: the applied theme is this helper's own Window property, kept local rather than declared globally.\n      const appliedTheme = (globalThis as unknown as AppliedThemeHolder).__obsidianIntegrationTestingAppliedTheme;\n      if (appliedTheme === undefined || document.body.classList.contains(`theme-${appliedTheme}`)) {\n        return null;\n      }\n\n      let shownTheme = 'neither dark nor light';\n      if (document.body.classList.contains('theme-dark')) {\n        shownTheme = 'dark';\n      } else if (document.body.classList.contains('theme-light')) {\n        shownTheme = 'light';\n      }\n      return `applyObsidianTheme applied the ${appliedTheme} theme, but the body is now ${shownTheme}`;\n    },\n    input: {},\n    transport,\n    vaultPath\n  }));\n\n  if (mismatch !== null) {\n    throw new Error(\n      `Refusing to ${action}: ${mismatch}. Something reset the theme after it was applied - typically a bare app.changeTheme, or a config reload. Call applyObsidianTheme again, or pass shouldVerifyTheme: false to capture the frame as it is.`\n    );\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAgCA,SAAS,sBAAsB;AAC/B,SAAS,mCAAmC;AA6E5C,MAAM,kCAAkC;AAgBxC,eAAsB,mBAAmB,QAAiD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,eAAe,4BAA8E;AAAA,IACjG,MAAM,SAAS,EAAE,KAAK,KAAK,EAAE,UAAU,GAAG,OAAO,gBAAgB,uBAAuB,QAAQ,GAAuB;AACrH,YAAM,YAAY,mBAAmB,SAAS,aAAa;AAC3D,YAAM,YAAY,SAAS,cAAc;AAEzC,UAAI,YAAY,SAAS;AAGzB,YAAM,IAAI,MAAM,WAAW;AAE3B,YAAM,UAAU;AAAA,QACd,SAAS,OAAO,cAAc;AAAA,QAC9B,MAAM,YAA8B;AAClC,gBAAM,aAAa,MAAM,IAAI,MAAM,eAAe,YAAY;AAC9D,iBAAO,SAAS,KAAK,UAAU,SAAS,SAAS,KAAK,YAAY,UAAU;AAAA,QAC9E;AAAA,QACA,uBAAuB;AAAA,MACzB,CAAC;AAGD,MAAC,WAA6C,2CAA2C;AACzF,aAAO;AAAA,IACT;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAaA,eAAsB,6BAA6B,QAA2D;AAC5G,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,MAAM,eAAe,4BAAwF;AAAA,IAC5H,WAA0B;AAExB,YAAM,eAAgB,WAA6C;AACnE,UAAI,iBAAiB,UAAa,SAAS,KAAK,UAAU,SAAS,SAAS,YAAY,EAAE,GAAG;AAC3F,eAAO;AAAA,MACT;AAEA,UAAI,aAAa;AACjB,UAAI,SAAS,KAAK,UAAU,SAAS,YAAY,GAAG;AAClD,qBAAa;AAAA,MACf,WAAW,SAAS,KAAK,UAAU,SAAS,aAAa,GAAG;AAC1D,qBAAa;AAAA,MACf;AACA,aAAO,kCAAkC,YAAY,+BAA+B,UAAU;AAAA,IAChG;AAAA,IACA,OAAO,CAAC;AAAA,IACR;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,MAAI,aAAa,MAAM;AACrB,UAAM,IAAI;AAAA,MACR,eAAe,MAAM,KAAK,QAAQ;AAAA,IACpC;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/esm/capture-obsidian-screenshot.d.mts

@@ -15,7 +15,14 @@
  * name — see `hide-vault-name.ts` for why a `temp-vault-<random>` bleeds
  * through the caption band and rewrites a checked-in PNG on every run — and by
  * hiding the focused element's blinking caret for the length of the capture —
- * see `hide-caret.ts` for why that is a transparent caret and not a blur.
+ * see `hide-caret.ts` for why that is a transparent caret and not a blur —
+ * and by drawing the window focused whether or not the OS gave it focus — see
+ * `pin-window-focus.ts` for the title bar that otherwise darkens one run in
+ * five.
+ *
+ * And it refuses a frame whose theme has changed since `applyObsidianTheme` set
+ * it — see `apply-obsidian-theme.ts` for the config reload that silently turns a
+ * dark capture run light.
  */
 import type { ObsidianTransport } from './transport.mjs';
 /**
@@ -56,6 +63,33 @@ export interface CaptureObsidianScreenshotOptions {
      * @default `true`
      */
     readonly shouldHideVaultName?: boolean;
+    /**
+     * Whether to draw the window as focused while capturing, so the frame does
+     * not depend on whether the operating system gave the window foreground
+     * focus that run.
+     *
+     * Obsidian darkens the title bar of an unfocused window, and a freshly
+     * launched one is routinely refused the foreground. The `is-focused` class is
+     * added for the capture and handed back to Obsidian afterwards; the window's
+     * real focus is never touched. Turn it off only to photograph the unfocused
+     * chrome itself, and expect such a frame to differ between runs.
+     *
+     * @default `true`
+     */
+    readonly shouldPinWindowFocus?: boolean;
+    /**
+     * Whether to refuse the frame when the body is no longer in the theme
+     * `applyObsidianTheme` last applied.
+     *
+     * A theme lost after it was applied fails nothing on its own: the frame is
+     * simply shot in the other theme and written over the committed one. Refusing
+     * turns that into a named error. Nothing is checked when no theme was applied
+     * through `applyObsidianTheme`. Turn it off only for a frame that changes the
+     * theme on purpose.
+     *
+     * @default `true`
+     */
+    readonly shouldVerifyTheme?: boolean;
     /**
      * Override the transport. When omitted, the transport the current test
      * context is driving is used.
@@ -83,10 +117,15 @@ export interface CaptureObsidianScreenshotOptions {
  * photograph it. The focused element's caret is hidden for the capture too, and
  * restored after it, so a frame with a focused field does not alternate between
  * two blink phases; {@link CaptureObsidianScreenshotOptions.shouldHideCaret}
+ * turns that off. The window is drawn focused whether or not the OS gave it
+ * focus; {@link CaptureObsidianScreenshotOptions.shouldPinWindowFocus} turns
+ * that off. A frame whose body has left the theme `applyObsidianTheme`
+ * applied is refused; {@link CaptureObsidianScreenshotOptions.shouldVerifyTheme}
  * turns that off.
  *
  * @param options - Optional size, transport and vault overrides.
  * @returns A {@link Promise} that resolves to the raw PNG bytes.
- * @throws Error if the active transport cannot capture screenshots.
+ * @throws Error if the active transport cannot capture screenshots, or if the
+ *   theme has changed since `applyObsidianTheme` applied it.
  */
 export declare function captureObsidianScreenshot(options?: CaptureObsidianScreenshotOptions): Promise<Uint8Array>;

package/dist/lib/esm/capture-obsidian-screenshot.mjs

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { assertObsidianThemeUnchanged } from "./apply-obsidian-theme.mjs";
 import {
   getTransportOptions,
   getVaultPath
@@ -6,12 +7,15 @@ import {
 import { hideCaret } from "./hide-caret.mjs";
 import { hideVaultName } from "./hide-vault-name.mjs";
 import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
+import { pinWindowFocus } from "./pin-window-focus.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
 async function captureObsidianScreenshot(options) {
   const {
     heightInPixels,
     shouldHideCaret = true,
     shouldHideVaultName = true,
+    shouldPinWindowFocus = true,
+    shouldVerifyTheme = true,
     transport: transportOverride,
     vaultPath,
     widthInPixels
@@ -21,6 +25,13 @@ async function captureObsidianScreenshot(options) {
   if (!transport.captureScreenshot) {
     throw new Error("captureObsidianScreenshot: the active transport cannot capture screenshots.");
   }
+  if (shouldVerifyTheme) {
+    await assertObsidianThemeUnchanged({
+      action: "capture a screenshot",
+      transport,
+      vaultPath: cwd
+    });
+  }
   if (shouldHideVaultName) {
     await hideVaultName({
       transport,
@@ -31,6 +42,10 @@ async function captureObsidianScreenshot(options) {
     transport,
     vaultPath: cwd
   }) : void 0;
+  const pinnedWindowFocus = shouldPinWindowFocus ? await pinWindowFocus({
+    transport,
+    vaultPath: cwd
+  }) : void 0;
   try {
     return await transport.captureScreenshot(normalizeOptionalProperties({
       cwd,
@@ -38,10 +53,11 @@ async function captureObsidianScreenshot(options) {
       widthInPixels
     }));
   } finally {
+    await pinnedWindowFocus?.restore();
     await hiddenCaret?.restore();
   }
 }
 export {
   captureObsidianScreenshot
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/capture-obsidian-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Captures a screenshot of the Obsidian instance the current test context is\n * already driving.\n *\n * The transport-level `captureScreenshot` needs a transport in hand, which a\n * test running under the harness's global setup never has \u2014 the instance is\n * owned by that setup and reached through the context provider. This is the\n * context-resolving entry point, the screenshot counterpart of\n * `evalInObsidian` / `pollInObsidian`: with no arguments at all it captures\n * whatever instance the active project is driving, desktop or mobile.\n *\n * It also makes the frame REPRODUCIBLE before taking it, by hiding the vault's\n * name \u2014 see `hide-vault-name.ts` for why a `temp-vault-<random>` bleeds\n * through the caption band and rewrites a checked-in PNG on every run \u2014 and by\n * hiding the focused element's blinking caret for the length of the capture \u2014\n * see `hide-caret.ts` for why that is a transparent caret and not a blur.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian) covered by integration tests, not unit tests. */\n\nimport process from 'node:process';\n\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { hideCaret } from './hide-caret.mjs';\nimport { hideVaultName } from './hide-vault-name.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\n/**\n * Options for {@link captureObsidianScreenshot}.\n */\nexport interface CaptureObsidianScreenshotOptions {\n  /**\n   * The exact height in pixels the captured image should have.\n   *\n   * Desktop only, and only meaningful together with {@link widthInPixels}.\n   * Ignored on mobile, where the image is always the device's native\n   * framebuffer \u2014 size those by choosing an AVD with the wanted screen\n   * geometry.\n   */\n  readonly heightInPixels?: number;\n\n  /**\n   * Whether to hide the focused element's caret while capturing, so the frame\n   * does not depend on which phase of its blink the capture caught.\n   *\n   * The caret is made transparent, not blurred: the focus, its ring and\n   * anything open because of it \u2014 a suggester under an input \u2014 all stay as the\n   * test built them, and the caret is put back once the frame is taken. Turn it\n   * off only to photograph the caret itself, and expect such a frame to differ\n   * between runs.\n   *\n   * @default `true`\n   */\n  readonly shouldHideCaret?: boolean;\n\n  /**\n   * Whether to hide the vault's name before capturing, so the frame does not\n   * depend on the random suffix of the harness's temporary vault.\n   *\n   * A default rather than a knob: reproducibility is what a checked-in\n   * screenshot is for, and the row it collapses sits under the caption band,\n   * so nothing a reader sees moves. Turn it off only to photograph the vault\n   * switcher itself.\n   *\n   * @default `true`\n   */\n  readonly shouldHideVaultName?: boolean;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault path to capture. When omitted, the current test context's vault\n   * is used.\n   */\n  readonly vaultPath?: string;\n\n  /**\n   * The exact width in pixels the captured image should have.\n   *\n   * See {@link heightInPixels} \u2014 the two are set together or not at all.\n   */\n  readonly widthInPixels?: number;\n}\n\n/**\n * Captures a PNG screenshot of the running Obsidian instance, resolving the\n * transport and vault from the current test context.\n *\n * The vault's name is hidden first, so two runs of the same suite against two\n * differently-named temporary vaults produce byte-identical PNGs. Pass\n * {@link CaptureObsidianScreenshotOptions.shouldHideVaultName} as `false` to\n * photograph it. The focused element's caret is hidden for the capture too, and\n * restored after it, so a frame with a focused field does not alternate between\n * two blink phases; {@link CaptureObsidianScreenshotOptions.shouldHideCaret}\n * turns that off.\n *\n * @param options - Optional size, transport and vault overrides.\n * @returns A {@link Promise} that resolves to the raw PNG bytes.\n * @throws Error if the active transport cannot capture screenshots.\n */\nexport async function captureObsidianScreenshot(options?: CaptureObsidianScreenshotOptions): Promise<Uint8Array> {\n  const {\n    heightInPixels,\n    shouldHideCaret = true,\n    shouldHideVaultName = true,\n    transport: transportOverride,\n    vaultPath,\n    widthInPixels\n  } = options ?? {};\n\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!transport.captureScreenshot) {\n    throw new Error('captureObsidianScreenshot: the active transport cannot capture screenshots.');\n  }\n\n  if (shouldHideVaultName) {\n    await hideVaultName({\n      transport,\n      vaultPath: cwd\n    });\n  }\n\n  const hiddenCaret = shouldHideCaret\n    ? await hideCaret({\n      transport,\n      vaultPath: cwd\n    })\n    : undefined;\n\n  try {\n    return await transport.captureScreenshot(normalizeOptionalProperties<CaptureScreenshotParams>({\n      cwd,\n      heightInPixels,\n      widthInPixels\n    }));\n  } finally {\n    await hiddenCaret?.restore();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAsBA,OAAO,aAAa;AAKpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAC1B,SAAS,qBAAqB;AAC9B,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA+ErC,eAAsB,0BAA0B,SAAiE;AAC/G,QAAM;AAAA,IACJ;AAAA,IACA,kBAAkB;AAAA,IAClB,sBAAsB;AAAA,IACtB,WAAW;AAAA,IACX;AAAA,IACA;AAAA,EACF,IAAI,WAAW,CAAC;AAEhB,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AACvD,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,UAAU,mBAAmB;AAChC,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,MAAI,qBAAqB;AACvB,UAAM,cAAc;AAAA,MAClB;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,cAAc,kBAChB,MAAM,UAAU;AAAA,IAChB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,MAAI;AACF,WAAO,MAAM,UAAU,kBAAkB,4BAAqD;AAAA,MAC5F;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC,CAAC;AAAA,EACJ,UAAE;AACA,UAAM,aAAa,QAAQ;AAAA,EAC7B;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/capture-obsidian-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Captures a screenshot of the Obsidian instance the current test context is\n * already driving.\n *\n * The transport-level `captureScreenshot` needs a transport in hand, which a\n * test running under the harness's global setup never has \u2014 the instance is\n * owned by that setup and reached through the context provider. This is the\n * context-resolving entry point, the screenshot counterpart of\n * `evalInObsidian` / `pollInObsidian`: with no arguments at all it captures\n * whatever instance the active project is driving, desktop or mobile.\n *\n * It also makes the frame REPRODUCIBLE before taking it, by hiding the vault's\n * name \u2014 see `hide-vault-name.ts` for why a `temp-vault-<random>` bleeds\n * through the caption band and rewrites a checked-in PNG on every run \u2014 and by\n * hiding the focused element's blinking caret for the length of the capture \u2014\n * see `hide-caret.ts` for why that is a transparent caret and not a blur \u2014\n * and by drawing the window focused whether or not the OS gave it focus \u2014 see\n * `pin-window-focus.ts` for the title bar that otherwise darkens one run in\n * five.\n *\n * And it refuses a frame whose theme has changed since `applyObsidianTheme` set\n * it \u2014 see `apply-obsidian-theme.ts` for the config reload that silently turns a\n * dark capture run light.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian) covered by integration tests, not unit tests. */\n\nimport process from 'node:process';\n\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { assertObsidianThemeUnchanged } from './apply-obsidian-theme.mjs';\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { hideCaret } from './hide-caret.mjs';\nimport { hideVaultName } from './hide-vault-name.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { pinWindowFocus } from './pin-window-focus.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\n/**\n * Options for {@link captureObsidianScreenshot}.\n */\nexport interface CaptureObsidianScreenshotOptions {\n  /**\n   * The exact height in pixels the captured image should have.\n   *\n   * Desktop only, and only meaningful together with {@link widthInPixels}.\n   * Ignored on mobile, where the image is always the device's native\n   * framebuffer \u2014 size those by choosing an AVD with the wanted screen\n   * geometry.\n   */\n  readonly heightInPixels?: number;\n\n  /**\n   * Whether to hide the focused element's caret while capturing, so the frame\n   * does not depend on which phase of its blink the capture caught.\n   *\n   * The caret is made transparent, not blurred: the focus, its ring and\n   * anything open because of it \u2014 a suggester under an input \u2014 all stay as the\n   * test built them, and the caret is put back once the frame is taken. Turn it\n   * off only to photograph the caret itself, and expect such a frame to differ\n   * between runs.\n   *\n   * @default `true`\n   */\n  readonly shouldHideCaret?: boolean;\n\n  /**\n   * Whether to hide the vault's name before capturing, so the frame does not\n   * depend on the random suffix of the harness's temporary vault.\n   *\n   * A default rather than a knob: reproducibility is what a checked-in\n   * screenshot is for, and the row it collapses sits under the caption band,\n   * so nothing a reader sees moves. Turn it off only to photograph the vault\n   * switcher itself.\n   *\n   * @default `true`\n   */\n  readonly shouldHideVaultName?: boolean;\n\n  /**\n   * Whether to draw the window as focused while capturing, so the frame does\n   * not depend on whether the operating system gave the window foreground\n   * focus that run.\n   *\n   * Obsidian darkens the title bar of an unfocused window, and a freshly\n   * launched one is routinely refused the foreground. The `is-focused` class is\n   * added for the capture and handed back to Obsidian afterwards; the window's\n   * real focus is never touched. Turn it off only to photograph the unfocused\n   * chrome itself, and expect such a frame to differ between runs.\n   *\n   * @default `true`\n   */\n  readonly shouldPinWindowFocus?: boolean;\n\n  /**\n   * Whether to refuse the frame when the body is no longer in the theme\n   * `applyObsidianTheme` last applied.\n   *\n   * A theme lost after it was applied fails nothing on its own: the frame is\n   * simply shot in the other theme and written over the committed one. Refusing\n   * turns that into a named error. Nothing is checked when no theme was applied\n   * through `applyObsidianTheme`. Turn it off only for a frame that changes the\n   * theme on purpose.\n   *\n   * @default `true`\n   */\n  readonly shouldVerifyTheme?: boolean;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault path to capture. When omitted, the current test context's vault\n   * is used.\n   */\n  readonly vaultPath?: string;\n\n  /**\n   * The exact width in pixels the captured image should have.\n   *\n   * See {@link heightInPixels} \u2014 the two are set together or not at all.\n   */\n  readonly widthInPixels?: number;\n}\n\n/**\n * Captures a PNG screenshot of the running Obsidian instance, resolving the\n * transport and vault from the current test context.\n *\n * The vault's name is hidden first, so two runs of the same suite against two\n * differently-named temporary vaults produce byte-identical PNGs. Pass\n * {@link CaptureObsidianScreenshotOptions.shouldHideVaultName} as `false` to\n * photograph it. The focused element's caret is hidden for the capture too, and\n * restored after it, so a frame with a focused field does not alternate between\n * two blink phases; {@link CaptureObsidianScreenshotOptions.shouldHideCaret}\n * turns that off. The window is drawn focused whether or not the OS gave it\n * focus; {@link CaptureObsidianScreenshotOptions.shouldPinWindowFocus} turns\n * that off. A frame whose body has left the theme `applyObsidianTheme`\n * applied is refused; {@link CaptureObsidianScreenshotOptions.shouldVerifyTheme}\n * turns that off.\n *\n * @param options - Optional size, transport and vault overrides.\n * @returns A {@link Promise} that resolves to the raw PNG bytes.\n * @throws Error if the active transport cannot capture screenshots, or if the\n *   theme has changed since `applyObsidianTheme` applied it.\n */\nexport async function captureObsidianScreenshot(options?: CaptureObsidianScreenshotOptions): Promise<Uint8Array> {\n  const {\n    heightInPixels,\n    shouldHideCaret = true,\n    shouldHideVaultName = true,\n    shouldPinWindowFocus = true,\n    shouldVerifyTheme = true,\n    transport: transportOverride,\n    vaultPath,\n    widthInPixels\n  } = options ?? {};\n\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!transport.captureScreenshot) {\n    throw new Error('captureObsidianScreenshot: the active transport cannot capture screenshots.');\n  }\n\n  if (shouldVerifyTheme) {\n    await assertObsidianThemeUnchanged({\n      action: 'capture a screenshot',\n      transport,\n      vaultPath: cwd\n    });\n  }\n\n  if (shouldHideVaultName) {\n    await hideVaultName({\n      transport,\n      vaultPath: cwd\n    });\n  }\n\n  const hiddenCaret = shouldHideCaret\n    ? await hideCaret({\n      transport,\n      vaultPath: cwd\n    })\n    : undefined;\n\n  const pinnedWindowFocus = shouldPinWindowFocus\n    ? await pinWindowFocus({\n      transport,\n      vaultPath: cwd\n    })\n    : undefined;\n\n  try {\n    return await transport.captureScreenshot(normalizeOptionalProperties<CaptureScreenshotParams>({\n      cwd,\n      heightInPixels,\n      widthInPixels\n    }));\n  } finally {\n    await pinnedWindowFocus?.restore();\n    await hiddenCaret?.restore();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA6BA,OAAO,aAAa;AAKpB,SAAS,oCAAoC;AAC7C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAC1B,SAAS,qBAAqB;AAC9B,SAAS,mCAAmC;AAC5C,SAAS,sBAAsB;AAC/B,SAAS,4BAA4B;AAiHrC,eAAsB,0BAA0B,SAAiE;AAC/G,QAAM;AAAA,IACJ;AAAA,IACA,kBAAkB;AAAA,IAClB,sBAAsB;AAAA,IACtB,uBAAuB;AAAA,IACvB,oBAAoB;AAAA,IACpB,WAAW;AAAA,IACX;AAAA,IACA;AAAA,EACF,IAAI,WAAW,CAAC;AAEhB,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AACvD,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,UAAU,mBAAmB;AAChC,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,MAAI,mBAAmB;AACrB,UAAM,6BAA6B;AAAA,MACjC,QAAQ;AAAA,MACR;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,MAAI,qBAAqB;AACvB,UAAM,cAAc;AAAA,MAClB;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,cAAc,kBAChB,MAAM,UAAU;AAAA,IAChB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,QAAM,oBAAoB,uBACtB,MAAM,eAAe;AAAA,IACrB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,MAAI;AACF,WAAO,MAAM,UAAU,kBAAkB,4BAAqD;AAAA,MAC5F;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC,CAAC;AAAA,EACJ,UAAE;AACA,UAAM,mBAAmB,QAAQ;AACjC,UAAM,aAAa,QAAQ;AAAA,EAC7B;AACF;",
  "names": []
}


package/dist/lib/esm/deterministic-raster.d.mts

@@ -0,0 +1,37 @@
+/**
+ * @file
+ *
+ * The Chromium switches that make an owned desktop instance rasterize the same
+ * frame to the same bytes every time it is captured.
+ *
+ * A sized capture pins the viewport with `Emulation.setDeviceMetricsOverride`
+ * and clears the override afterwards, so every capture re-rasterizes the page
+ * at the requested size. With GPU rasterization on, that re-raster is not
+ * deterministic: the soft `box-shadow` of a modal and of a suggester come back
+ * one value off in a single channel in a fraction of the captures, with nothing
+ * visibly different. Measured on a 1200x800 frame with a modal and a suggester
+ * open, 300 captures each:
+ *
+ * | Launch | Distinct frames |
+ * | --- | --- |
+ * | default | 3 (253 / 39 / 8) |
+ * | `--disable-partial-raster` | 3 (201 / 83 / 16) |
+ * | `--force-color-profile=srgb` | 3 (209 / 78 / 13) |
+ * | no size override at all | 1 |
+ * | `--disable-gpu-rasterization` | 1 |
+ *
+ * So the noise is the GPU rasterizer redoing the page after a resize, and the
+ * resize cannot go, because a sized capture is the whole point of the size
+ * options. Rasterizing on the CPU closes it while compositing stays on the GPU,
+ * which is why this is `--disable-gpu-rasterization` and not `--disable-gpu`
+ * (also stable, but it moves compositing to software as well). It cost no
+ * capture time in the same measurement.
+ */
+/**
+ * Chromium switches passed to every **owned** desktop instance so its captures
+ * are byte-reproducible.
+ *
+ * Only an owned instance gets them: an attached Obsidian was launched by
+ * somebody else, and its switches are not the harness's to choose.
+ */
+export declare const DETERMINISTIC_RASTER_LAUNCH_FLAGS: readonly string[];

package/dist/lib/esm/deterministic-raster.mjs

@@ -0,0 +1,7 @@
+const DETERMINISTIC_RASTER_LAUNCH_FLAGS = [
+  "--disable-gpu-rasterization"
+];
+export {
+  DETERMINISTIC_RASTER_LAUNCH_FLAGS
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -22,6 +22,10 @@ export interface ClickElementParams {
      * The element to click. The pointer is moved to its center. This is a live
      * renderer DOM node — the callback runs in-renderer, so no cross-process
      * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
+     *
+     * The input goes to the window that owns the element (its
+     * `ownerDocument.defaultView`), so an element in a popout is driven in that
+     * popout with no extra parameter.
      */
     readonly element: HTMLElement;
     /**
@@ -49,6 +53,18 @@ export interface ClickMouseParams {
      * @default `[]`
      */
     readonly modifiers?: readonly Modifier[];
+    /**
+     * The Obsidian window to click in: the main window or a popout. Pass the
+     * window that owns the target, e.g. `leaf.view.containerEl.win` for a popout
+     * leaf. Each Obsidian window is its own Electron web contents, so a click
+     * sent to one never reaches another, and the coordinates are in the named
+     * window's viewport.
+     *
+     * **On mobile** there are no popouts, so any window but the main one throws.
+     *
+     * @default the main window (`globalThis`)
+     */
+    readonly window?: Window;
     /**
      * The x coordinate (web-contents DIP) to click at.
      */
@@ -148,6 +164,10 @@ export interface HoverElementParams {
      * The element to hover. The pointer is moved to its center. This is a live
      * renderer DOM node — the callback runs in-renderer, so no cross-process
      * serialization is needed (same as {@link TypeIntoEditorParams.editor}).
+     *
+     * The input goes to the window that owns the element (its
+     * `ownerDocument.defaultView`), so an element in a popout is driven in that
+     * popout with no extra parameter.
      */
     readonly element: HTMLElement;
 }
@@ -226,6 +246,10 @@ 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.
      *
+     * It clicks in the main window unless {@link ClickMouseParams.window} names a
+     * popout. {@link Lib.clickElement} needs no such parameter: it clicks in the
+     * window that owns its element.
+     *
      * **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'`
@@ -313,6 +337,9 @@ export interface Lib {
      * **Desktop only — it throws on mobile**, for the same reason as
      * {@link Lib.hoverElement}: there is no touch pointer to move.
      *
+     * It moves the pointer in the main window unless
+     * {@link MoveMouseParams.window} names a popout.
+     *
      * **Must be awaited** — see {@link Lib.clickElement}.
      *
      * @param params - The web-contents DIP coordinates to move to.
@@ -371,6 +398,10 @@ 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.
      *
+     * It presses the key in the main window unless
+     * {@link PressKeyParams.window} names a popout. Each Obsidian window is its
+     * own web contents, so a key pressed in one never reaches another.
+     *
      * **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
@@ -461,6 +492,17 @@ export type MouseButton = 'left' | 'middle' | 'right';
  * Parameters for {@link Lib.moveMouse}.
  */
 export interface MoveMouseParams {
+    /**
+     * The Obsidian window to move the pointer in: the main window or a popout.
+     * Each Obsidian window is its own Electron web contents with its own pointer,
+     * and the coordinates are in the named window's viewport.
+     *
+     * Mobile has no pointer to move, so {@link Lib.moveMouse} throws there
+     * whatever this is.
+     *
+     * @default the main window (`globalThis`)
+     */
+    readonly window?: Window;
     /**
      * The x coordinate (web-contents DIP) to move the pointer to.
      */
@@ -515,6 +557,18 @@ export interface PressKeyParams {
      * @default `[]`
      */
     readonly modifiers?: readonly Modifier[];
+    /**
+     * The Obsidian window to press the key in: the main window or a popout. Pass
+     * the window that owns the focused target, e.g. `leaf.view.containerEl.win`
+     * for a popout leaf. Each Obsidian window is its own Electron web contents,
+     * so the key goes to the DOM-focused element of the window named here,
+     * whichever window the OS has focused, and never reaches another window.
+     *
+     * **On mobile** there are no popouts, so any window but the main one throws.
+     *
+     * @default the main window (`globalThis`)
+     */
+    readonly window?: Window;
 }
 /**
  * Parameters for {@link Lib.typeIntoEditor}.
@@ -523,6 +577,9 @@ export interface TypeIntoEditorParams {
     /**
      * The editor to type into. It is focused (with the caret moved to the end of
      * the document) before the keystrokes are injected.
+     *
+     * The keystrokes go to the window that owns the editor, so an editor in a
+     * popout is typed into in that popout with no extra parameter.
      */
     readonly editor: Editor;
     /**
@@ -540,6 +597,9 @@ export interface UnhoverElementParams {
      * just outside its bounding box. This is a live renderer DOM node — the
      * callback runs in-renderer, so no cross-process serialization is needed
      * (same as {@link TypeIntoEditorParams.editor}).
+     *
+     * The move goes to the window that owns the element, so an element in a
+     * popout is driven in that popout with no extra parameter.
      */
     readonly element: HTMLElement;
 }