obsidian-integration-testing 17.0.2 → 17.1.1

package/dist/lib/cjs/soft-keyboard.cjs

@@ -39,6 +39,8 @@ var import_promises = require("node:timers/promises");
 var import_adb = require("./adb.cjs");
 var import_device_screenshot = require("./device-screenshot.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_field_text_hold = require("./field-text-hold.cjs");
+var import_log = require("./log.cjs");
 var import_soft_keyboard_geometry = require("./soft-keyboard-geometry.cjs");
 const DEFAULT_DIAGNOSTICS_DIRECTORY = (0, import_node_path.join)(import_node_process.default.cwd(), "dist", "screenshots");
 const KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;
@@ -48,13 +50,19 @@ const KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY
 async function raiseSoftKeyboard(params) {
   await lowerSoftKeyboardIfShown(params);
   const textToRestore = await emptyFieldForTouch(params);
+  let snapshot;
   try {
-    return await tapUntilKeyboardIsUp(params);
-  } finally {
+    snapshot = await tapUntilKeyboardIsUp(params);
+  } catch (error) {
     if (textToRestore !== null) {
-      await writeFieldText(params, textToRestore);
+      await holdFieldTextBestEffort(params, textToRestore);
     }
+    throw error;
   }
+  if (textToRestore !== null) {
+    await restoreFieldText(params, textToRestore);
+  }
+  return snapshot;
 }
 async function tapDevice(params) {
   await (0, import_adb.runAdbText)({
@@ -99,6 +107,25 @@ async function emptyFieldForTouch(params) {
   await writeFieldText(params, "");
   return content.text;
 }
+async function holdFieldTextBestEffort(params, text) {
+  try {
+    await holdTextInField(params, text);
+  } catch {
+  }
+}
+async function holdTextInField(params, text) {
+  return await (0, import_field_text_hold.holdFieldText)({
+    expectedText: text,
+    async readText() {
+      const content = await readFieldContent(params);
+      return content?.text ?? null;
+    },
+    sleep: import_promises.setTimeout,
+    async writeText(value) {
+      await writeFieldText(params, value);
+    }
+  });
+}
 async function lowerSoftKeyboardIfShown(params) {
   let inputMethodState = await readInputMethodState(params);
   for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {
@@ -175,6 +202,20 @@ async function readSoftKeyboardViewport(params) {
     ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
   });
 }
+async function restoreFieldText(params, text) {
+  const result = await holdTextInField(params, text);
+  if (result.writeCount > 1) {
+    (0, import_log.log)(
+      `[soft-keyboard] The text written back into "${params.inputSelector}" was lost ${String(result.writeCount - 1)} time(s) and written again; reads: ${JSON.stringify(result.readTexts)}.`
+    );
+  }
+  if (!result.isHeld) {
+    throw new Error(
+      `raiseSoftKeyboard: the text written back into "${params.inputSelector}" after the touch did not stay there. Expected ${JSON.stringify(text)}; ${String(result.writeCount)} write(s), and the field read ${JSON.stringify(result.readTexts)}. A capture taken now would show the field without its text.
+device: ${await readInputMethodState(params)}`
+    );
+  }
+}
 async function tapUntilKeyboardIsUp(params) {
   const baselineSnapshot = await readSoftKeyboardViewport(params);
   let snapshot = baselineSnapshot;
@@ -220,4 +261,4 @@ async function writeFieldText(params, text) {
   raiseSoftKeyboard,
   tapDevice
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Raises the Android soft keyboard for a screenshot, and proves it came up.\n *\n * Two things have to be true, and the second is the one that is easy to miss:\n *\n * 1. The device must be allowed to draw a keyboard at all. The screenshot AVDs\n *    are built `hw.keyboard=yes`, so Android suppresses the on-screen one \u2014\n *    `withSoftKeyboardEnabled` in `device-settings` is what lifts that.\n * 2. The IME must be *asked* for by a gesture. A field that takes focus\n *    programmatically does not get one: an Android WebView raises the IME on a\n *    real touch, and a run with the setting flipped and no touch comes back with\n *    exactly the empty band it had before. `adb shell input tap` is that gesture.\n *\n * 3. The proof that it arrived is that the field **moved**, measured against a\n *    baseline read here before the first touch. An absolute offset from the\n *    viewport bottom is the same test only for a bottom-anchored field; for a\n *    centred modal it is already true with no keyboard, which used to break the\n *    loop below before it had dispatched a single touch and return success\n *    having done nothing. Reading the baseline first also makes that shape\n *    unrepresentable rather than merely corrected: the delta of the baseline\n *    against itself is zero, so the first iteration always taps.\n *\n *    **A keyboard ALREADY up is put down first**, because a delta cannot see\n *    one: the field has already lifted, so it reads as a field that never moved.\n *    That was every frame after the first of a suite that takes several \u2014 the\n *    keyboard left up by one frame, or brought back by Obsidian focusing the\n *    next modal's field, made the next baseline already-lifted (measured\n *    2026-09-20: frames 2-5 each failed `lift=0` beside `mInputShown=true`,\n *    each framebuffer showing a correctly lifted field under a fully drawn\n *    keyboard). The alternative was to accept `lift=0` whenever the device says\n *    a keyboard is showing, and it was refused: that is a frame the helper did\n *    not prove, which is the vacuous pass the delta was introduced to end,\n *    re-opened by a different door. So the device is asked, a showing IME is\n *    retracted with `KEYCODE_BACK`, and the lift is proved as before. It has to\n *    happen HERE, not after the previous capture: lowering it there was tried,\n *    and the IME came back on its own before the next baseline was read.\n *\n * 4. **That touch draws a selection handle when it lands inside TEXT**, and a\n *    device capture photographs it. Chromium shows the insertion handle on a tap\n *    into text and none on a tap into an EMPTY editable, and a value written by\n *    script raises none at all \u2014 so the field is emptied for the touch and its\n *    text written back afterwards. `obsidian-link-picker` shipped a teal handle\n *    in a store listing image twice before anyone worked out where it came from,\n *    and nothing in this module's own documentation of the touch hinted at it.\n *    See `shouldEmptyFieldForTouch`.\n *\n * The geometry that decides whether it worked is unit-tested in\n * `soft-keyboard-geometry`; everything here drives a real device, so the whole\n * module is integration-time code.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian on a real device) covered by integration tests, not unit tests. */\n\nimport {\n  mkdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\n\nimport { runAdbText } from './adb.cjs';\nimport { captureDeviceScreenshot } from './device-screenshot.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\n\n/**\n * Parameters for {@link raiseSoftKeyboard}.\n */\nexport interface RaiseSoftKeyboardParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where a failed attempt writes the device framebuffer.\n   *\n   * When omitted, it is `dist/screenshots` under the working directory \u2014 resolved at load, so there is no\n   * literal default to state here.\n   */\n  readonly diagnosticsDirectory?: string;\n\n  /**\n   * The CSS selector of the field to touch, e.g. `.prompt-input`.\n   */\n  readonly inputSelector: string;\n\n  /**\n   * The least a raised keyboard lifts the field by.\n   *\n   * When omitted, `DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS` from `soft-keyboard-geometry` applies.\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * Whether to empty the field before the touch, and write its text back afterwards.\n   *\n   * **On by default, because the touch that raises the keyboard also draws a selection handle when it\n   * lands inside TEXT.** Chromium shows the insertion handle on a tap into text and draws none on a tap\n   * into an EMPTY editable, and a device capture photographs it \u2014 which is how `obsidian-link-picker`\n   * shipped a teal handle in a store listing image twice before anyone understood where it came from. A\n   * value written by script raises no handle, so emptying the field, touching it, and writing the text\n   * back leaves the frame showing the same query with nothing hanging off it.\n   *\n   * Only an `<input>` or a `<textarea>` is emptied. A `contenteditable` holding text is REFUSED rather\n   * than written to: its content usually belongs to an editor that owns its own DOM, and blanking that\n   * by hand destroys it. Empty such a field yourself, or turn this off.\n   *\n   * Turning it off restores the pre-2026-09-23 behaviour exactly: the field is touched as it stands.\n   *\n   * @default true\n   */\n  readonly shouldEmptyFieldForTouch?: boolean;\n\n  /**\n   * The vault to read the geometry from. When omitted, the current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link tapDevice}.\n */\nexport interface TapDeviceParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where to touch it.\n   */\n  readonly point: SoftKeyboardTapPoint;\n}\n\n/**\n * Where a failed attempt leaves its evidence \u2014 under `dist/`, which a plugin repo using this harness gitignores, like the capture scratch files.\n */\nconst DEFAULT_DIAGNOSTICS_DIRECTORY = join(process.cwd(), 'dist', 'screenshots');\n\n/**\n * How long the IME takes to finish animating in, after which the layout has settled.\n */\nconst KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;\n\n/**\n * How long the IME takes to finish animating out after `KEYCODE_BACK`, measured in the capture suite this\n * was moved out of.\n */\nconst KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS = 900;\n\n/**\n * How many times `KEYCODE_BACK` is pressed before a keyboard that will not go down is reported.\n *\n * Two, because the first press can land while the IME is still animating UP from the focus that raised\n * it, and an IME mid-animation swallows the key without retracting.\n */\nconst KEYBOARD_RETRACT_ATTEMPT_COUNT = 2;\n\n/**\n * How long a keyboard reported showing is watched before `KEYCODE_BACK` is pressed at it.\n *\n * One retract animation: an IME already on its way down \u2014 the modal that raised it has just closed \u2014 is\n * still reported showing by a read taken at the start of its retract, and is gone by the end of it. Pressing\n * at the first read then lands the key on the app instead, which closes the modal the frame is about to\n * photograph. Two reads that agree across this window say the keyboard is staying up.\n */\nconst KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS;\n\n/**\n * What a field holds, and whether it is one this can put back.\n */\ninterface FieldContent {\n  /**\n   * Whether the field's value can be written \u2014 true for an `<input>` or a `<textarea>`, false for\n   * anything else, whose content usually belongs to an editor that owns its own DOM.\n   */\n  readonly canWrite: boolean;\n\n  /**\n   * The text the field currently holds.\n   */\n  readonly text: string;\n}\n\n/**\n * Raises the on-screen keyboard with a real touch on a field, and confirms it came up.\n *\n * Call it inside `withSoftKeyboardEnabled` \u2014 the device setting alone does not raise the keyboard, and this\n * touch alone cannot while the setting suppresses it.\n *\n * **A keyboard that is already up is put DOWN first.** The first geometry read is the baseline every later\n * read is compared against, so a keyboard already up would leave the field nothing to lift by and read as\n * one that never came. The device is asked before anything else, and a showing IME is retracted with\n * `KEYCODE_BACK` \u2014 asked FIRST because, with no IME showing, that key reaches the app and closes the very\n * modal the frame is about to photograph. So the helper is safe to call once per frame of a multi-frame\n * suite, and every call still proves its own lift. The other answer \u2014 accepting a zero lift whenever the\n * device reports a keyboard \u2014 was refused, because it accepts a frame the helper did not prove.\n *\n * **The field is EMPTIED for the touch and written back afterwards**, because a touch that lands inside\n * text draws Chromium's selection handle and the framebuffer photographs it \u2014 see\n * {@link RaiseSoftKeyboardParams.shouldEmptyFieldForTouch}, which turns that off.\n *\n * **The geometry returned is read with the field still empty**, and the text is written back after it.\n * That is the state the proven capture suites assert against, and it is deliberate rather than\n * incidental: the baseline is read AFTER the field is emptied, so the lift is measured between two reads\n * of the same field content. A field whose own text changes the layout around it \u2014 a suggester whose row\n * count answers the query \u2014 moves when it is cleared, and a delta measured across that move is not a\n * keyboard. Read the geometry again yourself if the restored text moves anything you are about to assert\n * on.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if a keyboard already up would not go down, if the field never matched, if it holds text\n *   this cannot empty and put back, or if it never lifted \u2014 the last after writing the device framebuffer\n *   and the device's own `input_method` state to the diagnostics directory.\n */\nexport async function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  await lowerSoftKeyboardIfShown(params);\n\n  const textToRestore = await emptyFieldForTouch(params);\n\n  try {\n    return await tapUntilKeyboardIsUp(params);\n  } finally {\n    // Restored even when the raise failed: a caller that is about to read its own diagnostic should not\n    // also have to discover that its query is gone.\n    if (textToRestore !== null) {\n      await writeFieldText(params, textToRestore);\n    }\n  }\n}\n\n/**\n * Touches the device at a point, the way a thumb would.\n *\n * @param params - The device and where to touch it.\n * @returns A {@link Promise} that resolves once the touch has been dispatched.\n */\nexport async function tapDevice(params: TapDeviceParams): Promise<void> {\n  await runAdbText({\n    commandArguments: ['shell', 'input', 'tap', String(params.point.xInPixels), String(params.point.yInPixels)],\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Writes the device framebuffer and reads the device's `input_method` state, then composes the failure.\n *\n * @param params - The device and the diagnostics directory.\n * @param baselineSnapshot - The geometry read before the first touch, which the verdict is measured against.\n * @param snapshot - The geometry read after the last touch.\n * @returns A {@link Promise} that resolves to the message to throw.\n */\nasync function buildFailureMessage(\n  params: RaiseSoftKeyboardParams,\n  baselineSnapshot: SoftKeyboardViewportSnapshot,\n  snapshot: SoftKeyboardViewportSnapshot\n): Promise<string> {\n  const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;\n  mkdirSync(diagnosticsDirectory, { recursive: true });\n\n  const screenshotPath = join(diagnosticsDirectory, 'keyboard-not-raised.png');\n  writeFileSync(screenshotPath, await captureDeviceScreenshot({ deviceId: params.deviceId }));\n\n  return buildSoftKeyboardDiagnosticMessage({\n    baselineSnapshot,\n    inputMethodState: await readInputMethodState(params),\n    screenshotPath,\n    snapshot\n  });\n}\n\n/**\n * Whether anything in the page matches the field's selector.\n *\n * @param params - The field to look for.\n * @returns A {@link Promise} that resolves to whether it matched.\n */\nasync function checkIsFieldPresent(params: RaiseSoftKeyboardParams): Promise<boolean> {\n  return await evalInObsidian({\n    callback({ inputSelector }): boolean {\n      return document.querySelector(inputSelector) !== null;\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Empties the field the touch is about to land on, and reports what to write back.\n *\n * @param params - The field to empty, and whether to empty it at all.\n * @returns A {@link Promise} that resolves to the text to restore, or `null` when nothing was emptied.\n * @throws Error if the field holds text that cannot be written back \u2014 a `contenteditable`, whose content\n *   belongs to an editor that owns its own DOM.\n */\nasync function emptyFieldForTouch(params: RaiseSoftKeyboardParams): Promise<null | string> {\n  if (params.shouldEmptyFieldForTouch === false) {\n    return null;\n  }\n\n  const content = await readFieldContent(params);\n\n  // Nothing matched. The geometry read does the reporting, with the message it always had.\n  if (!content || content.text === '') {\n    return null;\n  }\n\n  if (!content.canWrite) {\n    throw new Error(\n      `raiseSoftKeyboard: \"${params.inputSelector}\" holds text but is not an <input> or a <textarea>, so it `\n        + 'cannot be emptied for the touch and written back. The touch would land inside text and draw a '\n        + 'selection handle, which a device capture photographs. Empty the field yourself before calling, or '\n        + 'pass shouldEmptyFieldForTouch: false to touch it as it stands.'\n    );\n  }\n\n  await writeFieldText(params, '');\n\n  return content.text;\n}\n\n/**\n * Puts the keyboard down when the device reports one showing, so the baseline read next is one the touch\n * can lift the field from.\n *\n * **A keyboard is pressed at only once it has been reported showing TWICE, one retract animation apart.**\n * `KEYCODE_BACK` is retracted by the IME only while the IME is up; once it has gone, the key reaches the\n * app, and Obsidian closes the modal on screen \u2014 the one the caller is about to photograph. A keyboard\n * already on its way down (the modal that raised it has just closed, and the caller opened a fresh one\n * straight after) is still reported showing at the start of its retract, so pressing at the first read\n * raced it. It is watched for one retract animation first, and a keyboard that went down on its own is\n * left alone.\n *\n * **And a press that reached the app anyway is named as that.** The field is looked up before the press\n * and after it; one that matched before and not after was closed by the key, and saying so beats the\n * `nothing matches` that the raise would otherwise report a step later, about a selector that was right.\n *\n * @param params - The device to ask, and the field that must survive the press.\n * @returns A {@link Promise} that resolves once no keyboard is showing.\n * @throws Error if a keyboard is still showing after {@link KEYBOARD_RETRACT_ATTEMPT_COUNT} presses of\n *   `KEYCODE_BACK` \u2014 the raise that follows could prove nothing, and its own failure would blame a keyboard\n *   that never came when the truth is one that never left \u2014 or if a press closed the field's own UI.\n */\nasync function lowerSoftKeyboardIfShown(params: RaiseSoftKeyboardParams): Promise<void> {\n  let inputMethodState = await readInputMethodState(params);\n\n  for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    await sleep(KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS);\n    inputMethodState = await readInputMethodState(params);\n\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    const isFieldPresentBeforePress = await checkIsFieldPresent(params);\n    await runAdbText({\n      commandArguments: ['shell', 'input', 'keyevent', 'KEYCODE_BACK'],\n      deviceId: params.deviceId\n    });\n    await sleep(KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS);\n\n    if (isFieldPresentBeforePress && !await checkIsFieldPresent(params)) {\n      throw new Error(\n        'raiseSoftKeyboard: KEYCODE_BACK, pressed to put down a keyboard the device reported showing, reached the app instead and '\n          + `closed the UI holding \"${params.inputSelector}\" \u2014 it matched before the press and matches nothing after it. The `\n          + 'keyboard went down between the last read and the press. Let the previous keyboard settle before opening the UI '\n          + `to raise it on.\ndevice before the press: ${inputMethodState}`\n      );\n    }\n\n    inputMethodState = await readInputMethodState(params);\n  }\n\n  if (checkIsInputMethodShown(inputMethodState)) {\n    throw new Error(\n      `raiseSoftKeyboard: a keyboard was already up and did not go down after ${String(KEYBOARD_RETRACT_ATTEMPT_COUNT)} presses of `\n        + 'KEYCODE_BACK, so the lift that proves a raise could not be measured. The field would read as one that never '\n        + `moved under a keyboard that is plainly showing.\ndevice: ${inputMethodState}`\n    );\n  }\n}\n\n/**\n * Reads what the field holds, and whether it is one whose value can be written back.\n *\n * @param params - The field to read.\n * @returns A {@link Promise} that resolves to the content, or `null` when nothing matched the selector.\n */\nasync function readFieldContent(params: RaiseSoftKeyboardParams): Promise<FieldContent | null> {\n  return await evalInObsidian({\n    callback({ inputSelector }): FieldContent | null {\n      const element = document.querySelector(inputSelector);\n\n      if (!element) {\n        return null;\n      }\n\n      const canWrite = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;\n\n      return { canWrite, text: canWrite ? element.value : element.textContent };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Asks the device what its IME is doing \u2014 the only place that knows, since nothing in the page reports it.\n *\n * @param params - The device to ask.\n * @returns A {@link Promise} that resolves to the fields {@link parseInputMethodState} keeps.\n */\nasync function readInputMethodState(params: RaiseSoftKeyboardParams): Promise<string> {\n  const dumpsysOutput = await runAdbText({\n    commandArguments: ['shell', 'dumpsys', 'input_method'],\n    deviceId: params.deviceId\n  });\n\n  return parseInputMethodState(dumpsysOutput);\n}\n\n/**\n * Reads what the renderer knows about its own geometry.\n *\n * @param params - The field to measure and the vault to read it from.\n * @returns A {@link Promise} that resolves to the viewport and the field's rect, in CSS pixels.\n */\nasync function readSoftKeyboardViewport(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  return await evalInObsidian({\n    callback({ inputSelector }): SoftKeyboardViewportSnapshot {\n      const inputEl = document.querySelector(inputSelector);\n\n      // eslint-disable-next-line unicorn/consistent-function-scoping -- This closure is serialized and evaluated in the renderer, so a helper hoisted to module scope would not exist there.\n      function toRect(rect: DOMRect): ElementRect {\n        return {\n          height: rect.height,\n          left: rect.left,\n          top: rect.top,\n          width: rect.width\n        };\n      }\n\n      return {\n        devicePixelRatio: window.devicePixelRatio,\n        innerHeight: window.innerHeight,\n        inputRect: inputEl ? toRect(inputEl.getBoundingClientRect()) : null,\n        screenY: window.screenY\n      };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Touches the field until the keyboard is up, and says so when it never came.\n *\n * The baseline is read here rather than by the caller, so it is read with the field in the state the\n * taps are dispatched against \u2014 see {@link raiseSoftKeyboard} for why the two have to match.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if the field never matched, or if it never lifted.\n */\nasync function tapUntilKeyboardIsUp(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  const baselineSnapshot = await readSoftKeyboardViewport(params);\n  let snapshot = baselineSnapshot;\n\n  if (!snapshot.inputRect) {\n    throw new Error(`raiseSoftKeyboard: nothing matches \"${params.inputSelector}\", so there is no field to touch.`);\n  }\n\n  for (const point of resolveSoftKeyboardTapPoints({ snapshot })) {\n    if (checkIsUp(snapshot)) {\n      break;\n    }\n\n    await tapDevice({ deviceId: params.deviceId, point });\n    await sleep(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);\n    snapshot = await readSoftKeyboardViewport(params);\n  }\n\n  if (!checkIsUp(snapshot)) {\n    throw new Error(await buildFailureMessage(params, baselineSnapshot, snapshot));\n  }\n\n  return snapshot;\n\n  function checkIsUp(current: SoftKeyboardViewportSnapshot): boolean {\n    return checkIsSoftKeyboardUp({\n      baselineSnapshot,\n      ...(params.minimumKeyboardHeightInPixels !== undefined && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels }),\n      snapshot: current\n    });\n  }\n}\n\n/**\n * Writes a field's value and tells the page it changed.\n *\n * The `input` event is what a scripted write owes the page: without it a suggester keeps the rows it had\n * for the text that is no longer there. It bubbles, because that is how a framework listening on a\n * container hears it.\n *\n * @param params - The field to write.\n * @param text - What to write into it.\n * @returns A {@link Promise} that resolves once the write has been made.\n * @throws TypeError if the field is not one whose value can be written.\n */\nasync function writeFieldText(params: RaiseSoftKeyboardParams, text: string): Promise<void> {\n  await evalInObsidian({\n    callback({ inputSelector, text: value }): void {\n      const element = document.querySelector(inputSelector);\n\n      if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {\n        throw new TypeError(`raiseSoftKeyboard: \"${inputSelector}\" is not a field whose value can be written.`);\n      }\n\n      element.value = value;\n      element.dispatchEvent(new Event('input', { bubbles: true }));\n    },\n    input: { inputSelector: params.inputSelector, text },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process", "sleep"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Raises the Android soft keyboard for a screenshot, and proves it came up.\n *\n * Two things have to be true, and the second is the one that is easy to miss:\n *\n * 1. The device must be allowed to draw a keyboard at all. The screenshot AVDs\n *    are built `hw.keyboard=yes`, so Android suppresses the on-screen one \u2014\n *    `withSoftKeyboardEnabled` in `device-settings` is what lifts that.\n * 2. The IME must be *asked* for by a gesture. A field that takes focus\n *    programmatically does not get one: an Android WebView raises the IME on a\n *    real touch, and a run with the setting flipped and no touch comes back with\n *    exactly the empty band it had before. `adb shell input tap` is that gesture.\n *\n * 3. The proof that it arrived is that the field **moved**, measured against a\n *    baseline read here before the first touch. An absolute offset from the\n *    viewport bottom is the same test only for a bottom-anchored field; for a\n *    centred modal it is already true with no keyboard, which used to break the\n *    loop below before it had dispatched a single touch and return success\n *    having done nothing. Reading the baseline first also makes that shape\n *    unrepresentable rather than merely corrected: the delta of the baseline\n *    against itself is zero, so the first iteration always taps.\n *\n *    **A keyboard ALREADY up is put down first**, because a delta cannot see\n *    one: the field has already lifted, so it reads as a field that never moved.\n *    That was every frame after the first of a suite that takes several \u2014 the\n *    keyboard left up by one frame, or brought back by Obsidian focusing the\n *    next modal's field, made the next baseline already-lifted (measured\n *    2026-09-20: frames 2-5 each failed `lift=0` beside `mInputShown=true`,\n *    each framebuffer showing a correctly lifted field under a fully drawn\n *    keyboard). The alternative was to accept `lift=0` whenever the device says\n *    a keyboard is showing, and it was refused: that is a frame the helper did\n *    not prove, which is the vacuous pass the delta was introduced to end,\n *    re-opened by a different door. So the device is asked, a showing IME is\n *    retracted with `KEYCODE_BACK`, and the lift is proved as before. It has to\n *    happen HERE, not after the previous capture: lowering it there was tried,\n *    and the IME came back on its own before the next baseline was read.\n *\n * 4. **That touch draws a selection handle when it lands inside TEXT**, and a\n *    device capture photographs it. Chromium shows the insertion handle on a tap\n *    into text and none on a tap into an EMPTY editable, and a value written by\n *    script raises none at all \u2014 so the field is emptied for the touch and its\n *    text written back afterwards. `obsidian-link-picker` shipped a teal handle\n *    in a store listing image twice before anyone worked out where it came from,\n *    and nothing in this module's own documentation of the touch hinted at it.\n *    See `shouldEmptyFieldForTouch`.\n *\n *    **And the text written back has to be HELD, not just written.** The IME's input connection started from\n *    the emptied field, and about one time in five it wrote that empty state back over the harness's write,\n *    so the capture straight after showed the placeholder. The field is re-read until it holds, and written\n *    again when it does not.\n *\n * The geometry that decides whether it worked is unit-tested in\n * `soft-keyboard-geometry`; everything here drives a real device, so the whole\n * module is integration-time code.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian on a real device) covered by integration tests, not unit tests. */\n\nimport {\n  mkdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { HoldFieldTextResult } from './field-text-hold.cjs';\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.cjs';\n\nimport { runAdbText } from './adb.cjs';\nimport { captureDeviceScreenshot } from './device-screenshot.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { holdFieldText } from './field-text-hold.cjs';\nimport { log } from './log.cjs';\nimport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.cjs';\n\n/**\n * Parameters for {@link raiseSoftKeyboard}.\n */\nexport interface RaiseSoftKeyboardParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where a failed attempt writes the device framebuffer.\n   *\n   * When omitted, it is `dist/screenshots` under the working directory \u2014 resolved at load, so there is no\n   * literal default to state here.\n   */\n  readonly diagnosticsDirectory?: string;\n\n  /**\n   * The CSS selector of the field to touch, e.g. `.prompt-input`.\n   */\n  readonly inputSelector: string;\n\n  /**\n   * The least a raised keyboard lifts the field by.\n   *\n   * When omitted, `DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS` from `soft-keyboard-geometry` applies.\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * Whether to empty the field before the touch, and write its text back afterwards.\n   *\n   * **On by default, because the touch that raises the keyboard also draws a selection handle when it\n   * lands inside TEXT.** Chromium shows the insertion handle on a tap into text and draws none on a tap\n   * into an EMPTY editable, and a device capture photographs it \u2014 which is how `obsidian-link-picker`\n   * shipped a teal handle in a store listing image twice before anyone understood where it came from. A\n   * value written by script raises no handle, so emptying the field, touching it, and writing the text\n   * back leaves the frame showing the same query with nothing hanging off it.\n   *\n   * Only an `<input>` or a `<textarea>` is emptied. A `contenteditable` holding text is REFUSED rather\n   * than written to: its content usually belongs to an editor that owns its own DOM, and blanking that\n   * by hand destroys it. Empty such a field yourself, or turn this off.\n   *\n   * Turning it off restores the pre-2026-09-23 behaviour exactly: the field is touched as it stands.\n   *\n   * @default true\n   */\n  readonly shouldEmptyFieldForTouch?: boolean;\n\n  /**\n   * The vault to read the geometry from. When omitted, the current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link tapDevice}.\n */\nexport interface TapDeviceParams {\n  /**\n   * The device to touch.\n   */\n  readonly deviceId: string;\n\n  /**\n   * Where to touch it.\n   */\n  readonly point: SoftKeyboardTapPoint;\n}\n\n/**\n * Where a failed attempt leaves its evidence \u2014 under `dist/`, which a plugin repo using this harness gitignores, like the capture scratch files.\n */\nconst DEFAULT_DIAGNOSTICS_DIRECTORY = join(process.cwd(), 'dist', 'screenshots');\n\n/**\n * How long the IME takes to finish animating in, after which the layout has settled.\n */\nconst KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;\n\n/**\n * How long the IME takes to finish animating out after `KEYCODE_BACK`, measured in the capture suite this\n * was moved out of.\n */\nconst KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS = 900;\n\n/**\n * How many times `KEYCODE_BACK` is pressed before a keyboard that will not go down is reported.\n *\n * Two, because the first press can land while the IME is still animating UP from the focus that raised\n * it, and an IME mid-animation swallows the key without retracting.\n */\nconst KEYBOARD_RETRACT_ATTEMPT_COUNT = 2;\n\n/**\n * How long a keyboard reported showing is watched before `KEYCODE_BACK` is pressed at it.\n *\n * One retract animation: an IME already on its way down \u2014 the modal that raised it has just closed \u2014 is\n * still reported showing by a read taken at the start of its retract, and is gone by the end of it. Pressing\n * at the first read then lands the key on the app instead, which closes the modal the frame is about to\n * photograph. Two reads that agree across this window say the keyboard is staying up.\n */\nconst KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS;\n\n/**\n * What a field holds, and whether it is one this can put back.\n */\ninterface FieldContent {\n  /**\n   * Whether the field's value can be written \u2014 true for an `<input>` or a `<textarea>`, false for\n   * anything else, whose content usually belongs to an editor that owns its own DOM.\n   */\n  readonly canWrite: boolean;\n\n  /**\n   * The text the field currently holds.\n   */\n  readonly text: string;\n}\n\n/**\n * Raises the on-screen keyboard with a real touch on a field, and confirms it came up.\n *\n * Call it inside `withSoftKeyboardEnabled` \u2014 the device setting alone does not raise the keyboard, and this\n * touch alone cannot while the setting suppresses it.\n *\n * **A keyboard that is already up is put DOWN first.** The first geometry read is the baseline every later\n * read is compared against, so a keyboard already up would leave the field nothing to lift by and read as\n * one that never came. The device is asked before anything else, and a showing IME is retracted with\n * `KEYCODE_BACK` \u2014 asked FIRST because, with no IME showing, that key reaches the app and closes the very\n * modal the frame is about to photograph. So the helper is safe to call once per frame of a multi-frame\n * suite, and every call still proves its own lift. The other answer \u2014 accepting a zero lift whenever the\n * device reports a keyboard \u2014 was refused, because it accepts a frame the helper did not prove.\n *\n * **The field is EMPTIED for the touch and written back afterwards**, because a touch that lands inside\n * text draws Chromium's selection handle and the framebuffer photographs it \u2014 see\n * {@link RaiseSoftKeyboardParams.shouldEmptyFieldForTouch}, which turns that off.\n *\n * **The geometry returned is read with the field still empty**, and the text is written back after it.\n * That is the state the proven capture suites assert against, and it is deliberate rather than\n * incidental: the baseline is read AFTER the field is emptied, so the lift is measured between two reads\n * of the same field content. A field whose own text changes the layout around it \u2014 a suggester whose row\n * count answers the query \u2014 moves when it is cleared, and a delta measured across that move is not a\n * keyboard. Read the geometry again yourself if the restored text moves anything you are about to assert\n * on.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if a keyboard already up would not go down, if the field never matched, if it holds text\n *   this cannot empty and put back, if it never lifted \u2014 after writing the device framebuffer and the\n *   device's own `input_method` state to the diagnostics directory \u2014 or if the text written back would not\n *   stay in the field. A write-back the IME undoes is written again until it holds; see `restoreFieldText`.\n */\nexport async function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  await lowerSoftKeyboardIfShown(params);\n\n  const textToRestore = await emptyFieldForTouch(params);\n\n  let snapshot: SoftKeyboardViewportSnapshot;\n\n  try {\n    snapshot = await tapUntilKeyboardIsUp(params);\n  } catch (error) {\n    // Restored even when the raise failed: a caller that is about to read its own diagnostic should not\n    // also have to discover that its query is gone. Best-effort, so the raise's own error is the one thrown.\n    if (textToRestore !== null) {\n      await holdFieldTextBestEffort(params, textToRestore);\n    }\n\n    throw error;\n  }\n\n  if (textToRestore !== null) {\n    await restoreFieldText(params, textToRestore);\n  }\n\n  return snapshot;\n}\n\n/**\n * Touches the device at a point, the way a thumb would.\n *\n * @param params - The device and where to touch it.\n * @returns A {@link Promise} that resolves once the touch has been dispatched.\n */\nexport async function tapDevice(params: TapDeviceParams): Promise<void> {\n  await runAdbText({\n    commandArguments: ['shell', 'input', 'tap', String(params.point.xInPixels), String(params.point.yInPixels)],\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Writes the device framebuffer and reads the device's `input_method` state, then composes the failure.\n *\n * @param params - The device and the diagnostics directory.\n * @param baselineSnapshot - The geometry read before the first touch, which the verdict is measured against.\n * @param snapshot - The geometry read after the last touch.\n * @returns A {@link Promise} that resolves to the message to throw.\n */\nasync function buildFailureMessage(\n  params: RaiseSoftKeyboardParams,\n  baselineSnapshot: SoftKeyboardViewportSnapshot,\n  snapshot: SoftKeyboardViewportSnapshot\n): Promise<string> {\n  const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;\n  mkdirSync(diagnosticsDirectory, { recursive: true });\n\n  const screenshotPath = join(diagnosticsDirectory, 'keyboard-not-raised.png');\n  writeFileSync(screenshotPath, await captureDeviceScreenshot({ deviceId: params.deviceId }));\n\n  return buildSoftKeyboardDiagnosticMessage({\n    baselineSnapshot,\n    inputMethodState: await readInputMethodState(params),\n    screenshotPath,\n    snapshot\n  });\n}\n\n/**\n * Whether anything in the page matches the field's selector.\n *\n * @param params - The field to look for.\n * @returns A {@link Promise} that resolves to whether it matched.\n */\nasync function checkIsFieldPresent(params: RaiseSoftKeyboardParams): Promise<boolean> {\n  return await evalInObsidian({\n    callback({ inputSelector }): boolean {\n      return document.querySelector(inputSelector) !== null;\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Empties the field the touch is about to land on, and reports what to write back.\n *\n * @param params - The field to empty, and whether to empty it at all.\n * @returns A {@link Promise} that resolves to the text to restore, or `null` when nothing was emptied.\n * @throws Error if the field holds text that cannot be written back \u2014 a `contenteditable`, whose content\n *   belongs to an editor that owns its own DOM.\n */\nasync function emptyFieldForTouch(params: RaiseSoftKeyboardParams): Promise<null | string> {\n  if (params.shouldEmptyFieldForTouch === false) {\n    return null;\n  }\n\n  const content = await readFieldContent(params);\n\n  // Nothing matched. The geometry read does the reporting, with the message it always had.\n  if (!content || content.text === '') {\n    return null;\n  }\n\n  if (!content.canWrite) {\n    throw new Error(\n      `raiseSoftKeyboard: \"${params.inputSelector}\" holds text but is not an <input> or a <textarea>, so it `\n        + 'cannot be emptied for the touch and written back. The touch would land inside text and draw a '\n        + 'selection handle, which a device capture photographs. Empty the field yourself before calling, or '\n        + 'pass shouldEmptyFieldForTouch: false to touch it as it stands.'\n    );\n  }\n\n  await writeFieldText(params, '');\n\n  return content.text;\n}\n\n/**\n * Holds the text in the field without ever throwing \u2014 the restore on a raise that already failed.\n *\n * @param params - The field to write.\n * @param text - What it must hold.\n * @returns A {@link Promise} that resolves once the hold has run, whatever it found.\n */\nasync function holdFieldTextBestEffort(params: RaiseSoftKeyboardParams, text: string): Promise<void> {\n  try {\n    await holdTextInField(params, text);\n  } catch {\n    // The raise's own failure is what the caller needs to see; a field that is gone as well adds nothing to it.\n  }\n}\n\n/**\n * Writes the text into the field and holds it there, per {@link holdFieldText}.\n *\n * @param params - The field to write.\n * @param text - What it must hold.\n * @returns A {@link Promise} that resolves to what the hold found.\n */\nasync function holdTextInField(params: RaiseSoftKeyboardParams, text: string): Promise<HoldFieldTextResult> {\n  return await holdFieldText({\n    expectedText: text,\n    async readText(): Promise<null | string> {\n      const content = await readFieldContent(params);\n      return content?.text ?? null;\n    },\n    sleep,\n    async writeText(value: string): Promise<void> {\n      await writeFieldText(params, value);\n    }\n  });\n}\n\n/**\n * Puts the keyboard down when the device reports one showing, so the baseline read next is one the touch\n * can lift the field from.\n *\n * **A keyboard is pressed at only once it has been reported showing TWICE, one retract animation apart.**\n * `KEYCODE_BACK` is retracted by the IME only while the IME is up; once it has gone, the key reaches the\n * app, and Obsidian closes the modal on screen \u2014 the one the caller is about to photograph. A keyboard\n * already on its way down (the modal that raised it has just closed, and the caller opened a fresh one\n * straight after) is still reported showing at the start of its retract, so pressing at the first read\n * raced it. It is watched for one retract animation first, and a keyboard that went down on its own is\n * left alone.\n *\n * **And a press that reached the app anyway is named as that.** The field is looked up before the press\n * and after it; one that matched before and not after was closed by the key, and saying so beats the\n * `nothing matches` that the raise would otherwise report a step later, about a selector that was right.\n *\n * @param params - The device to ask, and the field that must survive the press.\n * @returns A {@link Promise} that resolves once no keyboard is showing.\n * @throws Error if a keyboard is still showing after {@link KEYBOARD_RETRACT_ATTEMPT_COUNT} presses of\n *   `KEYCODE_BACK` \u2014 the raise that follows could prove nothing, and its own failure would blame a keyboard\n *   that never came when the truth is one that never left \u2014 or if a press closed the field's own UI.\n */\nasync function lowerSoftKeyboardIfShown(params: RaiseSoftKeyboardParams): Promise<void> {\n  let inputMethodState = await readInputMethodState(params);\n\n  for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    await sleep(KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS);\n    inputMethodState = await readInputMethodState(params);\n\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    const isFieldPresentBeforePress = await checkIsFieldPresent(params);\n    await runAdbText({\n      commandArguments: ['shell', 'input', 'keyevent', 'KEYCODE_BACK'],\n      deviceId: params.deviceId\n    });\n    await sleep(KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS);\n\n    if (isFieldPresentBeforePress && !await checkIsFieldPresent(params)) {\n      throw new Error(\n        'raiseSoftKeyboard: KEYCODE_BACK, pressed to put down a keyboard the device reported showing, reached the app instead and '\n          + `closed the UI holding \"${params.inputSelector}\" \u2014 it matched before the press and matches nothing after it. The `\n          + 'keyboard went down between the last read and the press. Let the previous keyboard settle before opening the UI '\n          + `to raise it on.\ndevice before the press: ${inputMethodState}`\n      );\n    }\n\n    inputMethodState = await readInputMethodState(params);\n  }\n\n  if (checkIsInputMethodShown(inputMethodState)) {\n    throw new Error(\n      `raiseSoftKeyboard: a keyboard was already up and did not go down after ${String(KEYBOARD_RETRACT_ATTEMPT_COUNT)} presses of `\n        + 'KEYCODE_BACK, so the lift that proves a raise could not be measured. The field would read as one that never '\n        + `moved under a keyboard that is plainly showing.\ndevice: ${inputMethodState}`\n    );\n  }\n}\n\n/**\n * Reads what the field holds, and whether it is one whose value can be written back.\n *\n * @param params - The field to read.\n * @returns A {@link Promise} that resolves to the content, or `null` when nothing matched the selector.\n */\nasync function readFieldContent(params: RaiseSoftKeyboardParams): Promise<FieldContent | null> {\n  return await evalInObsidian({\n    callback({ inputSelector }): FieldContent | null {\n      const element = document.querySelector(inputSelector);\n\n      if (!element) {\n        return null;\n      }\n\n      const canWrite = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;\n\n      return { canWrite, text: canWrite ? element.value : element.textContent };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Asks the device what its IME is doing \u2014 the only place that knows, since nothing in the page reports it.\n *\n * @param params - The device to ask.\n * @returns A {@link Promise} that resolves to the fields {@link parseInputMethodState} keeps.\n */\nasync function readInputMethodState(params: RaiseSoftKeyboardParams): Promise<string> {\n  const dumpsysOutput = await runAdbText({\n    commandArguments: ['shell', 'dumpsys', 'input_method'],\n    deviceId: params.deviceId\n  });\n\n  return parseInputMethodState(dumpsysOutput);\n}\n\n/**\n * Reads what the renderer knows about its own geometry.\n *\n * @param params - The field to measure and the vault to read it from.\n * @returns A {@link Promise} that resolves to the viewport and the field's rect, in CSS pixels.\n */\nasync function readSoftKeyboardViewport(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  return await evalInObsidian({\n    callback({ inputSelector }): SoftKeyboardViewportSnapshot {\n      const inputEl = document.querySelector(inputSelector);\n\n      // eslint-disable-next-line unicorn/consistent-function-scoping -- This closure is serialized and evaluated in the renderer, so a helper hoisted to module scope would not exist there.\n      function toRect(rect: DOMRect): ElementRect {\n        return {\n          height: rect.height,\n          left: rect.left,\n          top: rect.top,\n          width: rect.width\n        };\n      }\n\n      return {\n        devicePixelRatio: window.devicePixelRatio,\n        innerHeight: window.innerHeight,\n        inputRect: inputEl ? toRect(inputEl.getBoundingClientRect()) : null,\n        screenY: window.screenY\n      };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Writes the emptied field's text back, and does not return until it has stayed there.\n *\n * **Writing it once is not enough.** The touch that raised the keyboard landed on the EMPTY field, so the\n * IME's input connection started from an empty field, and about one time in five a later update from it wrote\n * that empty state back over this write (measured 2026-09-25 in `obsidian-alias-quick-switcher`'s capture\n * suite: 2 of 10 frames showed the placeholder, while the Gboard strip still offered the word that had been\n * written). The capture taken straight after photographed the empty field, and nothing said so. So the field is\n * re-read until several reads agree, and written again whenever one does not.\n *\n * @param params - The field to write, and the device to ask about its IME when the text will not hold.\n * @param text - What the field held before it was emptied.\n * @returns A {@link Promise} that resolves once the text has held.\n * @throws Error if the text did not hold after every rewrite, or the field went away \u2014 naming every read and\n *   the device's `input_method` state, rather than returning with the field silently empty.\n */\nasync function restoreFieldText(params: RaiseSoftKeyboardParams, text: string): Promise<void> {\n  const result = await holdTextInField(params, text);\n\n  if (result.writeCount > 1) {\n    log(\n      `[soft-keyboard] The text written back into \"${params.inputSelector}\" was lost ${String(result.writeCount - 1)} time(s) `\n        + `and written again; reads: ${JSON.stringify(result.readTexts)}.`\n    );\n  }\n\n  if (!result.isHeld) {\n    throw new Error(\n      `raiseSoftKeyboard: the text written back into \"${params.inputSelector}\" after the touch did not stay there. `\n        + `Expected ${JSON.stringify(text)}; ${String(result.writeCount)} write(s), and the field read `\n        + `${JSON.stringify(result.readTexts)}. A capture taken now would show the field without its text.\ndevice: ${await readInputMethodState(params)}`\n    );\n  }\n}\n\n/**\n * Touches the field until the keyboard is up, and says so when it never came.\n *\n * The baseline is read here rather than by the caller, so it is read with the field in the state the\n * taps are dispatched against \u2014 see {@link raiseSoftKeyboard} for why the two have to match.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if the field never matched, or if it never lifted.\n */\nasync function tapUntilKeyboardIsUp(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  const baselineSnapshot = await readSoftKeyboardViewport(params);\n  let snapshot = baselineSnapshot;\n\n  if (!snapshot.inputRect) {\n    throw new Error(`raiseSoftKeyboard: nothing matches \"${params.inputSelector}\", so there is no field to touch.`);\n  }\n\n  for (const point of resolveSoftKeyboardTapPoints({ snapshot })) {\n    if (checkIsUp(snapshot)) {\n      break;\n    }\n\n    await tapDevice({ deviceId: params.deviceId, point });\n    await sleep(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);\n    snapshot = await readSoftKeyboardViewport(params);\n  }\n\n  if (!checkIsUp(snapshot)) {\n    throw new Error(await buildFailureMessage(params, baselineSnapshot, snapshot));\n  }\n\n  return snapshot;\n\n  function checkIsUp(current: SoftKeyboardViewportSnapshot): boolean {\n    return checkIsSoftKeyboardUp({\n      baselineSnapshot,\n      ...(params.minimumKeyboardHeightInPixels !== undefined && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels }),\n      snapshot: current\n    });\n  }\n}\n\n/**\n * Writes a field's value and tells the page it changed.\n *\n * The `input` event is what a scripted write owes the page: without it a suggester keeps the rows it had\n * for the text that is no longer there. It bubbles, because that is how a framework listening on a\n * container hears it.\n *\n * @param params - The field to write.\n * @param text - What to write into it.\n * @returns A {@link Promise} that resolves once the write has been made.\n * @throws TypeError if the field is not one whose value can be written.\n */\nasync function writeFieldText(params: RaiseSoftKeyboardParams, text: string): Promise<void> {\n  await evalInObsidian({\n    callback({ inputSelector, text: value }): void {\n      const element = document.querySelector(inputSelector);\n\n      if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {\n        throw new TypeError(`raiseSoftKeyboard: \"${inputSelector}\" is not a field whose value can be written.`);\n      }\n\n      element.value = value;\n      element.dispatchEvent(new Event('input', { bubbles: true }));\n    },\n    input: { inputSelector: params.inputSelector, text },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4DA,qBAGO;AACP,uBAAqB;AACrB,0BAAoB;AACpB,sBAAoC;AASpC,iBAA2B;AAC3B,+BAAwC;AACxC,8BAA+B;AAC/B,6BAA8B;AAC9B,iBAAoB;AACpB,oCAMO;AA2EP,MAAM,oCAAgC,uBAAK,oBAAAA,QAAQ,IAAI,GAAG,QAAQ,aAAa;AAK/E,MAAM,wCAAwC;AAM9C,MAAM,yCAAyC;AAQ/C,MAAM,iCAAiC;AAUvC,MAAM,oDAAoD;AAmD1D,eAAsB,kBAAkB,QAAwE;AAC9G,QAAM,yBAAyB,MAAM;AAErC,QAAM,gBAAgB,MAAM,mBAAmB,MAAM;AAErD,MAAI;AAEJ,MAAI;AACF,eAAW,MAAM,qBAAqB,MAAM;AAAA,EAC9C,SAAS,OAAO;AAGd,QAAI,kBAAkB,MAAM;AAC1B,YAAM,wBAAwB,QAAQ,aAAa;AAAA,IACrD;AAEA,UAAM;AAAA,EACR;AAEA,MAAI,kBAAkB,MAAM;AAC1B,UAAM,iBAAiB,QAAQ,aAAa;AAAA,EAC9C;AAEA,SAAO;AACT;AAQA,eAAsB,UAAU,QAAwC;AACtE,YAAM,uBAAW;AAAA,IACf,kBAAkB,CAAC,SAAS,SAAS,OAAO,OAAO,OAAO,MAAM,SAAS,GAAG,OAAO,OAAO,MAAM,SAAS,CAAC;AAAA,IAC1G,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AAUA,eAAe,oBACb,QACA,kBACA,UACiB;AACjB,QAAM,uBAAuB,OAAO,wBAAwB;AAC5D,gCAAU,sBAAsB,EAAE,WAAW,KAAK,CAAC;AAEnD,QAAM,qBAAiB,uBAAK,sBAAsB,yBAAyB;AAC3E,oCAAc,gBAAgB,UAAM,kDAAwB,EAAE,UAAU,OAAO,SAAS,CAAC,CAAC;AAE1F,aAAO,kEAAmC;AAAA,IACxC;AAAA,IACA,kBAAkB,MAAM,qBAAqB,MAAM;AAAA,IACnD;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAQA,eAAe,oBAAoB,QAAmD;AACpF,SAAO,UAAM,wCAAe;AAAA,IAC1B,SAAS,EAAE,cAAc,GAAY;AACnC,aAAO,SAAS,cAAc,aAAa,MAAM;AAAA,IACnD;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,cAAc;AAAA,IAC7C,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;AAUA,eAAe,mBAAmB,QAAyD;AACzF,MAAI,OAAO,6BAA6B,OAAO;AAC7C,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,MAAM,iBAAiB,MAAM;AAG7C,MAAI,CAAC,WAAW,QAAQ,SAAS,IAAI;AACnC,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ,UAAU;AACrB,UAAM,IAAI;AAAA,MACR,uBAAuB,OAAO,aAAa;AAAA,IAI7C;AAAA,EACF;AAEA,QAAM,eAAe,QAAQ,EAAE;AAE/B,SAAO,QAAQ;AACjB;AASA,eAAe,wBAAwB,QAAiC,MAA6B;AACnG,MAAI;AACF,UAAM,gBAAgB,QAAQ,IAAI;AAAA,EACpC,QAAQ;AAAA,EAER;AACF;AASA,eAAe,gBAAgB,QAAiC,MAA4C;AAC1G,SAAO,UAAM,sCAAc;AAAA,IACzB,cAAc;AAAA,IACd,MAAM,WAAmC;AACvC,YAAM,UAAU,MAAM,iBAAiB,MAAM;AAC7C,aAAO,SAAS,QAAQ;AAAA,IAC1B;AAAA,IACA,uBAAAC;AAAA,IACA,MAAM,UAAU,OAA8B;AAC5C,YAAM,eAAe,QAAQ,KAAK;AAAA,IACpC;AAAA,EACF,CAAC;AACH;AAwBA,eAAe,yBAAyB,QAAgD;AACtF,MAAI,mBAAmB,MAAM,qBAAqB,MAAM;AAExD,WAAS,UAAU,GAAG,UAAU,gCAAgC,WAAW;AACzE,QAAI,KAAC,uDAAwB,gBAAgB,GAAG;AAC9C;AAAA,IACF;AAEA,cAAM,gBAAAA,YAAM,iDAAiD;AAC7D,uBAAmB,MAAM,qBAAqB,MAAM;AAEpD,QAAI,KAAC,uDAAwB,gBAAgB,GAAG;AAC9C;AAAA,IACF;AAEA,UAAM,4BAA4B,MAAM,oBAAoB,MAAM;AAClE,cAAM,uBAAW;AAAA,MACf,kBAAkB,CAAC,SAAS,SAAS,YAAY,cAAc;AAAA,MAC/D,UAAU,OAAO;AAAA,IACnB,CAAC;AACD,cAAM,gBAAAA,YAAM,sCAAsC;AAElD,QAAI,6BAA6B,CAAC,MAAM,oBAAoB,MAAM,GAAG;AACnE,YAAM,IAAI;AAAA,QACR,mJAC8B,OAAO,aAAa;AAAA,2BAG/B,gBAAgB;AAAA,MACrC;AAAA,IACF;AAEA,uBAAmB,MAAM,qBAAqB,MAAM;AAAA,EACtD;AAEA,UAAI,uDAAwB,gBAAgB,GAAG;AAC7C,UAAM,IAAI;AAAA,MACR,0EAA0E,OAAO,8BAA8B,CAAC;AAAA,UAG5G,gBAAgB;AAAA,IACtB;AAAA,EACF;AACF;AAQA,eAAe,iBAAiB,QAA+D;AAC7F,SAAO,UAAM,wCAAe;AAAA,IAC1B,SAAS,EAAE,cAAc,GAAwB;AAC/C,YAAM,UAAU,SAAS,cAAc,aAAa;AAEpD,UAAI,CAAC,SAAS;AACZ,eAAO;AAAA,MACT;AAEA,YAAM,WAAW,mBAAmB,oBAAoB,mBAAmB;AAE3E,aAAO,EAAE,UAAU,MAAM,WAAW,QAAQ,QAAQ,QAAQ,YAAY;AAAA,IAC1E;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,cAAc;AAAA,IAC7C,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;AAQA,eAAe,qBAAqB,QAAkD;AACpF,QAAM,gBAAgB,UAAM,uBAAW;AAAA,IACrC,kBAAkB,CAAC,SAAS,WAAW,cAAc;AAAA,IACrD,UAAU,OAAO;AAAA,EACnB,CAAC;AAED,aAAO,qDAAsB,aAAa;AAC5C;AAQA,eAAe,yBAAyB,QAAwE;AAC9G,SAAO,UAAM,wCAAe;AAAA,IAC1B,SAAS,EAAE,cAAc,GAAiC;AACxD,YAAM,UAAU,SAAS,cAAc,aAAa;AAGpD,eAAS,OAAO,MAA4B;AAC1C,eAAO;AAAA,UACL,QAAQ,KAAK;AAAA,UACb,MAAM,KAAK;AAAA,UACX,KAAK,KAAK;AAAA,UACV,OAAO,KAAK;AAAA,QACd;AAAA,MACF;AAEA,aAAO;AAAA,QACL,kBAAkB,OAAO;AAAA,QACzB,aAAa,OAAO;AAAA,QACpB,WAAW,UAAU,OAAO,QAAQ,sBAAsB,CAAC,IAAI;AAAA,QAC/D,SAAS,OAAO;AAAA,MAClB;AAAA,IACF;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,cAAc;AAAA,IAC7C,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;AAkBA,eAAe,iBAAiB,QAAiC,MAA6B;AAC5F,QAAM,SAAS,MAAM,gBAAgB,QAAQ,IAAI;AAEjD,MAAI,OAAO,aAAa,GAAG;AACzB;AAAA,MACE,+CAA+C,OAAO,aAAa,cAAc,OAAO,OAAO,aAAa,CAAC,CAAC,sCAC7E,KAAK,UAAU,OAAO,SAAS,CAAC;AAAA,IACnE;AAAA,EACF;AAEA,MAAI,CAAC,OAAO,QAAQ;AAClB,UAAM,IAAI;AAAA,MACR,kDAAkD,OAAO,aAAa,kDACtD,KAAK,UAAU,IAAI,CAAC,KAAK,OAAO,OAAO,UAAU,CAAC,iCAC3D,KAAK,UAAU,OAAO,SAAS,CAAC;AAAA,UACnC,MAAM,qBAAqB,MAAM,CAAC;AAAA,IACxC;AAAA,EACF;AACF;AAYA,eAAe,qBAAqB,QAAwE;AAC1G,QAAM,mBAAmB,MAAM,yBAAyB,MAAM;AAC9D,MAAI,WAAW;AAEf,MAAI,CAAC,SAAS,WAAW;AACvB,UAAM,IAAI,MAAM,uCAAuC,OAAO,aAAa,mCAAmC;AAAA,EAChH;AAEA,aAAW,aAAS,4DAA6B,EAAE,SAAS,CAAC,GAAG;AAC9D,QAAI,UAAU,QAAQ,GAAG;AACvB;AAAA,IACF;AAEA,UAAM,UAAU,EAAE,UAAU,OAAO,UAAU,MAAM,CAAC;AACpD,cAAM,gBAAAA,YAAM,qCAAqC;AACjD,eAAW,MAAM,yBAAyB,MAAM;AAAA,EAClD;AAEA,MAAI,CAAC,UAAU,QAAQ,GAAG;AACxB,UAAM,IAAI,MAAM,MAAM,oBAAoB,QAAQ,kBAAkB,QAAQ,CAAC;AAAA,EAC/E;AAEA,SAAO;AAEP,WAAS,UAAU,SAAgD;AACjE,eAAO,qDAAsB;AAAA,MAC3B;AAAA,MACA,GAAI,OAAO,kCAAkC,UAAa,EAAE,+BAA+B,OAAO,8BAA8B;AAAA,MAChI,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;AAcA,eAAe,eAAe,QAAiC,MAA6B;AAC1F,YAAM,wCAAe;AAAA,IACnB,SAAS,EAAE,eAAe,MAAM,MAAM,GAAS;AAC7C,YAAM,UAAU,SAAS,cAAc,aAAa;AAEpD,UAAI,EAAE,mBAAmB,qBAAqB,EAAE,mBAAmB,sBAAsB;AACvF,cAAM,IAAI,UAAU,uBAAuB,aAAa,8CAA8C;AAAA,MACxG;AAEA,cAAQ,QAAQ;AAChB,cAAQ,cAAc,IAAI,MAAM,SAAS,EAAE,SAAS,KAAK,CAAC,CAAC;AAAA,IAC7D;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,eAAe,KAAK;AAAA,IACnD,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;",
  "names": ["process", "sleep"]
}


package/dist/lib/cjs/soft-keyboard.d.cts

@@ -46,6 +46,11 @@
  *    and nothing in this module's own documentation of the touch hinted at it.
  *    See `shouldEmptyFieldForTouch`.
  *
+ *    **And the text written back has to be HELD, not just written.** The IME's input connection started from
+ *    the emptied field, and about one time in five it wrote that empty state back over the harness's write,
+ *    so the capture straight after showed the placeholder. The field is re-read until it holds, and written
+ *    again when it does not.
+ *
  * The geometry that decides whether it worked is unit-tested in
  * `soft-keyboard-geometry`; everything here drives a real device, so the whole
  * module is integration-time code.
@@ -142,8 +147,9 @@ export interface TapDeviceParams {
  * @param params - The device, the field to touch, and how far it must lift.
  * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.
  * @throws Error if a keyboard already up would not go down, if the field never matched, if it holds text
- *   this cannot empty and put back, or if it never lifted — the last after writing the device framebuffer
- *   and the device's own `input_method` state to the diagnostics directory.
+ *   this cannot empty and put back, if it never lifted — after writing the device framebuffer and the
+ *   device's own `input_method` state to the diagnostics directory — or if the text written back would not
+ *   stay in the field. A write-back the IME undoes is written again until it holds; see `restoreFieldText`.
  */
 export declare function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot>;
 /**

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

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

@@ -3,12 +3,14 @@ import {
   getTransportOptions,
   getVaultPath
 } from "./context-provider.mjs";
+import { hideCaret } from "./hide-caret.mjs";
 import { hideVaultName } from "./hide-vault-name.mjs";
 import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
 async function captureObsidianScreenshot(options) {
   const {
     heightInPixels,
+    shouldHideCaret = true,
     shouldHideVaultName = true,
     transport: transportOverride,
     vaultPath,
@@ -25,13 +27,21 @@ async function captureObsidianScreenshot(options) {
       vaultPath: cwd
     });
   }
-  return transport.captureScreenshot(normalizeOptionalProperties({
-    cwd,
-    heightInPixels,
-    widthInPixels
-  }));
+  const hiddenCaret = shouldHideCaret ? await hideCaret({
+    transport,
+    vaultPath: cwd
+  }) : void 0;
+  try {
+    return await transport.captureScreenshot(normalizeOptionalProperties({
+      cwd,
+      heightInPixels,
+      widthInPixels
+    }));
+  } finally {
+    await hiddenCaret?.restore();
+  }
 }
 export {
   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.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { hideCaret } from './hide-caret.mjs';\nimport { hideVaultName } from './hide-vault-name.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\n/**\n * Options for {@link captureObsidianScreenshot}.\n */\nexport interface CaptureObsidianScreenshotOptions {\n  /**\n   * The exact height in pixels the captured image should have.\n   *\n   * Desktop only, and only meaningful together with {@link widthInPixels}.\n   * Ignored on mobile, where the image is always the device's native\n   * framebuffer \u2014 size those by choosing an AVD with the wanted screen\n   * geometry.\n   */\n  readonly heightInPixels?: number;\n\n  /**\n   * Whether to hide the focused element's caret while capturing, so the frame\n   * does not depend on which phase of its blink the capture caught.\n   *\n   * The caret is made transparent, not blurred: the focus, its ring and\n   * anything open because of it \u2014 a suggester under an input \u2014 all stay as the\n   * test built them, and the caret is put back once the frame is taken. Turn it\n   * off only to photograph the caret itself, and expect such a frame to differ\n   * between runs.\n   *\n   * @default `true`\n   */\n  readonly shouldHideCaret?: boolean;\n\n  /**\n   * Whether to hide the vault's name before capturing, so the frame does not\n   * depend on the random suffix of the harness's temporary vault.\n   *\n   * A default rather than a knob: reproducibility is what a checked-in\n   * screenshot is for, and the row it collapses sits under the caption band,\n   * so nothing a reader sees moves. Turn it off only to photograph the vault\n   * switcher itself.\n   *\n   * @default `true`\n   */\n  readonly shouldHideVaultName?: boolean;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault path to capture. When omitted, the current test context's vault\n   * is used.\n   */\n  readonly vaultPath?: string;\n\n  /**\n   * The exact width in pixels the captured image should have.\n   *\n   * See {@link heightInPixels} \u2014 the two are set together or not at all.\n   */\n  readonly widthInPixels?: number;\n}\n\n/**\n * Captures a PNG screenshot of the running Obsidian instance, resolving the\n * transport and vault from the current test context.\n *\n * The vault's name is hidden first, so two runs of the same suite against two\n * differently-named temporary vaults produce byte-identical PNGs. Pass\n * {@link CaptureObsidianScreenshotOptions.shouldHideVaultName} as `false` to\n * photograph it. The focused element's caret is hidden for the capture too, and\n * restored after it, so a frame with a focused field does not alternate between\n * two blink phases; {@link CaptureObsidianScreenshotOptions.shouldHideCaret}\n * turns that off.\n *\n * @param options - Optional size, transport and vault overrides.\n * @returns A {@link Promise} that resolves to the raw PNG bytes.\n * @throws Error if the active transport cannot capture screenshots.\n */\nexport async function captureObsidianScreenshot(options?: CaptureObsidianScreenshotOptions): Promise<Uint8Array> {\n  const {\n    heightInPixels,\n    shouldHideCaret = true,\n    shouldHideVaultName = true,\n    transport: transportOverride,\n    vaultPath,\n    widthInPixels\n  } = options ?? {};\n\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!transport.captureScreenshot) {\n    throw new Error('captureObsidianScreenshot: the active transport cannot capture screenshots.');\n  }\n\n  if (shouldHideVaultName) {\n    await hideVaultName({\n      transport,\n      vaultPath: cwd\n    });\n  }\n\n  const hiddenCaret = shouldHideCaret\n    ? await hideCaret({\n      transport,\n      vaultPath: cwd\n    })\n    : undefined;\n\n  try {\n    return await transport.captureScreenshot(normalizeOptionalProperties<CaptureScreenshotParams>({\n      cwd,\n      heightInPixels,\n      widthInPixels\n    }));\n  } finally {\n    await hiddenCaret?.restore();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAsBA,OAAO,aAAa;AAKpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAC1B,SAAS,qBAAqB;AAC9B,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA+ErC,eAAsB,0BAA0B,SAAiE;AAC/G,QAAM;AAAA,IACJ;AAAA,IACA,kBAAkB;AAAA,IAClB,sBAAsB;AAAA,IACtB,WAAW;AAAA,IACX;AAAA,IACA;AAAA,EACF,IAAI,WAAW,CAAC;AAEhB,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AACvD,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,UAAU,mBAAmB;AAChC,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,MAAI,qBAAqB;AACvB,UAAM,cAAc;AAAA,MAClB;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAEA,QAAM,cAAc,kBAChB,MAAM,UAAU;AAAA,IAChB;AAAA,IACA,WAAW;AAAA,EACb,CAAC,IACC;AAEJ,MAAI;AACF,WAAO,MAAM,UAAU,kBAAkB,4BAAqD;AAAA,MAC5F;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC,CAAC;AAAA,EACJ,UAAE;AACA,UAAM,aAAa,QAAQ;AAAA,EAC7B;AACF;",
  "names": []
}


package/dist/lib/esm/field-text-hold.d.mts

@@ -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/esm/field-text-hold.mjs

@@ -0,0 +1,32 @@
+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 };
+}
+export {
+  holdFieldText
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/hide-caret.d.mts

@@ -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.mjs';
+/**
+ * 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>;