obsidian-integration-testing 16.0.0 → 17.0.0

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

@@ -148,12 +148,25 @@ export declare const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
  * A bare "the keyboard did not come up" is unreadable — what the reader needs is what the page saw and what
  * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is
  * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of
- * its own, being the one reading that an already-up keyboard also produces.
+ * its own, saying what is left once an already-up keyboard has been ruled out.
  *
  * @param params - The evidence gathered before the first touch and after the last one.
  * @returns The message, ready to throw.
  */
 export declare function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string;
+/**
+ * Decides whether the device reports an IME showing, from `dumpsys input_method`.
+ *
+ * This is the DEVICE's answer, and it is the one `raiseSoftKeyboard` asks before it measures anything:
+ * nothing in the page reports the keyboard, and the geometric proof in {@link checkIsSoftKeyboardUp}
+ * cannot see a keyboard that was already up when its baseline was read. It is deliberately NOT the proof
+ * that a raise worked — a device reports `mInputShown=true` just as readily for an IME drawn over a field
+ * that never moved, which is exactly the unproved frame the geometric delta exists to refuse.
+ *
+ * @param inputMethodState - The fields {@link parseInputMethodState} returned.
+ * @returns Whether the device says an IME is showing.
+ */
+export declare function checkIsInputMethodShown(inputMethodState: string): boolean;
 /**
  * Decides whether the IME is up, from how far the field moved.
  *
@@ -167,7 +180,9 @@ export declare function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyb
  * that from a centred modal with no keyboard — both read as "clear of the bottom and not moving" — and of
  * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than
  * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard
- * down, which is what `raiseSoftKeyboard` does.
+ * down. `raiseSoftKeyboard` guarantees that itself: it asks the device ({@link checkIsInputMethodShown})
+ * and puts a showing keyboard down before it reads the baseline, so every call proves its own lift rather
+ * than taking the device's word for one.
  *
  * @param params - The geometry before and after the touch, and how far the field must have lifted.
  * @returns Whether the field lifted far enough to have made room for a keyboard.

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

@@ -42,30 +42,18 @@ var import_eval_in_obsidian = require("./eval-in-obsidian.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;
+const KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS = 900;
+const KEYBOARD_RETRACT_ATTEMPT_COUNT = 2;
+const KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS = KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS;
 async function raiseSoftKeyboard(params) {
-  const baselineSnapshot = await readSoftKeyboardViewport(params);
-  let snapshot = baselineSnapshot;
-  if (!snapshot.inputRect) {
-    throw new Error(`raiseSoftKeyboard: nothing matches "${params.inputSelector}", so there is no field to touch.`);
-  }
-  for (const point of (0, import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints)({ snapshot })) {
-    if (checkIsUp(snapshot)) {
-      break;
+  await lowerSoftKeyboardIfShown(params);
+  const textToRestore = await emptyFieldForTouch(params);
+  try {
+    return await tapUntilKeyboardIsUp(params);
+  } finally {
+    if (textToRestore !== null) {
+      await writeFieldText(params, textToRestore);
     }
-    await tapDevice({ deviceId: params.deviceId, point });
-    await (0, import_promises.setTimeout)(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);
-    snapshot = await readSoftKeyboardViewport(params);
-  }
-  if (!checkIsUp(snapshot)) {
-    throw new Error(await buildFailureMessage(params, baselineSnapshot, snapshot));
-  }
-  return snapshot;
-  function checkIsUp(current) {
-    return (0, import_soft_keyboard_geometry.checkIsSoftKeyboardUp)({
-      baselineSnapshot,
-      ...params.minimumKeyboardHeightInPixels !== void 0 && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels },
-      snapshot: current
-    });
   }
 }
 async function tapDevice(params) {
@@ -79,17 +67,91 @@ async function buildFailureMessage(params, baselineSnapshot, snapshot) {
   (0, import_node_fs.mkdirSync)(diagnosticsDirectory, { recursive: true });
   const screenshotPath = (0, import_node_path.join)(diagnosticsDirectory, "keyboard-not-raised.png");
   (0, import_node_fs.writeFileSync)(screenshotPath, await (0, import_device_screenshot.captureDeviceScreenshot)({ deviceId: params.deviceId }));
-  const dumpsysOutput = await (0, import_adb.runAdbText)({
-    commandArguments: ["shell", "dumpsys", "input_method"],
-    deviceId: params.deviceId
-  });
   return (0, import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage)({
     baselineSnapshot,
-    inputMethodState: (0, import_soft_keyboard_geometry.parseInputMethodState)(dumpsysOutput),
+    inputMethodState: await readInputMethodState(params),
     screenshotPath,
     snapshot
   });
 }
+async function checkIsFieldPresent(params) {
+  return await (0, import_eval_in_obsidian.evalInObsidian)({
+    callback({ inputSelector }) {
+      return document.querySelector(inputSelector) !== null;
+    },
+    input: { inputSelector: params.inputSelector },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
+async function emptyFieldForTouch(params) {
+  if (params.shouldEmptyFieldForTouch === false) {
+    return null;
+  }
+  const content = await readFieldContent(params);
+  if (!content || content.text === "") {
+    return null;
+  }
+  if (!content.canWrite) {
+    throw new Error(
+      `raiseSoftKeyboard: "${params.inputSelector}" holds text but is not an <input> or a <textarea>, so it cannot be emptied for the touch and written back. The touch would land inside text and draw a selection handle, which a device capture photographs. Empty the field yourself before calling, or pass shouldEmptyFieldForTouch: false to touch it as it stands.`
+    );
+  }
+  await writeFieldText(params, "");
+  return content.text;
+}
+async function lowerSoftKeyboardIfShown(params) {
+  let inputMethodState = await readInputMethodState(params);
+  for (let attempt = 0; attempt < KEYBOARD_RETRACT_ATTEMPT_COUNT; attempt++) {
+    if (!(0, import_soft_keyboard_geometry.checkIsInputMethodShown)(inputMethodState)) {
+      return;
+    }
+    await (0, import_promises.setTimeout)(KEYBOARD_SHOWN_CONFIRMATION_DELAY_IN_MILLISECONDS);
+    inputMethodState = await readInputMethodState(params);
+    if (!(0, import_soft_keyboard_geometry.checkIsInputMethodShown)(inputMethodState)) {
+      return;
+    }
+    const isFieldPresentBeforePress = await checkIsFieldPresent(params);
+    await (0, import_adb.runAdbText)({
+      commandArguments: ["shell", "input", "keyevent", "KEYCODE_BACK"],
+      deviceId: params.deviceId
+    });
+    await (0, import_promises.setTimeout)(KEYBOARD_RETRACT_DELAY_IN_MILLISECONDS);
+    if (isFieldPresentBeforePress && !await checkIsFieldPresent(params)) {
+      throw new Error(
+        `raiseSoftKeyboard: KEYCODE_BACK, pressed to put down a keyboard the device reported showing, reached the app instead and closed the UI holding "${params.inputSelector}" \u2014 it matched before the press and matches nothing after it. The keyboard went down between the last read and the press. Let the previous keyboard settle before opening the UI to raise it on.
+device before the press: ${inputMethodState}`
+      );
+    }
+    inputMethodState = await readInputMethodState(params);
+  }
+  if ((0, import_soft_keyboard_geometry.checkIsInputMethodShown)(inputMethodState)) {
+    throw new Error(
+      `raiseSoftKeyboard: a keyboard was already up and did not go down after ${String(KEYBOARD_RETRACT_ATTEMPT_COUNT)} presses of KEYCODE_BACK, so the lift that proves a raise could not be measured. The field would read as one that never moved under a keyboard that is plainly showing.
+device: ${inputMethodState}`
+    );
+  }
+}
+async function readFieldContent(params) {
+  return await (0, import_eval_in_obsidian.evalInObsidian)({
+    callback({ inputSelector }) {
+      const element = document.querySelector(inputSelector);
+      if (!element) {
+        return null;
+      }
+      const canWrite = element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;
+      return { canWrite, text: canWrite ? element.value : element.textContent };
+    },
+    input: { inputSelector: params.inputSelector },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
+async function readInputMethodState(params) {
+  const dumpsysOutput = await (0, import_adb.runAdbText)({
+    commandArguments: ["shell", "dumpsys", "input_method"],
+    deviceId: params.deviceId
+  });
+  return (0, import_soft_keyboard_geometry.parseInputMethodState)(dumpsysOutput);
+}
 async function readSoftKeyboardViewport(params) {
   return await (0, import_eval_in_obsidian.evalInObsidian)({
     callback({ inputSelector }) {
@@ -113,9 +175,49 @@ async function readSoftKeyboardViewport(params) {
     ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
   });
 }
+async function tapUntilKeyboardIsUp(params) {
+  const baselineSnapshot = await readSoftKeyboardViewport(params);
+  let snapshot = baselineSnapshot;
+  if (!snapshot.inputRect) {
+    throw new Error(`raiseSoftKeyboard: nothing matches "${params.inputSelector}", so there is no field to touch.`);
+  }
+  for (const point of (0, import_soft_keyboard_geometry.resolveSoftKeyboardTapPoints)({ snapshot })) {
+    if (checkIsUp(snapshot)) {
+      break;
+    }
+    await tapDevice({ deviceId: params.deviceId, point });
+    await (0, import_promises.setTimeout)(KEYBOARD_SETTLE_DELAY_IN_MILLISECONDS);
+    snapshot = await readSoftKeyboardViewport(params);
+  }
+  if (!checkIsUp(snapshot)) {
+    throw new Error(await buildFailureMessage(params, baselineSnapshot, snapshot));
+  }
+  return snapshot;
+  function checkIsUp(current) {
+    return (0, import_soft_keyboard_geometry.checkIsSoftKeyboardUp)({
+      baselineSnapshot,
+      ...params.minimumKeyboardHeightInPixels !== void 0 && { minimumKeyboardHeightInPixels: params.minimumKeyboardHeightInPixels },
+      snapshot: current
+    });
+  }
+}
+async function writeFieldText(params, text) {
+  await (0, import_eval_in_obsidian.evalInObsidian)({
+    callback({ inputSelector, text: value }) {
+      const element = document.querySelector(inputSelector);
+      if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLTextAreaElement)) {
+        throw new TypeError(`raiseSoftKeyboard: "${inputSelector}" is not a field whose value can be written.`);
+      }
+      element.value = value;
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+    },
+    input: { inputSelector: params.inputSelector, text },
+    ...params.vaultPath !== void 0 && { vaultPath: params.vaultPath }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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 * 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  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   * 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 * 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 * **Call it with the keyboard DOWN.** The first read is the baseline every later read is compared against,\n * so a keyboard that is already up leaves the field nothing to lift by and this throws. That is the\n * deliberate trade for working on a centred modal as well as a bottom-anchored one \u2014 see\n * {@link checkIsSoftKeyboardUp}.\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, the latter after writing the device\n *   framebuffer and the device's own `input_method` state to the diagnostics directory.\n */\nexport async function raiseSoftKeyboard(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 * 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  const dumpsysOutput = await runAdbText({\n    commandArguments: ['shell', 'dumpsys', 'input_method'],\n    deviceId: params.deviceId\n  });\n\n  return buildSoftKeyboardDiagnosticMessage({\n    baselineSnapshot,\n    inputMethodState: parseInputMethodState(dumpsysOutput),\n    screenshotPath,\n    snapshot\n  });\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/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,qBAGO;AACP,uBAAqB;AACrB,0BAAoB;AACpB,sBAAoC;AAQpC,iBAA2B;AAC3B,+BAAwC;AACxC,8BAA+B;AAC/B,oCAKO;AAuDP,MAAM,oCAAgC,uBAAK,oBAAAA,QAAQ,IAAI,GAAG,QAAQ,aAAa;AAK/E,MAAM,wCAAwC;AAkB9C,eAAsB,kBAAkB,QAAwE;AAC9G,QAAM,mBAAmB,MAAM,yBAAyB,MAAM;AAC9D,MAAI,WAAW;AAEf,MAAI,CAAC,SAAS,WAAW;AACvB,UAAM,IAAI,MAAM,uCAAuC,OAAO,aAAa,mCAAmC;AAAA,EAChH;AAEA,aAAW,aAAS,4DAA6B,EAAE,SAAS,CAAC,GAAG;AAC9D,QAAI,UAAU,QAAQ,GAAG;AACvB;AAAA,IACF;AAEA,UAAM,UAAU,EAAE,UAAU,OAAO,UAAU,MAAM,CAAC;AACpD,cAAM,gBAAAC,YAAM,qCAAqC;AACjD,eAAW,MAAM,yBAAyB,MAAM;AAAA,EAClD;AAEA,MAAI,CAAC,UAAU,QAAQ,GAAG;AACxB,UAAM,IAAI,MAAM,MAAM,oBAAoB,QAAQ,kBAAkB,QAAQ,CAAC;AAAA,EAC/E;AAEA,SAAO;AAEP,WAAS,UAAU,SAAgD;AACjE,eAAO,qDAAsB;AAAA,MAC3B;AAAA,MACA,GAAI,OAAO,kCAAkC,UAAa,EAAE,+BAA+B,OAAO,8BAA8B;AAAA,MAChI,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;AAQA,eAAsB,UAAU,QAAwC;AACtE,YAAM,uBAAW;AAAA,IACf,kBAAkB,CAAC,SAAS,SAAS,OAAO,OAAO,OAAO,MAAM,SAAS,GAAG,OAAO,OAAO,MAAM,SAAS,CAAC;AAAA,IAC1G,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;AAUA,eAAe,oBACb,QACA,kBACA,UACiB;AACjB,QAAM,uBAAuB,OAAO,wBAAwB;AAC5D,gCAAU,sBAAsB,EAAE,WAAW,KAAK,CAAC;AAEnD,QAAM,qBAAiB,uBAAK,sBAAsB,yBAAyB;AAC3E,oCAAc,gBAAgB,UAAM,kDAAwB,EAAE,UAAU,OAAO,SAAS,CAAC,CAAC;AAE1F,QAAM,gBAAgB,UAAM,uBAAW;AAAA,IACrC,kBAAkB,CAAC,SAAS,WAAW,cAAc;AAAA,IACrD,UAAU,OAAO;AAAA,EACnB,CAAC;AAED,aAAO,kEAAmC;AAAA,IACxC;AAAA,IACA,sBAAkB,qDAAsB,aAAa;AAAA,IACrD;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAQA,eAAe,yBAAyB,QAAwE;AAC9G,SAAO,UAAM,wCAAe;AAAA,IAC1B,SAAS,EAAE,cAAc,GAAiC;AACxD,YAAM,UAAU,SAAS,cAAc,aAAa;AAGpD,eAAS,OAAO,MAA4B;AAC1C,eAAO;AAAA,UACL,QAAQ,KAAK;AAAA,UACb,MAAM,KAAK;AAAA,UACX,KAAK,KAAK;AAAA,UACV,OAAO,KAAK;AAAA,QACd;AAAA,MACF;AAEA,aAAO;AAAA,QACL,kBAAkB,OAAO;AAAA,QACzB,aAAa,OAAO;AAAA,QACpB,WAAW,UAAU,OAAO,QAAQ,sBAAsB,CAAC,IAAI;AAAA,QAC/D,SAAS,OAAO;AAAA,MAClB;AAAA,IACF;AAAA,IACA,OAAO,EAAE,eAAe,OAAO,cAAc;AAAA,IAC7C,GAAI,OAAO,cAAc,UAAa,EAAE,WAAW,OAAO,UAAU;AAAA,EACtE,CAAC;AACH;",
  "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 * 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"]
}


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

@@ -22,6 +22,30 @@
  *    unrepresentable rather than merely corrected: the delta of the baseline
  *    against itself is zero, so the first iteration always taps.
  *
+ *    **A keyboard ALREADY up is put down first**, because a delta cannot see
+ *    one: the field has already lifted, so it reads as a field that never moved.
+ *    That was every frame after the first of a suite that takes several — the
+ *    keyboard left up by one frame, or brought back by Obsidian focusing the
+ *    next modal's field, made the next baseline already-lifted (measured
+ *    2026-09-20: frames 2-5 each failed `lift=0` beside `mInputShown=true`,
+ *    each framebuffer showing a correctly lifted field under a fully drawn
+ *    keyboard). The alternative was to accept `lift=0` whenever the device says
+ *    a keyboard is showing, and it was refused: that is a frame the helper did
+ *    not prove, which is the vacuous pass the delta was introduced to end,
+ *    re-opened by a different door. So the device is asked, a showing IME is
+ *    retracted with `KEYCODE_BACK`, and the lift is proved as before. It has to
+ *    happen HERE, not after the previous capture: lowering it there was tried,
+ *    and the IME came back on its own before the next baseline was read.
+ *
+ * 4. **That touch draws a selection handle when it lands inside TEXT**, and a
+ *    device capture photographs it. Chromium shows the insertion handle on a tap
+ *    into text and none on a tap into an EMPTY editable, and a value written by
+ *    script raises none at all — so the field is emptied for the touch and its
+ *    text written back afterwards. `obsidian-link-picker` shipped a teal handle
+ *    in a store listing image twice before anyone worked out where it came from,
+ *    and nothing in this module's own documentation of the touch hinted at it.
+ *    See `shouldEmptyFieldForTouch`.
+ *
  * 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.
@@ -52,6 +76,25 @@ export interface RaiseSoftKeyboardParams {
      * When omitted, `DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS` from `soft-keyboard-geometry` applies.
      */
     readonly minimumKeyboardHeightInPixels?: number;
+    /**
+     * Whether to empty the field before the touch, and write its text back afterwards.
+     *
+     * **On by default, because the touch that raises the keyboard also draws a selection handle when it
+     * lands inside TEXT.** Chromium shows the insertion handle on a tap into text and draws none on a tap
+     * into an EMPTY editable, and a device capture photographs it — which is how `obsidian-link-picker`
+     * shipped a teal handle in a store listing image twice before anyone understood where it came from. A
+     * value written by script raises no handle, so emptying the field, touching it, and writing the text
+     * back leaves the frame showing the same query with nothing hanging off it.
+     *
+     * Only an `<input>` or a `<textarea>` is emptied. A `contenteditable` holding text is REFUSED rather
+     * than written to: its content usually belongs to an editor that owns its own DOM, and blanking that
+     * by hand destroys it. Empty such a field yourself, or turn this off.
+     *
+     * Turning it off restores the pre-2026-09-23 behaviour exactly: the field is touched as it stands.
+     *
+     * @default true
+     */
+    readonly shouldEmptyFieldForTouch?: boolean;
     /**
      * The vault to read the geometry from. When omitted, the current test context's vault is used.
      */
@@ -76,15 +119,31 @@ export interface TapDeviceParams {
  * Call it inside `withSoftKeyboardEnabled` — the device setting alone does not raise the keyboard, and this
  * touch alone cannot while the setting suppresses it.
  *
- * **Call it with the keyboard DOWN.** The first read is the baseline every later read is compared against,
- * so a keyboard that is already up leaves the field nothing to lift by and this throws. That is the
- * deliberate trade for working on a centred modal as well as a bottom-anchored one — see
- * {@link checkIsSoftKeyboardUp}.
+ * **A keyboard that is already up is put DOWN first.** The first geometry read is the baseline every later
+ * read is compared against, so a keyboard already up would leave the field nothing to lift by and read as
+ * one that never came. The device is asked before anything else, and a showing IME is retracted with
+ * `KEYCODE_BACK` — asked FIRST because, with no IME showing, that key reaches the app and closes the very
+ * modal the frame is about to photograph. So the helper is safe to call once per frame of a multi-frame
+ * suite, and every call still proves its own lift. The other answer — accepting a zero lift whenever the
+ * device reports a keyboard — was refused, because it accepts a frame the helper did not prove.
+ *
+ * **The field is EMPTIED for the touch and written back afterwards**, because a touch that lands inside
+ * text draws Chromium's selection handle and the framebuffer photographs it — see
+ * {@link RaiseSoftKeyboardParams.shouldEmptyFieldForTouch}, which turns that off.
+ *
+ * **The geometry returned is read with the field still empty**, and the text is written back after it.
+ * That is the state the proven capture suites assert against, and it is deliberate rather than
+ * incidental: the baseline is read AFTER the field is emptied, so the lift is measured between two reads
+ * of the same field content. A field whose own text changes the layout around it — a suggester whose row
+ * count answers the query — moves when it is cleared, and a delta measured across that move is not a
+ * keyboard. Read the geometry again yourself if the restored text moves anything you are about to assert
+ * on.
  *
  * @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 the field never matched, or if it never lifted, the latter after writing the device
- *   framebuffer and the device's own `input_method` state to the diagnostics directory.
+ * @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.
  */
 export declare function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot>;
 /**