obsidian-integration-testing 17.1.1 → 17.2.0

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.1.1";
+const LIBRARY_VERSION = false ? "dev" : "17.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

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

@@ -47,6 +47,8 @@ const KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;
 const KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS = 900;
 const KEYBOARD_RETRACT_ATTEMPT_COUNT = 2;
 const KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS;
+const CARET_PARK_ATTEMPT_COUNT = 3;
+const CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS = 300;
 async function raiseSoftKeyboard(params) {
   await lowerSoftKeyboardIfShown(params);
   const textToRestore = await emptyFieldForTouch(params);
@@ -62,6 +64,9 @@ async function raiseSoftKeyboard(params) {
   if (textToRestore !== null) {
     await restoreFieldText(params, textToRestore);
   }
+  if (params.shouldPinKeyboardToolbar !== false) {
+    await parkCaretAtStart(params);
+  }
   return snapshot;
 }
 async function tapDevice(params) {
@@ -158,6 +163,36 @@ device: ${inputMethodState}`
     );
   }
 }
+async function parkCaretAtStart(params) {
+  const selections = [];
+  for (let attempt = 0; attempt < CARET_PARK_ATTEMPT_COUNT; attempt++) {
+    const isParked = await (0, import_eval_in_obsidian.evalInObsidian)({
+      callback({ inputSelector }) {
+        const element = document.querySelector(inputSelector);
+        if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {
+          return false;
+        }
+        element.setSelectionRange(0, 0);
+        return true;
+      },
+      input: { inputSelector: params.inputSelector },
+      ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+    });
+    if (!isParked) {
+      return;
+    }
+    await (0, import_promises.setTimeout)(CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS);
+    const selection = await readFieldSelection(params);
+    selections.push(selection);
+    if (selection?.selectionStart === 0 && selection.selectionEnd === 0) {
+      return;
+    }
+  }
+  throw new Error(
+    `raiseSoftKeyboard: the caret parked at offset 0 in "${params.inputSelector}" did not stay there, so Gboard's strip would show word predictions rather than its toolbar. ${String(CARET_PARK_ATTEMPT_COUNT)} attempt(s); the field read ${JSON.stringify(selections)}. Pass shouldPinKeyboardToolbar: false to leave the caret alone.
+device: ${await readInputMethodState(params)}`
+  );
+}
 async function readFieldContent(params) {
   return await (0, import_eval_in_obsidian.evalInObsidian)({
     callback({ inputSelector }) {
@@ -172,6 +207,16 @@ async function readFieldContent(params) {
     ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
   });
 }
+async function readFieldSelection(params) {
+  return await (0, import_eval_in_obsidian.evalInObsidian)({
+    callback({ inputSelector }) {
+      const element = document.querySelector(inputSelector);
+      return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement ? { selectionEnd: element.selectionEnd, selectionStart: element.selectionStart } : null;
+    },
+    input: { inputSelector: params.inputSelector },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
 async function readInputMethodState(params) {
   const dumpsysOutput = await (0, import_adb.runAdbText)({
     commandArguments: ["shell", "dumpsys", "input_method"],
@@ -261,4 +306,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 *    **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"]
}

+//# 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 * 5. **Gboard's suggestion strip is a second race, and parking the caret at offset 0 ends it.** With the\n *    keyboard up, Gboard draws either its toolbar (apps, stickers, GIF, clipboard, settings, theme, mic) or word\n *    predictions for the text before the caret. The touch landed on the emptied field, which gets the toolbar,\n *    and the write-back puts the caret at the end of the text, which gets predictions \u2014 once Gboard hears about\n *    it, which is a matter of timing. The predictions themselves come from the keyboard's learned dictionary\n *    and differ between runs. So a capture showed one of two strips, and two different sets of predictions\n *    when it showed the second. Suggestions cannot be switched off from the page: Obsidian's `.prompt-input`\n *    already carries `spellcheck=\"false\"`, and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`\n *    (`inputType=0x2080a1`). Gboard still predicts (measured 2026-09-25). With the caret at offset 0 there is\n *    no text before it, which is the empty-field state, so whichever way the race goes, the strip is the\n *    toolbar. See `shouldPinKeyboardToolbar`.\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   * Whether to park the caret at offset 0 once the keyboard is up, so Gboard's suggestion strip shows its\n   * toolbar rather than word predictions.\n   *\n   * **On by default, because the strip is otherwise a race between two states, and one of them varies.**\n   * Gboard shows its toolbar while nothing sits before the caret, and predictions for the word before it\n   * otherwise. The touch lands on the emptied field (toolbar). The write-back leaves the caret after the text\n   * (predictions), but only once Gboard has processed that update. And the predictions come from the\n   * keyboard's learned dictionary, so they differ from one run to the next. With the caret at offset 0 both\n   * outcomes of the race are the toolbar: measured 2026-09-25, six raises with the caret parked all gave\n   * byte-identical strip rows showing the toolbar, while the same field with the caret at the end showed\n   * `multiple` / `multiples` / `multiplex`.\n   *\n   * Turning suggestions off does not do this. Obsidian's prompt input already has `spellcheck=\"false\"`,\n   * and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`, yet Gboard still predicts.\n   *\n   * Only an `<input>` or a `<textarea>` is parked; any other field is left as it is. The caret is visible at\n   * offset 0 unless the capture hides it, which a device capture has to ask for with `hideCaret`.\n   *\n   * Turning it off leaves the caret where the write-back or the touch put it.\n   *\n   * @default true\n   */\n  readonly shouldPinKeyboardToolbar?: 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 * How many times the caret is parked at offset 0 before a caret that will not stay there is reported.\n */\nconst CARET_PARK_ATTEMPT_COUNT = 3;\n\n/**\n * How long a parked caret is left before it is read back \u2014 long enough for the IME to answer the selection\n * change, which is what would move it again.\n */\nconst CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS = 300;\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 * Where a field's caret is, as the selection offsets an `<input>` or a `<textarea>` reports.\n */\ninterface FieldSelection {\n  /**\n   * Where the selection ends.\n   */\n  readonly selectionEnd: null | number;\n\n  /**\n   * Where the selection starts.\n   */\n  readonly selectionStart: null | number;\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 caret is then parked at offset 0**, so Gboard's suggestion strip is its toolbar rather than word\n * predictions that race the write-back and vary between runs \u2014 see\n * {@link RaiseSoftKeyboardParams.shouldPinKeyboardToolbar}, 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 if the text written back would not\n *   stay in the field, or if the caret would not stay at offset 0. A write-back the IME undoes is written\n *   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  if (params.shouldPinKeyboardToolbar !== false) {\n    await parkCaretAtStart(params);\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 * Parks the field's caret at offset 0, and does not return until it has stayed there.\n *\n * Read back after {@link CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS}, and parked again when it moved: the IME\n * answers a selection change, and a caret it moved back to the end would bring the predictions back with it.\n *\n * @param params - The field whose caret to park.\n * @returns A {@link Promise} that resolves once the caret has stayed at offset 0, or at once for a field that\n *   is not an `<input>` or a `<textarea>`.\n * @throws Error if the caret did not stay at offset 0 after {@link CARET_PARK_ATTEMPT_COUNT} attempts.\n */\nasync function parkCaretAtStart(params: RaiseSoftKeyboardParams): Promise<void> {\n  const selections: (FieldSelection | null)[] = [];\n\n  for (let attempt = 0; attempt < CARET_PARK_ATTEMPT_COUNT; attempt++) {\n    const isParked = await evalInObsidian({\n      callback({ inputSelector }): boolean {\n        const element = document.querySelector(inputSelector);\n\n        if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {\n          return false;\n        }\n\n        element.setSelectionRange(0, 0);\n        return true;\n      },\n      input: { inputSelector: params.inputSelector },\n      ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n    });\n\n    if (!isParked) {\n      return;\n    }\n\n    await sleep(CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS);\n    const selection = await readFieldSelection(params);\n    selections.push(selection);\n\n    if (selection?.selectionStart === 0 && selection.selectionEnd === 0) {\n      return;\n    }\n  }\n\n  throw new Error(\n    `raiseSoftKeyboard: the caret parked at offset 0 in \"${params.inputSelector}\" did not stay there, so Gboard's `\n      + `strip would show word predictions rather than its toolbar. ${String(CARET_PARK_ATTEMPT_COUNT)} attempt(s); `\n      + `the field read ${JSON.stringify(selections)}. Pass shouldPinKeyboardToolbar: false to leave the caret alone.\ndevice: ${await readInputMethodState(params)}`\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 * Reads where the field's caret is.\n *\n * @param params - The field to read.\n * @returns A {@link Promise} that resolves to the selection, or `null` when nothing writable matched.\n */\nasync function readFieldSelection(params: RaiseSoftKeyboardParams): Promise<FieldSelection | null> {\n  return await evalInObsidian({\n    callback({ inputSelector }): FieldSelection | null {\n      const element = document.querySelector(inputSelector);\n\n      return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement\n        ? { selectionEnd: element.selectionEnd, selectionStart: element.selectionStart }\n        : null;\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": "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",
  "names": ["process", "sleep"]
}


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

@@ -51,6 +51,18 @@
  *    so the capture straight after showed the placeholder. The field is re-read until it holds, and written
  *    again when it does not.
  *
+ * 5. **Gboard's suggestion strip is a second race, and parking the caret at offset 0 ends it.** With the
+ *    keyboard up, Gboard draws either its toolbar (apps, stickers, GIF, clipboard, settings, theme, mic) or word
+ *    predictions for the text before the caret. The touch landed on the emptied field, which gets the toolbar,
+ *    and the write-back puts the caret at the end of the text, which gets predictions — once Gboard hears about
+ *    it, which is a matter of timing. The predictions themselves come from the keyboard's learned dictionary
+ *    and differ between runs. So a capture showed one of two strips, and two different sets of predictions
+ *    when it showed the second. Suggestions cannot be switched off from the page: Obsidian's `.prompt-input`
+ *    already carries `spellcheck="false"`, and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`
+ *    (`inputType=0x2080a1`). Gboard still predicts (measured 2026-09-25). With the caret at offset 0 there is
+ *    no text before it, which is the empty-field state, so whichever way the race goes, the strip is the
+ *    toolbar. See `shouldPinKeyboardToolbar`.
+ *
  * 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.
@@ -100,6 +112,30 @@ export interface RaiseSoftKeyboardParams {
      * @default true
      */
     readonly shouldEmptyFieldForTouch?: boolean;
+    /**
+     * Whether to park the caret at offset 0 once the keyboard is up, so Gboard's suggestion strip shows its
+     * toolbar rather than word predictions.
+     *
+     * **On by default, because the strip is otherwise a race between two states, and one of them varies.**
+     * Gboard shows its toolbar while nothing sits before the caret, and predictions for the word before it
+     * otherwise. The touch lands on the emptied field (toolbar). The write-back leaves the caret after the text
+     * (predictions), but only once Gboard has processed that update. And the predictions come from the
+     * keyboard's learned dictionary, so they differ from one run to the next. With the caret at offset 0 both
+     * outcomes of the race are the toolbar: measured 2026-09-25, six raises with the caret parked all gave
+     * byte-identical strip rows showing the toolbar, while the same field with the caret at the end showed
+     * `multiple` / `multiples` / `multiplex`.
+     *
+     * Turning suggestions off does not do this. Obsidian's prompt input already has `spellcheck="false"`,
+     * and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`, yet Gboard still predicts.
+     *
+     * Only an `<input>` or a `<textarea>` is parked; any other field is left as it is. The caret is visible at
+     * offset 0 unless the capture hides it, which a device capture has to ask for with `hideCaret`.
+     *
+     * Turning it off leaves the caret where the write-back or the touch put it.
+     *
+     * @default true
+     */
+    readonly shouldPinKeyboardToolbar?: boolean;
     /**
      * The vault to read the geometry from. When omitted, the current test context's vault is used.
      */
@@ -136,6 +172,10 @@ export interface TapDeviceParams {
  * text draws Chromium's selection handle and the framebuffer photographs it — see
  * {@link RaiseSoftKeyboardParams.shouldEmptyFieldForTouch}, which turns that off.
  *
+ * **The caret is then parked at offset 0**, so Gboard's suggestion strip is its toolbar rather than word
+ * predictions that race the write-back and vary between runs — see
+ * {@link RaiseSoftKeyboardParams.shouldPinKeyboardToolbar}, which turns that off.
+ *
  * **The geometry returned is read with the field still empty**, and the text is written back after it.
  * That is the state the proven capture suites assert against, and it is deliberate rather than
  * incidental: the baseline is read AFTER the field is emptied, so the lift is measured between two reads
@@ -148,8 +188,9 @@ export interface TapDeviceParams {
  * @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, 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`.
+ *   device's own `input_method` state to the diagnostics directory — if the text written back would not
+ *   stay in the field, or if the caret would not stay at offset 0. 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/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "17.1.1";
+const LIBRARY_VERSION = false ? "dev" : "17.2.0";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/soft-keyboard.d.mts

@@ -51,6 +51,18 @@
  *    so the capture straight after showed the placeholder. The field is re-read until it holds, and written
  *    again when it does not.
  *
+ * 5. **Gboard's suggestion strip is a second race, and parking the caret at offset 0 ends it.** With the
+ *    keyboard up, Gboard draws either its toolbar (apps, stickers, GIF, clipboard, settings, theme, mic) or word
+ *    predictions for the text before the caret. The touch landed on the emptied field, which gets the toolbar,
+ *    and the write-back puts the caret at the end of the text, which gets predictions — once Gboard hears about
+ *    it, which is a matter of timing. The predictions themselves come from the keyboard's learned dictionary
+ *    and differ between runs. So a capture showed one of two strips, and two different sets of predictions
+ *    when it showed the second. Suggestions cannot be switched off from the page: Obsidian's `.prompt-input`
+ *    already carries `spellcheck="false"`, and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`
+ *    (`inputType=0x2080a1`). Gboard still predicts (measured 2026-09-25). With the caret at offset 0 there is
+ *    no text before it, which is the empty-field state, so whichever way the race goes, the strip is the
+ *    toolbar. See `shouldPinKeyboardToolbar`.
+ *
  * 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.
@@ -100,6 +112,30 @@ export interface RaiseSoftKeyboardParams {
      * @default true
      */
     readonly shouldEmptyFieldForTouch?: boolean;
+    /**
+     * Whether to park the caret at offset 0 once the keyboard is up, so Gboard's suggestion strip shows its
+     * toolbar rather than word predictions.
+     *
+     * **On by default, because the strip is otherwise a race between two states, and one of them varies.**
+     * Gboard shows its toolbar while nothing sits before the caret, and predictions for the word before it
+     * otherwise. The touch lands on the emptied field (toolbar). The write-back leaves the caret after the text
+     * (predictions), but only once Gboard has processed that update. And the predictions come from the
+     * keyboard's learned dictionary, so they differ from one run to the next. With the caret at offset 0 both
+     * outcomes of the race are the toolbar: measured 2026-09-25, six raises with the caret parked all gave
+     * byte-identical strip rows showing the toolbar, while the same field with the caret at the end showed
+     * `multiple` / `multiples` / `multiplex`.
+     *
+     * Turning suggestions off does not do this. Obsidian's prompt input already has `spellcheck="false"`,
+     * and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`, yet Gboard still predicts.
+     *
+     * Only an `<input>` or a `<textarea>` is parked; any other field is left as it is. The caret is visible at
+     * offset 0 unless the capture hides it, which a device capture has to ask for with `hideCaret`.
+     *
+     * Turning it off leaves the caret where the write-back or the touch put it.
+     *
+     * @default true
+     */
+    readonly shouldPinKeyboardToolbar?: boolean;
     /**
      * The vault to read the geometry from. When omitted, the current test context's vault is used.
      */
@@ -136,6 +172,10 @@ export interface TapDeviceParams {
  * text draws Chromium's selection handle and the framebuffer photographs it — see
  * {@link RaiseSoftKeyboardParams.shouldEmptyFieldForTouch}, which turns that off.
  *
+ * **The caret is then parked at offset 0**, so Gboard's suggestion strip is its toolbar rather than word
+ * predictions that race the write-back and vary between runs — see
+ * {@link RaiseSoftKeyboardParams.shouldPinKeyboardToolbar}, which turns that off.
+ *
  * **The geometry returned is read with the field still empty**, and the text is written back after it.
  * That is the state the proven capture suites assert against, and it is deliberate rather than
  * incidental: the baseline is read AFTER the field is emptied, so the lift is measured between two reads
@@ -148,8 +188,9 @@ export interface TapDeviceParams {
  * @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, 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`.
+ *   device's own `input_method` state to the diagnostics directory — if the text written back would not
+ *   stay in the field, or if the caret would not stay at offset 0. 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/soft-keyboard.mjs

@@ -22,6 +22,8 @@ const KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS = 1500;
 const KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS = 900;
 const KEYBOARD_RETRACT_ATTEMPT_COUNT = 2;
 const KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS;
+const CARET_PARK_ATTEMPT_COUNT = 3;
+const CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS = 300;
 async function raiseSoftKeyboard(params) {
   await lowerSoftKeyboardIfShown(params);
   const textToRestore = await emptyFieldForTouch(params);
@@ -37,6 +39,9 @@ async function raiseSoftKeyboard(params) {
   if (textToRestore !== null) {
     await restoreFieldText(params, textToRestore);
   }
+  if (params.shouldPinKeyboardToolbar !== false) {
+    await parkCaretAtStart(params);
+  }
   return snapshot;
 }
 async function tapDevice(params) {
@@ -133,6 +138,36 @@ device: ${inputMethodState}`
     );
   }
 }
+async function parkCaretAtStart(params) {
+  const selections = [];
+  for (let attempt = 0; attempt < CARET_PARK_ATTEMPT_COUNT; attempt++) {
+    const isParked = await evalInObsidian({
+      callback({ inputSelector }) {
+        const element = document.querySelector(inputSelector);
+        if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {
+          return false;
+        }
+        element.setSelectionRange(0, 0);
+        return true;
+      },
+      input: { inputSelector: params.inputSelector },
+      ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+    });
+    if (!isParked) {
+      return;
+    }
+    await sleep(CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS);
+    const selection = await readFieldSelection(params);
+    selections.push(selection);
+    if (selection?.selectionStart === 0 && selection.selectionEnd === 0) {
+      return;
+    }
+  }
+  throw new Error(
+    `raiseSoftKeyboard: the caret parked at offset 0 in "${params.inputSelector}" did not stay there, so Gboard's strip would show word predictions rather than its toolbar. ${String(CARET_PARK_ATTEMPT_COUNT)} attempt(s); the field read ${JSON.stringify(selections)}. Pass shouldPinKeyboardToolbar: false to leave the caret alone.
+device: ${await readInputMethodState(params)}`
+  );
+}
 async function readFieldContent(params) {
   return await evalInObsidian({
     callback({ inputSelector }) {
@@ -147,6 +182,16 @@ async function readFieldContent(params) {
     ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
   });
 }
+async function readFieldSelection(params) {
+  return await evalInObsidian({
+    callback({ inputSelector }) {
+      const element = document.querySelector(inputSelector);
+      return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement ? { selectionEnd: element.selectionEnd, selectionStart: element.selectionStart } : null;
+    },
+    input: { inputSelector: params.inputSelector },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
 async function readInputMethodState(params) {
   const dumpsysOutput = await runAdbText({
     commandArguments: ["shell", "dumpsys", "input_method"],
@@ -235,4 +280,4 @@ export {
   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 *    **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.mjs';\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\n\nimport { runAdbText } from './adb.mjs';\nimport { captureDeviceScreenshot } from './device-screenshot.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { holdFieldText } from './field-text-hold.mjs';\nimport { log } from './log.mjs';\nimport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\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": "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",
  "names": []
}

+//# 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 * 5. **Gboard's suggestion strip is a second race, and parking the caret at offset 0 ends it.** With the\n *    keyboard up, Gboard draws either its toolbar (apps, stickers, GIF, clipboard, settings, theme, mic) or word\n *    predictions for the text before the caret. The touch landed on the emptied field, which gets the toolbar,\n *    and the write-back puts the caret at the end of the text, which gets predictions \u2014 once Gboard hears about\n *    it, which is a matter of timing. The predictions themselves come from the keyboard's learned dictionary\n *    and differ between runs. So a capture showed one of two strips, and two different sets of predictions\n *    when it showed the second. Suggestions cannot be switched off from the page: Obsidian's `.prompt-input`\n *    already carries `spellcheck=\"false\"`, and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`\n *    (`inputType=0x2080a1`). Gboard still predicts (measured 2026-09-25). With the caret at offset 0 there is\n *    no text before it, which is the empty-field state, so whichever way the race goes, the strip is the\n *    toolbar. See `shouldPinKeyboardToolbar`.\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.mjs';\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\n\nimport { runAdbText } from './adb.mjs';\nimport { captureDeviceScreenshot } from './device-screenshot.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { holdFieldText } from './field-text-hold.mjs';\nimport { log } from './log.mjs';\nimport {\n  buildSoftKeyboardDiagnosticMessage,\n  checkIsInputMethodShown,\n  checkIsSoftKeyboardUp,\n  parseInputMethodState,\n  resolveSoftKeyboardTapPoints\n} from './soft-keyboard-geometry.mjs';\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   * Whether to park the caret at offset 0 once the keyboard is up, so Gboard's suggestion strip shows its\n   * toolbar rather than word predictions.\n   *\n   * **On by default, because the strip is otherwise a race between two states, and one of them varies.**\n   * Gboard shows its toolbar while nothing sits before the caret, and predictions for the word before it\n   * otherwise. The touch lands on the emptied field (toolbar). The write-back leaves the caret after the text\n   * (predictions), but only once Gboard has processed that update. And the predictions come from the\n   * keyboard's learned dictionary, so they differ from one run to the next. With the caret at offset 0 both\n   * outcomes of the race are the toolbar: measured 2026-09-25, six raises with the caret parked all gave\n   * byte-identical strip rows showing the toolbar, while the same field with the caret at the end showed\n   * `multiple` / `multiples` / `multiplex`.\n   *\n   * Turning suggestions off does not do this. Obsidian's prompt input already has `spellcheck=\"false\"`,\n   * and the IME already receives `TYPE_TEXT_FLAG_NO_SUGGESTIONS`, yet Gboard still predicts.\n   *\n   * Only an `<input>` or a `<textarea>` is parked; any other field is left as it is. The caret is visible at\n   * offset 0 unless the capture hides it, which a device capture has to ask for with `hideCaret`.\n   *\n   * Turning it off leaves the caret where the write-back or the touch put it.\n   *\n   * @default true\n   */\n  readonly shouldPinKeyboardToolbar?: 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 * How many times the caret is parked at offset 0 before a caret that will not stay there is reported.\n */\nconst CARET_PARK_ATTEMPT_COUNT = 3;\n\n/**\n * How long a parked caret is left before it is read back \u2014 long enough for the IME to answer the selection\n * change, which is what would move it again.\n */\nconst CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS = 300;\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 * Where a field's caret is, as the selection offsets an `<input>` or a `<textarea>` reports.\n */\ninterface FieldSelection {\n  /**\n   * Where the selection ends.\n   */\n  readonly selectionEnd: null | number;\n\n  /**\n   * Where the selection starts.\n   */\n  readonly selectionStart: null | number;\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 caret is then parked at offset 0**, so Gboard's suggestion strip is its toolbar rather than word\n * predictions that race the write-back and vary between runs \u2014 see\n * {@link RaiseSoftKeyboardParams.shouldPinKeyboardToolbar}, 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 if the text written back would not\n *   stay in the field, or if the caret would not stay at offset 0. A write-back the IME undoes is written\n *   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  if (params.shouldPinKeyboardToolbar !== false) {\n    await parkCaretAtStart(params);\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 * Parks the field's caret at offset 0, and does not return until it has stayed there.\n *\n * Read back after {@link CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS}, and parked again when it moved: the IME\n * answers a selection change, and a caret it moved back to the end would bring the predictions back with it.\n *\n * @param params - The field whose caret to park.\n * @returns A {@link Promise} that resolves once the caret has stayed at offset 0, or at once for a field that\n *   is not an `<input>` or a `<textarea>`.\n * @throws Error if the caret did not stay at offset 0 after {@link CARET_PARK_ATTEMPT_COUNT} attempts.\n */\nasync function parkCaretAtStart(params: RaiseSoftKeyboardParams): Promise<void> {\n  const selections: (FieldSelection | null)[] = [];\n\n  for (let attempt = 0; attempt < CARET_PARK_ATTEMPT_COUNT; attempt++) {\n    const isParked = await evalInObsidian({\n      callback({ inputSelector }): boolean {\n        const element = document.querySelector(inputSelector);\n\n        if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {\n          return false;\n        }\n\n        element.setSelectionRange(0, 0);\n        return true;\n      },\n      input: { inputSelector: params.inputSelector },\n      ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n    });\n\n    if (!isParked) {\n      return;\n    }\n\n    await sleep(CARET_PARK_CONFIRMATION_DELAY_IN_MILLISECONDS);\n    const selection = await readFieldSelection(params);\n    selections.push(selection);\n\n    if (selection?.selectionStart === 0 && selection.selectionEnd === 0) {\n      return;\n    }\n  }\n\n  throw new Error(\n    `raiseSoftKeyboard: the caret parked at offset 0 in \"${params.inputSelector}\" did not stay there, so Gboard's `\n      + `strip would show word predictions rather than its toolbar. ${String(CARET_PARK_ATTEMPT_COUNT)} attempt(s); `\n      + `the field read ${JSON.stringify(selections)}. Pass shouldPinKeyboardToolbar: false to leave the caret alone.\ndevice: ${await readInputMethodState(params)}`\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 * Reads where the field's caret is.\n *\n * @param params - The field to read.\n * @returns A {@link Promise} that resolves to the selection, or `null` when nothing writable matched.\n */\nasync function readFieldSelection(params: RaiseSoftKeyboardParams): Promise<FieldSelection | null> {\n  return await evalInObsidian({\n    callback({ inputSelector }): FieldSelection | null {\n      const element = document.querySelector(inputSelector);\n\n      return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement\n        ? { selectionEnd: element.selectionEnd, selectionStart: element.selectionStart }\n        : null;\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": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "17.1.1",
+  "version": "17.2.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",