obsidian-integration-testing 17.2.0 → 17.3.0

package/dist/lib/cjs/pin-window-focus.cjs

@@ -0,0 +1,60 @@
+"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 pin_window_focus_exports = {};
+__export(pin_window_focus_exports, {
+  pinWindowFocus: () => pinWindowFocus
+});
+module.exports = __toCommonJS(pin_window_focus_exports);
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+async function pinWindowFocus(options) {
+  const { transport, vaultPath } = options ?? {};
+  const isPinned = await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    callback() {
+      if (document.body.hasClass("is-focused")) {
+        return false;
+      }
+      document.body.addClass("is-focused");
+      return true;
+    },
+    transport,
+    vaultPath
+  }));
+  return {
+    isPinned,
+    async restore() {
+      if (!isPinned) {
+        return;
+      }
+      await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+        callback() {
+          const { electronWindow } = globalThis;
+          document.body.toggleClass("is-focused", electronWindow?.isFocused() ?? document.hasFocus());
+        },
+        transport,
+        vaultPath
+      }));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pinWindowFocus
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/pin-window-focus.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Draws the Obsidian window as FOCUSED for the length of a capture, so a frame\n * does not depend on whether the operating system gave the window foreground\n * focus that run.\n *\n * Obsidian styles its window chrome from one class, `body.is-focused`, which it\n * keeps in step with the window itself: on desktop it runs\n * `body.toggleClass('is-focused', electronWindow.isFocused())` on every\n * `focuschange` (read from the 1.14.2 `app.js`). The title bar of an unfocused\n * window is darker, so a capture's bytes depended on something the harness does\n * not control. Measured in `obsidian-alias-quick-switcher` on 2026-09-25: five\n * back-to-back capture runs of an unchanged tree agreed byte for byte in runs\n * 2-5, and run 1 differed in EVERY desktop frame, in the title-bar band alone\n * (y 0-62, the full width, `rgb(29,29,29)` against `rgb(37,37,37)`). Windows'\n * focus-stealing prevention had refused the freshly launched window the\n * foreground, so the class was absent.\n *\n * **The class is pinned rather than the window focused.** Asking Electron for\n * `BrowserWindow.focus()` is a request the OS is free to refuse, which is the\n * same refusal that caused this; adding the class is deterministic and needs no\n * cooperation from anything. The frame then shows the focused chrome every run,\n * which is what the runs that got focus were already committing.\n *\n * **Restored afterwards, to what Obsidian itself would compute**, not to what it\n * was before: when focus arrives in the middle of a capture, Obsidian has\n * nothing left to toggle, so putting back a stale \"absent\" would leave a focused\n * window drawn unfocused. And only when this call added the class, so a window\n * that was focused all along is never touched.\n *\n * `captureObsidianScreenshot` calls this by default. It is exported for a\n * consumer capturing through a raw `connectToCdp` connection, the same reason\n * `hideCaret` and `hideVaultName` are.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian) covered by integration tests, not unit tests. */\n\nimport type { EvalInObsidianParams } from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\n\n/**\n * What {@link pinWindowFocus} returns: whether the class had to be added, and\n * how to undo that.\n */\nexport interface PinnedWindowFocus {\n  /**\n   * Whether the window was drawn unfocused, so the class was added. `false`\n   * means the window already carried it, and {@link restore} is then a no-op.\n   */\n  readonly isPinned: boolean;\n\n  /**\n   * Hands the class back to Obsidian: sets it to whether the window is\n   * focused now, exactly as Obsidian's own `focuschange` handler would.\n   *\n   * @returns A {@link Promise} that resolves once the class is restored.\n   */\n  restore: () => Promise<void>;\n}\n\n/**\n * Options for {@link pinWindowFocus}.\n */\nexport interface PinWindowFocusOptions {\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian window to pin. When omitted, the current test\n   * context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n// Kept local rather than declared globally, like every other holder of a\n// harness `window` property, so it never leaks into consumer types.\ninterface ElectronWindowHolder {\n  electronWindow?: FocusReportingWindow;\n}\n\ninterface FocusReportingWindow {\n  isFocused: () => boolean;\n}\n\n/**\n * Adds `is-focused` to the body when the window is drawn unfocused.\n *\n * @param options - Transport and vault overrides.\n * @returns A {@link Promise} that resolves to the {@link PinnedWindowFocus}.\n */\nexport async function pinWindowFocus(options?: PinWindowFocusOptions): Promise<PinnedWindowFocus> {\n  const { transport, vaultPath } = options ?? {};\n\n  const isPinned = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<Record<string, never>, boolean>>({\n    callback(): boolean {\n      if (document.body.hasClass('is-focused')) {\n        return false;\n      }\n\n      document.body.addClass('is-focused');\n      return true;\n    },\n    transport,\n    vaultPath\n  }));\n\n  return {\n    isPinned,\n    async restore(): Promise<void> {\n      if (!isPinned) {\n        return;\n      }\n\n      await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<Record<string, never>, void>>({\n        callback(): void {\n          // The same expression Obsidian's own handler evaluates: the Electron\n          // window's focus on desktop, the document's elsewhere.\n          // eslint-disable-next-line no-restricted-syntax -- Approved double cast: `electronWindow` is Obsidian's own Window property, kept local rather than declared globally.\n          const { electronWindow } = globalThis as unknown as ElectronWindowHolder;\n          document.body.toggleClass('is-focused', electronWindow?.isFocused() ?? document.hasFocus());\n        },\n        transport,\n        vaultPath\n      }));\n    }\n  };\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyCA,8BAA+B;AAC/B,2CAA4C;AAuD5C,eAAsB,eAAe,SAA6D;AAChG,QAAM,EAAE,WAAW,UAAU,IAAI,WAAW,CAAC;AAE7C,QAAM,WAAW,UAAM,4CAAe,kEAAkF;AAAA,IACtH,WAAoB;AAClB,UAAI,SAAS,KAAK,SAAS,YAAY,GAAG;AACxC,eAAO;AAAA,MACT;AAEA,eAAS,KAAK,SAAS,YAAY;AACnC,aAAO;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,SAAO;AAAA,IACL;AAAA,IACA,MAAM,UAAyB;AAC7B,UAAI,CAAC,UAAU;AACb;AAAA,MACF;AAEA,gBAAM,4CAAe,kEAA+E;AAAA,QAClG,WAAiB;AAIf,gBAAM,EAAE,eAAe,IAAI;AAC3B,mBAAS,KAAK,YAAY,cAAc,gBAAgB,UAAU,KAAK,SAAS,SAAS,CAAC;AAAA,QAC5F;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC,CAAC;AAAA,IACJ;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/cjs/pin-window-focus.d.cts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Draws the Obsidian window as FOCUSED for the length of a capture, so a frame
+ * does not depend on whether the operating system gave the window foreground
+ * focus that run.
+ *
+ * Obsidian styles its window chrome from one class, `body.is-focused`, which it
+ * keeps in step with the window itself: on desktop it runs
+ * `body.toggleClass('is-focused', electronWindow.isFocused())` on every
+ * `focuschange` (read from the 1.14.2 `app.js`). The title bar of an unfocused
+ * window is darker, so a capture's bytes depended on something the harness does
+ * not control. Measured in `obsidian-alias-quick-switcher` on 2026-09-25: five
+ * back-to-back capture runs of an unchanged tree agreed byte for byte in runs
+ * 2-5, and run 1 differed in EVERY desktop frame, in the title-bar band alone
+ * (y 0-62, the full width, `rgb(29,29,29)` against `rgb(37,37,37)`). Windows'
+ * focus-stealing prevention had refused the freshly launched window the
+ * foreground, so the class was absent.
+ *
+ * **The class is pinned rather than the window focused.** Asking Electron for
+ * `BrowserWindow.focus()` is a request the OS is free to refuse, which is the
+ * same refusal that caused this; adding the class is deterministic and needs no
+ * cooperation from anything. The frame then shows the focused chrome every run,
+ * which is what the runs that got focus were already committing.
+ *
+ * **Restored afterwards, to what Obsidian itself would compute**, not to what it
+ * was before: when focus arrives in the middle of a capture, Obsidian has
+ * nothing left to toggle, so putting back a stale "absent" would leave a focused
+ * window drawn unfocused. And only when this call added the class, so a window
+ * that was focused all along is never touched.
+ *
+ * `captureObsidianScreenshot` calls this by default. It is exported for a
+ * consumer capturing through a raw `connectToCdp` connection, the same reason
+ * `hideCaret` and `hideVaultName` are.
+ */
+import type { ObsidianTransport } from './transport.cjs';
+/**
+ * What {@link pinWindowFocus} returns: whether the class had to be added, and
+ * how to undo that.
+ */
+export interface PinnedWindowFocus {
+    /**
+     * Whether the window was drawn unfocused, so the class was added. `false`
+     * means the window already carried it, and {@link restore} is then a no-op.
+     */
+    readonly isPinned: boolean;
+    /**
+     * Hands the class back to Obsidian: sets it to whether the window is
+     * focused now, exactly as Obsidian's own `focuschange` handler would.
+     *
+     * @returns A {@link Promise} that resolves once the class is restored.
+     */
+    restore: () => Promise<void>;
+}
+/**
+ * Options for {@link pinWindowFocus}.
+ */
+export interface PinWindowFocusOptions {
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian window to pin. When omitted, the current test
+     * context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Adds `is-focused` to the body when the window is drawn unfocused.
+ *
+ * @param options - Transport and vault overrides.
+ * @returns A {@link Promise} that resolves to the {@link PinnedWindowFocus}.
+ */
+export declare function pinWindowFocus(options?: PinWindowFocusOptions): Promise<PinnedWindowFocus>;

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

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

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


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

@@ -186,7 +186,8 @@ 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
+ * @throws Error if the selector matches more than one element — the harness would empty one field while the
+ *   touch landed on another — if a keyboard already up would not go down, if the field never matched, if it holds text
  *   this cannot empty and put back, if it never lifted — after writing the device framebuffer and the
  *   device's own `input_method` state to the diagnostics directory — if the text written back would not
  *   stay in the field, or if the caret would not stay at offset 0. A write-back the IME undoes is written