obsidian-integration-testing 9.1.0 → 9.2.0

package/dist/lib/esm/run-version-matrix.d.mts

@@ -0,0 +1,49 @@
+/**
+ * @file
+ *
+ * Integration-time runner that executes a suite once per **distinct** supported
+ * Obsidian version.
+ *
+ * Thin glue over the pure `version-matrix.ts` decision layer: the only things
+ * that happen here are the single manifest fetch and the logging. Everything
+ * that decides — normalizing the requested specifiers, resolving them,
+ * de-duplicating on the resolved version, sequencing the runs, and building the
+ * failure summary — is pure and unit-tested next door.
+ *
+ * The loop lives above the transport rather than inside it because a test
+ * framework's global setup cannot re-run its own test files: it launches one
+ * instance for one run. Keeping the loop framework-agnostic (the caller supplies
+ * `run`) is what lets Vitest, Jest, and manual consumers all inherit it (L6).
+ */
+import type { ObsidianVersionMatrixEntry } from './version-matrix.mjs';
+/**
+ * Parameters for {@link runObsidianVersionMatrix}.
+ */
+export interface RunObsidianVersionMatrixParams {
+    /**
+     * Runs the suites against one concrete Obsidian version, throwing on failure.
+     *
+     * The entry's `version` is the concrete `x.y.z` to pin — typically forwarded to
+     * the test-runner child as `OBSIDIAN_VERSION`.
+     */
+    readonly run: (entry: ObsidianVersionMatrixEntry) => Promise<void> | void;
+    /**
+     * The version specifiers to run against: an array, or a comma-separated string
+     * so an env var can be passed straight through.
+     *
+     * Each accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.
+     * Defaults to both ends of the supported range (G99) when omitted or empty, and
+     * the list is always de-duplicated on the **resolved** version — so when public
+     * has caught up to catalyst, the suites run once.
+     */
+    readonly versions?: readonly string[] | string | undefined;
+}
+/**
+ * Runs a suite once per distinct supported Obsidian version.
+ *
+ * @param params - The per-version runner and the requested versions.
+ * @returns A {@link Promise} that resolves once every version has run successfully.
+ * @throws Error if no version could be resolved, or an {@link AggregateError}
+ *   naming every version whose run failed.
+ */
+export declare function runObsidianVersionMatrix(params: RunObsidianVersionMatrixParams): Promise<void>;

package/dist/lib/esm/run-version-matrix.mjs

@@ -0,0 +1,48 @@
+import { log } from "./log.mjs";
+import { fetchDesktopReleasesManifest } from "./obsidian-version-switch.mjs";
+import {
+  buildVersionMatrix,
+  formatVersionMatrixPlan,
+  formatVersionMatrixRunHeader,
+  hasChannelSpec,
+  resolveRequestedSpecs,
+  resolveVersionSpecs,
+  runVersionMatrixEntries
+} from "./version-matrix.mjs";
+async function runObsidianVersionMatrix(params) {
+  const { run, versions } = params;
+  const { isDefault, specs } = resolveRequestedSpecs(versions);
+  const manifest = hasChannelSpec(specs) ? await fetchDesktopReleasesManifest() : void 0;
+  const { droppedSpecs, resolvedSpecs } = resolveVersionSpecs({
+    manifest,
+    // The default list must not break every consumer's gate when a channel is
+    // Momentarily absent from the manifest; an explicitly requested specifier
+    // That cannot resolve is a real error.
+    shouldTolerateUnresolvableSpecs: isDefault,
+    specs
+  });
+  for (const { reason, spec } of droppedSpecs) {
+    logMatrix(`Skipping "${spec}": ${reason}`);
+  }
+  const entries = buildVersionMatrix(resolvedSpecs);
+  logPlan(resolvedSpecs, entries);
+  await runVersionMatrixEntries({
+    entries,
+    onEntryStart: (headerParams) => {
+      logMatrix(formatVersionMatrixRunHeader(headerParams));
+    },
+    run
+  });
+}
+function logMatrix(message) {
+  log(`[version-matrix] ${message}`);
+}
+function logPlan(resolvedSpecs, entries) {
+  for (const line of formatVersionMatrixPlan({ entries, resolvedSpecs })) {
+    logMatrix(line);
+  }
+}
+export {
+  runObsidianVersionMatrix
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -13,9 +13,15 @@
  * This lock makes the second run **wait** for the first to finish instead of
  * running concurrently. It is held for the entire run: acquired at the start of
  * the core setup and released by the core teardown (and by the process cleanup
- * handlers). The lock is a sentinel file in a shared temp directory, carrying
- * the holder's PID so a run that crashed without releasing leaves a lock that
- * the next run detects as stale and steals.
+ * handlers). The lock is a sentinel file in a shared temp directory, and its
+ * holder keeps a **heartbeat** timestamp inside it fresh for as long as it holds
+ * the lock — so a run that crashed without releasing stops beating and the next
+ * run detects the lock as stale and steals it.
+ *
+ * The heartbeat, not the holder's PID, is what proves a holder is still there: a
+ * PID probe only answers "does *a* process with this PID exist", which a
+ * recycled PID satisfies long after the real holder died — leaving every later
+ * run to block for the full acquisition timeout.
  */
 /**
  * Parameters for {@link acquireSetupLock}.

package/dist/lib/esm/setup-lock.mjs

@@ -10,12 +10,19 @@ import {
 } from "node:os";
 import { join } from "node:path";
 import process from "node:process";
+import { errorToString } from "./error-to-string.mjs";
 import { log } from "./log.mjs";
 const LOCK_DIR_NAME = "obsidian-integration-testing";
 const LOCK_FILE_SUFFIX = ".setup.lock";
 const POLL_INTERVAL_IN_MILLISECONDS = 500;
 const MILLISECONDS_PER_SECOND = 1e3;
 const SECONDS_PER_MINUTE = 60;
+const HEARTBEAT_INTERVAL_IN_SECONDS = 5;
+const HEARTBEAT_INTERVAL_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;
+const MISSED_HEARTBEATS_BEFORE_STALE = 24;
+const HEARTBEAT_STALE_IN_MILLISECONDS = HEARTBEAT_INTERVAL_IN_MILLISECONDS * MISSED_HEARTBEATS_BEFORE_STALE;
+const WAIT_LOG_INTERVAL_IN_SECONDS = 30;
+const WAIT_LOG_INTERVAL_IN_MILLISECONDS = WAIT_LOG_INTERVAL_IN_SECONDS * MILLISECONDS_PER_SECOND;
 const STALE_LOCK_AGE_IN_MINUTES = 30;
 const DEFAULT_TIMEOUT_IN_MINUTES = 60;
 const STALE_LOCK_AGE_IN_MILLISECONDS = STALE_LOCK_AGE_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
@@ -29,42 +36,119 @@ async function acquireSetupLock(params) {
   const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;
   const lockFilePath = getLockFilePath(scope);
   mkdirSync(getLockDir(), { recursive: true });
-  const deadlineInMilliseconds = Date.now() + timeoutInMilliseconds;
-  let hasLoggedWait = false;
+  const startedAtInMilliseconds = Date.now();
+  const deadlineInMilliseconds = startedAtInMilliseconds + timeoutInMilliseconds;
+  let lastLoggedWaitAtInMilliseconds = null;
   for (; ; ) {
-    if (tryCreateLockFile(lockFilePath, label)) {
-      return createLockHandle(lockFilePath);
+    const ownInfo = tryCreateLockFile(lockFilePath, label);
+    if (ownInfo) {
+      return createLockHandle({
+        label,
+        lockFilePath,
+        ownInfo,
+        scope
+      });
     }
     const info = readLockFileInfo(lockFilePath);
-    if (info && isLockStale(info)) {
+    if (info && checkIsLockStale(info)) {
       log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);
       rmSync(lockFilePath, { force: true });
+      if (Date.now() >= deadlineInMilliseconds) {
+        throw createTimeoutError({
+          info,
+          scope,
+          timeoutInMilliseconds
+        });
+      }
       continue;
     }
-    if (Date.now() >= deadlineInMilliseconds) {
-      throw new Error(
-        `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock held by ${describeHolder(info)}. Another integration-test run is still in progress.`
-      );
+    const nowInMilliseconds = Date.now();
+    if (nowInMilliseconds >= deadlineInMilliseconds) {
+      throw createTimeoutError({
+        info,
+        scope,
+        timeoutInMilliseconds
+      });
     }
-    if (!hasLoggedWait) {
-      hasLoggedWait = true;
-      log(`[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released...`);
+    const shouldLogWait = lastLoggedWaitAtInMilliseconds === null || nowInMilliseconds - lastLoggedWaitAtInMilliseconds >= WAIT_LOG_INTERVAL_IN_MILLISECONDS;
+    if (shouldLogWait) {
+      lastLoggedWaitAtInMilliseconds = nowInMilliseconds;
+      log(formatWaitMessage({
+        info,
+        label,
+        remainingInMilliseconds: deadlineInMilliseconds - nowInMilliseconds,
+        scope,
+        waitedInMilliseconds: nowInMilliseconds - startedAtInMilliseconds
+      }));
     }
     await delay(POLL_INTERVAL_IN_MILLISECONDS);
   }
 }
-function createLockHandle(lockFilePath) {
+function checkIsLockStale(info) {
+  const silentForInMilliseconds = Date.now() - getLastSeenAtInMilliseconds(info);
+  if (info.hostname === hostname()) {
+    return !checkIsProcessAlive(info.pid) || silentForInMilliseconds > HEARTBEAT_STALE_IN_MILLISECONDS;
+  }
+  return silentForInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;
+}
+function checkIsOwnLock(info) {
+  return info.pid === process.pid && info.hostname === hostname();
+}
+function checkIsProcessAlive(pid) {
+  try {
+    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function createLockHandle(params) {
+  const {
+    label,
+    lockFilePath,
+    ownInfo,
+    scope
+  } = params;
   let isReleased = false;
+  const heartbeatTimer = setInterval(() => {
+    const isStillOurs = refreshHeartbeat({
+      label,
+      lockFilePath,
+      ownInfo
+    });
+    if (isStillOurs) {
+      return;
+    }
+    clearInterval(heartbeatTimer);
+    log(`[integration-setup:${label}] The '${scope}' setup lock is no longer ours \u2014 another run took it over. Heartbeat stopped.`);
+  }, HEARTBEAT_INTERVAL_IN_MILLISECONDS);
+  heartbeatTimer.unref();
   return {
     release() {
       if (isReleased) {
         return;
       }
       isReleased = true;
+      clearInterval(heartbeatTimer);
+      const info = readLockFileInfo(lockFilePath);
+      if (info && !checkIsOwnLock(info)) {
+        log(`[integration-setup:${label}] Leaving the '${scope}' setup lock in place \u2014 it now belongs to ${describeInfo(info)}.`);
+        return;
+      }
       rmSync(lockFilePath, { force: true });
     }
   };
 }
+function createTimeoutError(params) {
+  const {
+    info,
+    scope,
+    timeoutInMilliseconds
+  } = params;
+  return new Error(
+    `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock held by ${describeHolder(info)}. Another integration-test run is still in progress.`
+  );
+}
 function delay(milliseconds) {
   return new Promise((resolve) => {
     setTimeout(resolve, milliseconds);
@@ -76,52 +160,81 @@ function describeHolder(info) {
 function describeInfo(info) {
   return `pid ${String(info.pid)} (${info.label}) on ${info.hostname}`;
 }
+function formatDuration(milliseconds) {
+  const totalSeconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);
+  const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);
+  const seconds = totalSeconds % SECONDS_PER_MINUTE;
+  return minutes > 0 ? `${String(minutes)}m ${String(seconds)}s` : `${String(seconds)}s`;
+}
+function formatWaitMessage(params) {
+  const {
+    info,
+    label,
+    remainingInMilliseconds,
+    scope,
+    waitedInMilliseconds
+  } = params;
+  const heldFor = info ? `, held for ${formatDuration(Date.now() - info.acquiredAtInMilliseconds)}` : "";
+  return `[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released (waited ${formatDuration(waitedInMilliseconds)}${heldFor}, giving up in ${formatDuration(remainingInMilliseconds)})...`;
+}
 function getErrorCode(error) {
   if (error instanceof Error && "code" in error && typeof error.code === "string") {
     return error.code;
   }
   return void 0;
 }
+function getLastSeenAtInMilliseconds(info) {
+  return info.heartbeatAtInMilliseconds ?? info.acquiredAtInMilliseconds;
+}
 function getLockDir() {
   return join(tmpdir(), LOCK_DIR_NAME);
 }
 function getLockFilePath(scope) {
   return join(getLockDir(), `${scope}${LOCK_FILE_SUFFIX}`);
 }
-function isLockStale(info) {
-  if (info.hostname === hostname()) {
-    return !isProcessAlive(info.pid);
-  }
-  return Date.now() - info.acquiredAtInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
-    return true;
-  } catch (error) {
-    return getErrorCode(error) === "EPERM";
-  }
-}
 function readLockFileInfo(lockFilePath) {
   try {
     return JSON.parse(readFileSync(lockFilePath, "utf-8"));
   } catch {
-    return void 0;
+    return null;
+  }
+}
+function refreshHeartbeat(params) {
+  const {
+    label,
+    lockFilePath,
+    ownInfo
+  } = params;
+  const info = readLockFileInfo(lockFilePath);
+  if (info && !checkIsOwnLock(info)) {
+    return false;
+  }
+  const refreshedInfo = {
+    ...ownInfo,
+    heartbeatAtInMilliseconds: Date.now()
+  };
+  try {
+    writeFileSync(lockFilePath, JSON.stringify(refreshedInfo));
+  } catch (error) {
+    log(`[integration-setup:${label}] Failed to refresh the setup lock heartbeat: ${errorToString(error)}`);
   }
+  return true;
 }
 function tryCreateLockFile(lockFilePath, label) {
+  const nowInMilliseconds = Date.now();
   const info = {
-    acquiredAtInMilliseconds: Date.now(),
+    acquiredAtInMilliseconds: nowInMilliseconds,
+    heartbeatAtInMilliseconds: nowInMilliseconds,
     hostname: hostname(),
     label,
     pid: process.pid
   };
   try {
     writeFileSync(lockFilePath, JSON.stringify(info), { flag: "wx" });
-    return true;
+    return info;
   } catch (error) {
     if (getErrorCode(error) === "EEXIST") {
-      return false;
+      return null;
     }
     throw error;
   }
@@ -129,4 +242,4 @@ function tryCreateLockFile(lockFilePath, label) {
 export {
   acquireSetupLock
 };
-//# 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, carrying\n * the holder's PID so a run that crashed without releasing leaves a lock that\n * the next run detects as stale and steals.\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 { 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 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  /** Short transport label for log messages (e.g. `\"obsidian-cli\"`). */\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  /** Releases the lock. Safe to call more than once. */\n  release(): void;\n}\n\n/**\n * The JSON payload stored inside a lock file, identifying the holder.\n */\ninterface LockFileInfo {\n  /** When the lock was acquired (`Date.now()` epoch milliseconds). */\n  readonly acquiredAtInMilliseconds: number;\n\n  /** The host that holds the lock (PID liveness is only valid on the same host). */\n  readonly hostname: string;\n\n  /** The transport label of the holding run. */\n  readonly label: string;\n\n  /** The process ID of the holding run. */\n  readonly pid: number;\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(getLockDir(), { recursive: true });\n\n  const deadlineInMilliseconds = Date.now() + timeoutInMilliseconds;\n  let hasLoggedWait = false;\n\n  for (;;) {\n    if (tryCreateLockFile(lockFilePath, label)) {\n      return createLockHandle(lockFilePath);\n    }\n\n    const info = readLockFileInfo(lockFilePath);\n    if (info && isLockStale(info)) {\n      log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);\n      rmSync(lockFilePath, { force: true });\n      continue;\n    }\n\n    if (Date.now() >= deadlineInMilliseconds) {\n      throw 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    if (!hasLoggedWait) {\n      hasLoggedWait = true;\n      log(`[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released...`);\n    }\n\n    await delay(POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Creates a {@link SetupLock} handle that removes the lock file on release.\n *\n * @param lockFilePath - The path to the lock file to remove on release.\n * @returns The lock handle.\n */\nfunction createLockHandle(lockFilePath: string): SetupLock {\n  let isReleased = false;\n  return {\n    release(): void {\n      if (isReleased) {\n        return;\n      }\n      isReleased = true;\n      rmSync(lockFilePath, { force: true });\n    }\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 `undefined` if it could not be read.\n * @returns A description string.\n */\nfunction describeHolder(info: LockFileInfo | undefined): 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 * 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 the shared lock directory inside the OS temp directory.\n *\n * @returns The absolute path to the lock directory.\n */\nfunction getLockDir(): 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(getLockDir(), `${scope}${LOCK_FILE_SUFFIX}`);\n}\n\n/**\n * Determines whether a lock can be considered abandoned.\n *\n * On the same host, the holder's PID is probed directly: a dead PID means the\n * run crashed without releasing. On a different host (a shared/network temp\n * directory) the PID cannot be probed, so an age 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 isLockStale(info: LockFileInfo): boolean {\n  if (info.hostname === hostname()) {\n    return !isProcessAlive(info.pid);\n  }\n\n  return Date.now() - info.acquiredAtInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;\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 isProcessAlive(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 * 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 `undefined` if it could not be read.\n */\nfunction readLockFileInfo(lockFilePath: string): LockFileInfo | undefined {\n  try {\n    return JSON.parse(readFileSync(lockFilePath, 'utf-8')) as LockFileInfo;\n  } catch {\n    return undefined;\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 `true` if the lock was acquired, `false` if it 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): boolean {\n  const info: LockFileInfo = {\n    acquiredAtInMilliseconds: Date.now(),\n    hostname: hostname(),\n    label,\n    pid: process.pid\n  };\n\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(info), { flag: 'wx' });\n    return true;\n  } catch (error: unknown) {\n    if (getErrorCode(error) === 'EEXIST') {\n      return false;\n    }\n    throw error;\n  }\n}\n"],
  "mappings": "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",
  "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\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  /** Short transport label for log messages (e.g. `\"obsidian-cli\"`). */\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  /** Releases the lock. Safe to call more than once. */\n  release(): void;\n}\n\n/**\n * Parameters for {@link createLockHandle}.\n */\ninterface CreateLockHandleParams {\n  /** The transport label of this run. */\n  readonly label: string;\n\n  /** The path to the lock file this run just created. */\n  readonly lockFilePath: string;\n\n  /** The lock info this run wrote when it acquired the lock. */\n  readonly ownInfo: LockFileInfo;\n\n  /** The lock scope, for log messages. */\n  readonly scope: string;\n}\n\n/**\n * Parameters for {@link createTimeoutError}.\n */\ninterface CreateTimeoutErrorParams {\n  /** The current holder's lock info, or `null` if it could not be read. */\n  readonly info: LockFileInfo | null;\n\n  /** The lock scope. */\n  readonly scope: string;\n\n  /** The timeout that elapsed. */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link formatWaitMessage}.\n */\ninterface FormatWaitMessageParams {\n  /** The current holder's lock info, or `null` if it could not be read. */\n  readonly info: LockFileInfo | null;\n\n  /** The transport label of the waiting run. */\n  readonly label: string;\n\n  /** How much of the acquisition timeout is left. */\n  readonly remainingInMilliseconds: number;\n\n  /** The lock scope. */\n  readonly scope: string;\n\n  /** How long this run has been waiting so far. */\n  readonly waitedInMilliseconds: number;\n}\n\n/**\n * The JSON payload stored inside a lock file, identifying the holder.\n */\ninterface LockFileInfo {\n  /** When the lock was acquired (`Date.now()` epoch milliseconds). */\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  /** The host that holds the lock (PID liveness is only valid on the same host). */\n  readonly hostname: string;\n\n  /** The transport label of the holding run. */\n  readonly label: string;\n\n  /** The process ID of the holding run. */\n  readonly pid: number;\n}\n\n/**\n * Parameters for {@link refreshHeartbeat}.\n */\ninterface RefreshHeartbeatParams {\n  /** The transport label of this run. */\n  readonly label: string;\n\n  /** The path to the lock file to refresh. */\n  readonly lockFilePath: string;\n\n  /** The lock info this run wrote when it acquired the lock. */\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(getLockDir(), { 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 = refreshHeartbeat({\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 * 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 getLockDir(): 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(getLockDir(), `${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 * 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 refreshHeartbeat(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 * 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/temp-vault.mjs

@@ -15,6 +15,7 @@ import {
   relative
 } from "node:path";
 import { getTransportOptions } from "./context-provider.mjs";
+import { TEMP_VAULT_DIR_PREFIX } from "./leftover-cleanup.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
 import {
   registerVault,
@@ -33,7 +34,7 @@ class TempVault {
    * @param path - An explicit vault path. If omitted, a temp directory is created.
    */
   constructor(path) {
-    this.path = path ?? mkdtempSync(join(tmpdir(), "temp-vault-"));
+    this.path = path ?? mkdtempSync(join(tmpdir(), TEMP_VAULT_DIR_PREFIX));
   }
   /**
    * Unregisters the vault from Obsidian and deletes the temp directory.
@@ -153,4 +154,4 @@ async function retryRm(path) {
 export {
   TempVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temp-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Manages temporary vault lifecycle for integration tests.\n */\n\nimport {\n  mkdirSync,\n  mkdtempSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  readdir,\n  readFile,\n  rm\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  dirname,\n  join,\n  relative\n} from 'node:path';\n\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\n\n/**\n * Content value for a single entry in a {@link PopulateFiles} map.\n *\n * - `string` \u2014 text file (written as UTF-8).\n * - `Uint8Array` \u2014 binary file (written as raw bytes; `Buffer` is accepted\n *   because `Buffer extends Uint8Array`).\n * - `undefined` \u2014 empty folder (the key **must** end with `/`).\n */\nexport type PopulateFileContent = string | Uint8Array | undefined;\n\n/**\n * A map of vault-relative paths to their content, used by\n * {@link TempVault.populate}.\n *\n * Paths ending with `/` denote folders and **must** have an `undefined` value.\n * All other paths are written as files.\n */\nexport type PopulateFilesParams = Record<string, PopulateFileContent>;\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10000;\n\n/**\n * A temporary Obsidian vault for integration tests.\n *\n * Creates a temp directory and registers it in the running Obsidian instance\n * so that the Obsidian CLI can target it via `cwd`.\n */\nexport class TempVault {\n  /**\n   * The absolute path to the temporary vault.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a new temp vault.\n   *\n   * @param path - An explicit vault path. If omitted, a temp directory is created.\n   */\n  public constructor(path?: string) {\n    this.path = path ?? mkdtempSync(join(tmpdir(), 'temp-vault-'));\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and deletes the temp directory.\n   *\n   * @param transportOverride - An explicit transport to use when unregistering.\n   *   When omitted, falls back to the transport configured via the context provider.\n   */\n  public async dispose(transportOverride?: ObsidianTransport): Promise<void> {\n    try {\n      await unregisterVault(this.path, transportOverride);\n    } finally {\n      await retryRm(this.path);\n    }\n  }\n\n  /**\n   * Writes files and folders into the vault directory.\n   * Parent directories are created automatically.\n   *\n   * - `string` values are written as UTF-8 text files.\n   * - `Uint8Array` values (including `Buffer`) are written as binary files.\n   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: PopulateFilesParams): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== undefined) {\n          throw new Error(`Folder path \"${filePath}\" must have undefined content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        if (content === undefined) {\n          throw new Error(`File path \"${filePath}\" must have defined content; use a trailing \"/\" for folders`);\n        }\n        mkdirSync(dirname(fullPath), { recursive: true });\n        writeFileSync(fullPath, content);\n      }\n    }\n  }\n\n  /**\n   * Registers this vault in the running Obsidian instance so the CLI can target it.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async register(transportOverride?: ObsidianTransport): Promise<void> {\n    await registerVault(this.path, transportOverride);\n  }\n\n  /**\n   * Async disposable support for `await using`.\n   *\n   * @returns A promise that resolves when the vault is disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    return this.dispose();\n  }\n\n  /* v8 ignore start -- Integration-time code that requires a running transport. */\n\n  /**\n   * Pushes all files from the local staging directory to the target device\n   * via the active transport's `pushFiles()`.\n   *\n   * On desktop transports this is a no-op (files are already local).\n   * On mobile transports (Appium) this pushes files to the device.\n   *\n   * Call this after {@link populate} and before {@link register} when using\n   * a mobile transport.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async syncToDevice(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n    if (!transport.pushFiles) {\n      return;\n    }\n\n    const files = await this.collectFiles(this.path);\n    await transport.pushFiles(this.path, files);\n  }\n\n  /**\n   * Recursively reads all files from a directory into a flat map.\n   *\n   * @param dir - The directory to read.\n   * @returns A map of relative file paths to content buffers.\n   */\n  private async collectFiles(dir: string): Promise<Record<string, Uint8Array>> {\n    const result: Record<string, Uint8Array> = {};\n    const entries = await readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name);\n      const relativePath = relative(this.path, fullPath);\n\n      if (entry.isDirectory()) {\n        Object.assign(result, await this.collectFiles(fullPath));\n      } else {\n        result[relativePath] = await readFile(fullPath);\n      }\n    }\n\n    return result;\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Retries `rm` until it succeeds or times out.\n * Obsidian may hold file locks briefly after a window is destroyed.\n *\n * @param path - The path to the directory to remove.\n * @returns A promise that resolves when the directory is removed.\n */\nasync function retryRm(path: string): Promise<void> {\n  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      await rm(path, { force: true, recursive: true });\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);\n      });\n    }\n  }\n  // Final attempt \u2014 let it throw.\n  await rm(path, { force: true, recursive: true });\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temp-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Manages temporary vault lifecycle for integration tests.\n */\n\nimport {\n  mkdirSync,\n  mkdtempSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  readdir,\n  readFile,\n  rm\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  dirname,\n  join,\n  relative\n} from 'node:path';\n\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\n\n/**\n * Content value for a single entry in a {@link PopulateFiles} map.\n *\n * - `string` \u2014 text file (written as UTF-8).\n * - `Uint8Array` \u2014 binary file (written as raw bytes; `Buffer` is accepted\n *   because `Buffer extends Uint8Array`).\n * - `undefined` \u2014 empty folder (the key **must** end with `/`).\n */\nexport type PopulateFileContent = string | Uint8Array | undefined;\n\n/**\n * A map of vault-relative paths to their content, used by\n * {@link TempVault.populate}.\n *\n * Paths ending with `/` denote folders and **must** have an `undefined` value.\n * All other paths are written as files.\n */\nexport type PopulateFilesParams = Record<string, PopulateFileContent>;\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10000;\n\n/**\n * A temporary Obsidian vault for integration tests.\n *\n * Creates a temp directory and registers it in the running Obsidian instance\n * so that the Obsidian CLI can target it via `cwd`.\n */\nexport class TempVault {\n  /**\n   * The absolute path to the temporary vault.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a new temp vault.\n   *\n   * @param path - An explicit vault path. If omitted, a temp directory is created.\n   */\n  public constructor(path?: string) {\n    this.path = path ?? mkdtempSync(join(tmpdir(), TEMP_VAULT_DIR_PREFIX));\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and deletes the temp directory.\n   *\n   * @param transportOverride - An explicit transport to use when unregistering.\n   *   When omitted, falls back to the transport configured via the context provider.\n   */\n  public async dispose(transportOverride?: ObsidianTransport): Promise<void> {\n    try {\n      await unregisterVault(this.path, transportOverride);\n    } finally {\n      await retryRm(this.path);\n    }\n  }\n\n  /**\n   * Writes files and folders into the vault directory.\n   * Parent directories are created automatically.\n   *\n   * - `string` values are written as UTF-8 text files.\n   * - `Uint8Array` values (including `Buffer`) are written as binary files.\n   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: PopulateFilesParams): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== undefined) {\n          throw new Error(`Folder path \"${filePath}\" must have undefined content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        if (content === undefined) {\n          throw new Error(`File path \"${filePath}\" must have defined content; use a trailing \"/\" for folders`);\n        }\n        mkdirSync(dirname(fullPath), { recursive: true });\n        writeFileSync(fullPath, content);\n      }\n    }\n  }\n\n  /**\n   * Registers this vault in the running Obsidian instance so the CLI can target it.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async register(transportOverride?: ObsidianTransport): Promise<void> {\n    await registerVault(this.path, transportOverride);\n  }\n\n  /**\n   * Async disposable support for `await using`.\n   *\n   * @returns A promise that resolves when the vault is disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    return this.dispose();\n  }\n\n  /* v8 ignore start -- Integration-time code that requires a running transport. */\n\n  /**\n   * Pushes all files from the local staging directory to the target device\n   * via the active transport's `pushFiles()`.\n   *\n   * On desktop transports this is a no-op (files are already local).\n   * On mobile transports (Appium) this pushes files to the device.\n   *\n   * Call this after {@link populate} and before {@link register} when using\n   * a mobile transport.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async syncToDevice(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n    if (!transport.pushFiles) {\n      return;\n    }\n\n    const files = await this.collectFiles(this.path);\n    await transport.pushFiles(this.path, files);\n  }\n\n  /**\n   * Recursively reads all files from a directory into a flat map.\n   *\n   * @param dir - The directory to read.\n   * @returns A map of relative file paths to content buffers.\n   */\n  private async collectFiles(dir: string): Promise<Record<string, Uint8Array>> {\n    const result: Record<string, Uint8Array> = {};\n    const entries = await readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name);\n      const relativePath = relative(this.path, fullPath);\n\n      if (entry.isDirectory()) {\n        Object.assign(result, await this.collectFiles(fullPath));\n      } else {\n        result[relativePath] = await readFile(fullPath);\n      }\n    }\n\n    return result;\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Retries `rm` until it succeeds or times out.\n * Obsidian may hold file locks briefly after a window is destroyed.\n *\n * @param path - The path to the directory to remove.\n * @returns A promise that resolves when the directory is removed.\n */\nasync function retryRm(path: string): Promise<void> {\n  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      await rm(path, { force: true, recursive: true });\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);\n      });\n    }\n  }\n  // Final attempt \u2014 let it throw.\n  await rm(path, { force: true, recursive: true });\n}\n"],
  "mappings": "AAMA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP,SAAS,2BAA2B;AACpC,SAAS,6BAA6B;AACtC,SAAS,4BAA4B;AACrC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAqBP,MAAM,iCAAiC;AACvC,MAAM,mCAAmC;AAQlC,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA,EAIL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,MAAe;AAChC,SAAK,OAAO,QAAQ,YAAY,KAAK,OAAO,GAAG,qBAAqB,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,QAAQ,mBAAsD;AACzE,QAAI;AACF,YAAM,gBAAgB,KAAK,MAAM,iBAAiB;AAAA,IACpD,UAAE;AACA,YAAM,QAAQ,KAAK,IAAI;AAAA,IACzB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,SAAS,OAAkC;AAChD,eAAW,CAAC,UAAU,OAAO,KAAK,OAAO,QAAQ,KAAK,GAAG;AACvD,YAAM,WAAW,KAAK,KAAK,MAAM,QAAQ;AACzC,UAAI,SAAS,SAAS,GAAG,GAAG;AAC1B,YAAI,YAAY,QAAW;AACzB,gBAAM,IAAI,MAAM,gBAAgB,QAAQ,+BAA+B;AAAA,QACzE;AACA,kBAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,MACzC,OAAO;AACL,YAAI,YAAY,QAAW;AACzB,gBAAM,IAAI,MAAM,cAAc,QAAQ,6DAA6D;AAAA,QACrG;AACA,kBAAU,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAChD,sBAAc,UAAU,OAAO;AAAA,MACjC;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,SAAS,mBAAsD;AAC1E,UAAM,cAAc,KAAK,MAAM,iBAAiB;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,OAAO,YAAY,IAAmB;AAClD,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,MAAa,aAAa,mBAAsD;AAC9E,UAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AACvF,QAAI,CAAC,UAAU,WAAW;AACxB;AAAA,IACF;AAEA,UAAM,QAAQ,MAAM,KAAK,aAAa,KAAK,IAAI;AAC/C,UAAM,UAAU,UAAU,KAAK,MAAM,KAAK;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAc,aAAa,KAAkD;AAC3E,UAAM,SAAqC,CAAC;AAC5C,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAE1D,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAW,KAAK,KAAK,MAAM,IAAI;AACrC,YAAM,eAAe,SAAS,KAAK,MAAM,QAAQ;AAEjD,UAAI,MAAM,YAAY,GAAG;AACvB,eAAO,OAAO,QAAQ,MAAM,KAAK,aAAa,QAAQ,CAAC;AAAA,MACzD,OAAO;AACL,eAAO,YAAY,IAAI,MAAM,SAAS,QAAQ;AAAA,MAChD;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAEF;AASA,eAAe,QAAQ,MAA6B;AAClD,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,YAAM,GAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAC/C;AAAA,IACF,QAAQ;AACN,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,8BAA8B;AAAA,MACpD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,QAAM,GAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AACjD;",
  "names": []
}
