obsidian-integration-testing 17.1.1 → 17.3.0

package/dist/lib/cjs/apply-obsidian-theme.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var apply_obsidian_theme_exports = {};
+__export(apply_obsidian_theme_exports, {
+  applyObsidianTheme: () => applyObsidianTheme,
+  assertObsidianThemeUnchanged: () => assertObsidianThemeUnchanged
+});
+module.exports = __toCommonJS(apply_obsidian_theme_exports);
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+const DEFAULT_TIMEOUT_IN_MILLISECONDS = 1e4;
+async function applyObsidianTheme(params) {
+  const {
+    theme,
+    timeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MILLISECONDS,
+    transport,
+    vaultPath
+  } = params;
+  await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.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 (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.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.`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,8BAA+B;AAC/B,2CAA4C;AA6E5C,MAAM,kCAAkC;AAgBxC,eAAsB,mBAAmB,QAAiD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,YAAM,4CAAe,kEAA8E;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,UAAM,4CAAe,kEAAwF;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/cjs/apply-obsidian-theme.d.cts

@@ -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.cjs';
+/**
+ * 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/cjs/capture-obsidian-screenshot.cjs

@@ -32,16 +32,20 @@ __export(capture_obsidian_screenshot_exports, {
 });
 module.exports = __toCommonJS(capture_obsidian_screenshot_exports);
 var import_node_process = __toESM(require("node:process"), 1);
+var import_apply_obsidian_theme = require("./apply-obsidian-theme.cjs");
 var import_context_provider = require("./context-provider.cjs");
 var import_hide_caret = require("./hide-caret.cjs");
 var import_hide_vault_name = require("./hide-vault-name.cjs");
 var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+var import_pin_window_focus = require("./pin-window-focus.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
 async function captureObsidianScreenshot(options) {
   const {
     heightInPixels,
     shouldHideCaret = true,
     shouldHideVaultName = true,
+    shouldPinWindowFocus = true,
+    shouldVerifyTheme = true,
     transport: transportOverride,
     vaultPath,
     widthInPixels
@@ -51,6 +55,13 @@ async function captureObsidianScreenshot(options) {
   if (!transport.captureScreenshot) {
     throw new Error("captureObsidianScreenshot: the active transport cannot capture screenshots.");
   }
+  if (shouldVerifyTheme) {
+    await (0, import_apply_obsidian_theme.assertObsidianThemeUnchanged)({
+      action: "capture a screenshot",
+      transport,
+      vaultPath: cwd
+    });
+  }
   if (shouldHideVaultName) {
     await (0, import_hide_vault_name.hideVaultName)({
       transport,
@@ -61,6 +72,10 @@ async function captureObsidianScreenshot(options) {
     transport,
     vaultPath: cwd
   }) : void 0;
+  const pinnedWindowFocus = shouldPinWindowFocus ? await (0, import_pin_window_focus.pinWindowFocus)({
+    transport,
+    vaultPath: cwd
+  }) : void 0;
   try {
     return await transport.captureScreenshot((0, import_normalize_optional_properties.normalizeOptionalProperties)({
       cwd,
@@ -68,6 +83,7 @@ async function captureObsidianScreenshot(options) {
       widthInPixels
     }));
   } finally {
+    await pinnedWindowFocus?.restore();
     await hiddenCaret?.restore();
   }
 }
@@ -75,4 +91,4 @@ async function captureObsidianScreenshot(options) {
 0 && (module.exports = {
   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.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { hideCaret } from './hide-caret.cjs';\nimport { hideVaultName } from './hide-vault-name.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,0BAAoB;AAKpB,8BAGO;AACP,wBAA0B;AAC1B,6BAA8B;AAC9B,2CAA4C;AAC5C,+BAAqC;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,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AACvD,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,UAAU,mBAAmB;AAChC,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,MAAI,qBAAqB;AACvB,cAAM,sCAAc;AAAA,MAClB;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,cAAc,kBAChB,UAAM,6BAAU;AAAA,IAChB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,MAAI;AACF,WAAO,MAAM,UAAU,sBAAkB,kEAAqD;AAAA,MAC5F;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC,CAAC;AAAA,EACJ,UAAE;AACA,UAAM,aAAa,QAAQ;AAAA,EAC7B;AACF;",
  "names": ["process"]
}

+//# 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.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { assertObsidianThemeUnchanged } from './apply-obsidian-theme.cjs';\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.cjs';\nimport { hideCaret } from './hide-caret.cjs';\nimport { hideVaultName } from './hide-vault-name.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { pinWindowFocus } from './pin-window-focus.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BA,0BAAoB;AAKpB,kCAA6C;AAC7C,8BAGO;AACP,wBAA0B;AAC1B,6BAA8B;AAC9B,2CAA4C;AAC5C,8BAA+B;AAC/B,+BAAqC;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,iBAAa,sCAAa,KAAK,oBAAAA,QAAQ,IAAI;AACvD,QAAM,YAAY,qBAAqB,UAAM,mDAAqB,6CAAoB,CAAC;AAEvF,MAAI,CAAC,UAAU,mBAAmB;AAChC,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,MAAI,mBAAmB;AACrB,cAAM,0DAA6B;AAAA,MACjC,QAAQ;AAAA,MACR;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,MAAI,qBAAqB;AACvB,cAAM,sCAAc;AAAA,MAClB;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,cAAc,kBAChB,UAAM,6BAAU;AAAA,IAChB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,QAAM,oBAAoB,uBACtB,UAAM,wCAAe;AAAA,IACrB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,MAAI;AACF,WAAO,MAAM,UAAU,sBAAkB,kEAAqD;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": ["process"]
}


package/dist/lib/cjs/capture-obsidian-screenshot.d.cts

@@ -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.cjs';
 /**
@@ -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/cjs/deterministic-raster.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deterministic_raster_exports = {};
+__export(deterministic_raster_exports, {
+  DETERMINISTIC_RASTER_LAUNCH_FLAGS: () => DETERMINISTIC_RASTER_LAUNCH_FLAGS
+});
+module.exports = __toCommonJS(deterministic_raster_exports);
+const DETERMINISTIC_RASTER_LAUNCH_FLAGS = [
+  "--disable-gpu-rasterization"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DETERMINISTIC_RASTER_LAUNCH_FLAGS
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/deterministic-raster.d.cts

@@ -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[];