obsidian-integration-testing 15.0.0 → 17.0.0

package/dist/lib/cjs/sharp-loader.d.cts

@@ -12,12 +12,31 @@
  */
 /**
  * A layer passed to `sharp`'s `composite`.
+ *
+ * The input is either bytes to draw — an SVG, a PNG — or a block `sharp` creates
+ * on the spot, which is how a flat fill is composited without building an image
+ * for it first.
  */
 export interface SharpCompositeLayer {
-    readonly input: Buffer;
+    readonly input: Buffer | SharpCreateInput;
     readonly left: number;
     readonly top: number;
 }
+/**
+ * A solid block of color, created by `sharp` rather than supplied as bytes.
+ */
+export interface SharpCreateInput {
+    readonly create: SharpCreateSpec;
+}
+/**
+ * The block `sharp` is asked to create: a rectangle of one flat color.
+ */
+export interface SharpCreateSpec {
+    readonly background: SharpRgbColor;
+    readonly channels: number;
+    readonly height: number;
+    readonly width: number;
+}
 /**
  * The `sharp` entry point the image helpers use.
  */
@@ -28,10 +47,12 @@ export type SharpFactory = (input: Uint8Array) => SharpInstance;
 export interface SharpInstance {
     blur: (this: void, sigma: number) => SharpInstance;
     composite: (this: void, layers: SharpCompositeLayer[]) => SharpInstance;
+    ensureAlpha: (this: void) => SharpInstance;
     metadata: (this: void) => Promise<SharpMetadata>;
     png: (this: void) => SharpInstance;
+    raw: (this: void) => SharpInstance;
     resize: (this: void, width: number, height: number, options?: SharpResizeOptions) => SharpInstance;
-    toBuffer: (this: void) => Promise<Buffer>;
+    toBuffer: SharpToBuffer;
     trim: (this: void, options: SharpTrimOptions) => SharpInstance;
 }
 /**
@@ -41,12 +62,56 @@ export interface SharpMetadata {
     readonly height?: number | undefined;
     readonly width?: number | undefined;
 }
+/**
+ * The geometry raw pixels have to be read with — without it they are a flat run of bytes.
+ */
+export interface SharpRawInfo {
+    readonly channels: number;
+    readonly height: number;
+    readonly width: number;
+}
+/**
+ * A frame's raw pixels and the geometry they have to be read with.
+ */
+export interface SharpRawResult {
+    readonly data: Uint8Array;
+    readonly info: SharpRawInfo;
+}
 /**
  * The subset of `sharp`'s resize options the image helpers set.
  */
 export interface SharpResizeOptions {
     readonly fit: 'cover' | 'fill';
 }
+/**
+ * Asks `toBuffer` for the pixels AND the geometry they are to be read with.
+ *
+ * Literal `true` rather than `boolean`, so the overload that returns
+ * {@link SharpRawResult} is only selected when the geometry is genuinely coming
+ * back — a `false` would resolve to bare bytes with the width silently missing.
+ */
+export interface SharpResolveWithObjectOptions {
+    readonly resolveWithObject: true;
+}
+/**
+ * A color as `sharp` names its channels.
+ */
+export interface SharpRgbColor {
+    readonly b: number;
+    readonly g: number;
+    readonly r: number;
+}
+/**
+ * `sharp`'s `toBuffer`, in the two shapes the image helpers call it in.
+ *
+ * Written as an overloaded call signature rather than a union return, because
+ * which one comes back is decided by the argument and a caller should not have
+ * to narrow a result it already knows the shape of.
+ */
+export interface SharpToBuffer {
+    (this: void): Promise<Buffer>;
+    (this: void, options: SharpResolveWithObjectOptions): Promise<SharpRawResult>;
+}
 /**
  * The subset of `sharp`'s trim options the image helpers set.
  */

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

@@ -20,6 +20,7 @@ var soft_keyboard_geometry_exports = {};
 __export(soft_keyboard_geometry_exports, {
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS: () => DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   buildSoftKeyboardDiagnosticMessage: () => buildSoftKeyboardDiagnosticMessage,
+  checkIsInputMethodShown: () => checkIsInputMethodShown,
   checkIsSoftKeyboardUp: () => checkIsSoftKeyboardUp,
   parseInputMethodState: () => parseInputMethodState,
   resolveSoftKeyboardTapPoints: () => resolveSoftKeyboardTapPoints
@@ -27,6 +28,7 @@ __export(soft_keyboard_geometry_exports, {
 module.exports = __toCommonJS(soft_keyboard_geometry_exports);
 const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
 const INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;
+const INPUT_SHOWN_REG_EXP = /(?:^|[\s|])mInputShown=true(?:$|[\s|])/;
 const CENTER_DIVISOR = 2;
 function buildSoftKeyboardDiagnosticMessage(params) {
   const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;
@@ -36,10 +38,13 @@ function buildSoftKeyboardDiagnosticMessage(params) {
     `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,
     `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,
     `device: ${params.inputMethodState || "(no input_method state reported)"}`,
-    ...lift === 0 ? ["The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts."] : []
+    ...lift === 0 ? [buildZeroLiftStatement(params.inputMethodState)] : []
   ];
   return lines.join("\n");
 }
+function checkIsInputMethodShown(inputMethodState) {
+  return INPUT_SHOWN_REG_EXP.test(inputMethodState);
+}
 function checkIsSoftKeyboardUp(params) {
   const baselineRect = params.baselineSnapshot.inputRect;
   const { inputRect } = params.snapshot;
@@ -65,6 +70,10 @@ function resolveSoftKeyboardTapPoints(params) {
     { xInPixels, yInPixels: centerYInPixels }
   ];
 }
+function buildZeroLiftStatement(inputMethodState) {
+  const cause = checkIsInputMethodShown(inputMethodState) ? "The device says a keyboard is showing now, so the touch raised one and it did not lift this field." : "The device says no keyboard is showing, so the touch raised none.";
+  return `The field did not move at all. No keyboard was up when the baseline was read \u2014 raiseSoftKeyboard puts down one the device reports showing before it measures \u2014 so this is not a keyboard left up by an earlier call. ${cause}`;
+}
 function formatMeasurement(value) {
   return value === null ? "(no input)" : String(value);
 }
@@ -72,8 +81,9 @@ function formatMeasurement(value) {
 0 && (module.exports = {
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   buildSoftKeyboardDiagnosticMessage,
+  checkIsInputMethodShown,
   checkIsSoftKeyboardUp,
   parseInputMethodState,
   resolveSoftKeyboardTapPoints
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, being the one reading that an already-up keyboard also produces.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`,\n    ...(lift === 0 ? ['The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts.'] : [])\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down, which is what `raiseSoftKeyboard` does.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  return topOffsetInPixels === 0\n    ? [{ xInPixels, yInPixels: centerYInPixels }]\n    : [\n      { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n      { xInPixels, yInPixels: centerYInPixels }\n    ];\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,IACxE,GAAI,SAAS,IAAI,CAAC,uLAAkL,IAAI,CAAC;AAAA,EAC3M;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,SAAO,sBAAsB,IACzB,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC,IAC1C;AAAA,IACA,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACJ;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * The flag `dumpsys input_method` sets while an IME is showing, as a whole token \u2014 so neither a value that\n * merely starts with `true` nor a longer field name ending in `mInputShown` can match.\n */\nconst INPUT_SHOWN_REG_EXP = /(?:^|[\\s|])mInputShown=true(?:$|[\\s|])/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, saying what is left once an already-up keyboard has been ruled out.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`,\n    ...(lift === 0 ? [buildZeroLiftStatement(params.inputMethodState)] : [])\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the device reports an IME showing, from `dumpsys input_method`.\n *\n * This is the DEVICE's answer, and it is the one `raiseSoftKeyboard` asks before it measures anything:\n * nothing in the page reports the keyboard, and the geometric proof in {@link checkIsSoftKeyboardUp}\n * cannot see a keyboard that was already up when its baseline was read. It is deliberately NOT the proof\n * that a raise worked \u2014 a device reports `mInputShown=true` just as readily for an IME drawn over a field\n * that never moved, which is exactly the unproved frame the geometric delta exists to refuse.\n *\n * @param inputMethodState - The fields {@link parseInputMethodState} returned.\n * @returns Whether the device says an IME is showing.\n */\nexport function checkIsInputMethodShown(inputMethodState: string): boolean {\n  return INPUT_SHOWN_REG_EXP.test(inputMethodState);\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down. `raiseSoftKeyboard` guarantees that itself: it asks the device ({@link checkIsInputMethodShown})\n * and puts a showing keyboard down before it reads the baseline, so every call proves its own lift rather\n * than taking the device's word for one.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  return topOffsetInPixels === 0\n    ? [{ xInPixels, yInPixels: centerYInPixels }]\n    : [\n      { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n      { xInPixels, yInPixels: centerYInPixels }\n    ];\n}\n\n/**\n * Says what a lift of zero means, now that `raiseSoftKeyboard` puts down any keyboard already showing\n * before it reads its baseline.\n *\n * It used to be a hint \u2014 \"if the device says the keyboard is showing, it was already up\" \u2014 printed under an\n * error whose own device line often said exactly that. The helper has since taken that cause away, so the\n * sentence states what is left rather than guessing at what might be.\n *\n * @param inputMethodState - The fields {@link parseInputMethodState} returned after the last touch.\n * @returns The statement.\n */\nfunction buildZeroLiftStatement(inputMethodState: string): string {\n  const cause = checkIsInputMethodShown(inputMethodState)\n    ? 'The device says a keyboard is showing now, so the touch raised one and it did not lift this field.'\n    : 'The device says no keyboard is showing, so the touch raised none.';\n\n  return 'The field did not move at all. No keyboard was up when the baseline was read \u2014 raiseSoftKeyboard puts down '\n    + `one the device reports showing before it measures \u2014 so this is not a keyboard left up by an earlier call. ${cause}`;\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAMnC,MAAM,sBAAsB;AAK5B,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,IACxE,GAAI,SAAS,IAAI,CAAC,uBAAuB,OAAO,gBAAgB,CAAC,IAAI,CAAC;AAAA,EACxE;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAcO,SAAS,wBAAwB,kBAAmC;AACzE,SAAO,oBAAoB,KAAK,gBAAgB;AAClD;AAsBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,SAAO,sBAAsB,IACzB,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC,IAC1C;AAAA,IACA,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACJ;AAaA,SAAS,uBAAuB,kBAAkC;AAChE,QAAM,QAAQ,wBAAwB,gBAAgB,IAClD,uGACA;AAEJ,SAAO,kOAC0G,KAAK;AACxH;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}


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"]
}
