obsidian-integration-testing 17.0.2 → 17.1.1

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

@@ -33,12 +33,14 @@ __export(capture_obsidian_screenshot_exports, {
 module.exports = __toCommonJS(capture_obsidian_screenshot_exports);
 var import_node_process = __toESM(require("node:process"), 1);
 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_transport_factory = require("./transport-factory.cjs");
 async function captureObsidianScreenshot(options) {
   const {
     heightInPixels,
+    shouldHideCaret = true,
     shouldHideVaultName = true,
     transport: transportOverride,
     vaultPath,
@@ -55,14 +57,22 @@ async function captureObsidianScreenshot(options) {
       vaultPath: cwd
     });
   }
-  return transport.captureScreenshot((0, import_normalize_optional_properties.normalizeOptionalProperties)({
-    cwd,
-    heightInPixels,
-    widthInPixels
-  }));
+  const hiddenCaret = shouldHideCaret ? await (0, import_hide_caret.hideCaret)({
+    transport,
+    vaultPath: cwd
+  }) : void 0;
+  try {
+    return await transport.captureScreenshot((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+      cwd,
+      heightInPixels,
+      widthInPixels
+    }));
+  } finally {
+    await hiddenCaret?.restore();
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   captureObsidianScreenshot
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]
}


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

@@ -13,7 +13,9 @@
  *
  * It also makes the frame REPRODUCIBLE before taking it, by hiding the vault's
  * 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.
+ * 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.
  */
 import type { ObsidianTransport } from './transport.cjs';
 /**
@@ -29,6 +31,19 @@ export interface CaptureObsidianScreenshotOptions {
      * geometry.
      */
     readonly heightInPixels?: number;
+    /**
+     * Whether to hide the focused element's caret while capturing, so the frame
+     * does not depend on which phase of its blink the capture caught.
+     *
+     * The caret is made transparent, not blurred: the focus, its ring and
+     * anything open because of it — a suggester under an input — all stay as the
+     * test built them, and the caret is put back once the frame is taken. Turn it
+     * off only to photograph the caret itself, and expect such a frame to differ
+     * between runs.
+     *
+     * @default `true`
+     */
+    readonly shouldHideCaret?: boolean;
     /**
      * Whether to hide the vault's name before capturing, so the frame does not
      * depend on the random suffix of the harness's temporary vault.
@@ -65,7 +80,10 @@ export interface CaptureObsidianScreenshotOptions {
  * The vault's name is hidden first, so two runs of the same suite against two
  * differently-named temporary vaults produce byte-identical PNGs. Pass
  * {@link CaptureObsidianScreenshotOptions.shouldHideVaultName} as `false` to
- * photograph it.
+ * 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.
  *
  * @param options - Optional size, transport and vault overrides.
  * @returns A {@link Promise} that resolves to the raw PNG bytes.

package/dist/lib/cjs/field-text-hold.cjs

@@ -0,0 +1,56 @@
+"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 field_text_hold_exports = {};
+__export(field_text_hold_exports, {
+  holdFieldText: () => holdFieldText
+});
+module.exports = __toCommonJS(field_text_hold_exports);
+const DEFAULT_CONFIRMATION_READ_COUNT = 3;
+const DEFAULT_INTERVAL_IN_MILLISECONDS = 300;
+const DEFAULT_MAX_WRITE_COUNT = 4;
+async function holdFieldText(params) {
+  const confirmationReadCount = params.confirmationReadCount ?? DEFAULT_CONFIRMATION_READ_COUNT;
+  const intervalInMilliseconds = params.intervalInMilliseconds ?? DEFAULT_INTERVAL_IN_MILLISECONDS;
+  const maxWriteCount = params.maxWriteCount ?? DEFAULT_MAX_WRITE_COUNT;
+  const readTexts = [];
+  await params.writeText(params.expectedText);
+  let writeCount = 1;
+  let agreeingReadCount = 0;
+  while (agreeingReadCount < confirmationReadCount) {
+    await params.sleep(intervalInMilliseconds);
+    const text = await params.readText();
+    readTexts.push(text);
+    if (text === params.expectedText) {
+      agreeingReadCount++;
+      continue;
+    }
+    if (text === null || writeCount >= maxWriteCount) {
+      return { isHeld: false, readTexts, writeCount };
+    }
+    await params.writeText(params.expectedText);
+    writeCount++;
+    agreeingReadCount = 0;
+  }
+  return { isHeld: true, readTexts, writeCount };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  holdFieldText
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/field-text-hold.d.cts

@@ -0,0 +1,81 @@
+/**
+ * @file
+ *
+ * Holds a scripted write to a field until it stays put.
+ *
+ * `raiseSoftKeyboard` empties its field for the touch that raises the IME and writes the text back afterwards.
+ * The write lands, and then about one time in five it is undone: the touch started the IME's input connection
+ * from the EMPTY field, and a later update from that connection writes the empty state back over the harness's
+ * write. Nothing reports it — the capture taken straight after simply shows the placeholder — so the write is
+ * not done until repeated reads agree it held.
+ *
+ * The loop is pure, with the read, the write and the sleep injected, the same split as `poll-until`: the
+ * orchestration is unit-tested here, and only its wiring to a live renderer sits in the integration-only
+ * `soft-keyboard`.
+ */
+/**
+ * Parameters for {@link holdFieldText}.
+ */
+export interface HoldFieldTextParams {
+    /**
+     * How many consecutive reads must show the text before it counts as held.
+     *
+     * @default 3
+     */
+    readonly confirmationReadCount?: number;
+    /**
+     * The text the field must end up holding.
+     */
+    readonly expectedText: string;
+    /**
+     * The wait before each read.
+     *
+     * @default 300
+     */
+    readonly intervalInMilliseconds?: number;
+    /**
+     * How many writes are made in all, the first included, before the text is reported lost.
+     *
+     * @default 4
+     */
+    readonly maxWriteCount?: number;
+    /**
+     * Reads what the field holds now, or `null` when the field is gone.
+     */
+    readonly readText: (this: void) => Promise<null | string>;
+    /**
+     * Sleeps for the given number of milliseconds.
+     */
+    readonly sleep: (this: void, milliseconds: number) => Promise<void>;
+    /**
+     * Writes the text into the field.
+     */
+    readonly writeText: (this: void, text: string) => Promise<void>;
+}
+/**
+ * What {@link holdFieldText} found.
+ */
+export interface HoldFieldTextResult {
+    /**
+     * Whether the text held for the whole confirmation window.
+     */
+    readonly isHeld: boolean;
+    /**
+     * Every read, in order — the evidence a failure reports.
+     */
+    readonly readTexts: readonly (null | string)[];
+    /**
+     * How many writes were made, the first included. Above one means the text was lost and written again.
+     */
+    readonly writeCount: number;
+}
+/**
+ * Writes the text, then re-reads the field until it has shown the text on enough consecutive reads, writing it
+ * again each time a read shows anything else.
+ *
+ * A read of `null` ends the hold at once, as not held: the field is gone, so there is nothing left to write into.
+ *
+ * @param params - The text, how to read and write the field, and how long it must hold.
+ * @returns A {@link Promise} that resolves to whether the text held, every read, and how many writes it took.
+ */
+export declare function holdFieldText(params: HoldFieldTextParams): Promise<HoldFieldTextResult>;

package/dist/lib/cjs/hide-caret.cjs

@@ -0,0 +1,78 @@
+"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 hide_caret_exports = {};
+__export(hide_caret_exports, {
+  hideCaret: () => hideCaret
+});
+module.exports = __toCommonJS(hide_caret_exports);
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+async function hideCaret(options) {
+  const { transport, vaultPath } = options ?? {};
+  const isHidden = await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    callback() {
+      let activeEl = document.activeElement;
+      while (activeEl?.shadowRoot?.activeElement) {
+        activeEl = activeEl.shadowRoot.activeElement;
+      }
+      if (!activeEl?.instanceOf(HTMLElement) || activeEl === document.body) {
+        return false;
+      }
+      const holder = globalThis;
+      const existing = holder.__obsidianIntegrationTestingHiddenCaret;
+      if (existing?.el !== activeEl) {
+        existing?.el.setCssStyles({ caretColor: existing.previousCaretColor });
+        holder.__obsidianIntegrationTestingHiddenCaret = {
+          el: activeEl,
+          previousCaretColor: activeEl.style.caretColor
+        };
+      }
+      activeEl.setCssStyles({ caretColor: "transparent" });
+      return true;
+    },
+    transport,
+    vaultPath
+  }));
+  return {
+    isHidden,
+    async restore() {
+      if (!isHidden) {
+        return;
+      }
+      await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+        callback() {
+          const holder = globalThis;
+          const record = holder.__obsidianIntegrationTestingHiddenCaret;
+          if (!record) {
+            return;
+          }
+          record.el.setCssStyles({ caretColor: record.previousCaretColor });
+          holder.__obsidianIntegrationTestingHiddenCaret = void 0;
+        },
+        transport,
+        vaultPath
+      }));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hideCaret
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/hide-caret.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Hides the text caret of the focused element for the length of a capture, so\n * a frame does not depend on which phase of its blink the capture landed in.\n *\n * A focused `<input>` or a focused editor blinks its caret about twice a second,\n * and a capture photographs whichever phase it happens to catch. Two captures\n * of an unchanged window therefore alternate between two byte streams: measured\n * against Obsidian 1.14 at the 1200x800 store size, eight captures 170 ms apart\n * gave 2 distinct PNGs for a focused modal input and 2 for a focused Markdown\n * editor, and exactly 1 each once the caret was transparent.\n *\n * **`caret-color: transparent`, not `blur()`**, and the difference is not\n * cosmetic. Blurring does make the bytes stable too, but it is a state change\n * the app observes: in the same run an open `AbstractInputSuggest` popover closed\n * the moment its input lost focus, so a blur would photograph a different frame\n * from the one the test built. It also drops the focus ring, which does not\n * blink and is often part of what the frame is showing. Obsidian draws its\n * editor caret natively (the CodeMirror cursor layer is empty), so one\n * `caret-color` covers inputs and the editor alike.\n *\n * **Restored afterwards**, unlike the vault name `hideVaultName` hides: the\n * focused field is live state a test goes on typing into, and a caret that\n * silently stayed invisible would be a surprise with no error attached.\n *\n * `captureObsidianScreenshot` calls this by default. It is exported for the\n * captures that cannot: `captureDeviceScreenshot` reads the device framebuffer\n * over `adb` and has no page channel, and its typical frame \u2014 a field with the\n * soft keyboard under it \u2014 is exactly the frame where blurring is wrong, since\n * blurring would take the keyboard down with the focus.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian) covered by integration tests, not unit tests. */\n\nimport type { EvalInObsidianParams } 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 * What {@link hideCaret} returns: whether a caret was hidden, and how to put it\n * back.\n */\nexport interface HiddenCaret {\n  /**\n   * Whether an element held focus, and so had a caret to hide. `false` is a\n   * legitimate answer \u2014 a frame with nothing focused has no caret \u2014 and\n   * {@link restore} is then a no-op.\n   */\n  readonly isHidden: boolean;\n\n  /**\n   * Puts the focused element's own inline `caret-color` back, exactly as it\n   * was \u2014 removed when it had none.\n   *\n   * @returns A {@link Promise} that resolves once the caret is restored.\n   */\n  restore: () => Promise<void>;\n}\n\n/**\n * Options for {@link hideCaret}.\n */\nexport interface HideCaretOptions {\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 hide the caret in. When omitted, the\n   * current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n// A `window` property rather than a closure variable: the hide and the restore\n// are two separate evaluations, and the element is not serializable. The key is\n// spelled out in the holder rather than shared through a constant, because a\n// 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 HiddenCaretHolder {\n  __obsidianIntegrationTestingHiddenCaret?: HiddenCaretRecord | undefined;\n}\n\ninterface HiddenCaretRecord {\n  readonly el: HTMLElement;\n  readonly previousCaretColor: string;\n}\n\n/**\n * Makes the caret of the focused element transparent, leaving the focus itself\n * alone.\n *\n * The element is found through nested shadow roots, since\n * `document.activeElement` stops at a shadow host and the caret belongs to the\n * element inside it. Re-applying before a restore keeps the ORIGINAL value, so\n * two hides and one restore still leave the element as it was found; a hide on\n * a different element first restores the one an unrestored hide left behind.\n *\n * @param options - Transport and vault overrides.\n * @returns A {@link Promise} that resolves to the {@link HiddenCaret}.\n */\nexport async function hideCaret(options?: HideCaretOptions): Promise<HiddenCaret> {\n  const { transport, vaultPath } = options ?? {};\n\n  const isHidden = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<Record<string, never>, boolean>>({\n    callback(): boolean {\n      let activeEl = document.activeElement;\n      while (activeEl?.shadowRoot?.activeElement) {\n        activeEl = activeEl.shadowRoot.activeElement;\n      }\n\n      if (!activeEl?.instanceOf(HTMLElement) || activeEl === document.body) {\n        return false;\n      }\n\n      // eslint-disable-next-line no-restricted-syntax -- Approved double cast: the hidden-caret record is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n      const holder = globalThis as unknown as HiddenCaretHolder;\n      const existing = holder.__obsidianIntegrationTestingHiddenCaret;\n      if (existing?.el !== activeEl) {\n        // A hide that was never restored, on an element that has since lost\n        // focus: put that one back rather than orphan it invisible.\n        existing?.el.setCssStyles({ caretColor: existing.previousCaretColor });\n        holder.__obsidianIntegrationTestingHiddenCaret = {\n          el: activeEl,\n          previousCaretColor: activeEl.style.caretColor\n        };\n      }\n\n      activeEl.setCssStyles({ caretColor: 'transparent' });\n      return true;\n    },\n    transport,\n    vaultPath\n  }));\n\n  return {\n    isHidden,\n    async restore(): Promise<void> {\n      if (!isHidden) {\n        return;\n      }\n\n      await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<Record<string, never>, void>>({\n        callback(): void {\n          // eslint-disable-next-line no-restricted-syntax -- Approved double cast: the hidden-caret record is our internal Window augmentation, intentionally kept local (not declared globally) to avoid leaking into consumer types.\n          const holder = globalThis as unknown as HiddenCaretHolder;\n          const record = holder.__obsidianIntegrationTestingHiddenCaret;\n          if (!record) {\n            return;\n          }\n\n          record.el.setCssStyles({ caretColor: record.previousCaretColor });\n          holder.__obsidianIntegrationTestingHiddenCaret = undefined;\n        },\n        transport,\n        vaultPath\n      }));\n    }\n  };\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsCA,8BAA+B;AAC/B,2CAA4C;AAqE5C,eAAsB,UAAU,SAAkD;AAChF,QAAM,EAAE,WAAW,UAAU,IAAI,WAAW,CAAC;AAE7C,QAAM,WAAW,UAAM,4CAAe,kEAAkF;AAAA,IACtH,WAAoB;AAClB,UAAI,WAAW,SAAS;AACxB,aAAO,UAAU,YAAY,eAAe;AAC1C,mBAAW,SAAS,WAAW;AAAA,MACjC;AAEA,UAAI,CAAC,UAAU,WAAW,WAAW,KAAK,aAAa,SAAS,MAAM;AACpE,eAAO;AAAA,MACT;AAGA,YAAM,SAAS;AACf,YAAM,WAAW,OAAO;AACxB,UAAI,UAAU,OAAO,UAAU;AAG7B,kBAAU,GAAG,aAAa,EAAE,YAAY,SAAS,mBAAmB,CAAC;AACrE,eAAO,0CAA0C;AAAA,UAC/C,IAAI;AAAA,UACJ,oBAAoB,SAAS,MAAM;AAAA,QACrC;AAAA,MACF;AAEA,eAAS,aAAa,EAAE,YAAY,cAAc,CAAC;AACnD,aAAO;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,SAAO;AAAA,IACL;AAAA,IACA,MAAM,UAAyB;AAC7B,UAAI,CAAC,UAAU;AACb;AAAA,MACF;AAEA,gBAAM,4CAAe,kEAA+E;AAAA,QAClG,WAAiB;AAEf,gBAAM,SAAS;AACf,gBAAM,SAAS,OAAO;AACtB,cAAI,CAAC,QAAQ;AACX;AAAA,UACF;AAEA,iBAAO,GAAG,aAAa,EAAE,YAAY,OAAO,mBAAmB,CAAC;AAChE,iBAAO,0CAA0C;AAAA,QACnD;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC,CAAC;AAAA,IACJ;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/cjs/hide-caret.d.cts

@@ -0,0 +1,81 @@
+/**
+ * @file
+ *
+ * Hides the text caret of the focused element for the length of a capture, so
+ * a frame does not depend on which phase of its blink the capture landed in.
+ *
+ * A focused `<input>` or a focused editor blinks its caret about twice a second,
+ * and a capture photographs whichever phase it happens to catch. Two captures
+ * of an unchanged window therefore alternate between two byte streams: measured
+ * against Obsidian 1.14 at the 1200x800 store size, eight captures 170 ms apart
+ * gave 2 distinct PNGs for a focused modal input and 2 for a focused Markdown
+ * editor, and exactly 1 each once the caret was transparent.
+ *
+ * **`caret-color: transparent`, not `blur()`**, and the difference is not
+ * cosmetic. Blurring does make the bytes stable too, but it is a state change
+ * the app observes: in the same run an open `AbstractInputSuggest` popover closed
+ * the moment its input lost focus, so a blur would photograph a different frame
+ * from the one the test built. It also drops the focus ring, which does not
+ * blink and is often part of what the frame is showing. Obsidian draws its
+ * editor caret natively (the CodeMirror cursor layer is empty), so one
+ * `caret-color` covers inputs and the editor alike.
+ *
+ * **Restored afterwards**, unlike the vault name `hideVaultName` hides: the
+ * focused field is live state a test goes on typing into, and a caret that
+ * silently stayed invisible would be a surprise with no error attached.
+ *
+ * `captureObsidianScreenshot` calls this by default. It is exported for the
+ * captures that cannot: `captureDeviceScreenshot` reads the device framebuffer
+ * over `adb` and has no page channel, and its typical frame — a field with the
+ * soft keyboard under it — is exactly the frame where blurring is wrong, since
+ * blurring would take the keyboard down with the focus.
+ */
+import type { ObsidianTransport } from './transport.cjs';
+/**
+ * What {@link hideCaret} returns: whether a caret was hidden, and how to put it
+ * back.
+ */
+export interface HiddenCaret {
+    /**
+     * Whether an element held focus, and so had a caret to hide. `false` is a
+     * legitimate answer — a frame with nothing focused has no caret — and
+     * {@link restore} is then a no-op.
+     */
+    readonly isHidden: boolean;
+    /**
+     * Puts the focused element's own inline `caret-color` back, exactly as it
+     * was — removed when it had none.
+     *
+     * @returns A {@link Promise} that resolves once the caret is restored.
+     */
+    restore: () => Promise<void>;
+}
+/**
+ * Options for {@link hideCaret}.
+ */
+export interface HideCaretOptions {
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian window to hide the caret in. When omitted, the
+     * current test context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Makes the caret of the focused element transparent, leaving the focus itself
+ * alone.
+ *
+ * The element is found through nested shadow roots, since
+ * `document.activeElement` stops at a shadow host and the caret belongs to the
+ * element inside it. Re-applying before a restore keeps the ORIGINAL value, so
+ * two hides and one restore still leave the element as it was found; a hide on
+ * a different element first restores the one an unrestored hide left behind.
+ *
+ * @param options - Transport and vault overrides.
+ * @returns A {@link Promise} that resolves to the {@link HiddenCaret}.
+ */
+export declare function hideCaret(options?: HideCaretOptions): Promise<HiddenCaret>;

package/dist/lib/cjs/index.cjs

@@ -68,6 +68,7 @@ __export(index_exports, {
   fitScreenshotToCanvas: () => import_fit_screenshot.fitScreenshotToCanvas,
   getAppConfig: () => import_app_config.getAppConfig,
   getVersionMetadata: () => import_obsidian_metadata.getVersionMetadata,
+  hideCaret: () => import_hide_caret.hideCaret,
   hideVaultName: () => import_hide_vault_name.hideVaultName,
   isPng: () => import_capture_screenshot.isPng,
   isScriptTimeoutError: () => import_eval_cap_exceeded_error.isScriptTimeoutError,
@@ -133,6 +134,7 @@ var import_eval_cap_exceeded_error = require("./eval-cap-exceeded-error.cjs");
 var import_eval_cap = require("./eval-cap.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_fit_screenshot = require("./fit-screenshot.cjs");
+var import_hide_caret = require("./hide-caret.cjs");
 var import_hide_vault_name = require("./hide-vault-name.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
 var import_installer_compatibility = require("./installer-compatibility.cjs");
@@ -211,6 +213,7 @@ var import_version_matrix = require("./version-matrix.cjs");
   fitScreenshotToCanvas,
   getAppConfig,
   getVersionMetadata,
+  hideCaret,
   hideVaultName,
   isPng,
   isScriptTimeoutError,
@@ -250,4 +253,4 @@ var import_version_matrix = require("./version-matrix.cjs");
   withSoftKeyboardEnabled,
   writeDeviceSetting
 });
-//# 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 { RunAdbParams } from './adb.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\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 { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.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  BuildDemoVaultPopulateAsyncParams,\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 { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.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 { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.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  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\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 { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.cjs';\nexport {\n  buildStatusBarBandFailureMessage,\n  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,\n  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,\n  paintOutStatusBar,\n  resolveStatusBarBand\n} from './paint-out-status-bar.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 { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.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  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\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;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;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAEP,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAQzC,kCAMO;AAEP,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAOO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,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 { RunAdbParams } from './adb.cjs';\nexport {\n  runAdbBinary,\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.cjs';\nexport type {\n  AppConfigRestore,\n  GetAppConfigParams,\n  SetAppConfigParams,\n  WithAppConfigParams\n} from './app-config.cjs';\nexport {\n  getAppConfig,\n  restoreAppConfig,\n  setAppConfig,\n  withAppConfig\n} from './app-config.cjs';\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 { CdpCommandTimeoutErrorConstructorParams } from './cdp-command-timeout-error.cjs';\nexport { CdpCommandTimeoutError } from './cdp-command-timeout-error.cjs';\nexport type { ConfigDirectoryFallbackErrorConstructorParams } from './config-directory-fallback-error.cjs';\nexport { ConfigDirectoryFallbackError } from './config-directory-fallback-error.cjs';\nexport {\n  assertValidConfigDirectory,\n  DEFAULT_CONFIG_DIRECTORY\n} from './config-directory.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  BuildDemoVaultPopulateAsyncParams,\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 { CaptureDeviceScreenshotParams } from './device-screenshot.cjs';\nexport { captureDeviceScreenshot } from './device-screenshot.cjs';\nexport type {\n  DeviceSettingRestore,\n  DeviceSettingRestoreDelete,\n  DeviceSettingRestoreWrite\n} from './device-setting-restore.cjs';\nexport {\n  DeviceSettingRestoreKind,\n  resolveDeviceSettingRestore\n} from './device-setting-restore.cjs';\nexport type { BuildDeviceSettingsCommandArgumentsParams } from './device-settings-command.cjs';\nexport {\n  buildDeviceSettingsCommandArguments,\n  DeviceSettingNamespace,\n  DeviceSettingVerb\n} from './device-settings-command.cjs';\nexport type {\n  DeviceSettingParams,\n  WithSoftKeyboardEnabledParams,\n  WriteDeviceSettingParams\n} from './device-settings.cjs';\nexport {\n  deleteDeviceSetting,\n  readDeviceSetting,\n  withSoftKeyboardEnabled,\n  writeDeviceSetting\n} from './device-settings.cjs';\nexport type {\n  ElectronCompatibility,\n  ElectronCompatibilityTier,\n  ResolveElectronCompatibilityParams\n} from './electron-compatibility.cjs';\nexport { resolveElectronCompatibility } from './electron-compatibility.cjs';\nexport type {\n  EmulatorDeviceCandidate,\n  SelectEmulatorDeviceIdParams\n} from './emulator-device-id.cjs';\nexport { selectEmulatorDeviceId } from './emulator-device-id.cjs';\nexport type { EvalCapExceededErrorConstructorParams } from './eval-cap-exceeded-error.cjs';\nexport {\n  EvalCapExceededError,\n  isScriptTimeoutError\n} from './eval-cap-exceeded-error.cjs';\nexport { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from './eval-cap.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 {\n  HiddenCaret,\n  HideCaretOptions\n} from './hide-caret.cjs';\nexport { hideCaret } from './hide-caret.cjs';\nexport type { HideVaultNameOptions } from './hide-vault-name.cjs';\nexport { hideVaultName } from './hide-vault-name.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  LabelCaptionMeasurement,\n  LabelScreenshotOptions,\n  MeasureLabelCaptionParams\n} from './label-screenshot.cjs';\nexport {\n  buildLabelSvg,\n  computeLabelBand,\n  escapeSvgText,\n  labelScreenshot,\n  measureLabelCaption\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 { OpenObsidianSettingsTabParams } from './open-obsidian-settings-tab.cjs';\nexport { openObsidianSettingsTab } from './open-obsidian-settings-tab.cjs';\nexport type { OwnedInstanceExitedErrorConstructorParams } from './owned-instance-exited-error.cjs';\nexport { OwnedInstanceExitedError } from './owned-instance-exited-error.cjs';\nexport type {\n  BuildStatusBarBandFailureMessageParams,\n  PaintOutStatusBarOptions,\n  ResolveStatusBarBandParams,\n  StatusBarBandColor,\n  StatusBarBandVerdict\n} from './paint-out-status-bar.cjs';\nexport {\n  buildStatusBarBandFailureMessage,\n  DEFAULT_STATUS_BAR_EDGE_MARGIN_IN_PIXELS,\n  DEFAULT_STATUS_BAR_SAMPLE_INSET_IN_PIXELS,\n  paintOutStatusBar,\n  resolveStatusBarBand\n} from './paint-out-status-bar.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 { ResolveEmulatorDeviceIdParams } from './resolve-emulator-device-id.cjs';\nexport { resolveEmulatorDeviceId } from './resolve-emulator-device-id.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  BuildSoftKeyboardDiagnosticMessageParams,\n  CheckIsSoftKeyboardUpParams,\n  ElementRect,\n  ResolveSoftKeyboardTapPointsParams,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\nexport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\nexport type {\n  RaiseSoftKeyboardParams,\n  TapDeviceParams\n} from './soft-keyboard.cjs';\nexport {\n  raiseSoftKeyboard,\n  tapDevice\n} from './soft-keyboard.cjs';\nexport type { StaleBuildErrorConstructorParams } from './stale-build-error.cjs';\nexport { StaleBuildError } from './stale-build-error.cjs';\nexport type {\n  PopulateFileContent,\n  PopulateFilesParams,\n  TemporaryVaultConstructorOptions\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;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;AAOA,iBAIO;AAOP,wBAKO;AAMP,qCAAoC;AAEpC,yCAA0C;AAK1C,gCAKO;AAEP,uCAAuC;AAEvC,6CAA6C;AAC7C,8BAGO;AAKP,4BAA6B;AAK7B,wBAA0B;AAM1B,8BAIO;AAOP,kCAGO;AAMP,iCAGO;AAEP,6BAAkC;AAClC,4CAA2C;AAE3C,+BAAwC;AAMxC,oCAGO;AAEP,qCAIO;AAMP,6BAKO;AAMP,oCAA6C;AAK7C,gCAAuC;AAEvC,qCAGO;AACP,sBAAiD;AAkBjD,8BAA+B;AAM/B,4BAGO;AAKP,wBAA0B;AAE1B,6BAA8B;AAE9B,kDAAkD;AAMlD,qCAA8C;AAE9C,4CAA4C;AAQ5C,8BAMO;AAEP,0BAAoC;AAOpC,+BAAmC;AACnC,8BAGO;AAEP,wCAAwC;AAExC,yCAAyC;AAQzC,kCAMO;AAEP,8BAA+B;AAC/B,iDAAgD;AAEhD,wCAAwC;AAExC,gCAAyC;AAEzC,wCAAwC;AASxC,oCAOO;AAKP,2BAGO;AAEP,+BAAgC;AAMhC,6BAA+B;AAK/B,8BAAgC;AAOhC,mCAAoC;AACpC,+BAA2C;AAM3C,+BAAuC;AAMvC,4BAGO;AAEP,4BAA+C;",
  "names": []
}


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

@@ -50,6 +50,8 @@ export type { ClickElementParams, ClickMouseParams, CommonArguments, CreateNoteP
 export { evalInObsidian } from './eval-in-obsidian.cjs';
 export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.cjs';
 export { computeFitToCanvas, fitScreenshotToCanvas } from './fit-screenshot.cjs';
+export type { HiddenCaret, HideCaretOptions } from './hide-caret.cjs';
+export { hideCaret } from './hide-caret.cjs';
 export type { HideVaultNameOptions } from './hide-vault-name.cjs';
 export { hideVaultName } from './hide-vault-name.cjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "17.0.2";
+const LIBRARY_VERSION = false ? "dev" : "17.1.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION