obsidian-integration-testing 9.2.0 → 9.2.2

package/dist/lib/esm/eval-in-obsidian.d.mts

@@ -3,7 +3,7 @@
  *
  * Evaluates a function inside a running Obsidian instance via a pluggable transport.
  */
-import type { App, Editor, Modifier } from 'obsidian';
+import type { App, Editor, Modifier, TFile } from 'obsidian';
 import type * as obsidian from 'obsidian';
 import type { Promisable } from 'type-fest';
 import type { ContextArgs, ContextId } from './context-id.mjs';
@@ -33,6 +33,20 @@ export interface CommonArgs {
      */
     obsidianModule: typeof obsidian;
 }
+/**
+ * Parameters for {@link CommonArgs.createNote}.
+ */
+export interface CreateNoteParams {
+    /**
+     * The note's content. This exact string is what the created note is read back
+     * against, so it is the definition of a successful write.
+     */
+    readonly content: string;
+    /**
+     * The vault-relative path to create, extension included.
+     */
+    readonly path: string;
+}
 /**
  * Parameters for {@link evalInObsidian}.
  */
@@ -108,6 +122,35 @@ export interface HoverElementParams {
  * ```
  */
 export interface Lib {
+    /**
+     * Creates a note and does not return until its content is verifiably on
+     * disk, rewriting it if it is not.
+     *
+     * Use this instead of `app.vault.create` in any suite that may run on
+     * Android. The emulator transport loses roughly **0.9 %** of `vault.create`
+     * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on
+     * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,
+     * and it does not heal on its own. A suite doing ~34 creates per run
+     * therefore has a ~26 % chance of at least one lost write, and whichever test
+     * loses that lottery fails on a `waitUntil` for content that was never
+     * written — which is why it reads as an unrelated per-test flake rather than
+     * one shared cause.
+     *
+     * Verification is by **reading the note back**, never by inspecting
+     * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through
+     * `vault.modify` with the same content lands correctly (also measured), so a
+     * lost write costs a retry rather than a failure. A note whose content still
+     * does not match after the bounded retries throws, naming the path and both
+     * lengths, so a genuinely broken write fails loudly instead of spinning.
+     *
+     * Harmless everywhere else — on a transport that does not lose writes the
+     * read-back matches first time and nothing is rewritten.
+     *
+     * @param params - The note path and content.
+     * @returns A {@link Promise} resolving to the created file, once its content
+     *   is confirmed.
+     */
+    createNote(this: void, params: CreateNoteParams): Promise<TFile>;
     /**
      * Moves the mouse pointer to the center of an element using **trusted**
      * Electron pointer input, then polls until the element actually matches

package/dist/lib/esm/eval-in-obsidian.mjs

@@ -48,4 +48,4 @@ ${sanitizedDetail}`);
 export {
   evalInObsidian
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor,\n  Modifier\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.mjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { generateNamespaceCall } from './generate-function-call.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `fn` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `fn` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The shared library bag injected into every callback \u2014 see {@link Lib}.\n   *\n   * Never empty: the harness pre-populates a **base** set of renderer-driving\n   * helpers (trusted input \u2014 `typeIntoEditor` / `pressKey` / `moveMouse` /\n   * `hoverElement` / `unhoverElement` \u2014 and `waitUntil`), and provider packages\n   * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe\n   * library on top via {@link registerLibResolver}. A serialized closure reaches\n   * every shared helper through `lib` \u2014 `lib.typeIntoEditor({ editor, text })`,\n   * `lib.getFileOrNull({ app, \u2026 })` \u2014 instead of importing or hand-rolling them.\n   */\n  lib: Lib;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArgs.hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The shared library bag injected into every {@link evalInObsidian} callback as\n * {@link CommonArgs.lib}.\n *\n * Two layers compose into this one bag. The **base** \u2014 the harness-provided\n * renderer-driving helpers declared below (the trusted-input primitives and\n * {@link Lib.waitUntil}) \u2014 is always present. On top, provider packages register\n * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`\n * their whole renderer-safe library at runtime, and augment this **augmentable**\n * interface (the `i18next` `CustomTypeOptions` idiom) via\n * `declare module 'obsidian-integration-testing'` to type it. Multiple providers\n * compose: their exports merge at runtime and their augmentations merge in the\n * type system (`interface Lib extends \u2026`).\n *\n * @example\n * ```ts\n * declare module 'obsidian-integration-testing' {\n *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}\n * }\n * ```\n */\nexport interface Lib {\n  /**\n   * Moves the mouse pointer to the center of an element using **trusted**\n   * Electron pointer input, then polls until the element actually matches\n   * `:hover`.\n   *\n   * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`\n   * state takes effect in the CSS engine \u2014 real theme `var()` values and real\n   * compositing \u2014 instead of a hand-simulated cascade. It polls the live\n   * `element.matches(':hover')` state (not a fixed delay), so it is robust under\n   * shared-instance load. It targets the single shared window's **global**\n   * pointer, so only one element is hovered at a time.\n   *\n   * @param params - The element to hover.\n   * @returns A {@link Promise} that resolves once the element matches `:hover`.\n   */\n  hoverElement(this: void, params: HoverElementParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to the given web-contents coordinates using a\n   * **trusted** Electron pointer move.\n   *\n   * A trusted move (injected via Electron's `webContents.sendInputEvent`)\n   * updates the real pointer state in the CSS engine, so `:hover` rules\n   * genuinely apply \u2014 unlike `dispatchEvent(new MouseEvent('mouseover'))`,\n   * which is untrusted and never sets `:hover`. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time.\n   *\n   * This is the low-level primitive: it performs a single move and does **not**\n   * wait for any state to settle (callers poll their own readiness signal).\n   * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for\n   * element-relative moves; use `moveMouse` directly when an element-relative\n   * target does not fit (e.g. an element spanning the full viewport width).\n   *\n   * Synchronous: injecting the trusted move does no real awaiting, so the caller\n   * does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   */\n  moveMouse(this: void, params: MoveMouseParams): void;\n\n  /**\n   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a\n   * trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types\n   * printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link Lib.waitUntil}. It targets the single shared\n   * window's **global** focus, so only the DOM-focused element receives the key.\n   *\n   * Synchronous: injecting the trusted key press does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   */\n  pressKey(this: void, params: PressKeyParams): void;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link Lib.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp` a real\n   * user produces. Each keystroke is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to a point just outside an element's bounding box\n   * using a **trusted** Electron pointer move, then polls until the element no\n   * longer matches `:hover`.\n   *\n   * The inverse of {@link Lib.hoverElement}. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time. When\n   * an element spans the full viewport (no point outside its box is reachable),\n   * use {@link Lib.moveMouse} directly to move the pointer to a known empty\n   * coordinate instead.\n   *\n   * @param params - The element to move the pointer away from.\n   * @returns A {@link Promise} that resolves once the element no longer matches\n   *   `:hover`.\n   */\n  unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;\n\n  /**\n   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected\n   * replacement for the per-closure poll loops consumers would otherwise\n   * hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): Promise<void>;\n}\n\n/**\n * Parameters for {@link CommonArgs.moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link CommonArgs.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArgs.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link CommonArgs.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link CommonArgs.unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point\n   * just outside its bounding box. This is a live renderer DOM node \u2014 the\n   * callback runs in-renderer, so no cross-process serialization is needed\n   * (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link CommonArgs.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    args,\n    fn,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": "AAeA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AASpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA2BrC,MAAM,YAAY;AA+WlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,OAAO,CAAC,GAAG,WAAW,IAAI,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACjH,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,CAAC,WAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,QAAM,4BAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,aAAa,sBAAsB,mBAAmB;AAE5D,QAAM,YAAY,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAE9D,MAAI,cAAc,MAAM,cAAc,WAAW;AAC/C,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,SAAS;AAAA,EACjC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,SAAS,EAAE;AAAA,EACnF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,QAAQ,yCAAyC,2BAA2B;AAC/E,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type {\n  App,\n  Editor,\n  Modifier,\n  TFile\n} from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.mjs';\nimport type { GenerateNamespaceCallParams } from './generate-function-call.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport {\n  getTransportOptions,\n  getVaultPath\n} from './context-provider.mjs';\nimport { generateNamespaceCall } from './generate-function-call.mjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\ninterface EvalErrorEnvelope {\n  type: 'error';\n  value: string;\n}\n\n/**\n * Discriminated envelope returned by the registered `evalWrapper` from inside the Obsidian process.\n *\n * - `EvalErrorEnvelope` \u2014 `fn` threw; `value` is the serialized error.\n * - `EvalUndefinedEnvelope` \u2014 `fn` returned `undefined`.\n * - `EvalValueEnvelope` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | EvalErrorEnvelope\n  | EvalUndefinedEnvelope\n  | EvalValueEnvelope;\n\ninterface EvalUndefinedEnvelope {\n  type: 'undefined';\n}\n\ninterface EvalValueEnvelope {\n  value: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The shared library bag injected into every callback \u2014 see {@link Lib}.\n   *\n   * Never empty: the harness pre-populates a **base** set of renderer-driving\n   * helpers (trusted input \u2014 `typeIntoEditor` / `pressKey` / `moveMouse` /\n   * `hoverElement` / `unhoverElement` \u2014 and `waitUntil`), and provider packages\n   * (chiefly `obsidian-dev-utils`) `Object.assign` their whole renderer-safe\n   * library on top via {@link registerLibResolver}. A serialized closure reaches\n   * every shared helper through `lib` \u2014 `lib.typeIntoEditor({ editor, text })`,\n   * `lib.getFileOrNull({ app, \u2026 })` \u2014 instead of importing or hand-rolling them.\n   */\n  lib: Lib;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link CommonArgs.createNote}.\n */\nexport interface CreateNoteParams {\n  /**\n   * The note's content. This exact string is what the created note is read back\n   * against, so it is the definition of a successful write.\n   */\n  readonly content: string;\n\n  /**\n   * The vault-relative path to create, extension included.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  readonly args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  readonly contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  readonly shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Parameters for {@link CommonArgs.hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center. This is a live\n   * renderer DOM node \u2014 the callback runs in-renderer, so no cross-process\n   * serialization is needed (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The shared library bag injected into every {@link evalInObsidian} callback as\n * {@link CommonArgs.lib}.\n *\n * Two layers compose into this one bag. The **base** \u2014 the harness-provided\n * renderer-driving helpers declared below (the trusted-input primitives and\n * {@link Lib.waitUntil}) \u2014 is always present. On top, provider packages register\n * a renderer-side resolver via {@link registerLibResolver} to `Object.assign`\n * their whole renderer-safe library at runtime, and augment this **augmentable**\n * interface (the `i18next` `CustomTypeOptions` idiom) via\n * `declare module 'obsidian-integration-testing'` to type it. Multiple providers\n * compose: their exports merge at runtime and their augmentations merge in the\n * type system (`interface Lib extends \u2026`).\n *\n * @example\n * ```ts\n * declare module 'obsidian-integration-testing' {\n *   interface Lib extends (typeof import('obsidian-dev-utils/__merged')) {}\n * }\n * ```\n */\nexport interface Lib {\n  /**\n   * Creates a note and does not return until its content is verifiably on\n   * disk, rewriting it if it is not.\n   *\n   * Use this instead of `app.vault.create` in any suite that may run on\n   * Android. The emulator transport loses roughly **0.9 %** of `vault.create`\n   * writes (measured: 7 lost in 800 creates): the file lands **0 bytes** on\n   * disk while Obsidian's in-memory `TFile.stat` reports the full byte count,\n   * and it does not heal on its own. A suite doing ~34 creates per run\n   * therefore has a ~26 % chance of at least one lost write, and whichever test\n   * loses that lottery fails on a `waitUntil` for content that was never\n   * written \u2014 which is why it reads as an unrelated per-test flake rather than\n   * one shared cause.\n   *\n   * Verification is by **reading the note back**, never by inspecting\n   * `TFile.stat`: `stat` is exactly the field that lies here. A rewrite through\n   * `vault.modify` with the same content lands correctly (also measured), so a\n   * lost write costs a retry rather than a failure. A note whose content still\n   * does not match after the bounded retries throws, naming the path and both\n   * lengths, so a genuinely broken write fails loudly instead of spinning.\n   *\n   * Harmless everywhere else \u2014 on a transport that does not lose writes the\n   * read-back matches first time and nothing is rewritten.\n   *\n   * @param params - The note path and content.\n   * @returns A {@link Promise} resolving to the created file, once its content\n   *   is confirmed.\n   */\n  createNote(this: void, params: CreateNoteParams): Promise<TFile>;\n\n  /**\n   * Moves the mouse pointer to the center of an element using **trusted**\n   * Electron pointer input, then polls until the element actually matches\n   * `:hover`.\n   *\n   * Because the move is trusted (see {@link Lib.moveMouse}), the real `:hover`\n   * state takes effect in the CSS engine \u2014 real theme `var()` values and real\n   * compositing \u2014 instead of a hand-simulated cascade. It polls the live\n   * `element.matches(':hover')` state (not a fixed delay), so it is robust under\n   * shared-instance load. It targets the single shared window's **global**\n   * pointer, so only one element is hovered at a time.\n   *\n   * @param params - The element to hover.\n   * @returns A {@link Promise} that resolves once the element matches `:hover`.\n   */\n  hoverElement(this: void, params: HoverElementParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to the given web-contents coordinates using a\n   * **trusted** Electron pointer move.\n   *\n   * A trusted move (injected via Electron's `webContents.sendInputEvent`)\n   * updates the real pointer state in the CSS engine, so `:hover` rules\n   * genuinely apply \u2014 unlike `dispatchEvent(new MouseEvent('mouseover'))`,\n   * which is untrusted and never sets `:hover`. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time.\n   *\n   * This is the low-level primitive: it performs a single move and does **not**\n   * wait for any state to settle (callers poll their own readiness signal).\n   * Prefer {@link Lib.hoverElement} / {@link Lib.unhoverElement} for\n   * element-relative moves; use `moveMouse` directly when an element-relative\n   * target does not fit (e.g. an element spanning the full viewport width).\n   *\n   * Synchronous: injecting the trusted move does no real awaiting, so the caller\n   * does not need to `await` it.\n   *\n   * @param params - The web-contents DIP coordinates to move to.\n   */\n  moveMouse(this: void, params: MoveMouseParams): void;\n\n  /**\n   * Presses a single key (optionally with modifiers) using **trusted** Electron\n   * keyboard input, firing the full real key pipeline \u2014\n   * `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n   *\n   * This is the key-press analog of {@link Lib.typeIntoEditor}: it injects a\n   * trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence via Electron's\n   * `webContents.sendInputEvent`, so it is delivered to the window's DOM-focused\n   * element and flows through the real input pipeline \u2014 unlike\n   * `dispatchEvent(new KeyboardEvent(...))`, which is untrusted (`isTrusted:\n   * false`) and ignored by CodeMirror and most key handlers. Use it for special\n   * keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations\n   * (`Shift+Enter`, `Ctrl+A`) that {@link Lib.typeIntoEditor} (which types\n   * printable text) does not cover.\n   *\n   * This is the low-level primitive: it injects the key press and does **not**\n   * poll for any effect (a key press has no universal observable outcome \u2014\n   * `Enter` edits the document, `Escape` closes a modal, `ArrowDown` moves the\n   * selection). The caller focuses the intended target first, then awaits the\n   * expected effect via {@link Lib.waitUntil}. It targets the single shared\n   * window's **global** focus, so only the DOM-focused element receives the key.\n   *\n   * Synchronous: injecting the trusted key press does no real awaiting, so the\n   * caller does not need to `await` it.\n   *\n   * @param params - The key to press and any modifiers to hold.\n   */\n  pressKey(this: void, params: PressKeyParams): void;\n\n  /**\n   * Types text into a CodeMirror {@link Editor} using **trusted** Electron\n   * keyboard input.\n   *\n   * Typing is pressing each character key in turn: this focuses the editor\n   * (caret to end) and presses every code point of `text` via\n   * {@link Lib.pressKey} \u2014 the same trusted `keyDown` \u2192 `char` \u2192 `keyUp` a real\n   * user produces. Each keystroke is delivered to the window's DOM-focused\n   * element and flows through CodeMirror's real input pipeline, so the typed\n   * text reaches the document **only if the editor genuinely holds focus**.\n   * This makes \"the user typed into the editor\" a faithful end-to-end check,\n   * unlike `dispatchEvent(new KeyboardEvent(...))` (untrusted \u2014 ignored by\n   * CodeMirror) or `execCommand('insertText')` (mutates the selection even\n   * when the editor is not focused, masking focus bugs as false positives).\n   *\n   * After injecting the keystrokes it polls until the document reflects the\n   * input, or a bounded timeout elapses (the expected outcome when the editor\n   * is read-only and rejects the input, or when focus was stolen).\n   *\n   * @param params - The editor to type into and the text to type.\n   * @returns A {@link Promise} that resolves once the keystrokes have settled.\n   */\n  typeIntoEditor(this: void, params: TypeIntoEditorParams): Promise<void>;\n\n  /**\n   * Moves the mouse pointer to a point just outside an element's bounding box\n   * using a **trusted** Electron pointer move, then polls until the element no\n   * longer matches `:hover`.\n   *\n   * The inverse of {@link Lib.hoverElement}. It targets the single shared\n   * window's **global** pointer, so only one element is hovered at a time. When\n   * an element spans the full viewport (no point outside its box is reachable),\n   * use {@link Lib.moveMouse} directly to move the pointer to a known empty\n   * coordinate instead.\n   *\n   * @param params - The element to move the pointer away from.\n   * @returns A {@link Promise} that resolves once the element no longer matches\n   *   `:hover`.\n   */\n  unhoverElement(this: void, params: UnhoverElementParams): Promise<void>;\n\n  /**\n   * Polls a predicate until it becomes truthy, or rejects once a bounded\n   * timeout elapses.\n   *\n   * Integration-test `evalInObsidian` callbacks routinely need to wait for an\n   * asynchronous effect to settle (a view to open, a DOM node to appear, a\n   * setting to apply). Because the callback is serialized via `toString()` and\n   * cannot import modules, it can't reuse `obsidian-dev-utils`'\n   * `retryWithTimeout` / `runWithTimeout`. This helper is the shared, injected\n   * replacement for the per-closure poll loops consumers would otherwise\n   * hand-roll.\n   *\n   * The `predicate` may be synchronous or asynchronous \u2014 it is awaited on every\n   * poll. It is checked immediately, then re-checked every\n   * `intervalInMilliseconds` until it returns truthy or `timeoutInMilliseconds`\n   * elapses, at which point the returned {@link Promise} rejects (the error\n   * includes `message` when provided).\n   *\n   * @param params - The predicate to poll plus optional timeout, interval, and\n   *   timeout message.\n   * @returns A {@link Promise} that resolves once the predicate is truthy.\n   */\n  waitUntil(this: void, params: WaitUntilParams): Promise<void>;\n}\n\n/**\n * Parameters for {@link CommonArgs.moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link CommonArgs.pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g.\n   * `'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, an arrow key\n   * (`'Up'` / `'Down'` / `'Left'` / `'Right'`), or a printable character\n   * (`'a'`, `'1'`). The produced character (when the key inserts text) is the\n   * literal `key` value; case-correct text belongs to\n   * {@link CommonArgs.typeIntoEditor}, not a key-press primitive.\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold while the key is pressed, using Obsidian's\n   * {@link Modifier} names (the same values as an Obsidian `Hotkey`). `'Mod'`\n   * resolves per-platform (Cmd on macOS, Ctrl elsewhere); each is mapped to\n   * Electron's lowercase `sendInputEvent` modifier name.\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link CommonArgs.typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (with the caret moved to the end of\n   * the document) before the keystrokes are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link CommonArgs.pressKey}\n   * (a trusted `keyDown` \u2192 `char` \u2192 `keyUp`), exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link CommonArgs.unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point\n   * just outside its bounding box. This is a live renderer DOM node \u2014 the\n   * callback runs in-renderer, so no cross-process serialization is needed\n   * (same as {@link TypeIntoEditorParams.editor}).\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link CommonArgs.waitUntil}.\n */\nexport interface WaitUntilParams {\n  /**\n   * The polling interval between predicate checks.\n   *\n   * @default `50`\n   */\n  readonly intervalInMilliseconds?: number;\n\n  /**\n   * An optional detail appended to the timeout error message, describing what\n   * was being waited for.\n   */\n  readonly message?: string;\n\n  /**\n   * The condition to wait for. Polled immediately, then on every interval until\n   * it returns a truthy value. May be synchronous or asynchronous \u2014 it is\n   * awaited on each poll.\n   *\n   * @returns Whether the awaited condition has been met.\n   */\n  predicate(this: void): boolean | Promise<boolean>;\n\n  /**\n   * The maximum time to wait before rejecting.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? getVaultPath() ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  await ensureNamespaceBootstrapped(transport, cwd);\n\n  const namespaceCallParams: GenerateNamespaceCallParams = {\n    args,\n    fn,\n    ...(contextId !== undefined && { contextId: String(contextId) })\n  };\n\n  const expression = generateNamespaceCall(namespaceCallParams);\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n"],
  "mappings": "AAgBA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AASpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,mCAAmC;AAC5C,SAAS,4BAA4B;AA2BrC,MAAM,YAAY;AA6ZlB,eAAsB,eACpB,QACiB;AAEjB,QAAM,EAAE,OAAO,CAAC,GAAG,WAAW,IAAI,4BAA4B,OAAO,WAAW,mBAAmB,UAAU,IAAI;AACjH,QAAM,MAAM,aAAa,aAAa,KAAK,QAAQ,IAAI;AAGvD,MAAI,cAAc,UAAa,CAAC,WAAW,SAAS,GAAG;AACrD,UAAM,IAAI,MAAM,8BAA8B,SAAS,EAAE;AAAA,EAC3D;AAEA,QAAM,YAAY,qBAAqB,MAAM,qBAAqB,oBAAoB,CAAC;AAEvF,MAAI,CAAC,2BAA2B;AAC9B,UAAM,UAAU,eAAe,GAAG;AAAA,EACpC;AAEA,QAAM,4BAA4B,WAAW,GAAG;AAEhD,QAAM,sBAAmD;AAAA,IACvD;AAAA,IACA;AAAA,IACA,GAAI,cAAc,UAAa,EAAE,WAAW,OAAO,SAAS,EAAE;AAAA,EAChE;AAEA,QAAM,aAAa,sBAAsB,mBAAmB;AAE5D,QAAM,YAAY,MAAM,UAAU,SAAS,YAAY,EAAE,IAAI,CAAC;AAE9D,MAAI,cAAc,MAAM,cAAc,WAAW;AAC/C,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,KAAK,MAAM,SAAS;AAAA,EACjC,QAAQ;AACN,UAAM,IAAI,MAAM,sDAAsD,SAAS,EAAE;AAAA,EACnF;AAEA,MAAI,UAAU,UAAU;AACtB,QAAI,SAAS,SAAS,SAAS;AAI7B,YAAM,kBAAkB,SAAS,MAC9B,QAAQ,yCAAyC,2BAA2B;AAC/E,YAAM,IAAI,MAAM;AAAA,EAA2C,eAAe,EAAE;AAAA,IAC9E;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AAClB;",
  "names": []
}


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

@@ -83,6 +83,37 @@ export interface LeftoverRoot {
     /** 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}.
  */
@@ -149,6 +180,28 @@ export declare function resolveLeftoverMaxAgeInMilliseconds(options: ObsidianTra
  * @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.
  *

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

@@ -25,6 +25,22 @@ function resolveLeftoverMaxAgeInMilliseconds(options) {
 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();
@@ -83,6 +99,7 @@ export {
   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.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 * 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 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": "AA2BA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,YAAY;AAOd,MAAM,2CAA2C;AAOjD,MAAM,wBAAwB;AAK9B,MAAM,6BAA6B;AAMnC,MAAM,wBAAwB;AA0G9B,SAAS,qBAAqB,QAA6C;AAChF,MAAI,OAAO,yBAAyB,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,oBAAoB,OAAO,4BAA4B,OAAO;AAC9E;AAYO,SAAS,oBAAoB,QAA6C;AAC/E,QAAM,gBAAgB,OAAO,iBAAiB,CAAC;AAC/C,SAAO,OAAO,MACX,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,CAAC,SAAS,OAAO,SAAS,KAAK,CAAC,WAAW,KAAK,WAAW,MAAM,CAAC,CAAC,EAC1E,OAAO,CAAC,SAAS,CAAC,cAAc,SAAS,IAAI,CAAC;AACnD;AASO,SAAS,oCAAoC,SAAuD;AACzG,SAAO,SAAS,gCAAgC;AAClD;AASO,SAAS,4BAA4B,SAAwD;AAClG,SAAO,SAAS,wBAAwB;AAC1C;AAaA,eAAsB,mBAAmB,SAAwE;AAC/G,QAAM,uBAAuB,SAAS,wBAAwB;AAC9D,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,QAAQ,SAAS,SAAS,wBAAwB;AAExD,MAAI,cAAc;AAClB,MAAI,eAAe;AAEnB,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,oBAAoB;AAAA,MAChC,eAAe,SAAS;AAAA,MACxB,OAAO,MAAM,aAAa,KAAK,IAAI;AAAA,MACnC,UAAU,KAAK;AAAA,IACjB,CAAC;AAED,eAAW,QAAQ,OAAO;AACxB,YAAM,OAAO,KAAK,KAAK,MAAM,IAAI;AACjC,UAAI,CAAC,MAAM,oBAAoB,EAAE,sBAAsB,mBAAmB,KAAK,CAAC,GAAG;AACjF;AAAA,MACF;AAEA,UAAI;AACF,cAAM,GAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAC/C;AAAA,MACF,QAAQ;AACN;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,aAAa,aAAa;AACrC;AAQA,eAAe,oBAAoB,QAAqD;AACtF,QAAM,EAAE,sBAAsB,kBAAkB,IAAI;AACpD,MAAI;AACF,UAAM,QAAQ,MAAM,KAAK,OAAO,IAAI;AACpC,WAAO,MAAM,YAAY,KACpB,qBAAqB,EAAE,sBAAsB,0BAA0B,MAAM,SAAS,kBAAkB,CAAC;AAAA,EAChH,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAOA,SAAS,0BAA0C;AACjD,SAAO;AAAA,IACL,EAAE,MAAM,OAAO,GAAG,UAAU,CAAC,qBAAqB,EAAE;AAAA,IACpD,EAAE,MAAM,KAAK,OAAO,GAAG,qBAAqB,GAAG,UAAU,CAAC,0BAA0B,EAAE;AAAA,EACxF;AACF;AAQA,eAAe,aAAa,MAAiC;AAC3D,MAAI;AACF,WAAO,MAAM,QAAQ,IAAI;AAAA,EAC3B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;",
  "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 = 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": "AA2BA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,YAAY;AAOd,MAAM,2CAA2C;AAOjD,MAAM,wBAAwB;AAK9B,MAAM,6BAA6B;AAMnC,MAAM,wBAAwB;AA8I9B,SAAS,qBAAqB,QAA6C;AAChF,MAAI,OAAO,yBAAyB,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,oBAAoB,OAAO,4BAA4B,OAAO;AAC9E;AAYO,SAAS,oBAAoB,QAA6C;AAC/E,QAAM,gBAAgB,OAAO,iBAAiB,CAAC;AAC/C,SAAO,OAAO,MACX,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,CAAC,SAAS,OAAO,SAAS,KAAK,CAAC,WAAW,KAAK,WAAW,MAAM,CAAC,CAAC,EAC1E,OAAO,CAAC,SAAS,CAAC,cAAc,SAAS,IAAI,CAAC;AACnD;AASO,SAAS,oCAAoC,SAAuD;AACzG,SAAO,SAAS,gCAAgC;AAClD;AASO,SAAS,4BAA4B,SAAwD;AAClG,SAAO,SAAS,wBAAwB;AAC1C;AAuBA,eAAsB,qBACpB,QACqC;AACrC,QAAM,EAAE,WAAW,WAAW,cAAc,IAAI;AAEhD,QAAM,QAAQ,oBAAoB,EAAE,OAAO,MAAM,UAAU,GAAG,UAAU,CAAC,qBAAqB,EAAE,CAAC;AACjG,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,EAAE,aAAa,CAAC,GAAG,cAAc,EAAE;AAAA,EAC5C;AAEA,aAAW,QAAQ,OAAO;AACxB,QAAI;AACF,YAAM,UAAU,GAAG,aAAa,GAAG,IAAI,EAAE;AAAA,IAC3C,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,QAAM,iBAAiB,oBAAoB,EAAE,OAAO,MAAM,UAAU,GAAG,UAAU,CAAC,qBAAqB,EAAE,CAAC;AAC1G,QAAM,cAAc,MAAM,OAAO,CAAC,SAAS,eAAe,SAAS,IAAI,CAAC;AAExE,SAAO,EAAE,aAAa,cAAc,MAAM,SAAS,YAAY,OAAO;AACxE;AAaA,eAAsB,mBAAmB,SAAwE;AAC/G,QAAM,uBAAuB,SAAS,wBAAwB;AAC9D,QAAM,oBAAoB,KAAK,IAAI;AACnC,QAAM,QAAQ,SAAS,SAAS,wBAAwB;AAExD,MAAI,cAAc;AAClB,MAAI,eAAe;AAEnB,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,oBAAoB;AAAA,MAChC,eAAe,SAAS;AAAA,MACxB,OAAO,MAAM,aAAa,KAAK,IAAI;AAAA,MACnC,UAAU,KAAK;AAAA,IACjB,CAAC;AAED,eAAW,QAAQ,OAAO;AACxB,YAAM,OAAO,KAAK,KAAK,MAAM,IAAI;AACjC,UAAI,CAAC,MAAM,oBAAoB,EAAE,sBAAsB,mBAAmB,KAAK,CAAC,GAAG;AACjF;AAAA,MACF;AAEA,UAAI;AACF,cAAM,GAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAC/C;AAAA,MACF,QAAQ;AACN;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,aAAa,aAAa;AACrC;AAQA,eAAe,oBAAoB,QAAqD;AACtF,QAAM,EAAE,sBAAsB,kBAAkB,IAAI;AACpD,MAAI;AACF,UAAM,QAAQ,MAAM,KAAK,OAAO,IAAI;AACpC,WAAO,MAAM,YAAY,KACpB,qBAAqB,EAAE,sBAAsB,0BAA0B,MAAM,SAAS,kBAAkB,CAAC;AAAA,EAChH,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAOA,SAAS,0BAA0C;AACjD,SAAO;AAAA,IACL,EAAE,MAAM,OAAO,GAAG,UAAU,CAAC,qBAAqB,EAAE;AAAA,IACpD,EAAE,MAAM,KAAK,OAAO,GAAG,qBAAqB,GAAG,UAAU,CAAC,0BAA0B,EAAE;AAAA,EACxF;AACF;AAQA,eAAe,aAAa,MAAiC;AAC3D,MAAI;AACF,WAAO,MAAM,QAAQ,IAAI;AAAA,EAC3B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;",
  "names": []
}


package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "9.1.1";
+const LIBRARY_VERSION = false ? "dev" : "9.2.1";
 export {
   LIBRARY_VERSION
 };