obsidian-integration-testing 12.1.2 → 12.3.0

package/dist/lib/cjs/setup-lock.cjs

@@ -28,7 +28,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var setup_lock_exports = {};
 __export(setup_lock_exports, {
-  acquireSetupLock: () => acquireSetupLock
+  ANDROID_SETUP_LOCK_SCOPE: () => ANDROID_SETUP_LOCK_SCOPE,
+  acquireSetupLock: () => acquireSetupLock,
+  checkIsSetupLockHeld: () => checkIsSetupLockHeld,
+  tryAcquireSetupLock: () => tryAcquireSetupLock
 });
 module.exports = __toCommonJS(setup_lock_exports);
 var import_node_fs = require("node:fs");
@@ -37,6 +40,7 @@ var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
 var import_error_to_string = require("./error-to-string.cjs");
 var import_log = require("./log.cjs");
+const ANDROID_SETUP_LOCK_SCOPE = "android";
 const LOCK_DIR_NAME = "obsidian-integration-testing";
 const LOCK_FILE_SUFFIX = ".setup.lock";
 const POLL_INTERVAL_IN_MILLISECONDS = 500;
@@ -75,9 +79,8 @@ async function acquireSetupLock(params) {
       });
     }
     const info = readLockFileInfo(lockFilePath);
-    if (info && checkIsLockStale(info)) {
-      (0, import_log.log)(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);
-      (0, import_node_fs.rmSync)(lockFilePath, { force: true });
+    if (info && checkIsLockStale(info, HEARTBEAT_STALE_IN_MILLISECONDS)) {
+      stealStaleLock({ info, label, lockFilePath, scope });
       if (Date.now() >= deadlineInMilliseconds) {
         throw createTimeoutError({
           info,
@@ -109,10 +112,48 @@ async function acquireSetupLock(params) {
     await delay(POLL_INTERVAL_IN_MILLISECONDS);
   }
 }
-function checkIsLockStale(info) {
+function checkIsSetupLockHeld(scope) {
+  let text;
+  try {
+    text = (0, import_node_fs.readFileSync)(getLockFilePath(scope), "utf-8");
+  } catch (error) {
+    return getErrorCode(error) !== "ENOENT";
+  }
+  let info;
+  try {
+    info = JSON.parse(text);
+  } catch {
+    return true;
+  }
+  return !checkIsLockStale(info, HEARTBEAT_STALE_IN_MILLISECONDS);
+}
+function tryAcquireSetupLock(params) {
+  const { label, scope } = params;
+  const lockFilePath = getLockFilePath(scope);
+  (0, import_node_fs.mkdirSync)(getLockDirectory(), { recursive: true });
+  let ownInfo = tryCreateLockFile(lockFilePath, label);
+  if (!ownInfo) {
+    const info = readLockFileInfo(lockFilePath);
+    if (!info || !checkIsLockStale(info, params.staleAfterSilenceInMilliseconds ?? HEARTBEAT_STALE_IN_MILLISECONDS)) {
+      return void 0;
+    }
+    stealStaleLock({ info, label, lockFilePath, scope });
+    ownInfo = tryCreateLockFile(lockFilePath, label);
+    if (!ownInfo) {
+      return void 0;
+    }
+  }
+  return createLockHandle({
+    label,
+    lockFilePath,
+    ownInfo,
+    scope
+  });
+}
+function checkIsLockStale(info, heartbeatStaleInMilliseconds) {
   const silentForInMilliseconds = Date.now() - getLastSeenAtInMilliseconds(info);
   if (info.hostname === (0, import_node_os.hostname)()) {
-    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > HEARTBEAT_STALE_IN_MILLISECONDS;
+    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > heartbeatStaleInMilliseconds;
   }
   return silentForInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;
 }
@@ -245,6 +286,10 @@ function readLockFileInfo(lockFilePath) {
     return null;
   }
 }
+function stealStaleLock(params) {
+  (0, import_log.log)(`[integration-setup:${params.label}] Stealing stale '${params.scope}' setup lock from ${describeInfo(params.info)}.`);
+  (0, import_node_fs.rmSync)(params.lockFilePath, { force: true });
+}
 function tryCreateLockFile(lockFilePath, label) {
   const nowInMilliseconds = Date.now();
   const info = {
@@ -266,6 +311,9 @@ function tryCreateLockFile(lockFilePath, label) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  acquireSetupLock
+  ANDROID_SETUP_LOCK_SCOPE,
+  acquireSetupLock,
+  checkIsSetupLockHeld,
+  tryAcquireSetupLock
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/setup-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Cross-process advisory lock that serializes whole integration-test runs.\n *\n * Two test runs that drive the same shared resources corrupt each other: on\n * desktop they share the single local Obsidian instance, its `obsidian.json`\n * registry, and the CDP port; on Android they share the emulator and the Appium\n * server. One run's setup/teardown kills or reconfigures the instance the other\n * run is mid-eval on (observed as `ECONNREFUSED` or \"vault not open\"), so both\n * runs fail.\n *\n * This lock makes the second run **wait** for the first to finish instead of\n * running concurrently. It is held for the entire run: acquired at the start of\n * the core setup and released by the core teardown (and by the process cleanup\n * handlers). The lock is a sentinel file in a shared temp directory, and its\n * holder keeps a **heartbeat** timestamp inside it fresh for as long as it holds\n * the lock \u2014 so a run that crashed without releasing stops beating and the next\n * run detects the lock as stale and steals it.\n *\n * The heartbeat, not the holder's PID, is what proves a holder is still there: a\n * PID probe only answers \"does *a* process with this PID exist\", which a\n * recycled PID satisfies long after the real holder died \u2014 leaving every later\n * run to block for the full acquisition timeout.\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  hostname,\n  tmpdir\n} from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { errorToString } from './error-to-string.cjs';\nimport { log } from './log.cjs';\n\nconst LOCK_DIR_NAME = 'obsidian-integration-testing';\nconst LOCK_FILE_SUFFIX = '.setup.lock';\nconst POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst SECONDS_PER_MINUTE = 60;\nconst HEARTBEAT_INTERVAL_IN_SECONDS = 5;\nconst HEARTBEAT_INTERVAL_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;\n// Generous on purpose: a dead holder is normally caught instantly by the PID\n// Probe, so this threshold only has to cover the recycled-PID case. Two minutes\n// Keeps a holder that blocks its event loop during heavy synchronous work (a\n// Large vault sync, an installer unpack) from being robbed while it is alive.\nconst MISSED_HEARTBEATS_BEFORE_STALE = 24;\nconst HEARTBEAT_STALE_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_MILLISECONDS * MISSED_HEARTBEATS_BEFORE_STALE;\nconst WAIT_LOG_INTERVAL_IN_SECONDS = 30;\nconst WAIT_LOG_INTERVAL_IN_MILLISECONDS = WAIT_LOG_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;\nconst STALE_LOCK_AGE_IN_MINUTES = 30;\nconst DEFAULT_TIMEOUT_IN_MINUTES = 60;\nconst STALE_LOCK_AGE_IN_MILLISECONDS = STALE_LOCK_AGE_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Parameters for {@link acquireSetupLock}.\n */\nexport interface AcquireSetupLockParams {\n  /**\n  Short transport label for log messages (e.g. `\"obsidian-cli\"`).\n   */\n  readonly label: string;\n\n  /**\n   * Logical scope the lock serializes within. Runs that share resources must\n   * use the same scope (e.g. `\"desktop\"` for the CLI/CDP transports, `\"android\"`\n   * for the Appium transport).\n   */\n  readonly scope: string;\n\n  /**\n   * Maximum time to wait for a competing run to release the lock before giving\n   * up and throwing.\n   *\n   * @default 1 hour\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n}\n\n/**\n * A held setup lock. Release it once the run's teardown is complete.\n */\nexport interface SetupLock {\n  /**\n  Releases the lock. Safe to call more than once.\n   */\n  release(): void;\n}\n\n/**\n * Parameters for {@link createLockHandle}.\n */\ninterface CreateLockHandleParams {\n  /**\n  The transport label of this run.\n   */\n  readonly label: string;\n\n  /**\n  The path to the lock file this run just created.\n   */\n  readonly lockFilePath: string;\n\n  /**\n  The lock info this run wrote when it acquired the lock.\n   */\n  readonly ownInfo: LockFileInfo;\n\n  /**\n  The lock scope, for log messages.\n   */\n  readonly scope: string;\n}\n\n/**\n * Parameters for {@link createTimeoutError}.\n */\ninterface CreateTimeoutErrorParams {\n  /**\n  The current holder's lock info, or `null` if it could not be read.\n   */\n  readonly info: LockFileInfo | null;\n\n  /**\n  The lock scope.\n   */\n  readonly scope: string;\n\n  /**\n  The timeout that elapsed.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link formatWaitMessage}.\n */\ninterface FormatWaitMessageParams {\n  /**\n  The current holder's lock info, or `null` if it could not be read.\n   */\n  readonly info: LockFileInfo | null;\n\n  /**\n  The transport label of the waiting run.\n   */\n  readonly label: string;\n\n  /**\n  How much of the acquisition timeout is left.\n   */\n  readonly remainingInMilliseconds: number;\n\n  /**\n  The lock scope.\n   */\n  readonly scope: string;\n\n  /**\n  How long this run has been waiting so far.\n   */\n  readonly waitedInMilliseconds: number;\n}\n\n/**\n * The JSON payload stored inside a lock file, identifying the holder.\n */\ninterface LockFileInfo {\n  /**\n  When the lock was acquired (`Date.now()` epoch milliseconds).\n   */\n  readonly acquiredAtInMilliseconds: number;\n\n  /**\n   * When the holder last proved it was still alive (`Date.now()` epoch\n   * milliseconds), refreshed every {@link HEARTBEAT_INTERVAL_IN_MILLISECONDS}\n   * while the lock is held.\n   *\n   * Absent in a lock file written by an older version of this package, which\n   * stamped the PID but never beat.\n   */\n  readonly heartbeatAtInMilliseconds?: number | undefined;\n\n  /**\n  The host that holds the lock (PID liveness is only valid on the same host).\n   */\n  readonly hostname: string;\n\n  /**\n  The transport label of the holding run.\n   */\n  readonly label: string;\n\n  /**\n  The process ID of the holding run.\n   */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link didRefreshHeartbeat}.\n */\ninterface RefreshHeartbeatParams {\n  /**\n  The transport label of this run.\n   */\n  readonly label: string;\n\n  /**\n  The path to the lock file to refresh.\n   */\n  readonly lockFilePath: string;\n\n  /**\n  The lock info this run wrote when it acquired the lock.\n   */\n  readonly ownInfo: LockFileInfo;\n}\n\n/**\n * Acquires the cross-process setup lock for the given scope, waiting until any\n * competing run releases it (or its lock is detected as stale).\n *\n * @param params - The lock parameters.\n * @returns A handle whose {@link SetupLock.release} frees the lock.\n * @throws If the lock cannot be acquired within `timeoutInMilliseconds`.\n */\nexport async function acquireSetupLock(params: AcquireSetupLockParams): Promise<SetupLock> {\n  const {\n    label,\n    scope\n  } = params;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const lockFilePath = getLockFilePath(scope);\n  mkdirSync(getLockDirectory(), { recursive: true });\n\n  const startedAtInMilliseconds = Date.now();\n  const deadlineInMilliseconds = startedAtInMilliseconds + timeoutInMilliseconds;\n  let lastLoggedWaitAtInMilliseconds: null | number = null;\n\n  for (;;) {\n    const ownInfo = tryCreateLockFile(lockFilePath, label);\n    if (ownInfo) {\n      return createLockHandle({\n        label,\n        lockFilePath,\n        ownInfo,\n        scope\n      });\n    }\n\n    const info = readLockFileInfo(lockFilePath);\n    if (info && checkIsLockStale(info)) {\n      log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);\n      rmSync(lockFilePath, { force: true });\n      // Retry immediately \u2014 but still honour the deadline, so a lock that a\n      // Competing run keeps recreating cannot spin this loop forever.\n      if (Date.now() >= deadlineInMilliseconds) {\n        throw createTimeoutError({\n          info,\n          scope,\n          timeoutInMilliseconds\n        });\n      }\n      continue;\n    }\n\n    const nowInMilliseconds = Date.now();\n    if (nowInMilliseconds >= deadlineInMilliseconds) {\n      throw createTimeoutError({\n        info,\n        scope,\n        timeoutInMilliseconds\n      });\n    }\n\n    const shouldLogWait = lastLoggedWaitAtInMilliseconds === null\n      || nowInMilliseconds - lastLoggedWaitAtInMilliseconds >= WAIT_LOG_INTERVAL_IN_MILLISECONDS;\n    if (shouldLogWait) {\n      lastLoggedWaitAtInMilliseconds = nowInMilliseconds;\n      log(formatWaitMessage({\n        info,\n        label,\n        remainingInMilliseconds: deadlineInMilliseconds - nowInMilliseconds,\n        scope,\n        waitedInMilliseconds: nowInMilliseconds - startedAtInMilliseconds\n      }));\n    }\n\n    await delay(POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Determines whether a lock can be considered abandoned.\n *\n * A live holder refreshes its heartbeat every\n * {@link HEARTBEAT_INTERVAL_IN_MILLISECONDS}, so a heartbeat that stopped means\n * the holder is gone. That is the primary signal, because the recorded PID alone\n * cannot be trusted: {@link checkIsProcessAlive} only answers \"does *a* process\n * with this PID exist\", which a recycled PID satisfies long after the holder\n * died.\n *\n * On the same host a dead PID is still an immediate give-away, so it is kept as\n * a fast path. On a different host (a shared/network temp directory) the PID\n * cannot be probed at all and the two clocks may disagree, so the much wider\n * {@link STALE_LOCK_AGE_IN_MILLISECONDS} threshold is used instead.\n *\n * @param info - The parsed lock info.\n * @returns `true` if the lock is stale and may be stolen.\n */\nfunction checkIsLockStale(info: LockFileInfo): boolean {\n  const silentForInMilliseconds = Date.now() - getLastSeenAtInMilliseconds(info);\n\n  if (info.hostname === hostname()) {\n    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > HEARTBEAT_STALE_IN_MILLISECONDS;\n  }\n\n  return silentForInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;\n}\n\n/**\n * Determines whether a lock file still names this process as its holder.\n *\n * @param info - The parsed lock info.\n * @returns `true` if this process holds the lock.\n */\nfunction checkIsOwnLock(info: LockFileInfo): boolean {\n  return info.pid === process.pid && info.hostname === hostname();\n}\n\n/**\n * Checks whether a process with the given PID is currently alive.\n *\n * @param pid - The process ID to probe.\n * @returns `true` if the process exists.\n */\nfunction checkIsProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);\n    return true;\n  } catch (error: unknown) {\n    // `EPERM` means the process exists but is owned by another user \u2014 still alive.\n    return getErrorCode(error) === 'EPERM';\n  }\n}\n\n/**\n * Creates a {@link SetupLock} handle that keeps the lock's heartbeat fresh while\n * held and removes the lock file on release.\n *\n * The heartbeat timer is `unref`ed so it can never keep the process alive on its\n * own, and it stops as soon as the lock file names somebody else \u2014 a run whose\n * lock was stolen must not overwrite its successor's lock, nor delete it on\n * release.\n *\n * @param params - The handle parameters.\n * @returns The lock handle.\n */\nfunction createLockHandle(params: CreateLockHandleParams): SetupLock {\n  const {\n    label,\n    lockFilePath,\n    ownInfo,\n    scope\n  } = params;\n  let isReleased = false;\n\n  const heartbeatTimer = setInterval(() => {\n    const isStillOurs = didRefreshHeartbeat({\n      label,\n      lockFilePath,\n      ownInfo\n    });\n    if (isStillOurs) {\n      return;\n    }\n    clearInterval(heartbeatTimer);\n    log(`[integration-setup:${label}] The '${scope}' setup lock is no longer ours \u2014 another run took it over. Heartbeat stopped.`);\n  }, HEARTBEAT_INTERVAL_IN_MILLISECONDS);\n  heartbeatTimer.unref();\n\n  return {\n    release(): void {\n      if (isReleased) {\n        return;\n      }\n      isReleased = true;\n      clearInterval(heartbeatTimer);\n\n      const info = readLockFileInfo(lockFilePath);\n      if (info && !checkIsOwnLock(info)) {\n        log(`[integration-setup:${label}] Leaving the '${scope}' setup lock in place \u2014 it now belongs to ${describeInfo(info)}.`);\n        return;\n      }\n      rmSync(lockFilePath, { force: true });\n    }\n  };\n}\n\n/**\n * Builds the error thrown when the lock could not be acquired in time.\n *\n * @param params - The error parameters.\n * @returns The error to throw.\n */\nfunction createTimeoutError(params: CreateTimeoutErrorParams): Error {\n  const {\n    info,\n    scope,\n    timeoutInMilliseconds\n  } = params;\n  return new Error(\n    `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock `\n      + `held by ${describeHolder(info)}. Another integration-test run is still in progress.`\n  );\n}\n\n/**\n * Resolves after the given delay. Used to poll between lock-acquisition attempts.\n *\n * @param milliseconds - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(milliseconds: number): Promise<void> {\n  return new Promise<void>((resolve) => {\n    setTimeout(resolve, milliseconds);\n  });\n}\n\n/**\n * Builds a human-readable description of the current lock holder for log/error\n * messages.\n *\n * @param info - The parsed lock info, or `null` if it could not be read.\n * @returns A description string.\n */\nfunction describeHolder(info: LockFileInfo | null): string {\n  return info ? describeInfo(info) : 'another run';\n}\n\n/**\n * Formats a {@link LockFileInfo} as a short identifier string.\n *\n * @param info - The lock info.\n * @returns A string like `pid 1234 (obsidian-cli) on host`.\n */\nfunction describeInfo(info: LockFileInfo): string {\n  return `pid ${String(info.pid)} (${info.label}) on ${info.hostname}`;\n}\n\n/**\n * Rewrites the lock file with a fresh heartbeat timestamp, so waiting runs can\n * tell this holder apart from a crashed one whose PID has been recycled.\n *\n * A lock file that is missing or unreadable is still treated as ours and rewritten:\n * this run never released, so its claim stands.\n *\n * @param params - The refresh parameters.\n * @returns `true` while the lock is still ours, `false` once another run owns it.\n */\nfunction didRefreshHeartbeat(params: RefreshHeartbeatParams): boolean {\n  const {\n    label,\n    lockFilePath,\n    ownInfo\n  } = params;\n\n  const info = readLockFileInfo(lockFilePath);\n  if (info && !checkIsOwnLock(info)) {\n    return false;\n  }\n\n  const refreshedInfo: LockFileInfo = {\n    ...ownInfo,\n    heartbeatAtInMilliseconds: Date.now()\n  };\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(refreshedInfo));\n  } catch (error: unknown) {\n    // Not fatal: the lock is still held and will still be released. Only its\n    // Heartbeat goes stale, which at worst lets a waiting run steal it.\n    log(`[integration-setup:${label}] Failed to refresh the setup lock heartbeat: ${errorToString(error)}`);\n  }\n  return true;\n}\n\n/**\n * Formats a duration as a compact `1m 30s` / `45s` string for progress logs.\n *\n * @param milliseconds - The duration in milliseconds.\n * @returns The formatted duration.\n */\nfunction formatDuration(milliseconds: number): string {\n  const totalSeconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);\n  const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);\n  const seconds = totalSeconds % SECONDS_PER_MINUTE;\n  return minutes > 0 ? `${String(minutes)}m ${String(seconds)}s` : `${String(seconds)}s`;\n}\n\n/**\n * Builds the periodic \"still waiting\" progress line, so a legitimate multi-minute\n * wait is distinguishable from a hang in the terminal.\n *\n * @param params - The message parameters.\n * @returns The message to log.\n */\nfunction formatWaitMessage(params: FormatWaitMessageParams): string {\n  const {\n    info,\n    label,\n    remainingInMilliseconds,\n    scope,\n    waitedInMilliseconds\n  } = params;\n  const heldFor = info ? `, held for ${formatDuration(Date.now() - info.acquiredAtInMilliseconds)}` : '';\n  return `[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released `\n    + `(waited ${formatDuration(waitedInMilliseconds)}${heldFor}, giving up in ${formatDuration(remainingInMilliseconds)})...`;\n}\n\n/**\n * Extracts the `code` from a Node.js system error, if present.\n *\n * @param error - The thrown value.\n * @returns The error code string, or `undefined` if not a coded error.\n */\nfunction getErrorCode(error: unknown): string | undefined {\n  if (error instanceof Error && 'code' in error && typeof error.code === 'string') {\n    return error.code;\n  }\n  return undefined;\n}\n\n/**\n * Returns when the holder was last known to be alive \u2014 its most recent heartbeat,\n * falling back to its acquisition time for a lock file written by an older\n * version of this package that stamped no heartbeat at all.\n *\n * @param info - The parsed lock info.\n * @returns The epoch milliseconds of the holder's last sign of life.\n */\nfunction getLastSeenAtInMilliseconds(info: LockFileInfo): number {\n  return info.heartbeatAtInMilliseconds ?? info.acquiredAtInMilliseconds;\n}\n\n/**\n * Returns the shared lock directory inside the OS temp directory.\n *\n * @returns The absolute path to the lock directory.\n */\nfunction getLockDirectory(): string {\n  return join(tmpdir(), LOCK_DIR_NAME);\n}\n\n/**\n * Returns the lock file path for the given scope.\n *\n * @param scope - The lock scope.\n * @returns The absolute path to the scope's lock file.\n */\nfunction getLockFilePath(scope: string): string {\n  return join(getLockDirectory(), `${scope}${LOCK_FILE_SUFFIX}`);\n}\n\n/**\n * Reads and parses the lock file, if it exists and is valid JSON.\n *\n * @param lockFilePath - The path to the lock file.\n * @returns The parsed lock info, or `null` if it could not be read.\n */\nfunction readLockFileInfo(lockFilePath: string): LockFileInfo | null {\n  try {\n    return JSON.parse(readFileSync(lockFilePath, 'utf-8')) as LockFileInfo;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Attempts to atomically create the lock file (failing if it already exists).\n *\n * @param lockFilePath - The path to the lock file.\n * @param label - The transport label to record in the lock file.\n * @returns The lock info written on success, or `null` if the lock is already held.\n * @throws If the file system fails for any reason other than the file existing.\n */\nfunction tryCreateLockFile(lockFilePath: string, label: string): LockFileInfo | null {\n  const nowInMilliseconds = Date.now();\n  const info: LockFileInfo = {\n    acquiredAtInMilliseconds: nowInMilliseconds,\n    heartbeatAtInMilliseconds: nowInMilliseconds,\n    hostname: hostname(),\n    label,\n    pid: process.pid\n  };\n\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(info), { flag: 'wx' });\n    return info;\n  } catch (error: unknown) {\n    if (getErrorCode(error) === 'EEXIST') {\n      return null;\n    }\n    throw error;\n  }\n}\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/setup-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Cross-process advisory lock that serializes whole integration-test runs.\n *\n * Two test runs that drive the same shared resources corrupt each other: on\n * desktop they share the single local Obsidian instance, its `obsidian.json`\n * registry, and the CDP port; on Android they share the emulator and the Appium\n * server. One run's setup/teardown kills or reconfigures the instance the other\n * run is mid-eval on (observed as `ECONNREFUSED` or \"vault not open\"), so both\n * runs fail.\n *\n * This lock makes the second run **wait** for the first to finish instead of\n * running concurrently. It is held for the entire run: acquired at the start of\n * the core setup and released by the core teardown (and by the process cleanup\n * handlers). The lock is a sentinel file in a shared temp directory, and its\n * holder keeps a **heartbeat** timestamp inside it fresh for as long as it holds\n * the lock \u2014 so a run that crashed without releasing stops beating and the next\n * run detects the lock as stale and steals it.\n *\n * The heartbeat, not the holder's PID, is what proves a holder is still there: a\n * PID probe only answers \"does *a* process with this PID exist\", which a\n * recycled PID satisfies long after the real holder died \u2014 leaving every later\n * run to block for the full acquisition timeout.\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  hostname,\n  tmpdir\n} from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { errorToString } from './error-to-string.cjs';\nimport { log } from './log.cjs';\n\n/**\n * The scope every Android run serializes on: the Appium transport's global\n * setup, a project that takes the lock itself, and the emulator reaper all\n * have to name the same one, or they serialize against nothing.\n */\nexport const ANDROID_SETUP_LOCK_SCOPE = 'android';\n\nconst LOCK_DIR_NAME = 'obsidian-integration-testing';\nconst LOCK_FILE_SUFFIX = '.setup.lock';\nconst POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst SECONDS_PER_MINUTE = 60;\nconst HEARTBEAT_INTERVAL_IN_SECONDS = 5;\nconst HEARTBEAT_INTERVAL_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;\n// Generous on purpose: a dead holder is normally caught instantly by the PID\n// Probe, so this threshold only has to cover the recycled-PID case. Two minutes\n// Keeps a holder that blocks its event loop during heavy synchronous work (a\n// Large vault sync, an installer unpack) from being robbed while it is alive.\nconst MISSED_HEARTBEATS_BEFORE_STALE = 24;\nconst HEARTBEAT_STALE_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_MILLISECONDS * MISSED_HEARTBEATS_BEFORE_STALE;\nconst WAIT_LOG_INTERVAL_IN_SECONDS = 30;\nconst WAIT_LOG_INTERVAL_IN_MILLISECONDS = WAIT_LOG_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;\nconst STALE_LOCK_AGE_IN_MINUTES = 30;\nconst DEFAULT_TIMEOUT_IN_MINUTES = 60;\nconst STALE_LOCK_AGE_IN_MILLISECONDS = STALE_LOCK_AGE_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Parameters for {@link acquireSetupLock}.\n */\nexport interface AcquireSetupLockParams {\n  /**\n  Short transport label for log messages (e.g. `\"obsidian-cli\"`).\n   */\n  readonly label: string;\n\n  /**\n   * Logical scope the lock serializes within. Runs that share resources must\n   * use the same scope (e.g. `\"desktop\"` for the CLI/CDP transports, `\"android\"`\n   * for the Appium transport).\n   */\n  readonly scope: string;\n\n  /**\n   * Maximum time to wait for a competing run to release the lock before giving\n   * up and throwing.\n   *\n   * @default 1 hour\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n}\n\n/**\n * A held setup lock. Release it once the run's teardown is complete.\n */\nexport interface SetupLock {\n  /**\n  Releases the lock. Safe to call more than once.\n   */\n  release(): void;\n}\n\n/**\n * Parameters for {@link tryAcquireSetupLock}.\n */\nexport interface TryAcquireSetupLockParams {\n  /**\n  Short transport label for log messages, recorded in the lock file as the holder's.\n   */\n  readonly label: string;\n\n  /**\n  Logical scope the lock serializes within \u2014 see {@link AcquireSetupLockParams.scope}.\n   */\n  readonly scope: string;\n\n  /**\n   * How long a same-host holder whose PID is still alive may go without a\n   * heartbeat before its lock counts as abandoned.\n   *\n   * A dead holder PID is abandoned at once whatever this says. The default is\n   * the threshold every waiting run steals on; a caller that is *always* waiting\n   * \u2014 the emulator reaper \u2014 passes a far wider one, so a live run that blocks\n   * its event loop for a couple of minutes is not robbed of its lock.\n   *\n   * @default 2 minutes\n   */\n  readonly staleAfterSilenceInMilliseconds?: number | undefined;\n}\n\n/**\n * Parameters for {@link createLockHandle}.\n */\ninterface CreateLockHandleParams {\n  /**\n  The transport label of this run.\n   */\n  readonly label: string;\n\n  /**\n  The path to the lock file this run just created.\n   */\n  readonly lockFilePath: string;\n\n  /**\n  The lock info this run wrote when it acquired the lock.\n   */\n  readonly ownInfo: LockFileInfo;\n\n  /**\n  The lock scope, for log messages.\n   */\n  readonly scope: string;\n}\n\n/**\n * Parameters for {@link createTimeoutError}.\n */\ninterface CreateTimeoutErrorParams {\n  /**\n  The current holder's lock info, or `null` if it could not be read.\n   */\n  readonly info: LockFileInfo | null;\n\n  /**\n  The lock scope.\n   */\n  readonly scope: string;\n\n  /**\n  The timeout that elapsed.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link formatWaitMessage}.\n */\ninterface FormatWaitMessageParams {\n  /**\n  The current holder's lock info, or `null` if it could not be read.\n   */\n  readonly info: LockFileInfo | null;\n\n  /**\n  The transport label of the waiting run.\n   */\n  readonly label: string;\n\n  /**\n  How much of the acquisition timeout is left.\n   */\n  readonly remainingInMilliseconds: number;\n\n  /**\n  The lock scope.\n   */\n  readonly scope: string;\n\n  /**\n  How long this run has been waiting so far.\n   */\n  readonly waitedInMilliseconds: number;\n}\n\n/**\n * The JSON payload stored inside a lock file, identifying the holder.\n */\ninterface LockFileInfo {\n  /**\n  When the lock was acquired (`Date.now()` epoch milliseconds).\n   */\n  readonly acquiredAtInMilliseconds: number;\n\n  /**\n   * When the holder last proved it was still alive (`Date.now()` epoch\n   * milliseconds), refreshed every {@link HEARTBEAT_INTERVAL_IN_MILLISECONDS}\n   * while the lock is held.\n   *\n   * Absent in a lock file written by an older version of this package, which\n   * stamped the PID but never beat.\n   */\n  readonly heartbeatAtInMilliseconds?: number | undefined;\n\n  /**\n  The host that holds the lock (PID liveness is only valid on the same host).\n   */\n  readonly hostname: string;\n\n  /**\n  The transport label of the holding run.\n   */\n  readonly label: string;\n\n  /**\n  The process ID of the holding run.\n   */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link didRefreshHeartbeat}.\n */\ninterface RefreshHeartbeatParams {\n  /**\n  The transport label of this run.\n   */\n  readonly label: string;\n\n  /**\n  The path to the lock file to refresh.\n   */\n  readonly lockFilePath: string;\n\n  /**\n  The lock info this run wrote when it acquired the lock.\n   */\n  readonly ownInfo: LockFileInfo;\n}\n\n/**\n * Parameters for {@link stealStaleLock}.\n */\ninterface StealStaleLockParams {\n  /**\n  The abandoned holder's lock info.\n   */\n  readonly info: LockFileInfo;\n\n  /**\n  The transport label of the stealing run.\n   */\n  readonly label: string;\n\n  /**\n  The path to the lock file to remove.\n   */\n  readonly lockFilePath: string;\n\n  /**\n  The lock scope, for the log message.\n   */\n  readonly scope: string;\n}\n\n/**\n * Acquires the cross-process setup lock for the given scope, waiting until any\n * competing run releases it (or its lock is detected as stale).\n *\n * @param params - The lock parameters.\n * @returns A handle whose {@link SetupLock.release} frees the lock.\n * @throws If the lock cannot be acquired within `timeoutInMilliseconds`.\n */\nexport async function acquireSetupLock(params: AcquireSetupLockParams): Promise<SetupLock> {\n  const {\n    label,\n    scope\n  } = params;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const lockFilePath = getLockFilePath(scope);\n  mkdirSync(getLockDirectory(), { recursive: true });\n\n  const startedAtInMilliseconds = Date.now();\n  const deadlineInMilliseconds = startedAtInMilliseconds + timeoutInMilliseconds;\n  let lastLoggedWaitAtInMilliseconds: null | number = null;\n\n  for (;;) {\n    const ownInfo = tryCreateLockFile(lockFilePath, label);\n    if (ownInfo) {\n      return createLockHandle({\n        label,\n        lockFilePath,\n        ownInfo,\n        scope\n      });\n    }\n\n    const info = readLockFileInfo(lockFilePath);\n    if (info && checkIsLockStale(info, HEARTBEAT_STALE_IN_MILLISECONDS)) {\n      stealStaleLock({ info, label, lockFilePath, scope });\n      // Retry immediately \u2014 but still honour the deadline, so a lock that a\n      // Competing run keeps recreating cannot spin this loop forever.\n      if (Date.now() >= deadlineInMilliseconds) {\n        throw createTimeoutError({\n          info,\n          scope,\n          timeoutInMilliseconds\n        });\n      }\n      continue;\n    }\n\n    const nowInMilliseconds = Date.now();\n    if (nowInMilliseconds >= deadlineInMilliseconds) {\n      throw createTimeoutError({\n        info,\n        scope,\n        timeoutInMilliseconds\n      });\n    }\n\n    const shouldLogWait = lastLoggedWaitAtInMilliseconds === null\n      || nowInMilliseconds - lastLoggedWaitAtInMilliseconds >= WAIT_LOG_INTERVAL_IN_MILLISECONDS;\n    if (shouldLogWait) {\n      lastLoggedWaitAtInMilliseconds = nowInMilliseconds;\n      log(formatWaitMessage({\n        info,\n        label,\n        remainingInMilliseconds: deadlineInMilliseconds - nowInMilliseconds,\n        scope,\n        waitedInMilliseconds: nowInMilliseconds - startedAtInMilliseconds\n      }));\n    }\n\n    await delay(POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Reports whether a run currently holds the setup lock for a scope.\n *\n * A lock file that exists but cannot be read counts as held \u2014 the same answer\n * {@link acquireSetupLock} gives by waiting on it: it is either mid-write or\n * corrupt, and either way no run can take it.\n *\n * @param scope - The lock scope.\n * @returns `true` when a holder that is not stale owns the lock.\n */\nexport function checkIsSetupLockHeld(scope: string): boolean {\n  let text: string;\n  try {\n    text = readFileSync(getLockFilePath(scope), 'utf-8');\n  } catch (error: unknown) {\n    return getErrorCode(error) !== 'ENOENT';\n  }\n\n  let info: LockFileInfo;\n  try {\n    info = JSON.parse(text) as LockFileInfo;\n  } catch {\n    return true;\n  }\n\n  return !checkIsLockStale(info, HEARTBEAT_STALE_IN_MILLISECONDS);\n}\n\n/**\n * Takes the setup lock for a scope if it is free or abandoned, without waiting.\n *\n * One attempt: a live holder \u2014 or a lock file that cannot be read \u2014 means\n * `undefined`, and the caller decides whether to try again later.\n *\n * @param params - The lock parameters.\n * @returns A handle whose {@link SetupLock.release} frees the lock, or `undefined` while another run holds it.\n * @throws If the file system fails for any reason other than the lock file already existing.\n */\nexport function tryAcquireSetupLock(params: TryAcquireSetupLockParams): SetupLock | undefined {\n  const { label, scope } = params;\n  const lockFilePath = getLockFilePath(scope);\n  mkdirSync(getLockDirectory(), { recursive: true });\n\n  let ownInfo = tryCreateLockFile(lockFilePath, label);\n  if (!ownInfo) {\n    const info = readLockFileInfo(lockFilePath);\n    if (!info || !checkIsLockStale(info, params.staleAfterSilenceInMilliseconds ?? HEARTBEAT_STALE_IN_MILLISECONDS)) {\n      return undefined;\n    }\n\n    stealStaleLock({ info, label, lockFilePath, scope });\n    ownInfo = tryCreateLockFile(lockFilePath, label);\n    if (!ownInfo) {\n      // Another run recreated it between the steal and this attempt; it is theirs now.\n      return undefined;\n    }\n  }\n\n  return createLockHandle({\n    label,\n    lockFilePath,\n    ownInfo,\n    scope\n  });\n}\n\n/**\n * Determines whether a lock can be considered abandoned.\n *\n * A live holder refreshes its heartbeat every\n * {@link HEARTBEAT_INTERVAL_IN_MILLISECONDS}, so a heartbeat that stopped means\n * the holder is gone. That is the primary signal, because the recorded PID alone\n * cannot be trusted: {@link checkIsProcessAlive} only answers \"does *a* process\n * with this PID exist\", which a recycled PID satisfies long after the holder\n * died.\n *\n * On the same host a dead PID is still an immediate give-away, so it is kept as\n * a fast path. On a different host (a shared/network temp directory) the PID\n * cannot be probed at all and the two clocks may disagree, so the much wider\n * {@link STALE_LOCK_AGE_IN_MILLISECONDS} threshold is used instead.\n *\n * @param info - The parsed lock info.\n * @param heartbeatStaleInMilliseconds - How long a same-host holder whose PID is alive may stay silent.\n * @returns `true` if the lock is stale and may be stolen.\n */\nfunction checkIsLockStale(info: LockFileInfo, heartbeatStaleInMilliseconds: number): boolean {\n  const silentForInMilliseconds = Date.now() - getLastSeenAtInMilliseconds(info);\n\n  if (info.hostname === hostname()) {\n    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > heartbeatStaleInMilliseconds;\n  }\n\n  return silentForInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;\n}\n\n/**\n * Determines whether a lock file still names this process as its holder.\n *\n * @param info - The parsed lock info.\n * @returns `true` if this process holds the lock.\n */\nfunction checkIsOwnLock(info: LockFileInfo): boolean {\n  return info.pid === process.pid && info.hostname === hostname();\n}\n\n/**\n * Checks whether a process with the given PID is currently alive.\n *\n * @param pid - The process ID to probe.\n * @returns `true` if the process exists.\n */\nfunction checkIsProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);\n    return true;\n  } catch (error: unknown) {\n    // `EPERM` means the process exists but is owned by another user \u2014 still alive.\n    return getErrorCode(error) === 'EPERM';\n  }\n}\n\n/**\n * Creates a {@link SetupLock} handle that keeps the lock's heartbeat fresh while\n * held and removes the lock file on release.\n *\n * The heartbeat timer is `unref`ed so it can never keep the process alive on its\n * own, and it stops as soon as the lock file names somebody else \u2014 a run whose\n * lock was stolen must not overwrite its successor's lock, nor delete it on\n * release.\n *\n * @param params - The handle parameters.\n * @returns The lock handle.\n */\nfunction createLockHandle(params: CreateLockHandleParams): SetupLock {\n  const {\n    label,\n    lockFilePath,\n    ownInfo,\n    scope\n  } = params;\n  let isReleased = false;\n\n  const heartbeatTimer = setInterval(() => {\n    const isStillOurs = didRefreshHeartbeat({\n      label,\n      lockFilePath,\n      ownInfo\n    });\n    if (isStillOurs) {\n      return;\n    }\n    clearInterval(heartbeatTimer);\n    log(`[integration-setup:${label}] The '${scope}' setup lock is no longer ours \u2014 another run took it over. Heartbeat stopped.`);\n  }, HEARTBEAT_INTERVAL_IN_MILLISECONDS);\n  heartbeatTimer.unref();\n\n  return {\n    release(): void {\n      if (isReleased) {\n        return;\n      }\n      isReleased = true;\n      clearInterval(heartbeatTimer);\n\n      const info = readLockFileInfo(lockFilePath);\n      if (info && !checkIsOwnLock(info)) {\n        log(`[integration-setup:${label}] Leaving the '${scope}' setup lock in place \u2014 it now belongs to ${describeInfo(info)}.`);\n        return;\n      }\n      rmSync(lockFilePath, { force: true });\n    }\n  };\n}\n\n/**\n * Builds the error thrown when the lock could not be acquired in time.\n *\n * @param params - The error parameters.\n * @returns The error to throw.\n */\nfunction createTimeoutError(params: CreateTimeoutErrorParams): Error {\n  const {\n    info,\n    scope,\n    timeoutInMilliseconds\n  } = params;\n  return new Error(\n    `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock `\n      + `held by ${describeHolder(info)}. Another integration-test run is still in progress.`\n  );\n}\n\n/**\n * Resolves after the given delay. Used to poll between lock-acquisition attempts.\n *\n * @param milliseconds - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(milliseconds: number): Promise<void> {\n  return new Promise<void>((resolve) => {\n    setTimeout(resolve, milliseconds);\n  });\n}\n\n/**\n * Builds a human-readable description of the current lock holder for log/error\n * messages.\n *\n * @param info - The parsed lock info, or `null` if it could not be read.\n * @returns A description string.\n */\nfunction describeHolder(info: LockFileInfo | null): string {\n  return info ? describeInfo(info) : 'another run';\n}\n\n/**\n * Formats a {@link LockFileInfo} as a short identifier string.\n *\n * @param info - The lock info.\n * @returns A string like `pid 1234 (obsidian-cli) on host`.\n */\nfunction describeInfo(info: LockFileInfo): string {\n  return `pid ${String(info.pid)} (${info.label}) on ${info.hostname}`;\n}\n\n/**\n * Rewrites the lock file with a fresh heartbeat timestamp, so waiting runs can\n * tell this holder apart from a crashed one whose PID has been recycled.\n *\n * A lock file that is missing or unreadable is still treated as ours and rewritten:\n * this run never released, so its claim stands.\n *\n * @param params - The refresh parameters.\n * @returns `true` while the lock is still ours, `false` once another run owns it.\n */\nfunction didRefreshHeartbeat(params: RefreshHeartbeatParams): boolean {\n  const {\n    label,\n    lockFilePath,\n    ownInfo\n  } = params;\n\n  const info = readLockFileInfo(lockFilePath);\n  if (info && !checkIsOwnLock(info)) {\n    return false;\n  }\n\n  const refreshedInfo: LockFileInfo = {\n    ...ownInfo,\n    heartbeatAtInMilliseconds: Date.now()\n  };\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(refreshedInfo));\n  } catch (error: unknown) {\n    // Not fatal: the lock is still held and will still be released. Only its\n    // Heartbeat goes stale, which at worst lets a waiting run steal it.\n    log(`[integration-setup:${label}] Failed to refresh the setup lock heartbeat: ${errorToString(error)}`);\n  }\n  return true;\n}\n\n/**\n * Formats a duration as a compact `1m 30s` / `45s` string for progress logs.\n *\n * @param milliseconds - The duration in milliseconds.\n * @returns The formatted duration.\n */\nfunction formatDuration(milliseconds: number): string {\n  const totalSeconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);\n  const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);\n  const seconds = totalSeconds % SECONDS_PER_MINUTE;\n  return minutes > 0 ? `${String(minutes)}m ${String(seconds)}s` : `${String(seconds)}s`;\n}\n\n/**\n * Builds the periodic \"still waiting\" progress line, so a legitimate multi-minute\n * wait is distinguishable from a hang in the terminal.\n *\n * @param params - The message parameters.\n * @returns The message to log.\n */\nfunction formatWaitMessage(params: FormatWaitMessageParams): string {\n  const {\n    info,\n    label,\n    remainingInMilliseconds,\n    scope,\n    waitedInMilliseconds\n  } = params;\n  const heldFor = info ? `, held for ${formatDuration(Date.now() - info.acquiredAtInMilliseconds)}` : '';\n  return `[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released `\n    + `(waited ${formatDuration(waitedInMilliseconds)}${heldFor}, giving up in ${formatDuration(remainingInMilliseconds)})...`;\n}\n\n/**\n * Extracts the `code` from a Node.js system error, if present.\n *\n * @param error - The thrown value.\n * @returns The error code string, or `undefined` if not a coded error.\n */\nfunction getErrorCode(error: unknown): string | undefined {\n  if (error instanceof Error && 'code' in error && typeof error.code === 'string') {\n    return error.code;\n  }\n  return undefined;\n}\n\n/**\n * Returns when the holder was last known to be alive \u2014 its most recent heartbeat,\n * falling back to its acquisition time for a lock file written by an older\n * version of this package that stamped no heartbeat at all.\n *\n * @param info - The parsed lock info.\n * @returns The epoch milliseconds of the holder's last sign of life.\n */\nfunction getLastSeenAtInMilliseconds(info: LockFileInfo): number {\n  return info.heartbeatAtInMilliseconds ?? info.acquiredAtInMilliseconds;\n}\n\n/**\n * Returns the shared lock directory inside the OS temp directory.\n *\n * @returns The absolute path to the lock directory.\n */\nfunction getLockDirectory(): string {\n  return join(tmpdir(), LOCK_DIR_NAME);\n}\n\n/**\n * Returns the lock file path for the given scope.\n *\n * @param scope - The lock scope.\n * @returns The absolute path to the scope's lock file.\n */\nfunction getLockFilePath(scope: string): string {\n  return join(getLockDirectory(), `${scope}${LOCK_FILE_SUFFIX}`);\n}\n\n/**\n * Reads and parses the lock file, if it exists and is valid JSON.\n *\n * @param lockFilePath - The path to the lock file.\n * @returns The parsed lock info, or `null` if it could not be read.\n */\nfunction readLockFileInfo(lockFilePath: string): LockFileInfo | null {\n  try {\n    return JSON.parse(readFileSync(lockFilePath, 'utf-8')) as LockFileInfo;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Removes an abandoned holder's lock file, saying whose it was.\n *\n * @param params - The abandoned holder, and who is taking over.\n */\nfunction stealStaleLock(params: StealStaleLockParams): void {\n  log(`[integration-setup:${params.label}] Stealing stale '${params.scope}' setup lock from ${describeInfo(params.info)}.`);\n  rmSync(params.lockFilePath, { force: true });\n}\n\n/**\n * Attempts to atomically create the lock file (failing if it already exists).\n *\n * @param lockFilePath - The path to the lock file.\n * @param label - The transport label to record in the lock file.\n * @returns The lock info written on success, or `null` if the lock is already held.\n * @throws If the file system fails for any reason other than the file existing.\n */\nfunction tryCreateLockFile(lockFilePath: string, label: string): LockFileInfo | null {\n  const nowInMilliseconds = Date.now();\n  const info: LockFileInfo = {\n    acquiredAtInMilliseconds: nowInMilliseconds,\n    heartbeatAtInMilliseconds: nowInMilliseconds,\n    hostname: hostname(),\n    label,\n    pid: process.pid\n  };\n\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(info), { flag: 'wx' });\n    return info;\n  } catch (error: unknown) {\n    if (getErrorCode(error) === 'EEXIST') {\n      return null;\n    }\n    throw error;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,qBAKO;AACP,qBAGO;AACP,uBAAqB;AACrB,0BAAoB;AAEpB,6BAA8B;AAC9B,iBAAoB;AAOb,MAAM,2BAA2B;AAExC,MAAM,gBAAgB;AACtB,MAAM,mBAAmB;AACzB,MAAM,gCAAgC;AACtC,MAAM,0BAA0B;AAChC,MAAM,qBAAqB;AAC3B,MAAM,gCAAgC;AACtC,MAAM,qCAAqC,gCAAgC;AAK3E,MAAM,iCAAiC;AACvC,MAAM,kCAAkC,qCAAqC;AAC7E,MAAM,+BAA+B;AACrC,MAAM,oCAAoC,+BAA+B;AACzE,MAAM,4BAA4B;AAClC,MAAM,6BAA6B;AACnC,MAAM,iCAAiC,4BAA4B,qBAAqB;AACxF,MAAM,kCAAkC,6BAA6B,qBAAqB;AAC1F,MAAM,iCAAiC;AAoOvC,eAAsB,iBAAiB,QAAoD;AACzF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,eAAe,gBAAgB,KAAK;AAC1C,gCAAU,iBAAiB,GAAG,EAAE,WAAW,KAAK,CAAC;AAEjD,QAAM,0BAA0B,KAAK,IAAI;AACzC,QAAM,yBAAyB,0BAA0B;AACzD,MAAI,iCAAgD;AAEpD,aAAS;AACP,UAAM,UAAU,kBAAkB,cAAc,KAAK;AACrD,QAAI,SAAS;AACX,aAAO,iBAAiB;AAAA,QACtB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAEA,UAAM,OAAO,iBAAiB,YAAY;AAC1C,QAAI,QAAQ,iBAAiB,MAAM,+BAA+B,GAAG;AACnE,qBAAe,EAAE,MAAM,OAAO,cAAc,MAAM,CAAC;AAGnD,UAAI,KAAK,IAAI,KAAK,wBAAwB;AACxC,cAAM,mBAAmB;AAAA,UACvB;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AACA;AAAA,IACF;AAEA,UAAM,oBAAoB,KAAK,IAAI;AACnC,QAAI,qBAAqB,wBAAwB;AAC/C,YAAM,mBAAmB;AAAA,QACvB;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAEA,UAAM,gBAAgB,mCAAmC,QACpD,oBAAoB,kCAAkC;AAC3D,QAAI,eAAe;AACjB,uCAAiC;AACjC,0BAAI,kBAAkB;AAAA,QACpB;AAAA,QACA;AAAA,QACA,yBAAyB,yBAAyB;AAAA,QAClD;AAAA,QACA,sBAAsB,oBAAoB;AAAA,MAC5C,CAAC,CAAC;AAAA,IACJ;AAEA,UAAM,MAAM,6BAA6B;AAAA,EAC3C;AACF;AAYO,SAAS,qBAAqB,OAAwB;AAC3D,MAAI;AACJ,MAAI;AACF,eAAO,6BAAa,gBAAgB,KAAK,GAAG,OAAO;AAAA,EACrD,SAAS,OAAgB;AACvB,WAAO,aAAa,KAAK,MAAM;AAAA,EACjC;AAEA,MAAI;AACJ,MAAI;AACF,WAAO,KAAK,MAAM,IAAI;AAAA,EACxB,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,CAAC,iBAAiB,MAAM,+BAA+B;AAChE;AAYO,SAAS,oBAAoB,QAA0D;AAC5F,QAAM,EAAE,OAAO,MAAM,IAAI;AACzB,QAAM,eAAe,gBAAgB,KAAK;AAC1C,gCAAU,iBAAiB,GAAG,EAAE,WAAW,KAAK,CAAC;AAEjD,MAAI,UAAU,kBAAkB,cAAc,KAAK;AACnD,MAAI,CAAC,SAAS;AACZ,UAAM,OAAO,iBAAiB,YAAY;AAC1C,QAAI,CAAC,QAAQ,CAAC,iBAAiB,MAAM,OAAO,mCAAmC,+BAA+B,GAAG;AAC/G,aAAO;AAAA,IACT;AAEA,mBAAe,EAAE,MAAM,OAAO,cAAc,MAAM,CAAC;AACnD,cAAU,kBAAkB,cAAc,KAAK;AAC/C,QAAI,CAAC,SAAS;AAEZ,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,iBAAiB;AAAA,IACtB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAqBA,SAAS,iBAAiB,MAAoB,8BAA+C;AAC3F,QAAM,0BAA0B,KAAK,IAAI,IAAI,4BAA4B,IAAI;AAE7E,MAAI,KAAK,iBAAa,yBAAS,GAAG;AAChC,WAAO,CAAC,oBAAoB,KAAK,GAAG,KAAK,0BAA0B;AAAA,EACrE;AAEA,SAAO,0BAA0B;AACnC;AAQA,SAAS,eAAe,MAA6B;AACnD,SAAO,KAAK,QAAQ,oBAAAA,QAAQ,OAAO,KAAK,iBAAa,yBAAS;AAChE;AAQA,SAAS,oBAAoB,KAAsB;AACjD,MAAI;AACF,wBAAAA,QAAQ,KAAK,KAAK,8BAA8B;AAChD,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,WAAO,aAAa,KAAK,MAAM;AAAA,EACjC;AACF;AAcA,SAAS,iBAAiB,QAA2C;AACnE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,MAAI,aAAa;AAEjB,QAAM,iBAAiB,YAAY,MAAM;AACvC,UAAM,cAAc,oBAAoB;AAAA,MACtC;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AACD,QAAI,aAAa;AACf;AAAA,IACF;AACA,kBAAc,cAAc;AAC5B,wBAAI,sBAAsB,KAAK,UAAU,KAAK,oFAA+E;AAAA,EAC/H,GAAG,kCAAkC;AACrC,iBAAe,MAAM;AAErB,SAAO;AAAA,IACL,UAAgB;AACd,UAAI,YAAY;AACd;AAAA,MACF;AACA,mBAAa;AACb,oBAAc,cAAc;AAE5B,YAAM,OAAO,iBAAiB,YAAY;AAC1C,UAAI,QAAQ,CAAC,eAAe,IAAI,GAAG;AACjC,4BAAI,sBAAsB,KAAK,kBAAkB,KAAK,kDAA6C,aAAa,IAAI,CAAC,GAAG;AACxH;AAAA,MACF;AACA,iCAAO,cAAc,EAAE,OAAO,KAAK,CAAC;AAAA,IACtC;AAAA,EACF;AACF;AAQA,SAAS,mBAAmB,QAAyC;AACnE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,SAAO,IAAI;AAAA,IACT,mBAAmB,OAAO,qBAAqB,CAAC,uBAAuB,KAAK,yCAC7D,eAAe,IAAI,CAAC;AAAA,EACrC;AACF;AAQA,SAAS,MAAM,cAAqC;AAClD,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,eAAW,SAAS,YAAY;AAAA,EAClC,CAAC;AACH;AASA,SAAS,eAAe,MAAmC;AACzD,SAAO,OAAO,aAAa,IAAI,IAAI;AACrC;AAQA,SAAS,aAAa,MAA4B;AAChD,SAAO,OAAO,OAAO,KAAK,GAAG,CAAC,KAAK,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACpE;AAYA,SAAS,oBAAoB,QAAyC;AACpE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,OAAO,iBAAiB,YAAY;AAC1C,MAAI,QAAQ,CAAC,eAAe,IAAI,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,gBAA8B;AAAA,IAClC,GAAG;AAAA,IACH,2BAA2B,KAAK,IAAI;AAAA,EACtC;AACA,MAAI;AACF,sCAAc,cAAc,KAAK,UAAU,aAAa,CAAC;AAAA,EAC3D,SAAS,OAAgB;AAGvB,wBAAI,sBAAsB,KAAK,qDAAiD,sCAAc,KAAK,CAAC,EAAE;AAAA,EACxG;AACA,SAAO;AACT;AAQA,SAAS,eAAe,cAA8B;AACpD,QAAM,eAAe,KAAK,MAAM,eAAe,uBAAuB;AACtE,QAAM,UAAU,KAAK,MAAM,eAAe,kBAAkB;AAC5D,QAAM,UAAU,eAAe;AAC/B,SAAO,UAAU,IAAI,GAAG,OAAO,OAAO,CAAC,KAAK,OAAO,OAAO,CAAC,MAAM,GAAG,OAAO,OAAO,CAAC;AACrF;AASA,SAAS,kBAAkB,QAAyC;AAClE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,UAAU,OAAO,cAAc,eAAe,KAAK,IAAI,IAAI,KAAK,wBAAwB,CAAC,KAAK;AACpG,SAAO,sBAAsB,KAAK,sBAAsB,KAAK,wBAAwB,eAAe,IAAI,CAAC,2BAC1F,eAAe,oBAAoB,CAAC,GAAG,OAAO,kBAAkB,eAAe,uBAAuB,CAAC;AACxH;AAQA,SAAS,aAAa,OAAoC;AACxD,MAAI,iBAAiB,SAAS,UAAU,SAAS,OAAO,MAAM,SAAS,UAAU;AAC/E,WAAO,MAAM;AAAA,EACf;AACA,SAAO;AACT;AAUA,SAAS,4BAA4B,MAA4B;AAC/D,SAAO,KAAK,6BAA6B,KAAK;AAChD;AAOA,SAAS,mBAA2B;AAClC,aAAO,2BAAK,uBAAO,GAAG,aAAa;AACrC;AAQA,SAAS,gBAAgB,OAAuB;AAC9C,aAAO,uBAAK,iBAAiB,GAAG,GAAG,KAAK,GAAG,gBAAgB,EAAE;AAC/D;AAQA,SAAS,iBAAiB,cAA2C;AACnE,MAAI;AACF,WAAO,KAAK,UAAM,6BAAa,cAAc,OAAO,CAAC;AAAA,EACvD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAOA,SAAS,eAAe,QAAoC;AAC1D,sBAAI,sBAAsB,OAAO,KAAK,qBAAqB,OAAO,KAAK,qBAAqB,aAAa,OAAO,IAAI,CAAC,GAAG;AACxH,6BAAO,OAAO,cAAc,EAAE,OAAO,KAAK,CAAC;AAC7C;AAUA,SAAS,kBAAkB,cAAsB,OAAoC;AACnF,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,OAAqB;AAAA,IACzB,0BAA0B;AAAA,IAC1B,2BAA2B;AAAA,IAC3B,cAAU,yBAAS;AAAA,IACnB;AAAA,IACA,KAAK,oBAAAA,QAAQ;AAAA,EACf;AAEA,MAAI;AACF,sCAAc,cAAc,KAAK,UAAU,IAAI,GAAG,EAAE,MAAM,KAAK,CAAC;AAChE,WAAO;AAAA,EACT,SAAS,OAAgB;AACvB,QAAI,aAAa,KAAK,MAAM,UAAU;AACpC,aAAO;AAAA,IACT;AACA,UAAM;AAAA,EACR;AACF;",
  "names": ["process"]
}


package/dist/lib/cjs/setup-lock.d.cts

@@ -23,6 +23,12 @@
  * recycled PID satisfies long after the real holder died — leaving every later
  * run to block for the full acquisition timeout.
  */
+/**
+ * The scope every Android run serializes on: the Appium transport's global
+ * setup, a project that takes the lock itself, and the emulator reaper all
+ * have to name the same one, or they serialize against nothing.
+ */
+export declare const ANDROID_SETUP_LOCK_SCOPE = "android";
 /**
  * Parameters for {@link acquireSetupLock}.
  */
@@ -54,6 +60,31 @@ export interface SetupLock {
      */
     release(): void;
 }
+/**
+ * Parameters for {@link tryAcquireSetupLock}.
+ */
+export interface TryAcquireSetupLockParams {
+    /**
+    Short transport label for log messages, recorded in the lock file as the holder's.
+     */
+    readonly label: string;
+    /**
+    Logical scope the lock serializes within — see {@link AcquireSetupLockParams.scope}.
+     */
+    readonly scope: string;
+    /**
+     * How long a same-host holder whose PID is still alive may go without a
+     * heartbeat before its lock counts as abandoned.
+     *
+     * A dead holder PID is abandoned at once whatever this says. The default is
+     * the threshold every waiting run steals on; a caller that is *always* waiting
+     * — the emulator reaper — passes a far wider one, so a live run that blocks
+     * its event loop for a couple of minutes is not robbed of its lock.
+     *
+     * @default 2 minutes
+     */
+    readonly staleAfterSilenceInMilliseconds?: number | undefined;
+}
 /**
  * Acquires the cross-process setup lock for the given scope, waiting until any
  * competing run releases it (or its lock is detected as stale).
@@ -63,3 +94,25 @@ export interface SetupLock {
  * @throws If the lock cannot be acquired within `timeoutInMilliseconds`.
  */
 export declare function acquireSetupLock(params: AcquireSetupLockParams): Promise<SetupLock>;
+/**
+ * Reports whether a run currently holds the setup lock for a scope.
+ *
+ * A lock file that exists but cannot be read counts as held — the same answer
+ * {@link acquireSetupLock} gives by waiting on it: it is either mid-write or
+ * corrupt, and either way no run can take it.
+ *
+ * @param scope - The lock scope.
+ * @returns `true` when a holder that is not stale owns the lock.
+ */
+export declare function checkIsSetupLockHeld(scope: string): boolean;
+/**
+ * Takes the setup lock for a scope if it is free or abandoned, without waiting.
+ *
+ * One attempt: a live holder — or a lock file that cannot be read — means
+ * `undefined`, and the caller decides whether to try again later.
+ *
+ * @param params - The lock parameters.
+ * @returns A handle whose {@link SetupLock.release} frees the lock, or `undefined` while another run holds it.
+ * @throws If the file system fails for any reason other than the lock file already existing.
+ */
+export declare function tryAcquireSetupLock(params: TryAcquireSetupLockParams): SetupLock | undefined;

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;
 /**