obsidian-integration-testing 12.1.2 → 12.2.0

package/dist/lib/cjs/poll-in-obsidian.cjs

@@ -69,4 +69,4 @@ async function pollInObsidian(params) {
 0 && (module.exports = {
   pollInObsidian
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/poll-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side \"kick off, then poll\" helper over {@link evalInObsidian}.\n *\n * A single `evalInObsidian` closure cannot run longer than CDP's ~30s\n * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole\n * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does\n * it from Node instead: it optionally runs a short `start` closure once to kick\n * the work off, then repeatedly runs a short `poll` closure \u2014 each a separate,\n * well-under-30s eval \u2014 until the Node-side `until` predicate accepts a poll\n * result, or a Node-side timeout elapses. It removes the per-test hand-rolled\n * `evalInObsidian` + `sleep` loop.\n *\n * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is\n * the integration-only wiring (it drives a live Obsidian), covered by an\n * integration test.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian via evalInObsidian) covered by integration tests, not unit tests. */\n\nimport type { Promisable } from 'type-fest';\n\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { ContextArguments } from './context-id.cjs';\nimport type {\n  CommonArguments,\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { ContextId } from './context-id.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { pollUntil } from './poll-until.cjs';\n\nconst DEFAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS = 120_000;\n\n/**\n * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for\n * the shared forwarded fields (`input` / `contextId` / `transport` / `vaultPath`);\n * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side\n * acceptance predicate.\n */\nexport interface PollInObsidianParams<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * A {@link ContextId} shared by `start` and `poll`, so `start` can stash\n   * non-serializable state that `poll` later reads. When omitted, each closure\n   * gets a fresh empty `context`.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Additional arguments passed to both `start` and `poll` (serialized like\n   * {@link EvalInObsidianParams.input}).\n   */\n  readonly input?: Input;\n\n  /**\n   * Delay between `poll` attempts, in milliseconds.\n   *\n   * @default `500`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * The closure polled repeatedly inside Obsidian. Keep it short (well under the\n   * ~30s CDP cap): it should read and return a JSON-serializable status, not\n   * await the long operation itself.\n   */\n  poll(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<PollResult>;\n\n  /**\n   * An optional closure run **once** before polling begins, to kick off the\n   * long-running work (fire-and-forget from Node's perspective). Keep it short \u2014\n   * start the work and return; do not await it to completion here.\n   */\n  start?(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<unknown>;\n\n  /**\n   * Total budget before the poll rejects, in milliseconds.\n   *\n   * @default `120000`\n   */\n  readonly timeoutInMilliseconds?: number;\n\n  /**\n   * Optional detail appended to the timeout error message.\n   */\n  readonly timeoutMessage?: string;\n\n  /**\n   * Override the transport (forwarded to every underlying `evalInObsidian`).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning\n   * `true` resolves {@link pollInObsidian} with that result.\n   */\n  until(this: void, result: PollResult): boolean;\n\n  /**\n   * The vault path to evaluate against (forwarded to every underlying\n   * `evalInObsidian`).\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Kicks off an optional `start` closure once, then polls `poll` from Node until\n * `until` accepts a result or the timeout elapses.\n *\n * @param params - The poll parameters.\n * @returns A {@link Promise} that resolves with the first accepted `poll` result.\n */\nexport async function pollInObsidian<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: PollInObsidianParams<Input, PollResult, TContextId>\n): Promise<PollResult> {\n  const {\n    contextId,\n    input,\n    intervalInMilliseconds = DEFAULT_POLL_INTERVAL_IN_MILLISECONDS,\n    poll,\n    start,\n    timeoutInMilliseconds = DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS,\n    timeoutMessage,\n    transport,\n    until,\n    vaultPath\n  } = params;\n\n  async function runEval<Result>(callback: (functionArguments: CommonArguments & ContextArguments<TContextId> & Input) => Promisable<Result>): Promise<Result> {\n    const evalParams: EvalInObsidianParams<Input, Result, TContextId> = {\n      callback,\n      ...(input !== undefined && { input }),\n      ...(contextId !== undefined && { contextId }),\n      ...(transport !== undefined && { transport }),\n      ...(vaultPath !== undefined && { vaultPath })\n    };\n    return evalInObsidian<Input, Result, TContextId>(evalParams);\n  }\n\n  if (start) {\n    await runEval(start);\n  }\n\n  return pollUntil<PollResult>({\n    attempt: async () => runEval(poll),\n    intervalInMilliseconds,\n    nowInMilliseconds: () => Date.now(),\n    sleep: async (milliseconds: number) => {\n      await sleep(milliseconds);\n    },\n    timeoutInMilliseconds,\n    until,\n    ...(timeoutMessage !== undefined && { timeoutMessage })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,sBAAoC;AAUpC,wBAA0B;AAC1B,8BAA+B;AAC/B,wBAA0B;AAE1B,MAAM,wCAAwC;AAC9C,MAAM,uCAAuC;AAgF7C,eAAsB,eACpB,QACqB;AACrB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,iBAAe,QAAgB,UAA8H;AAC3J,UAAM,aAA8D;AAAA,MAClE;AAAA,MACA,GAAI,UAAU,UAAa,EAAE,MAAM;AAAA,MACnC,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,IAC7C;AACA,eAAO,wCAA0C,UAAU;AAAA,EAC7D;AAEA,MAAI,OAAO;AACT,UAAM,QAAQ,KAAK;AAAA,EACrB;AAEA,aAAO,6BAAsB;AAAA,IAC3B,SAAS,YAAY,QAAQ,IAAI;AAAA,IACjC;AAAA,IACA,mBAAmB,MAAM,KAAK,IAAI;AAAA,IAClC,OAAO,OAAO,iBAAyB;AACrC,gBAAM,gBAAAA,YAAM,YAAY;AAAA,IAC1B;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,mBAAmB,UAAa,EAAE,eAAe;AAAA,EACvD,CAAC;AACH;",
  "names": ["sleep"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/poll-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side \"kick off, then poll\" helper over {@link evalInObsidian}.\n *\n * A single `evalInObsidian` closure cannot run longer than the transport's\n * per-eval cap \u2014 30s by default on both, and a declared number rather than an\n * inherited one: desktop uses `commandTimeoutInMilliseconds`, Android sends\n * `scriptTimeoutInMilliseconds` as its W3C `timeouts.script` capability. Either\n * way an overrun is reported as `EvalCapExceededError`, which names the\n * cap and points here. So a long-running in-Obsidian operation (e.g. a whole\n * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does\n * it from Node instead: it optionally runs a short `start` closure once to kick\n * the work off, then repeatedly runs a short `poll` closure \u2014 each a separate,\n * well-under-30s eval \u2014 until the Node-side `until` predicate accepts a poll\n * result, or a Node-side timeout elapses. It removes the per-test hand-rolled\n * `evalInObsidian` + `sleep` loop.\n *\n * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is\n * the integration-only wiring (it drives a live Obsidian), covered by an\n * integration test.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian via evalInObsidian) covered by integration tests, not unit tests. */\n\nimport type { Promisable } from 'type-fest';\n\nimport { setTimeout as sleep } from 'node:timers/promises';\n\nimport type { ContextArguments } from './context-id.cjs';\nimport type {\n  CommonArguments,\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { ContextId } from './context-id.cjs';\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { pollUntil } from './poll-until.cjs';\n\nconst DEFAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS = 120_000;\n\n/**\n * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for\n * the shared forwarded fields (`input` / `contextId` / `transport` / `vaultPath`);\n * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side\n * acceptance predicate.\n */\nexport interface PollInObsidianParams<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * A {@link ContextId} shared by `start` and `poll`, so `start` can stash\n   * non-serializable state that `poll` later reads. When omitted, each closure\n   * gets a fresh empty `context`.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * Additional arguments passed to both `start` and `poll` (serialized like\n   * {@link EvalInObsidianParams.input}).\n   */\n  readonly input?: Input;\n\n  /**\n   * Delay between `poll` attempts, in milliseconds.\n   *\n   * @default `500`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * The closure polled repeatedly inside Obsidian. Keep it short (well under the\n   * ~30s CDP cap): it should read and return a JSON-serializable status, not\n   * await the long operation itself.\n   */\n  poll(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<PollResult>;\n\n  /**\n   * An optional closure run **once** before polling begins, to kick off the\n   * long-running work (fire-and-forget from Node's perspective). Keep it short \u2014\n   * start the work and return; do not await it to completion here.\n   */\n  start?(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<unknown>;\n\n  /**\n   * Total budget before the poll rejects, in milliseconds.\n   *\n   * @default `120000`\n   */\n  readonly timeoutInMilliseconds?: number;\n\n  /**\n   * Optional detail appended to the timeout error message.\n   */\n  readonly timeoutMessage?: string;\n\n  /**\n   * Override the transport (forwarded to every underlying `evalInObsidian`).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning\n   * `true` resolves {@link pollInObsidian} with that result.\n   */\n  until(this: void, result: PollResult): boolean;\n\n  /**\n   * The vault path to evaluate against (forwarded to every underlying\n   * `evalInObsidian`).\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Kicks off an optional `start` closure once, then polls `poll` from Node until\n * `until` accepts a result or the timeout elapses.\n *\n * @param params - The poll parameters.\n * @returns A {@link Promise} that resolves with the first accepted `poll` result.\n */\nexport async function pollInObsidian<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: PollInObsidianParams<Input, PollResult, TContextId>\n): Promise<PollResult> {\n  const {\n    contextId,\n    input,\n    intervalInMilliseconds = DEFAULT_POLL_INTERVAL_IN_MILLISECONDS,\n    poll,\n    start,\n    timeoutInMilliseconds = DEFAULT_POLL_TIMEOUT_IN_MILLISECONDS,\n    timeoutMessage,\n    transport,\n    until,\n    vaultPath\n  } = params;\n\n  async function runEval<Result>(callback: (functionArguments: CommonArguments & ContextArguments<TContextId> & Input) => Promisable<Result>): Promise<Result> {\n    const evalParams: EvalInObsidianParams<Input, Result, TContextId> = {\n      callback,\n      ...(input !== undefined && { input }),\n      ...(contextId !== undefined && { contextId }),\n      ...(transport !== undefined && { transport }),\n      ...(vaultPath !== undefined && { vaultPath })\n    };\n    return evalInObsidian<Input, Result, TContextId>(evalParams);\n  }\n\n  if (start) {\n    await runEval(start);\n  }\n\n  return pollUntil<PollResult>({\n    attempt: async () => runEval(poll),\n    intervalInMilliseconds,\n    nowInMilliseconds: () => Date.now(),\n    sleep: async (milliseconds: number) => {\n      await sleep(milliseconds);\n    },\n    timeoutInMilliseconds,\n    until,\n    ...(timeoutMessage !== undefined && { timeoutMessage })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,sBAAoC;AAUpC,wBAA0B;AAC1B,8BAA+B;AAC/B,wBAA0B;AAE1B,MAAM,wCAAwC;AAC9C,MAAM,uCAAuC;AAgF7C,eAAsB,eACpB,QACqB;AACrB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,wBAAwB;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,iBAAe,QAAgB,UAA8H;AAC3J,UAAM,aAA8D;AAAA,MAClE;AAAA,MACA,GAAI,UAAU,UAAa,EAAE,MAAM;AAAA,MACnC,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,MAC3C,GAAI,cAAc,UAAa,EAAE,UAAU;AAAA,IAC7C;AACA,eAAO,wCAA0C,UAAU;AAAA,EAC7D;AAEA,MAAI,OAAO;AACT,UAAM,QAAQ,KAAK;AAAA,EACrB;AAEA,aAAO,6BAAsB;AAAA,IAC3B,SAAS,YAAY,QAAQ,IAAI;AAAA,IACjC;AAAA,IACA,mBAAmB,MAAM,KAAK,IAAI;AAAA,IAClC,OAAO,OAAO,iBAAyB;AACrC,gBAAM,gBAAAA,YAAM,YAAY;AAAA,IAC1B;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,mBAAmB,UAAa,EAAE,eAAe;AAAA,EACvD,CAAC;AACH;",
  "names": ["sleep"]
}


package/dist/lib/cjs/poll-in-obsidian.d.cts

@@ -3,8 +3,12 @@
  *
  * Node-side "kick off, then poll" helper over {@link evalInObsidian}.
  *
- * A single `evalInObsidian` closure cannot run longer than CDP's ~30s
- * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole
+ * A single `evalInObsidian` closure cannot run longer than the transport's
+ * per-eval cap — 30s by default on both, and a declared number rather than an
+ * inherited one: desktop uses `commandTimeoutInMilliseconds`, Android sends
+ * `scriptTimeoutInMilliseconds` as its W3C `timeouts.script` capability. Either
+ * way an overrun is reported as `EvalCapExceededError`, which names the
+ * cap and points here. So a long-running in-Obsidian operation (e.g. a whole
  * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does
  * it from Node instead: it optionally runs a short `start` closure once to kick
  * the work off, then repeatedly runs a short `poll` closure — each a separate,

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": "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",
  "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;