obsidian-integration-testing 12.1.2 → 12.2.0

package/dist/lib/esm/setup-lock.d.mts

@@ -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/esm/setup-lock.mjs

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import process from "node:process";
 import { errorToString } from "./error-to-string.mjs";
 import { log } from "./log.mjs";
+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;
@@ -50,9 +51,8 @@ async function acquireSetupLock(params) {
       });
     }
     const info = readLockFileInfo(lockFilePath);
-    if (info && checkIsLockStale(info)) {
-      log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);
-      rmSync(lockFilePath, { force: true });
+    if (info && checkIsLockStale(info, HEARTBEAT_STALE_IN_MILLISECONDS)) {
+      stealStaleLock({ info, label, lockFilePath, scope });
       if (Date.now() >= deadlineInMilliseconds) {
         throw createTimeoutError({
           info,
@@ -84,10 +84,48 @@ async function acquireSetupLock(params) {
     await delay(POLL_INTERVAL_IN_MILLISECONDS);
   }
 }
-function checkIsLockStale(info) {
+function checkIsSetupLockHeld(scope) {
+  let text;
+  try {
+    text = 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);
+  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 === hostname()) {
-    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > HEARTBEAT_STALE_IN_MILLISECONDS;
+    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > heartbeatStaleInMilliseconds;
   }
   return silentForInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;
 }
@@ -220,6 +258,10 @@ function readLockFileInfo(lockFilePath) {
     return null;
   }
 }
+function stealStaleLock(params) {
+  log(`[integration-setup:${params.label}] Stealing stale '${params.scope}' setup lock from ${describeInfo(params.info)}.`);
+  rmSync(params.lockFilePath, { force: true });
+}
 function tryCreateLockFile(lockFilePath, label) {
   const nowInMilliseconds = Date.now();
   const info = {
@@ -240,6 +282,9 @@ function tryCreateLockFile(lockFilePath, label) {
   }
 }
 export {
-  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.mjs';\nimport { log } from './log.mjs';\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": "AA0BA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,OAAO,aAAa;AAEpB,SAAS,qBAAqB;AAC9B,SAAS,WAAW;AAEpB,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;AA+KvC,eAAsB,iBAAiB,QAAoD;AACzF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,eAAe,gBAAgB,KAAK;AAC1C,YAAU,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,IAAI,GAAG;AAClC,UAAI,sBAAsB,KAAK,qBAAqB,KAAK,qBAAqB,aAAa,IAAI,CAAC,GAAG;AACnG,aAAO,cAAc,EAAE,OAAO,KAAK,CAAC;AAGpC,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,UAAI,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;AAoBA,SAAS,iBAAiB,MAA6B;AACrD,QAAM,0BAA0B,KAAK,IAAI,IAAI,4BAA4B,IAAI;AAE7E,MAAI,KAAK,aAAa,SAAS,GAAG;AAChC,WAAO,CAAC,oBAAoB,KAAK,GAAG,KAAK,0BAA0B;AAAA,EACrE;AAEA,SAAO,0BAA0B;AACnC;AAQA,SAAS,eAAe,MAA6B;AACnD,SAAO,KAAK,QAAQ,QAAQ,OAAO,KAAK,aAAa,SAAS;AAChE;AAQA,SAAS,oBAAoB,KAAsB;AACjD,MAAI;AACF,YAAQ,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,QAAI,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,YAAI,sBAAsB,KAAK,kBAAkB,KAAK,kDAA6C,aAAa,IAAI,CAAC,GAAG;AACxH;AAAA,MACF;AACA,aAAO,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,kBAAc,cAAc,KAAK,UAAU,aAAa,CAAC;AAAA,EAC3D,SAAS,OAAgB;AAGvB,QAAI,sBAAsB,KAAK,iDAAiD,cAAc,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,SAAO,KAAK,OAAO,GAAG,aAAa;AACrC;AAQA,SAAS,gBAAgB,OAAuB;AAC9C,SAAO,KAAK,iBAAiB,GAAG,GAAG,KAAK,GAAG,gBAAgB,EAAE;AAC/D;AAQA,SAAS,iBAAiB,cAA2C;AACnE,MAAI;AACF,WAAO,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;AAAA,EACvD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAUA,SAAS,kBAAkB,cAAsB,OAAoC;AACnF,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,OAAqB;AAAA,IACzB,0BAA0B;AAAA,IAC1B,2BAA2B;AAAA,IAC3B,UAAU,SAAS;AAAA,IACnB;AAAA,IACA,KAAK,QAAQ;AAAA,EACf;AAEA,MAAI;AACF,kBAAc,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": []
}

+//# 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.mjs';\nimport { log } from './log.mjs';\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": "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",
  "names": []
}


package/dist/lib/esm/transport-appium.d.mts

@@ -103,6 +103,16 @@ export interface AppiumTransportConfig {
      * Target platform. Determines WebView context naming and device file paths.
      */
     platform: 'android' | 'ios';
+    /**
+     * The per-script cap, in milliseconds, this session was given as its W3C
+     * `timeouts.script` capability.
+     *
+     * Carried only so a script timeout can be reported with the number that
+     * produced it; the capability itself is set when the session is created.
+     *
+     * @default `30000`
+     */
+    scriptTimeoutInMilliseconds?: number;
     /**
      * Whether registering a vault also prunes the **other** `temp-vault-*`
      * registrations earlier runs left in Obsidian Mobile's `localStorage`.
@@ -179,9 +189,17 @@ export declare class AppiumTransport implements ObsidianTransport {
      * can time out on slow emulators).
      */
     private isInWebViewContext;
+    /**
+     * Whether the previous eval ended in a cap overrun, so the next one is owed the recovery grace.
+     *
+     * The abandoned closure is still running in the guest, and Appium serializes commands per session, so
+     * the next command queues behind whatever is left of it. See {@link AppiumTransport.evaluateWithinCap}.
+     */
+    private isRecoveringFromCapOverrun;
     private readonly isSessionOwner;
     private readonly layoutReadyTimeoutInMilliseconds;
     private readonly platform;
+    private readonly scriptTimeoutInMilliseconds;
     private readonly shouldSweepLeftovers;
     private readonly vaultBasePath;
     private readonly webviewTimeoutInMilliseconds;
@@ -345,6 +363,23 @@ export declare class AppiumTransport implements ObsidianTransport {
      * to Chrome or other WebViews on the device.
      */
     private ensureWebViewContext;
+    /**
+     * Runs one Execute Script under the per-eval cap, raising {@link EvalCapExceededError} if it outlasts it.
+     *
+     * The cap covers the script ALONE — `ensureWebViewContext` and `ensureInputChannel` run before it,
+     * because a `switchContext` legitimately costs ~17s (**L19**) and charging that to a test's own budget
+     * would report the harness's setup as the test's overrun.
+     *
+     * The abandoned request is deliberately left in flight rather than cancelled. Nothing can cancel it:
+     * `Runtime.terminateExecution` over the transport's own CDP channel was measured releasing nothing,
+     * and a guest-side abort hook could not even be installed in time. What the same runs did show is that
+     * the session usually keeps serving — a vault read-back was answered 528ms after one such abandonment,
+     * with the session free — so bounding the wait costs a test its closure, not the rest of its suite.
+     *
+     * @param script - The script to run, already wrapped in its `return (...)`.
+     * @returns The script's result.
+     */
+    private evaluateWithinCap;
     /**
      * Converts a host-side vault path to the device-side path.
      *