obsidian-integration-testing 12.2.0 → 12.3.0

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

@@ -29,21 +29,27 @@ const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
 const INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;
 const CENTER_DIVISOR = 2;
 function buildSoftKeyboardDiagnosticMessage(params) {
-  const { inputRect } = params.snapshot;
-  const inputBottom = inputRect ? inputRect.top + inputRect.height : null;
-  return [
+  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;
+  const currentTop = params.snapshot.inputRect?.top ?? null;
+  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;
+  const lines = [
     `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,
-    `page: innerHeight=${String(params.snapshot.innerHeight)} inputBottom=${inputBottom === null ? "(no input)" : String(inputBottom)}`,
+    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,
     `device: ${params.inputMethodState || "(no input_method state reported)"}`
-  ].join("\n");
+  ];
+  if (lift === 0) {
+    lines.push("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.");
+  }
+  return lines.join("\n");
 }
 function checkIsSoftKeyboardUp(params) {
+  const baselineRect = params.baselineSnapshot.inputRect;
   const { inputRect } = params.snapshot;
-  if (!inputRect) {
+  if (!baselineRect || !inputRect) {
     return false;
   }
   const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;
-  return params.snapshot.innerHeight - (inputRect.top + inputRect.height) > minimumKeyboardHeightInPixels;
+  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;
 }
 function parseInputMethodState(dumpsysOutput) {
   return dumpsysOutput.split("\n").filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line)).map((line) => line.trim()).join(" | ");
@@ -64,6 +70,9 @@ function resolveSoftKeyboardTapPoints(params) {
     { xInPixels, yInPixels: centerYInPixels }
   ];
 }
+function formatMeasurement(value) {
+  return value === null ? "(no input)" : String(value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
@@ -72,4 +81,4 @@ function resolveSoftKeyboardTapPoints(params) {
   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 * the field's own offset from the bottom, which is why the detection here is\n * geometric rather than an API call. Two runs failed on that before a framebuffer\n * dump said so, which is also why the diagnostic below exists.\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 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 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.\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.\n *\n * @param params - The evidence gathered after the last touch.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const { inputRect } = params.snapshot;\n  const inputBottom = inputRect ? inputRect.top + inputRect.height : null;\n\n  return [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} inputBottom=${inputBottom === null ? '(no input)' : String(inputBottom)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`\n  ].join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from the page's own geometry.\n *\n * @param params - The geometry to judge, and how far the field must have lifted.\n * @returns Whether the field has stopped short of the bottom to make room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const { inputRect } = params.snapshot;\n  if (!inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return params.snapshot.innerHeight - (inputRect.top + inputRect.height) > 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  if (topOffsetInPixels === 0) {\n    return [{ xInPixels, yInPixels: centerYInPixels }];\n  }\n\n  return [\n    { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n    { xInPixels, yInPixels: centerYInPixels }\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyIO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAWhB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,QAAM,cAAc,YAAY,UAAU,MAAM,UAAU,SAAS;AAEnE,SAAO;AAAA,IACL,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,gBAAgB,gBAAgB,OAAO,eAAe,OAAO,WAAW,CAAC;AAAA,IACjI,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,EAC1E,EAAE,KAAK,IAAI;AACb;AAQO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,OAAO,SAAS,eAAe,UAAU,MAAM,UAAU,UAAU;AAC5E;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,MAAI,sBAAsB,GAAG;AAC3B,WAAO,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACF;",
  "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 * 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  ];\n\n  if (lift === 0) {\n    lines.push('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  if (topOffsetInPixels === 0) {\n    return [{ xInPixels, yInPixels: centerYInPixels }];\n  }\n\n  return [\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,EAC1E;AAEA,MAAI,SAAS,GAAG;AACd,UAAM,KAAK,uLAAkL;AAAA,EAC/L;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,MAAI,sBAAsB,GAAG;AAC3B,WAAO,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC;AAAA,EACnD;AAEA,SAAO;AAAA,IACL,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACF;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}


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

@@ -8,9 +8,21 @@
  * and the modal container all stay at their full height with the keyboard shown
  * and `dumpsys input_method` reporting `mInputShown=true` — Obsidian Mobile keeps
  * a full-screen container and lifts its contents inside it. The only signal is
- * the field's own offset from the bottom, which is why the detection here is
- * geometric rather than an API call. Two runs failed on that before a framebuffer
- * dump said so, which is also why the diagnostic below exists.
+ * that the field *moves*, which is why the detection here is geometric rather
+ * than an API call. Two runs failed on that before a framebuffer dump said so,
+ * which is also why the diagnostic below exists.
+ *
+ * **The signal is a DELTA against a baseline read before the touch, not the
+ * field's absolute offset from the bottom.** The absolute offset was the original
+ * test and it is right only for a **bottom-anchored** field — a suggester, a
+ * command palette — where "clear of the bottom" and "lifted" are the same
+ * sentence. For a **centred modal** the condition is already true with no
+ * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned
+ * success having dispatched no touch (measured 2026-09-12 against a centred
+ * prompt modal: the field's `top` read `352.4453125` before and after real taps
+ * and the check said the keyboard was up both times). A delta is the same public
+ * API for both shapes, and it costs a field that cannot move its verdict — see
+ * {@link checkIsSoftKeyboardUp} for the one case that trades away.
  *
  * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.
  */
@@ -18,6 +30,10 @@
  * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.
  */
 export interface BuildSoftKeyboardDiagnosticMessageParams {
+    /**
+     * The geometry read before the first touch, which is what the verdict is measured against.
+     */
+    readonly baselineSnapshot: SoftKeyboardViewportSnapshot;
     /**
      * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.
      */
@@ -35,6 +51,13 @@ export interface BuildSoftKeyboardDiagnosticMessageParams {
  * Parameters for {@link checkIsSoftKeyboardUp}.
  */
 export interface CheckIsSoftKeyboardUpParams {
+    /**
+     * The geometry read **before** the first touch, with the keyboard still down.
+     *
+     * Required, and deliberately not optional: an absent baseline could only mean falling back to the
+     * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.
+     */
+    readonly baselineSnapshot: SoftKeyboardViewportSnapshot;
     /**
      * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.
      *
@@ -42,7 +65,7 @@ export interface CheckIsSoftKeyboardUpParams {
      */
     readonly minimumKeyboardHeightInPixels?: number;
     /**
-     * The geometry to judge.
+     * The geometry to judge, read after the touch.
      */
     readonly snapshot: SoftKeyboardViewportSnapshot;
 }
@@ -123,17 +146,31 @@ export declare const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
  * Builds the message a failed raise reports.
  *
  * 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 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.
  *
- * @param params - The evidence gathered after the last touch.
+ * @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 IME is up, from the page's own geometry.
+ * Decides whether the IME is up, from how far the field moved.
+ *
+ * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least
+ * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,
+ * so a field that has not moved has had no keyboard arrive under it — whether it is a bottom-anchored
+ * suggester or a centred modal.
+ *
+ * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was
+ * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates
+ * 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.
  *
- * @param params - The geometry to judge, and how far the field must have lifted.
- * @returns Whether the field has stopped short of the bottom to make room for a keyboard.
+ * @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.
  */
 export declare function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean;
 /**

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

@@ -43,7 +43,8 @@ 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;
 async function raiseSoftKeyboard(params) {
-  let snapshot = await readSoftKeyboardViewport(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.`);
   }
@@ -56,11 +57,12 @@ async function raiseSoftKeyboard(params) {
     snapshot = await readSoftKeyboardViewport(params);
   }
   if (!checkIsUp(snapshot)) {
-    throw new Error(await buildFailureMessage(params, 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
     });
@@ -72,7 +74,7 @@ async function tapDevice(params) {
     deviceId: params.deviceId
   });
 }
-async function buildFailureMessage(params, snapshot) {
+async function buildFailureMessage(params, baselineSnapshot, snapshot) {
   const diagnosticsDirectory = params.diagnosticsDirectory ?? DEFAULT_DIAGNOSTICS_DIRECTORY;
   (0, import_node_fs.mkdirSync)(diagnosticsDirectory, { recursive: true });
   const screenshotPath = (0, import_node_path.join)(diagnosticsDirectory, "keyboard-not-raised.png");
@@ -82,6 +84,7 @@ async function buildFailureMessage(params, snapshot) {
     deviceId: params.deviceId
   });
   return (0, import_soft_keyboard_geometry.buildSoftKeyboardDiagnosticMessage)({
+    baselineSnapshot,
     inputMethodState: (0, import_soft_keyboard_geometry.parseInputMethodState)(dumpsysOutput),
     screenshotPath,
     snapshot
@@ -115,4 +118,4 @@ async function readSoftKeyboardViewport(params) {
   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 * 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 gitignored across the fleet, 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 * @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 keyboard never came up, after writing the device framebuffer and the device's own\n *   `input_method` state to the diagnostics directory.\n */\nexport async function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot> {\n  let snapshot = await readSoftKeyboardViewport(params);\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, snapshot));\n  }\n\n  return snapshot;\n\n  function checkIsUp(current: SoftKeyboardViewportSnapshot): boolean {\n    return checkIsSoftKeyboardUp({\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 snapshot - The geometry read after the last touch.\n * @returns A {@link Promise} that resolves to the message to throw.\n */\nasync function buildFailureMessage(params: RaiseSoftKeyboardParams, snapshot: SoftKeyboardViewportSnapshot): 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    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;AAsBA,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;AAa9C,eAAsB,kBAAkB,QAAwE;AAC9G,MAAI,WAAW,MAAM,yBAAyB,MAAM;AAEpD,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,QAAQ,CAAC;AAAA,EAC7D;AAEA,SAAO;AAEP,WAAS,UAAU,SAAgD;AACjE,eAAO,qDAAsB;AAAA,MAC3B,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;AASA,eAAe,oBAAoB,QAAiC,UAAyD;AAC3H,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,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 * 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"]
}


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

@@ -13,6 +13,15 @@
  *    real touch, and a run with the setting flipped and no touch comes back with
  *    exactly the empty band it had before. `adb shell input tap` is that gesture.
  *
+ * 3. The proof that it arrived is that the field **moved**, measured against a
+ *    baseline read here before the first touch. An absolute offset from the
+ *    viewport bottom is the same test only for a bottom-anchored field; for a
+ *    centred modal it is already true with no keyboard, which used to break the
+ *    loop below before it had dispatched a single touch and return success
+ *    having done nothing. Reading the baseline first also makes that shape
+ *    unrepresentable rather than merely corrected: the delta of the baseline
+ *    against itself is zero, so the first iteration always taps.
+ *
  * The geometry that decides whether it worked is unit-tested in
  * `soft-keyboard-geometry`; everything here drives a real device, so the whole
  * module is integration-time code.
@@ -67,10 +76,15 @@ export interface TapDeviceParams {
  * Call it inside `withSoftKeyboardEnabled` — the device setting alone does not raise the keyboard, and this
  * touch alone cannot while the setting suppresses it.
  *
+ * **Call it with the keyboard DOWN.** The first read is the baseline every later read is compared against,
+ * so a keyboard that is already up leaves the field nothing to lift by and this throws. That is the
+ * deliberate trade for working on a centred modal as well as a bottom-anchored one — see
+ * {@link checkIsSoftKeyboardUp}.
+ *
  * @param params - The device, the field to touch, and how far it must lift.
  * @returns A {@link Promise} that resolves to the geometry read once the keyboard is up.
- * @throws Error if the keyboard never came up, after writing the device framebuffer and the device's own
- *   `input_method` state to the diagnostics directory.
+ * @throws Error if the field never matched, or if it never lifted, the latter after writing the device
+ *   framebuffer and the device's own `input_method` state to the diagnostics directory.
  */
 export declare function raiseSoftKeyboard(params: RaiseSoftKeyboardParams): Promise<SoftKeyboardViewportSnapshot>;
 /**