obsidian-integration-testing 9.2.2 → 10.0.0

package/dist/lib/esm/json-with-functions.mjs

@@ -2,21 +2,21 @@ import { getFunctionExpressionString } from "./function-expression.mjs";
 function jsonWithFunctions(value) {
   const functionMap = /* @__PURE__ */ new Map();
   const JSON_INDENT = 2;
-  const json = JSON.stringify(value, (_key, val) => {
-    if (typeof val === "function") {
+  const json = JSON.stringify(value, (_key, value_) => {
+    if (typeof value_ === "function") {
       const placeholder = `__fn_${String(functionMap.size)}__`;
-      functionMap.set(placeholder, getFunctionExpressionString(val));
+      functionMap.set(placeholder, getFunctionExpressionString(value_));
       return placeholder;
     }
-    return val;
+    return value_;
   }, JSON_INDENT);
   let result = json;
-  for (const [placeholder, fnSource] of functionMap) {
-    result = result.replace(`"${placeholder}"`, fnSource);
+  for (const [placeholder, functionSource] of functionMap) {
+    result = result.replace(`"${placeholder}"`, () => functionSource);
   }
   return result;
 }
 export {
   jsonWithFunctions
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/leftover-cleanup.d.mts

@@ -53,16 +53,22 @@ export interface CheckIsLeftoverStaleParams {
      * every entry stale.
      */
     readonly maxAgeInMilliseconds: number;
-    /** The entry's modification time, in epoch milliseconds. */
+    /**
+    The entry's modification time, in epoch milliseconds.
+     */
     readonly modifiedAtInMilliseconds: number;
-    /** The current time, in epoch milliseconds. */
+    /**
+    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). */
+    /**
+    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
@@ -70,7 +76,9 @@ export interface FilterLeftoverNamesParams {
      * and blank lines are dropped.
      */
     readonly names: readonly string[];
-    /** Directory-name prefixes that mark an entry as the harness's own residue. */
+    /**
+    Directory-name prefixes that mark an entry as the harness's own residue.
+     */
     readonly prefixes: readonly string[];
 }
 /**
@@ -78,9 +86,13 @@ export interface FilterLeftoverNamesParams {
  * residue inside it.
  */
 export interface LeftoverRoot {
-    /** The absolute path to scan. */
+    /**
+    The absolute path to scan.
+     */
     readonly path: string;
-    /** Directory-name prefixes that mark an entry as removable residue. */
+    /**
+    Directory-name prefixes that mark an entry as removable residue.
+     */
     readonly prefixes: readonly string[];
 }
 /**
@@ -97,8 +109,10 @@ export interface SweepDeviceLeftoversParams {
      * 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 removeDirectory: (path: string) => Promise<void>;
+    /**
+    The absolute device path the vaults sit under, including its trailing separator.
+     */
     readonly vaultBasePath: string;
 }
 /**
@@ -111,14 +125,18 @@ export interface SweepDeviceLeftoversResult {
      * and a caller can only say so if it knows which one.
      */
     readonly failedNames: string[];
-    /** How many directories are verifiably gone. */
+    /**
+    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). */
+    /**
+    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.
@@ -136,9 +154,13 @@ export interface SweepHostLeftoversOptions {
  * Result of {@link sweepHostLeftovers}.
  */
 export interface SweepHostLeftoversResult {
-    /** How many directories were selected for removal but could not be removed. */
+    /**
+    How many directories were selected for removal but could not be removed.
+     */
     readonly failedCount: number;
-    /** How many directories were removed. */
+    /**
+    How many directories were removed.
+     */
     readonly removedCount: number;
 }
 /**
@@ -172,14 +194,6 @@ export declare function filterLeftoverNames(params: FilterLeftoverNamesParams):
  * @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.
@@ -214,3 +228,11 @@ export declare function sweepDeviceLeftovers(params: SweepDeviceLeftoversParams)
  * @returns How many directories were removed, and how many resisted removal.
  */
 export declare function sweepHostLeftovers(options?: SweepHostLeftoversOptions): Promise<SweepHostLeftoversResult>;
+/**
+ * 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 willSweepLeftovers(options: ObsidianTransportOptions | undefined): boolean;

package/dist/lib/esm/leftover-cleanup.mjs

@@ -22,18 +22,15 @@ function filterLeftoverNames(params) {
 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 { listNames, removeDirectory, 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}`);
+      await removeDirectory(`${vaultBasePath}${name}`);
     } catch {
     }
   }
@@ -50,12 +47,12 @@ async function sweepHostLeftovers(options) {
   for (const root of roots) {
     const names = filterLeftoverNames({
       excludedNames: options?.excludedNames,
-      names: await readDirNames(root.path),
+      names: await readDirectoryNames(root.path),
       prefixes: root.prefixes
     });
     for (const name of names) {
       const path = join(root.path, name);
-      if (!await checkIsRemovableDir({ maxAgeInMilliseconds, nowInMilliseconds, path })) {
+      if (!await checkIsRemovableDirectory({ maxAgeInMilliseconds, nowInMilliseconds, path })) {
         continue;
       }
       try {
@@ -68,7 +65,10 @@ async function sweepHostLeftovers(options) {
   }
   return { failedCount, removedCount };
 }
-async function checkIsRemovableDir(params) {
+function willSweepLeftovers(options) {
+  return options?.shouldSweepLeftovers ?? true;
+}
+async function checkIsRemovableDirectory(params) {
   const { maxAgeInMilliseconds, nowInMilliseconds } = params;
   try {
     const stats = await stat(params.path);
@@ -83,7 +83,7 @@ function getDefaultLeftoverRoots() {
     { path: join(tmpdir(), HARNESS_TEMP_DIR_NAME), prefixes: [OWNED_USER_DATA_DIR_PREFIX] }
   ];
 }
-async function readDirNames(path) {
+async function readDirectoryNames(path) {
   try {
     return await readdir(path);
   } catch {
@@ -98,8 +98,8 @@ export {
   checkIsLeftoverStale,
   filterLeftoverNames,
   resolveLeftoverMaxAgeInMilliseconds,
-  resolveShouldSweepLeftovers,
   sweepDeviceLeftovers,
-  sweepHostLeftovers
+  sweepHostLeftovers,
+  willSweepLeftovers
 };
-//# 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.mjs';\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": []
}

+//# 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.mjs';\n\n/**\n * Default for the `leftoverMaxAgeInMilliseconds` transport option \u2014 two hours.\n */\nexport const DEFAULT_LEFTOVER_MAX_AGE_IN_MILLISECONDS = 7_200_000;\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  /**\n  The entry's modification time, in epoch milliseconds.\n   */\n  readonly modifiedAtInMilliseconds: number;\n\n  /**\n  The current time, in epoch milliseconds.\n   */\n  readonly nowInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link filterLeftoverNames}.\n */\nexport interface FilterLeftoverNamesParams {\n  /**\n  Names to keep even when they match a prefix (e.g. the current run's own vault).\n   */\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  /**\n  Directory-name prefixes that mark an entry as the harness's own residue.\n   */\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  /**\n  The absolute path to scan.\n   */\n  readonly path: string;\n\n  /**\n  Directory-name prefixes that mark an entry as removable residue.\n   */\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 removeDirectory: (path: string) => Promise<void>;\n\n  /**\n  The absolute device path the vaults sit under, including its trailing separator.\n   */\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  /**\n  How many directories are verifiably gone.\n   */\n  readonly removedCount: number;\n}\n\n/**\n * Options for {@link sweepHostLeftovers}.\n */\nexport interface SweepHostLeftoversOptions {\n  /**\n  Names to keep regardless of age (e.g. the current run's own directories).\n   */\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  /**\n  How many directories were selected for removal but could not be removed.\n   */\n  readonly failedCount: number;\n\n  /**\n  How many directories were removed.\n   */\n  readonly removedCount: number;\n}\n\n/**\n * Parameters for {@link checkIsRemovableDir}.\n */\ninterface CheckIsRemovableDirectoryParams {\n  /**\n  How old the entry must be to be removed (`0` disables the gate).\n   */\n  readonly maxAgeInMilliseconds: number;\n\n  /**\n  The sweep's reference time, in epoch milliseconds.\n   */\n  readonly nowInMilliseconds: number;\n\n  /**\n  The absolute path to the entry.\n   */\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 * 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, removeDirectory, 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 removeDirectory(`${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 readDirectoryNames(root.path),\n      prefixes: root.prefixes\n    });\n\n    for (const name of names) {\n      const path = join(root.path, name);\n      if (!await checkIsRemovableDirectory({ 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 * 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 willSweepLeftovers(options: ObsidianTransportOptions | undefined): boolean {\n  return options?.shouldSweepLeftovers ?? true;\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 checkIsRemovableDirectory(params: CheckIsRemovableDirectoryParams): 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 readDirectoryNames(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/esm/library.mjs

@@ -1,5 +1,5 @@
-const LIBRARY_VERSION = false ? "dev" : "9.2.1";
+const LIBRARY_VERSION = false ? "dev" : "9.2.2";
 export {
   LIBRARY_VERSION
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2xpYnJhcnkudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBMaWJyYXJ5IG1ldGFkYXRhIGNvbnN0YW50cy4gVGhlIGBPQlNJRElBTl9JTlRFR1JBVElPTl9URVNUSU5HX1ZFUlNJT05gIGdsb2JhbFxuICogaXMgcmVwbGFjZWQgYXQgYnVpbGQgdGltZSBieSBlc2J1aWxkJ3MgYGRlZmluZWAgb3B0aW9uIHdpdGggdGhlIHZlcnNpb25cbiAqIGZyb20gYHBhY2thZ2UuanNvbmAuXG4gKi9cblxuLyoqXG4gKiBUaGUgdmVyc2lvbiBvZiB0aGUgYG9ic2lkaWFuLWludGVncmF0aW9uLXRlc3RpbmdgIGxpYnJhcnkuXG4gKiBBdCBidWlsZCB0aW1lLCBgT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OYCBpcyByZXBsYWNlZCBieSBlc2J1aWxkJ3NcbiAqIGBkZWZpbmVgIG9wdGlvbi4gQXQgdGVzdCB0aW1lIChWaXRlc3QpLCBpdCBmYWxscyBiYWNrIHRvIGAnZGV2J2AuXG4gKi9cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBCdWlsZC10aW1lIGNvbnN0YW50OyB0aGUgZWxzZSBicmFuY2ggaXMgb25seSByZWFjaGFibGUgd2hlbiBlc2J1aWxkJ3MgZGVmaW5lIHJlcGxhY2VzIHRoZSBnbG9iYWwuICovXG5leHBvcnQgY29uc3QgTElCUkFSWV9WRVJTSU9OOiBzdHJpbmcgPSB0eXBlb2YgT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OID09PSAndW5kZWZpbmVkJ1xuICA/ICdkZXYnXG4gIDogT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OO1xuLyogdjggaWdub3JlIHN0b3AgKi9cblxuZGVjbGFyZSBjb25zdCBPQlNJRElBTl9JTlRFR1JBVElPTl9URVNUSU5HX1ZFUlNJT046IHN0cmluZyB8IHVuZGVmaW5lZDtcbiJdLAogICJtYXBwaW5ncyI6ICJBQWNPLE1BQU0sa0JBQTBCLFFBQ25DLFFBQ0E7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2xpYnJhcnkudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBMaWJyYXJ5IG1ldGFkYXRhIGNvbnN0YW50cy4gVGhlIGBPQlNJRElBTl9JTlRFR1JBVElPTl9URVNUSU5HX1ZFUlNJT05gIGdsb2JhbFxuICogaXMgcmVwbGFjZWQgYXQgYnVpbGQgdGltZSBieSBlc2J1aWxkJ3MgYGRlZmluZWAgb3B0aW9uIHdpdGggdGhlIHZlcnNpb25cbiAqIGZyb20gYHBhY2thZ2UuanNvbmAuXG4gKi9cblxuLyoqXG4gKiBUaGUgdmVyc2lvbiBvZiB0aGUgYG9ic2lkaWFuLWludGVncmF0aW9uLXRlc3RpbmdgIGxpYnJhcnkuXG4gKiBBdCBidWlsZCB0aW1lLCBgT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OYCBpcyByZXBsYWNlZCBieSBlc2J1aWxkJ3NcbiAqIGBkZWZpbmVgIG9wdGlvbi4gQXQgdGVzdCB0aW1lIChWaXRlc3QpLCBpdCBmYWxscyBiYWNrIHRvIGAnZGV2J2AuXG4gKi9cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBCdWlsZC10aW1lIGNvbnN0YW50OyB0aGUgZWxzZSBicmFuY2ggaXMgb25seSByZWFjaGFibGUgd2hlbiBlc2J1aWxkJ3MgZGVmaW5lIHJlcGxhY2VzIHRoZSBnbG9iYWwuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgdW5pY29ybi9uby10eXBlb2YtdW5kZWZpbmVkIC0tIFRoZSBgdHlwZW9mYCBndWFyZCBpcyByZXF1aXJlZDogb3V0c2lkZSBhIGJ1aWx0IGJ1bmRsZSB0aGUgZ2xvYmFsIGlzIG5ldmVyIERFQ0xBUkVELCBzbyByZWFkaW5nIGl0IGRpcmVjdGx5IHRocm93cyBhIGBSZWZlcmVuY2VFcnJvcmAgcmF0aGVyIHRoYW4geWllbGRpbmcgYHVuZGVmaW5lZGAuXG5leHBvcnQgY29uc3QgTElCUkFSWV9WRVJTSU9OOiBzdHJpbmcgPSB0eXBlb2YgT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OID09PSAndW5kZWZpbmVkJ1xuICA/ICdkZXYnXG4gIDogT0JTSURJQU5fSU5URUdSQVRJT05fVEVTVElOR19WRVJTSU9OO1xuLyogdjggaWdub3JlIHN0b3AgKi9cblxuZGVjbGFyZSBjb25zdCBPQlNJRElBTl9JTlRFR1JBVElPTl9URVNUSU5HX1ZFUlNJT046IHN0cmluZyB8IHVuZGVmaW5lZDtcbiJdLAogICJtYXBwaW5ncyI6ICJBQWVPLE1BQU0sa0JBQTBCLFFBQ25DLFFBQ0E7IiwKICAibmFtZXMiOiBbXQp9Cg==