obsidian-integration-testing 17.1.0 → 17.1.1

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

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_text_hold_exports = {};
+__export(field_text_hold_exports, {
+  holdFieldText: () => holdFieldText
+});
+module.exports = __toCommonJS(field_text_hold_exports);
+const DEFAULT_CONFIRMATION_READ_COUNT = 3;
+const DEFAULT_INTERVAL_IN_MILLISECONDS = 300;
+const DEFAULT_MAX_WRITE_COUNT = 4;
+async function holdFieldText(params) {
+  const confirmationReadCount = params.confirmationReadCount ?? DEFAULT_CONFIRMATION_READ_COUNT;
+  const intervalInMilliseconds = params.intervalInMilliseconds ?? DEFAULT_INTERVAL_IN_MILLISECONDS;
+  const maxWriteCount = params.maxWriteCount ?? DEFAULT_MAX_WRITE_COUNT;
+  const readTexts = [];
+  await params.writeText(params.expectedText);
+  let writeCount = 1;
+  let agreeingReadCount = 0;
+  while (agreeingReadCount < confirmationReadCount) {
+    await params.sleep(intervalInMilliseconds);
+    const text = await params.readText();
+    readTexts.push(text);
+    if (text === params.expectedText) {
+      agreeingReadCount++;
+      continue;
+    }
+    if (text === null || writeCount >= maxWriteCount) {
+      return { isHeld: false, readTexts, writeCount };
+    }
+    await params.writeText(params.expectedText);
+    writeCount++;
+    agreeingReadCount = 0;
+  }
+  return { isHeld: true, readTexts, writeCount };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  holdFieldText
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2ZpZWxkLXRleHQtaG9sZC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEhvbGRzIGEgc2NyaXB0ZWQgd3JpdGUgdG8gYSBmaWVsZCB1bnRpbCBpdCBzdGF5cyBwdXQuXG4gKlxuICogYHJhaXNlU29mdEtleWJvYXJkYCBlbXB0aWVzIGl0cyBmaWVsZCBmb3IgdGhlIHRvdWNoIHRoYXQgcmFpc2VzIHRoZSBJTUUgYW5kIHdyaXRlcyB0aGUgdGV4dCBiYWNrIGFmdGVyd2FyZHMuXG4gKiBUaGUgd3JpdGUgbGFuZHMsIGFuZCB0aGVuIGFib3V0IG9uZSB0aW1lIGluIGZpdmUgaXQgaXMgdW5kb25lOiB0aGUgdG91Y2ggc3RhcnRlZCB0aGUgSU1FJ3MgaW5wdXQgY29ubmVjdGlvblxuICogZnJvbSB0aGUgRU1QVFkgZmllbGQsIGFuZCBhIGxhdGVyIHVwZGF0ZSBmcm9tIHRoYXQgY29ubmVjdGlvbiB3cml0ZXMgdGhlIGVtcHR5IHN0YXRlIGJhY2sgb3ZlciB0aGUgaGFybmVzcydzXG4gKiB3cml0ZS4gTm90aGluZyByZXBvcnRzIGl0IFx1MjAxNCB0aGUgY2FwdHVyZSB0YWtlbiBzdHJhaWdodCBhZnRlciBzaW1wbHkgc2hvd3MgdGhlIHBsYWNlaG9sZGVyIFx1MjAxNCBzbyB0aGUgd3JpdGUgaXNcbiAqIG5vdCBkb25lIHVudGlsIHJlcGVhdGVkIHJlYWRzIGFncmVlIGl0IGhlbGQuXG4gKlxuICogVGhlIGxvb3AgaXMgcHVyZSwgd2l0aCB0aGUgcmVhZCwgdGhlIHdyaXRlIGFuZCB0aGUgc2xlZXAgaW5qZWN0ZWQsIHRoZSBzYW1lIHNwbGl0IGFzIGBwb2xsLXVudGlsYDogdGhlXG4gKiBvcmNoZXN0cmF0aW9uIGlzIHVuaXQtdGVzdGVkIGhlcmUsIGFuZCBvbmx5IGl0cyB3aXJpbmcgdG8gYSBsaXZlIHJlbmRlcmVyIHNpdHMgaW4gdGhlIGludGVncmF0aW9uLW9ubHlcbiAqIGBzb2Z0LWtleWJvYXJkYC5cbiAqL1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHtAbGluayBob2xkRmllbGRUZXh0fS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBIb2xkRmllbGRUZXh0UGFyYW1zIHtcbiAgLyoqXG4gICAqIEhvdyBtYW55IGNvbnNlY3V0aXZlIHJlYWRzIG11c3Qgc2hvdyB0aGUgdGV4dCBiZWZvcmUgaXQgY291bnRzIGFzIGhlbGQuXG4gICAqXG4gICAqIEBkZWZhdWx0IDNcbiAgICovXG4gIHJlYWRvbmx5IGNvbmZpcm1hdGlvblJlYWRDb3VudD86IG51bWJlcjtcblxuICAvKipcbiAgICogVGhlIHRleHQgdGhlIGZpZWxkIG11c3QgZW5kIHVwIGhvbGRpbmcuXG4gICAqL1xuICByZWFkb25seSBleHBlY3RlZFRleHQ6IHN0cmluZztcblxuICAvKipcbiAgICogVGhlIHdhaXQgYmVmb3JlIGVhY2ggcmVhZC5cbiAgICpcbiAgICogQGRlZmF1bHQgMzAwXG4gICAqL1xuICByZWFkb25seSBpbnRlcnZhbEluTWlsbGlzZWNvbmRzPzogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBIb3cgbWFueSB3cml0ZXMgYXJlIG1hZGUgaW4gYWxsLCB0aGUgZmlyc3QgaW5jbHVkZWQsIGJlZm9yZSB0aGUgdGV4dCBpcyByZXBvcnRlZCBsb3N0LlxuICAgKlxuICAgKiBAZGVmYXVsdCA0XG4gICAqL1xuICByZWFkb25seSBtYXhXcml0ZUNvdW50PzogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBSZWFkcyB3aGF0IHRoZSBmaWVsZCBob2xkcyBub3csIG9yIGBudWxsYCB3aGVuIHRoZSBmaWVsZCBpcyBnb25lLlxuICAgKi9cbiAgcmVhZG9ubHkgcmVhZFRleHQ6ICh0aGlzOiB2b2lkKSA9PiBQcm9taXNlPG51bGwgfCBzdHJpbmc+O1xuXG4gIC8qKlxuICAgKiBTbGVlcHMgZm9yIHRoZSBnaXZlbiBudW1iZXIgb2YgbWlsbGlzZWNvbmRzLlxuICAgKi9cbiAgcmVhZG9ubHkgc2xlZXA6ICh0aGlzOiB2b2lkLCBtaWxsaXNlY29uZHM6IG51bWJlcikgPT4gUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogV3JpdGVzIHRoZSB0ZXh0IGludG8gdGhlIGZpZWxkLlxuICAgKi9cbiAgcmVhZG9ubHkgd3JpdGVUZXh0OiAodGhpczogdm9pZCwgdGV4dDogc3RyaW5nKSA9PiBQcm9taXNlPHZvaWQ+O1xufVxuXG4vKipcbiAqIFdoYXQge0BsaW5rIGhvbGRGaWVsZFRleHR9IGZvdW5kLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEhvbGRGaWVsZFRleHRSZXN1bHQge1xuICAvKipcbiAgICogV2hldGhlciB0aGUgdGV4dCBoZWxkIGZvciB0aGUgd2hvbGUgY29uZmlybWF0aW9uIHdpbmRvdy5cbiAgICovXG4gIHJlYWRvbmx5IGlzSGVsZDogYm9vbGVhbjtcblxuICAvKipcbiAgICogRXZlcnkgcmVhZCwgaW4gb3JkZXIgXHUyMDE0IHRoZSBldmlkZW5jZSBhIGZhaWx1cmUgcmVwb3J0cy5cbiAgICovXG4gIHJlYWRvbmx5IHJlYWRUZXh0czogcmVhZG9ubHkgKG51bGwgfCBzdHJpbmcpW107XG5cbiAgLyoqXG4gICAqIEhvdyBtYW55IHdyaXRlcyB3ZXJlIG1hZGUsIHRoZSBmaXJzdCBpbmNsdWRlZC4gQWJvdmUgb25lIG1lYW5zIHRoZSB0ZXh0IHdhcyBsb3N0IGFuZCB3cml0dGVuIGFnYWluLlxuICAgKi9cbiAgcmVhZG9ubHkgd3JpdGVDb3VudDogbnVtYmVyO1xufVxuXG5jb25zdCBERUZBVUxUX0NPTkZJUk1BVElPTl9SRUFEX0NPVU5UID0gMztcbmNvbnN0IERFRkFVTFRfSU5URVJWQUxfSU5fTUlMTElTRUNPTkRTID0gMzAwO1xuY29uc3QgREVGQVVMVF9NQVhfV1JJVEVfQ09VTlQgPSA0O1xuXG4vKipcbiAqIFdyaXRlcyB0aGUgdGV4dCwgdGhlbiByZS1yZWFkcyB0aGUgZmllbGQgdW50aWwgaXQgaGFzIHNob3duIHRoZSB0ZXh0IG9uIGVub3VnaCBjb25zZWN1dGl2ZSByZWFkcywgd3JpdGluZyBpdFxuICogYWdhaW4gZWFjaCB0aW1lIGEgcmVhZCBzaG93cyBhbnl0aGluZyBlbHNlLlxuICpcbiAqIEEgcmVhZCBvZiBgbnVsbGAgZW5kcyB0aGUgaG9sZCBhdCBvbmNlLCBhcyBub3QgaGVsZDogdGhlIGZpZWxkIGlzIGdvbmUsIHNvIHRoZXJlIGlzIG5vdGhpbmcgbGVmdCB0byB3cml0ZSBpbnRvLlxuICpcbiAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgdGV4dCwgaG93IHRvIHJlYWQgYW5kIHdyaXRlIHRoZSBmaWVsZCwgYW5kIGhvdyBsb25nIGl0IG11c3QgaG9sZC5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gd2hldGhlciB0aGUgdGV4dCBoZWxkLCBldmVyeSByZWFkLCBhbmQgaG93IG1hbnkgd3JpdGVzIGl0IHRvb2suXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBob2xkRmllbGRUZXh0KHBhcmFtczogSG9sZEZpZWxkVGV4dFBhcmFtcyk6IFByb21pc2U8SG9sZEZpZWxkVGV4dFJlc3VsdD4ge1xuICBjb25zdCBjb25maXJtYXRpb25SZWFkQ291bnQgPSBwYXJhbXMuY29uZmlybWF0aW9uUmVhZENvdW50ID8/IERFRkFVTFRfQ09ORklSTUFUSU9OX1JFQURfQ09VTlQ7XG4gIGNvbnN0IGludGVydmFsSW5NaWxsaXNlY29uZHMgPSBwYXJhbXMuaW50ZXJ2YWxJbk1pbGxpc2Vjb25kcyA/PyBERUZBVUxUX0lOVEVSVkFMX0lOX01JTExJU0VDT05EUztcbiAgY29uc3QgbWF4V3JpdGVDb3VudCA9IHBhcmFtcy5tYXhXcml0ZUNvdW50ID8/IERFRkFVTFRfTUFYX1dSSVRFX0NPVU5UO1xuICBjb25zdCByZWFkVGV4dHM6IChudWxsIHwgc3RyaW5nKVtdID0gW107XG5cbiAgYXdhaXQgcGFyYW1zLndyaXRlVGV4dChwYXJhbXMuZXhwZWN0ZWRUZXh0KTtcbiAgbGV0IHdyaXRlQ291bnQgPSAxO1xuICBsZXQgYWdyZWVpbmdSZWFkQ291bnQgPSAwO1xuXG4gIHdoaWxlIChhZ3JlZWluZ1JlYWRDb3VudCA8IGNvbmZpcm1hdGlvblJlYWRDb3VudCkge1xuICAgIGF3YWl0IHBhcmFtcy5zbGVlcChpbnRlcnZhbEluTWlsbGlzZWNvbmRzKTtcbiAgICBjb25zdCB0ZXh0ID0gYXdhaXQgcGFyYW1zLnJlYWRUZXh0KCk7XG4gICAgcmVhZFRleHRzLnB1c2godGV4dCk7XG5cbiAgICBpZiAodGV4dCA9PT0gcGFyYW1zLmV4cGVjdGVkVGV4dCkge1xuICAgICAgYWdyZWVpbmdSZWFkQ291bnQrKztcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cblxuICAgIGlmICh0ZXh0ID09PSBudWxsIHx8IHdyaXRlQ291bnQgPj0gbWF4V3JpdGVDb3VudCkge1xuICAgICAgcmV0dXJuIHsgaXNIZWxkOiBmYWxzZSwgcmVhZFRleHRzLCB3cml0ZUNvdW50IH07XG4gICAgfVxuXG4gICAgYXdhaXQgcGFyYW1zLndyaXRlVGV4dChwYXJhbXMuZXhwZWN0ZWRUZXh0KTtcbiAgICB3cml0ZUNvdW50Kys7XG4gICAgYWdyZWVpbmdSZWFkQ291bnQgPSAwO1xuICB9XG5cbiAgcmV0dXJuIHsgaXNIZWxkOiB0cnVlLCByZWFkVGV4dHMsIHdyaXRlQ291bnQgfTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFrRkEsTUFBTSxrQ0FBa0M7QUFDeEMsTUFBTSxtQ0FBbUM7QUFDekMsTUFBTSwwQkFBMEI7QUFXaEMsZUFBc0IsY0FBYyxRQUEyRDtBQUM3RixRQUFNLHdCQUF3QixPQUFPLHlCQUF5QjtBQUM5RCxRQUFNLHlCQUF5QixPQUFPLDBCQUEwQjtBQUNoRSxRQUFNLGdCQUFnQixPQUFPLGlCQUFpQjtBQUM5QyxRQUFNLFlBQStCLENBQUM7QUFFdEMsUUFBTSxPQUFPLFVBQVUsT0FBTyxZQUFZO0FBQzFDLE1BQUksYUFBYTtBQUNqQixNQUFJLG9CQUFvQjtBQUV4QixTQUFPLG9CQUFvQix1QkFBdUI7QUFDaEQsVUFBTSxPQUFPLE1BQU0sc0JBQXNCO0FBQ3pDLFVBQU0sT0FBTyxNQUFNLE9BQU8sU0FBUztBQUNuQyxjQUFVLEtBQUssSUFBSTtBQUVuQixRQUFJLFNBQVMsT0FBTyxjQUFjO0FBQ2hDO0FBQ0E7QUFBQSxJQUNGO0FBRUEsUUFBSSxTQUFTLFFBQVEsY0FBYyxlQUFlO0FBQ2hELGFBQU8sRUFBRSxRQUFRLE9BQU8sV0FBVyxXQUFXO0FBQUEsSUFDaEQ7QUFFQSxVQUFNLE9BQU8sVUFBVSxPQUFPLFlBQVk7QUFDMUM7QUFDQSx3QkFBb0I7QUFBQSxFQUN0QjtBQUVBLFNBQU8sRUFBRSxRQUFRLE1BQU0sV0FBVyxXQUFXO0FBQy9DOyIsCiAgIm5hbWVzIjogW10KfQo=

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

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

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

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

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

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


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

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

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

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

package/dist/lib/esm/field-text-hold.mjs

@@ -0,0 +1,32 @@
+const DEFAULT_CONFIRMATION_READ_COUNT = 3;
+const DEFAULT_INTERVAL_IN_MILLISECONDS = 300;
+const DEFAULT_MAX_WRITE_COUNT = 4;
+async function holdFieldText(params) {
+  const confirmationReadCount = params.confirmationReadCount ?? DEFAULT_CONFIRMATION_READ_COUNT;
+  const intervalInMilliseconds = params.intervalInMilliseconds ?? DEFAULT_INTERVAL_IN_MILLISECONDS;
+  const maxWriteCount = params.maxWriteCount ?? DEFAULT_MAX_WRITE_COUNT;
+  const readTexts = [];
+  await params.writeText(params.expectedText);
+  let writeCount = 1;
+  let agreeingReadCount = 0;
+  while (agreeingReadCount < confirmationReadCount) {
+    await params.sleep(intervalInMilliseconds);
+    const text = await params.readText();
+    readTexts.push(text);
+    if (text === params.expectedText) {
+      agreeingReadCount++;
+      continue;
+    }
+    if (text === null || writeCount >= maxWriteCount) {
+      return { isHeld: false, readTexts, writeCount };
+    }
+    await params.writeText(params.expectedText);
+    writeCount++;
+    agreeingReadCount = 0;
+  }
+  return { isHeld: true, readTexts, writeCount };
+}
+export {
+  holdFieldText
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

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

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

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

package/dist/lib/esm/soft-keyboard.mjs

@@ -8,6 +8,8 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { runAdbText } from "./adb.mjs";
 import { captureDeviceScreenshot } from "./device-screenshot.mjs";
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { holdFieldText } from "./field-text-hold.mjs";
+import { log } from "./log.mjs";
 import {
   buildSoftKeyboardDiagnosticMessage,
   checkIsInputMethodShown,
@@ -23,13 +25,19 @@ const KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY
 async function raiseSoftKeyboard(params) {
   await lowerSoftKeyboardIfShown(params);
   const textToRestore = await emptyFieldForTouch(params);
+  let snapshot;
   try {
-    return await tapUntilKeyboardIsUp(params);
-  } finally {
+    snapshot = await tapUntilKeyboardIsUp(params);
+  } catch (error) {
     if (textToRestore !== null) {
-      await writeFieldText(params, textToRestore);
+      await holdFieldTextBestEffort(params, textToRestore);
     }
+    throw error;
   }
+  if (textToRestore !== null) {
+    await restoreFieldText(params, textToRestore);
+  }
+  return snapshot;
 }
 async function tapDevice(params) {
   await runAdbText({
@@ -74,6 +82,25 @@ async function emptyFieldForTouch(params) {
   await writeFieldText(params, "");
   return content.text;
 }
+async function holdFieldTextBestEffort(params, text) {
+  try {
+    await holdTextInField(params, text);
+  } catch {
+  }
+}
+async function holdTextInField(params, text) {
+  return await holdFieldText({
+    expectedText: text,
+    async readText() {
+      const content = await readFieldContent(params);
+      return content?.text ?? null;
+    },
+    sleep,
+    async writeText(value) {
+      await writeFieldText(params, value);
+    }
+  });
+}
 async function lowerSoftKeyboardIfShown(params) {
   let inputMethodState = await readInputMethodState(params);
   for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {
@@ -150,6 +177,20 @@ async function readSoftKeyboardViewport(params) {
     ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
   });
 }
+async function restoreFieldText(params, text) {
+  const result = await holdTextInField(params, text);
+  if (result.writeCount > 1) {
+    log(
+      `[soft-keyboard] The text written back into "${params.inputSelector}" was lost ${String(result.writeCount - 1)} time(s) and written again; reads: ${JSON.stringify(result.readTexts)}.`
+    );
+  }
+  if (!result.isHeld) {
+    throw new Error(
+      `raiseSoftKeyboard: the text written back into "${params.inputSelector}" after the touch did not stay there. Expected ${JSON.stringify(text)}; ${String(result.writeCount)} write(s), and the field read ${JSON.stringify(result.readTexts)}. A capture taken now would show the field without its text.
+device: ${await readInputMethodState(params)}`
+    );
+  }
+}
 async function tapUntilKeyboardIsUp(params) {
   const baselineSnapshot = await readSoftKeyboardViewport(params);
   let snapshot = baselineSnapshot;
@@ -194,4 +235,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 * The geometry that decides whether it worked is unit-tested in\n * `soft-keyboard-geometry`; everything here drives a real device, so the whole\n * module is integration-time code.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian on a real device) covered by integration tests, not unit tests. */\n\nimport {\n  mkdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type {\n  ElementRect,\n  SoftKeyboardTapPoint,\n  SoftKeyboardViewportSnapshot\n} from './soft-keyboard-geometry.mjs';\n\nimport { runAdbText } from './adb.mjs';\nimport { captureDeviceScreenshot } from './device-screenshot.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.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, or if it never lifted \u2014 the last after writing the device framebuffer\n *   and the device's own `input_method` state to the diagnostics directory.\n */\nexport async function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  await lowerSoftKeyboardIfShown(params);\n\n  const textToRestore = await emptyFieldForTouch(params);\n\n  try {\n    return await tapUntilKeyboardIsUp(params);\n  } finally {\n    // Restored even when the raise failed: a caller that is about to read its own diagnostic should not\n    // also have to discover that its query is gone.\n    if (textToRestore !== null) {\n      await writeFieldText(params, textToRestore);\n    }\n  }\n}\n\n/**\n * Touches the device at a point, the way a thumb would.\n *\n * @param params - The device and where to touch it.\n * @returns A {@link Promise} that resolves once the touch has been dispatched.\n */\nexport async function tapDevice(params: TapDeviceParams): Promise<void> {\n  await runAdbText({\n    commandArguments: ['shell', 'input', 'tap', String(params.point.xInPixels), String(params.point.yInPixels)],\n    deviceId: params.deviceId\n  });\n}\n\n/**\n * Writes the device framebuffer and reads the device's `input_method` state, then composes the failure.\n *\n * @param params - The device and the diagnostics directory.\n * @param baselineSnapshot - The geometry read before the first touch, which the verdict is measured against.\n * @param snapshot - The geometry read after the last touch.\n * @returns A {@link Promise} that resolves to the message to throw.\n */\nasync function buildFailureMessage(\n  params: RaiseSoftKeyboardParams,\n  baselineSnapshot: SoftKeyboardViewportSnapshot,\n  snapshot: SoftKeyboardViewportSnapshot\n): Promise<string> {\n  const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;\n  mkdirSync(diagnosticsDirectory, { recursive: true });\n\n  const screenshotPath = join(diagnosticsDirectory, 'keyboard-not-raised.png');\n  writeFileSync(screenshotPath, await captureDeviceScreenshot({ deviceId: params.deviceId }));\n\n  return buildSoftKeyboardDiagnosticMessage({\n    baselineSnapshot,\n    inputMethodState: await readInputMethodState(params),\n    screenshotPath,\n    snapshot\n  });\n}\n\n/**\n * Whether anything in the page matches the field's selector.\n *\n * @param params - The field to look for.\n * @returns A {@link Promise} that resolves to whether it matched.\n */\nasync function checkIsFieldPresent(params: RaiseSoftKeyboardParams): Promise<boolean> {\n  return await evalInObsidian({\n    callback({ inputSelector }): boolean {\n      return document.querySelector(inputSelector) !== null;\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Empties the field the touch is about to land on, and reports what to write back.\n *\n * @param params - The field to empty, and whether to empty it at all.\n * @returns A {@link Promise} that resolves to the text to restore, or `null` when nothing was emptied.\n * @throws Error if the field holds text that cannot be written back \u2014 a `contenteditable`, whose content\n *   belongs to an editor that owns its own DOM.\n */\nasync function emptyFieldForTouch(params: RaiseSoftKeyboardParams): Promise<null | string> {\n  if (params.shouldEmptyFieldForTouch === false) {\n    return null;\n  }\n\n  const content = await readFieldContent(params);\n\n  // Nothing matched. The geometry read does the reporting, with the message it always had.\n  if (!content || content.text === '') {\n    return null;\n  }\n\n  if (!content.canWrite) {\n    throw new Error(\n      `raiseSoftKeyboard: \"${params.inputSelector}\" holds text but is not an <input> or a <textarea>, so it `\n        + 'cannot be emptied for the touch and written back. The touch would land inside text and draw a '\n        + 'selection handle, which a device capture photographs. Empty the field yourself before calling, or '\n        + 'pass shouldEmptyFieldForTouch: false to touch it as it stands.'\n    );\n  }\n\n  await writeFieldText(params, '');\n\n  return content.text;\n}\n\n/**\n * Puts the keyboard down when the device reports one showing, so the baseline read next is one the touch\n * can lift the field from.\n *\n * **A keyboard is pressed at only once it has been reported showing TWICE, one retract animation apart.**\n * `KEYCODE_BACK` is retracted by the IME only while the IME is up; once it has gone, the key reaches the\n * app, and Obsidian closes the modal on screen \u2014 the one the caller is about to photograph. A keyboard\n * already on its way down (the modal that raised it has just closed, and the caller opened a fresh one\n * straight after) is still reported showing at the start of its retract, so pressing at the first read\n * raced it. It is watched for one retract animation first, and a keyboard that went down on its own is\n * left alone.\n *\n * **And a press that reached the app anyway is named as that.** The field is looked up before the press\n * and after it; one that matched before and not after was closed by the key, and saying so beats the\n * `nothing matches` that the raise would otherwise report a step later, about a selector that was right.\n *\n * @param params - The device to ask, and the field that must survive the press.\n * @returns A {@link Promise} that resolves once no keyboard is showing.\n * @throws Error if a keyboard is still showing after {@link KEYBOARD_RETRACT_ATTEMPT_COUNT} presses of\n *   `KEYCODE_BACK` \u2014 the raise that follows could prove nothing, and its own failure would blame a keyboard\n *   that never came when the truth is one that never left \u2014 or if a press closed the field's own UI.\n */\nasync function lowerSoftKeyboardIfShown(params: RaiseSoftKeyboardParams): Promise<void> {\n  let inputMethodState = await readInputMethodState(params);\n\n  for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    await sleep(KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS);\n    inputMethodState = await readInputMethodState(params);\n\n    if (!checkIsInputMethodShown(inputMethodState)) {\n      return;\n    }\n\n    const isFieldPresentBeforePress = await checkIsFieldPresent(params);\n    await runAdbText({\n      commandArguments: ['shell', 'input', 'keyevent', 'KEYCODE_BACK'],\n      deviceId: params.deviceId\n    });\n    await sleep(KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS);\n\n    if (isFieldPresentBeforePress && !await checkIsFieldPresent(params)) {\n      throw new Error(\n        'raiseSoftKeyboard: KEYCODE_BACK, pressed to put down a keyboard the device reported showing, reached the app instead and '\n          + `closed the UI holding \"${params.inputSelector}\" \u2014 it matched before the press and matches nothing after it. The `\n          + 'keyboard went down between the last read and the press. Let the previous keyboard settle before opening the UI '\n          + `to raise it on.\ndevice before the press: ${inputMethodState}`\n      );\n    }\n\n    inputMethodState = await readInputMethodState(params);\n  }\n\n  if (checkIsInputMethodShown(inputMethodState)) {\n    throw new Error(\n      `raiseSoftKeyboard: a keyboard was already up and did not go down after ${String(KEYBOARD_RETRACT_ATTEMPT_COUNT)} presses of `\n        + 'KEYCODE_BACK, so the lift that proves a raise could not be measured. The field would read as one that never '\n        + `moved under a keyboard that is plainly showing.\ndevice: ${inputMethodState}`\n    );\n  }\n}\n\n/**\n * Reads what the field holds, and whether it is one whose value can be written back.\n *\n * @param params - The field to read.\n * @returns A {@link Promise} that resolves to the content, or `null` when nothing matched the selector.\n */\nasync function readFieldContent(params: RaiseSoftKeyboardParams): Promise<FieldContent | null> {\n  return await evalInObsidian({\n    callback({ inputSelector }): FieldContent | null {\n      const element = document.querySelector(inputSelector);\n\n      if (!element) {\n        return null;\n      }\n\n      const canWrite = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;\n\n      return { canWrite, text: canWrite ? element.value : element.textContent };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Asks the device what its IME is doing \u2014 the only place that knows, since nothing in the page reports it.\n *\n * @param params - The device to ask.\n * @returns A {@link Promise} that resolves to the fields {@link parseInputMethodState} keeps.\n */\nasync function readInputMethodState(params: RaiseSoftKeyboardParams): Promise<string> {\n  const dumpsysOutput = await runAdbText({\n    commandArguments: ['shell', 'dumpsys', 'input_method'],\n    deviceId: params.deviceId\n  });\n\n  return parseInputMethodState(dumpsysOutput);\n}\n\n/**\n * Reads what the renderer knows about its own geometry.\n *\n * @param params - The field to measure and the vault to read it from.\n * @returns A {@link Promise} that resolves to the viewport and the field's rect, in CSS pixels.\n */\nasync function readSoftKeyboardViewport(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  return await evalInObsidian({\n    callback({ inputSelector }): SoftKeyboardViewportSnapshot {\n      const inputEl = document.querySelector(inputSelector);\n\n      // eslint-disable-next-line unicorn/consistent-function-scoping -- This closure is serialized and evaluated in the renderer, so a helper hoisted to module scope would not exist there.\n      function toRect(rect: DOMRect): ElementRect {\n        return {\n          height: rect.height,\n          left: rect.left,\n          top: rect.top,\n          width: rect.width\n        };\n      }\n\n      return {\n        devicePixelRatio: window.devicePixelRatio,\n        innerHeight: window.innerHeight,\n        inputRect: inputEl ? toRect(inputEl.getBoundingClientRect()) : null,\n        screenY: window.screenY\n      };\n    },\n    input: { inputSelector: params.inputSelector },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/**\n * Touches the field until the keyboard is up, and says so when it never came.\n *\n * The baseline is read here rather than by the caller, so it is read with the field in the state the\n * taps are dispatched against \u2014 see {@link raiseSoftKeyboard} for why the two have to match.\n *\n * @param params - The device, the field to touch, and how far it must lift.\n * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.\n * @throws Error if the field never matched, or if it never lifted.\n */\nasync function tapUntilKeyboardIsUp(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  const baselineSnapshot = await readSoftKeyboardViewport(params);\n  let snapshot = baselineSnapshot;\n\n  if (!snapshot.inputRect) {\n    throw new Error(`raiseSoftKeyboard: nothing matches \"${params.inputSelector}\", so there is no field to touch.`);\n  }\n\n  for (const point of resolveSoftKeyboardTapPoints({ snapshot })) {\n    if (checkIsUp(snapshot)) {\n      break;\n    }\n\n    await tapDevice({ deviceId: params.deviceId, point });\n    await sleep(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);\n    snapshot = await readSoftKeyboardViewport(params);\n  }\n\n  if (!checkIsUp(snapshot)) {\n    throw new Error(await buildFailureMessage(params, baselineSnapshot, snapshot));\n  }\n\n  return snapshot;\n\n  function checkIsUp(current: SoftKeyboardViewportSnapshot): boolean {\n    return checkIsSoftKeyboardUp({\n      baselineSnapshot,\n      ...(params.minimumKeyboardHeightInPixels !== undefined && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels }),\n      snapshot: current\n    });\n  }\n}\n\n/**\n * Writes a field's value and tells the page it changed.\n *\n * The `input` event is what a scripted write owes the page: without it a suggester keeps the rows it had\n * for the text that is no longer there. It bubbles, because that is how a framework listening on a\n * container hears it.\n *\n * @param params - The field to write.\n * @param text - What to write into it.\n * @returns A {@link Promise} that resolves once the write has been made.\n * @throws TypeError if the field is not one whose value can be written.\n */\nasync function writeFieldText(params: RaiseSoftKeyboardParams, text: string): Promise<void> {\n  await evalInObsidian({\n    callback({ inputSelector, text: value }): void {\n      const element = document.querySelector(inputSelector);\n\n      if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {\n        throw new TypeError(`raiseSoftKeyboard: \"${inputSelector}\" is not a field whose value can be written.`);\n      }\n\n      element.value = value;\n      element.dispatchEvent(new Event('input', { bubbles: true }));\n    },\n    input: { inputSelector: params.inputSelector, text },\n    ...(params.vaultPath !== undefined && { vaultPath: params.vaultPath })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# 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": []
}


package/package.json

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