obsidian-integration-testing 9.1.1 → 9.2.1

package/dist/lib/cjs/leftover-cleanup.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var leftover_cleanup_exports = {};
+__export(leftover_cleanup_exports, {
+  DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS: () => DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS,
+  HARNESS_TEMP_DIR_NAME: () => HARNESS_TEMP_DIR_NAME,
+  OWNED_USER_DATA_DIR_PREFIX: () => OWNED_USER_DATA_DIR_PREFIX,
+  TEMP_VAULT_DIR_PREFIX: () => TEMP_VAULT_DIR_PREFIX,
+  checkIsLeftoverStale: () => checkIsLeftoverStale,
+  filterLeftoverNames: () => filterLeftoverNames,
+  resolveLeftoverMaxAgeInMilliseconds: () => resolveLeftoverMaxAgeInMilliseconds,
+  resolveShouldSweepLeftovers: () => resolveShouldSweepLeftovers,
+  sweepDeviceLeftovers: () => sweepDeviceLeftovers,
+  sweepHostLeftovers: () => sweepHostLeftovers
+});
+module.exports = __toCommonJS(leftover_cleanup_exports);
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+const DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS = 72e5;
+const HARNESS_TEMP_DIR_NAME = "obsidian-integration-testing";
+const OWNED_USER_DATA_DIR_PREFIX = "userdata-";
+const TEMP_VAULT_DIR_PREFIX = "temp-vault-";
+function checkIsLeftoverStale(params) {
+  if (params.maxAgeInMilliseconds === 0) {
+    return true;
+  }
+  return params.nowInMilliseconds - params.modifiedAtInMilliseconds >= params.maxAgeInMilliseconds;
+}
+function filterLeftoverNames(params) {
+  const excludedNames = params.excludedNames ?? [];
+  return params.names.map((name) => name.trim()).filter((name) => params.prefixes.some((prefix) => name.startsWith(prefix))).filter((name) => !excludedNames.includes(name));
+}
+function resolveLeftoverMaxAgeInMilliseconds(options) {
+  return options?.leftoverMaxAgeInMilliseconds ?? DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS;
+}
+function resolveShouldSweepLeftovers(options) {
+  return options?.shouldSweepLeftovers ?? true;
+}
+async function sweepDeviceLeftovers(params) {
+  const { listNames, removeDir, vaultBasePath } = params;
+  const names = filterLeftoverNames({ names: await listNames(), prefixes: [TEMP_VAULT_DIR_PREFIX] });
+  if (names.length === 0) {
+    return { failedNames: [], removedCount: 0 };
+  }
+  for (const name of names) {
+    try {
+      await removeDir(`${vaultBasePath}${name}`);
+    } catch {
+    }
+  }
+  const survivingNames = filterLeftoverNames({ names: await listNames(), prefixes: [TEMP_VAULT_DIR_PREFIX] });
+  const failedNames = names.filter((name) => survivingNames.includes(name));
+  return { failedNames, removedCount: names.length - failedNames.length };
+}
+async function sweepHostLeftovers(options) {
+  const maxAgeInMilliseconds = options?.maxAgeInMilliseconds ?? DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS;
+  const nowInMilliseconds = Date.now();
+  const roots = options?.roots ?? getDefaultLeftoverRoots();
+  let failedCount = 0;
+  let removedCount = 0;
+  for (const root of roots) {
+    const names = filterLeftoverNames({
+      excludedNames: options?.excludedNames,
+      names: await readDirNames(root.path),
+      prefixes: root.prefixes
+    });
+    for (const name of names) {
+      const path = (0, import_node_path.join)(root.path, name);
+      if (!await checkIsRemovableDir({ maxAgeInMilliseconds, nowInMilliseconds, path })) {
+        continue;
+      }
+      try {
+        await (0, import_promises.rm)(path, { force: true, recursive: true });
+        removedCount++;
+      } catch {
+        failedCount++;
+      }
+    }
+  }
+  return { failedCount, removedCount };
+}
+async function checkIsRemovableDir(params) {
+  const { maxAgeInMilliseconds, nowInMilliseconds } = params;
+  try {
+    const stats = await (0, import_promises.stat)(params.path);
+    return stats.isDirectory() && checkIsLeftoverStale({ maxAgeInMilliseconds, modifiedAtInMilliseconds: stats.mtimeMs, nowInMilliseconds });
+  } catch {
+    return false;
+  }
+}
+function getDefaultLeftoverRoots() {
+  return [
+    { path: (0, import_node_os.tmpdir)(), prefixes: [TEMP_VAULT_DIR_PREFIX] },
+    { path: (0, import_node_path.join)((0, import_node_os.tmpdir)(), HARNESS_TEMP_DIR_NAME), prefixes: [OWNED_USER_DATA_DIR_PREFIX] }
+  ];
+}
+async function readDirNames(path) {
+  try {
+    return await (0, import_promises.readdir)(path);
+  } catch {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS,
+  HARNESS_TEMP_DIR_NAME,
+  OWNED_USER_DATA_DIR_PREFIX,
+  TEMP_VAULT_DIR_PREFIX,
+  checkIsLeftoverStale,
+  filterLeftoverNames,
+  resolveLeftoverMaxAgeInMilliseconds,
+  resolveShouldSweepLeftovers,
+  sweepDeviceLeftovers,
+  sweepHostLeftovers
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/leftover-cleanup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Sweeps the temporary directories a previous integration run leaked \u2014 the\n * `temp-vault-*` staging/vault directories and the owned instance's\n * `userdata-*` Chromium profiles.\n *\n * A run that dies mid-flight cannot clean up after itself: on Android the\n * teardown talks to the WebView, and a dead WebView is exactly what most\n * failures are (`Vault cleanup error (non-fatal): no such window`). Every\n * failure therefore leaks a vault, every leaked vault stays registered for\n * Obsidian to enumerate at startup, and that enumeration has to finish inside\n * the WebView-readiness budget \u2014 so each failure makes the next one likelier.\n * Sweeping foreign residue at the START of a run breaks that loop, because it\n * runs before anything that can die.\n *\n * The two sides use deliberately different safety gates (see the repo's L31):\n *\n * - **Device (Android)** \u2014 unconditional. Android runs hold the exclusive\n *   `android` setup lock, so no concurrent run can own a device vault, and an\n *   age gate would let a vault leaked ten minutes ago survive into the next run.\n * - **Host** \u2014 age-gated. Desktop runs are deliberately *not* serialized (each\n *   owns an isolated instance) and every project on the machine shares one\n *   `tmpdir()`, so a directory young enough to belong to a live run is left\n *   alone.\n */\n\nimport {\n  readdir,\n  rm,\n  stat\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport type { ObsidianTransportOptions } from './transport-options.cjs';\n\n/**\n * Default for the `leftoverMaxAgeInMilliseconds` transport option \u2014 two hours.\n */\nexport const DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS = 7200000;\n\n/**\n * Name of the harness's own directory inside {@link tmpdir}, which holds the\n * owned instances' user-data directories alongside the version/installer caches\n * and the setup locks.\n */\nexport const HARNESS_TEMP_DIR_NAME = 'obsidian-integration-testing';\n\n/**\n * Prefix of an owned desktop instance's isolated user-data directory.\n */\nexport const OWNED_USER_DATA_DIR_PREFIX = 'userdata-';\n\n/**\n * Prefix of a temporary vault directory, both on the host (where it is created)\n * and on an Android device (where it keeps its host basename).\n */\nexport const TEMP_VAULT_DIR_PREFIX = 'temp-vault-';\n\n/**\n * Parameters for {@link checkIsLeftoverStale}.\n */\nexport interface CheckIsLeftoverStaleParams {\n  /**\n   * How old an entry must be to count as stale. `0` disables the gate, making\n   * every entry stale.\n   */\n  readonly maxAgeInMilliseconds: number;\n\n  /** The entry's modification time, in epoch milliseconds. */\n  readonly modifiedAtInMilliseconds: number;\n\n  /** The current time, in epoch milliseconds. */\n  readonly nowInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link filterLeftoverNames}.\n */\nexport interface FilterLeftoverNamesParams {\n  /** Names to keep even when they match a prefix (e.g. the current run's own vault). */\n  readonly excludedNames?: readonly string[] | undefined;\n\n  /**\n   * Raw entry names. Accepts `adb shell ls` output split into lines, so each\n   * name is trimmed (dropping the trailing `\\r` an `adb` shell adds on Windows)\n   * and blank lines are dropped.\n   */\n  readonly names: readonly string[];\n\n  /** Directory-name prefixes that mark an entry as the harness's own residue. */\n  readonly prefixes: readonly string[];\n}\n\n/**\n * A directory the host sweep scans, together with the prefixes that mark\n * residue inside it.\n */\nexport interface LeftoverRoot {\n  /** The absolute path to scan. */\n  readonly path: string;\n\n  /** Directory-name prefixes that mark an entry as removable residue. */\n  readonly prefixes: readonly string[];\n}\n\n/**\n * Parameters for {@link sweepDeviceLeftovers}.\n */\nexport interface SweepDeviceLeftoversParams {\n  /**\n   * Lists the entry names directly under the vault base path. A listing failure\n   * must resolve to an empty list rather than reject \u2014 a device with no vault\n   * directory yet is the normal first-run state, not an error.\n   */\n  readonly listNames: () => Promise<readonly string[]>;\n\n  /**\n   * Removes ONE directory, by absolute device path. May reject; the caller\n   * treats a rejection as this directory failing and moves on to the next.\n   */\n  readonly removeDir: (path: string) => Promise<void>;\n\n  /** The absolute device path the vaults sit under, including its trailing separator. */\n  readonly vaultBasePath: string;\n}\n\n/**\n * Result of {@link sweepDeviceLeftovers}.\n */\nexport interface SweepDeviceLeftoversResult {\n  /**\n   * The names that were still present after the sweep. Named rather than\n   * counted, because the interesting case is a directory that fails EVERY run\n   * and a caller can only say so if it knows which one.\n   */\n  readonly failedNames: string[];\n\n  /** How many directories are verifiably gone. */\n  readonly removedCount: number;\n}\n\n/**\n * Options for {@link sweepHostLeftovers}.\n */\nexport interface SweepHostLeftoversOptions {\n  /** Names to keep regardless of age (e.g. the current run's own directories). */\n  readonly excludedNames?: readonly string[] | undefined;\n\n  /**\n   * How old a directory must be before it is removed. `0` removes every match.\n   *\n   * @default {@link DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS}\n   */\n  readonly maxAgeInMilliseconds?: number | undefined;\n\n  /**\n   * The roots to sweep. Defaults to the temp-vault root ({@link tmpdir}) and the\n   * owned user-data root (`<tmpdir>/{@link HARNESS_TEMP_DIR_NAME}`).\n   */\n  readonly roots?: readonly LeftoverRoot[] | undefined;\n}\n\n/**\n * Result of {@link sweepHostLeftovers}.\n */\nexport interface SweepHostLeftoversResult {\n  /** How many directories were selected for removal but could not be removed. */\n  readonly failedCount: number;\n\n  /** How many directories were removed. */\n  readonly removedCount: number;\n}\n\n/**\n * Parameters for {@link checkIsRemovableDir}.\n */\ninterface CheckIsRemovableDirParams {\n  /** How old the entry must be to be removed (`0` disables the gate). */\n  readonly maxAgeInMilliseconds: number;\n\n  /** The sweep's reference time, in epoch milliseconds. */\n  readonly nowInMilliseconds: number;\n\n  /** The absolute path to the entry. */\n  readonly path: string;\n}\n\n/**\n * Decides whether a leftover entry is old enough to be removed.\n *\n * The gate exists because every project on the machine shares one `tmpdir()`\n * and desktop runs are not serialized, so a young directory may well belong to\n * a run that is still in flight. An entry whose modification time is in the\n * future (a clock skew) is treated as live for the same reason.\n *\n * @param params - The age comparison inputs.\n * @returns `true` when the entry may be removed.\n */\nexport function checkIsLeftoverStale(params: CheckIsLeftoverStaleParams): boolean {\n  if (params.maxAgeInMilliseconds === 0) {\n    return true;\n  }\n\n  return params.nowInMilliseconds - params.modifiedAtInMilliseconds >= params.maxAgeInMilliseconds;\n}\n\n/**\n * Selects the entry names that are the harness's own residue.\n *\n * Name-only, so the caller can filter a large directory listing before paying\n * for a `stat` per entry, and so the Android sweep can feed it raw\n * `adb shell ls` output.\n *\n * @param params - The names, prefixes, and exclusions.\n * @returns The matching names, trimmed.\n */\nexport function filterLeftoverNames(params: FilterLeftoverNamesParams): string[] {\n  const excludedNames = params.excludedNames ?? [];\n  return params.names\n    .map((name) => name.trim())\n    .filter((name) => params.prefixes.some((prefix) => name.startsWith(prefix)))\n    .filter((name) => !excludedNames.includes(name));\n}\n\n/**\n * Resolves the leftover age gate, applying the default when the option is\n * omitted.\n *\n * @param options - The transport options.\n * @returns The max age in milliseconds (`0` disables the gate).\n */\nexport function resolveLeftoverMaxAgeInMilliseconds(options: ObsidianTransportOptions | undefined): number {\n  return options?.leftoverMaxAgeInMilliseconds ?? DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS;\n}\n\n/**\n * Resolves whether leftover directories are swept, applying the default when\n * the option is omitted.\n *\n * @param options - The transport options.\n * @returns `true` when the sweeps should run.\n */\nexport function resolveShouldSweepLeftovers(options: ObsidianTransportOptions | undefined): boolean {\n  return options?.shouldSweepLeftovers ?? true;\n}\n\n/**\n * Removes the leftover vault directories a device is carrying, one directory at\n * a time, and reports what is verifiably gone.\n *\n * **One directory per removal, and a failure is non-fatal.** Removing the whole\n * set in a single `rm -rf` lets one un-removable entry decide the fate of every\n * other: a name that the FUSE layer cannot express (an Android emulator can\n * produce one \u2014 `rm -rf`, `find -delete` and force-stopping Obsidian first all\n * answer `Operation not permitted`) is permanent, so a sweep that gives up on it\n * gives up forever, and the residue only grows. Per-directory, that entry costs\n * one warning per run instead of the whole sweep.\n *\n * **The result is measured, not assumed.** The directories are re-listed\n * afterwards and only the ones that actually disappeared are counted, because\n * the failure this was written for was a sweep that reported success while\n * clearing nothing \u2014 a removal command can exit non-zero, or partially succeed,\n * and neither is visible from its exit code alone.\n *\n * @param params - How to list and remove, and the base path to sweep.\n * @returns The verified removal count and the names that survived.\n */\nexport async function sweepDeviceLeftovers(\n  params: SweepDeviceLeftoversParams\n): Promise<SweepDeviceLeftoversResult> {\n  const { listNames, removeDir, vaultBasePath } = params;\n\n  const names = filterLeftoverNames({ names: await listNames(), prefixes: [TEMP_VAULT_DIR_PREFIX] });\n  if (names.length === 0) {\n    return { failedNames: [], removedCount: 0 };\n  }\n\n  for (const name of names) {\n    try {\n      await removeDir(`${vaultBasePath}${name}`);\n    } catch {\n      // Non-fatal by design: the next directory still gets its chance.\n    }\n  }\n\n  const survivingNames = filterLeftoverNames({ names: await listNames(), prefixes: [TEMP_VAULT_DIR_PREFIX] });\n  const failedNames = names.filter((name) => survivingNames.includes(name));\n\n  return { failedNames, removedCount: names.length - failedNames.length };\n}\n\n/**\n * Removes the host-side directories left behind by earlier runs.\n *\n * Best-effort throughout: an unreadable root, an entry that cannot be `stat`ed,\n * and a directory that refuses to be removed (a live process still holding a\n * handle answers `EPERM` on Windows) are all skipped rather than thrown, so a\n * sweep can never fail the run it is cleaning up for.\n *\n * @param options - The sweep options.\n * @returns How many directories were removed, and how many resisted removal.\n */\nexport async function sweepHostLeftovers(options?: SweepHostLeftoversOptions): Promise<SweepHostLeftoversResult> {\n  const maxAgeInMilliseconds = options?.maxAgeInMilliseconds ?? DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS;\n  const nowInMilliseconds = Date.now();\n  const roots = options?.roots ?? getDefaultLeftoverRoots();\n\n  let failedCount = 0;\n  let removedCount = 0;\n\n  for (const root of roots) {\n    const names = filterLeftoverNames({\n      excludedNames: options?.excludedNames,\n      names: await readDirNames(root.path),\n      prefixes: root.prefixes\n    });\n\n    for (const name of names) {\n      const path = join(root.path, name);\n      if (!await checkIsRemovableDir({ maxAgeInMilliseconds, nowInMilliseconds, path })) {\n        continue;\n      }\n\n      try {\n        await rm(path, { force: true, recursive: true });\n        removedCount++;\n      } catch {\n        failedCount++;\n      }\n    }\n  }\n\n  return { failedCount, removedCount };\n}\n\n/**\n * Checks whether a matched entry is a directory old enough to remove.\n *\n * @param params - The entry path and age-gate inputs.\n * @returns `true` when the entry may be removed.\n */\nasync function checkIsRemovableDir(params: CheckIsRemovableDirParams): Promise<boolean> {\n  const { maxAgeInMilliseconds, nowInMilliseconds } = params;\n  try {\n    const stats = await stat(params.path);\n    return stats.isDirectory()\n      && checkIsLeftoverStale({ maxAgeInMilliseconds, modifiedAtInMilliseconds: stats.mtimeMs, nowInMilliseconds });\n  } catch {\n    // Vanished, or unreadable \u2014 either way it is not ours to remove.\n    return false;\n  }\n}\n\n/**\n * Returns the roots swept when the caller does not name its own.\n *\n * @returns The temp-vault root and the owned user-data root.\n */\nfunction getDefaultLeftoverRoots(): LeftoverRoot[] {\n  return [\n    { path: tmpdir(), prefixes: [TEMP_VAULT_DIR_PREFIX] },\n    { path: join(tmpdir(), HARNESS_TEMP_DIR_NAME), prefixes: [OWNED_USER_DATA_DIR_PREFIX] }\n  ];\n}\n\n/**\n * Lists a directory's entry names, treating an unreadable directory as empty.\n *\n * @param path - The absolute path to list.\n * @returns The entry names, or an empty list.\n */\nasync function readDirNames(path: string): Promise<string[]> {\n  try {\n    return await readdir(path);\n  } catch {\n    return [];\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/leftover-cleanup.d.cts

@@ -0,0 +1,216 @@
+/**
+ * @file
+ *
+ * Sweeps the temporary directories a previous integration run leaked — the
+ * `temp-vault-*` staging/vault directories and the owned instance's
+ * `userdata-*` Chromium profiles.
+ *
+ * A run that dies mid-flight cannot clean up after itself: on Android the
+ * teardown talks to the WebView, and a dead WebView is exactly what most
+ * failures are (`Vault cleanup error (non-fatal): no such window`). Every
+ * failure therefore leaks a vault, every leaked vault stays registered for
+ * Obsidian to enumerate at startup, and that enumeration has to finish inside
+ * the WebView-readiness budget — so each failure makes the next one likelier.
+ * Sweeping foreign residue at the START of a run breaks that loop, because it
+ * runs before anything that can die.
+ *
+ * The two sides use deliberately different safety gates (see the repo's L31):
+ *
+ * - **Device (Android)** — unconditional. Android runs hold the exclusive
+ *   `android` setup lock, so no concurrent run can own a device vault, and an
+ *   age gate would let a vault leaked ten minutes ago survive into the next run.
+ * - **Host** — age-gated. Desktop runs are deliberately *not* serialized (each
+ *   owns an isolated instance) and every project on the machine shares one
+ *   `tmpdir()`, so a directory young enough to belong to a live run is left
+ *   alone.
+ */
+import type { ObsidianTransportOptions } from './transport-options.cjs';
+/**
+ * Default for the `leftoverMaxAgeInMilliseconds` transport option — two hours.
+ */
+export declare const DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS = 7200000;
+/**
+ * Name of the harness's own directory inside {@link tmpdir}, which holds the
+ * owned instances' user-data directories alongside the version/installer caches
+ * and the setup locks.
+ */
+export declare const HARNESS_TEMP_DIR_NAME = "obsidian-integration-testing";
+/**
+ * Prefix of an owned desktop instance's isolated user-data directory.
+ */
+export declare const OWNED_USER_DATA_DIR_PREFIX = "userdata-";
+/**
+ * Prefix of a temporary vault directory, both on the host (where it is created)
+ * and on an Android device (where it keeps its host basename).
+ */
+export declare const TEMP_VAULT_DIR_PREFIX = "temp-vault-";
+/**
+ * Parameters for {@link checkIsLeftoverStale}.
+ */
+export interface CheckIsLeftoverStaleParams {
+    /**
+     * How old an entry must be to count as stale. `0` disables the gate, making
+     * every entry stale.
+     */
+    readonly maxAgeInMilliseconds: number;
+    /** The entry's modification time, in epoch milliseconds. */
+    readonly modifiedAtInMilliseconds: number;
+    /** The current time, in epoch milliseconds. */
+    readonly nowInMilliseconds: number;
+}
+/**
+ * Parameters for {@link filterLeftoverNames}.
+ */
+export interface FilterLeftoverNamesParams {
+    /** Names to keep even when they match a prefix (e.g. the current run's own vault). */
+    readonly excludedNames?: readonly string[] | undefined;
+    /**
+     * Raw entry names. Accepts `adb shell ls` output split into lines, so each
+     * name is trimmed (dropping the trailing `\r` an `adb` shell adds on Windows)
+     * and blank lines are dropped.
+     */
+    readonly names: readonly string[];
+    /** Directory-name prefixes that mark an entry as the harness's own residue. */
+    readonly prefixes: readonly string[];
+}
+/**
+ * A directory the host sweep scans, together with the prefixes that mark
+ * residue inside it.
+ */
+export interface LeftoverRoot {
+    /** The absolute path to scan. */
+    readonly path: string;
+    /** Directory-name prefixes that mark an entry as removable residue. */
+    readonly prefixes: readonly string[];
+}
+/**
+ * Parameters for {@link sweepDeviceLeftovers}.
+ */
+export interface SweepDeviceLeftoversParams {
+    /**
+     * Lists the entry names directly under the vault base path. A listing failure
+     * must resolve to an empty list rather than reject — a device with no vault
+     * directory yet is the normal first-run state, not an error.
+     */
+    readonly listNames: () => Promise<readonly string[]>;
+    /**
+     * Removes ONE directory, by absolute device path. May reject; the caller
+     * treats a rejection as this directory failing and moves on to the next.
+     */
+    readonly removeDir: (path: string) => Promise<void>;
+    /** The absolute device path the vaults sit under, including its trailing separator. */
+    readonly vaultBasePath: string;
+}
+/**
+ * Result of {@link sweepDeviceLeftovers}.
+ */
+export interface SweepDeviceLeftoversResult {
+    /**
+     * The names that were still present after the sweep. Named rather than
+     * counted, because the interesting case is a directory that fails EVERY run
+     * and a caller can only say so if it knows which one.
+     */
+    readonly failedNames: string[];
+    /** How many directories are verifiably gone. */
+    readonly removedCount: number;
+}
+/**
+ * Options for {@link sweepHostLeftovers}.
+ */
+export interface SweepHostLeftoversOptions {
+    /** Names to keep regardless of age (e.g. the current run's own directories). */
+    readonly excludedNames?: readonly string[] | undefined;
+    /**
+     * How old a directory must be before it is removed. `0` removes every match.
+     *
+     * @default {@link DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS}
+     */
+    readonly maxAgeInMilliseconds?: number | undefined;
+    /**
+     * The roots to sweep. Defaults to the temp-vault root ({@link tmpdir}) and the
+     * owned user-data root (`<tmpdir>/{@link HARNESS_TEMP_DIR_NAME}`).
+     */
+    readonly roots?: readonly LeftoverRoot[] | undefined;
+}
+/**
+ * Result of {@link sweepHostLeftovers}.
+ */
+export interface SweepHostLeftoversResult {
+    /** How many directories were selected for removal but could not be removed. */
+    readonly failedCount: number;
+    /** How many directories were removed. */
+    readonly removedCount: number;
+}
+/**
+ * Decides whether a leftover entry is old enough to be removed.
+ *
+ * The gate exists because every project on the machine shares one `tmpdir()`
+ * and desktop runs are not serialized, so a young directory may well belong to
+ * a run that is still in flight. An entry whose modification time is in the
+ * future (a clock skew) is treated as live for the same reason.
+ *
+ * @param params - The age comparison inputs.
+ * @returns `true` when the entry may be removed.
+ */
+export declare function checkIsLeftoverStale(params: CheckIsLeftoverStaleParams): boolean;
+/**
+ * Selects the entry names that are the harness's own residue.
+ *
+ * Name-only, so the caller can filter a large directory listing before paying
+ * for a `stat` per entry, and so the Android sweep can feed it raw
+ * `adb shell ls` output.
+ *
+ * @param params - The names, prefixes, and exclusions.
+ * @returns The matching names, trimmed.
+ */
+export declare function filterLeftoverNames(params: FilterLeftoverNamesParams): string[];
+/**
+ * Resolves the leftover age gate, applying the default when the option is
+ * omitted.
+ *
+ * @param options - The transport options.
+ * @returns The max age in milliseconds (`0` disables the gate).
+ */
+export declare function resolveLeftoverMaxAgeInMilliseconds(options: ObsidianTransportOptions | undefined): number;
+/**
+ * Resolves whether leftover directories are swept, applying the default when
+ * the option is omitted.
+ *
+ * @param options - The transport options.
+ * @returns `true` when the sweeps should run.
+ */
+export declare function resolveShouldSweepLeftovers(options: ObsidianTransportOptions | undefined): boolean;
+/**
+ * Removes the leftover vault directories a device is carrying, one directory at
+ * a time, and reports what is verifiably gone.
+ *
+ * **One directory per removal, and a failure is non-fatal.** Removing the whole
+ * set in a single `rm -rf` lets one un-removable entry decide the fate of every
+ * other: a name that the FUSE layer cannot express (an Android emulator can
+ * produce one — `rm -rf`, `find -delete` and force-stopping Obsidian first all
+ * answer `Operation not permitted`) is permanent, so a sweep that gives up on it
+ * gives up forever, and the residue only grows. Per-directory, that entry costs
+ * one warning per run instead of the whole sweep.
+ *
+ * **The result is measured, not assumed.** The directories are re-listed
+ * afterwards and only the ones that actually disappeared are counted, because
+ * the failure this was written for was a sweep that reported success while
+ * clearing nothing — a removal command can exit non-zero, or partially succeed,
+ * and neither is visible from its exit code alone.
+ *
+ * @param params - How to list and remove, and the base path to sweep.
+ * @returns The verified removal count and the names that survived.
+ */
+export declare function sweepDeviceLeftovers(params: SweepDeviceLeftoversParams): Promise<SweepDeviceLeftoversResult>;
+/**
+ * Removes the host-side directories left behind by earlier runs.
+ *
+ * Best-effort throughout: an unreadable root, an entry that cannot be `stat`ed,
+ * and a directory that refuses to be removed (a live process still holding a
+ * handle answers `EPERM` on Windows) are all skipped rather than thrown, so a
+ * sweep can never fail the run it is cleaning up for.
+ *
+ * @param options - The sweep options.
+ * @returns How many directories were removed, and how many resisted removal.
+ */
+export declare function sweepHostLeftovers(options?: SweepHostLeftoversOptions): Promise<SweepHostLeftoversResult>;

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "9.1.0";
+const LIBRARY_VERSION = false ? "dev" : "9.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION