obsidian-integration-testing 12.0.0 → 12.1.0

package/dist/lib/esm/process-liveness.d.mts

@@ -0,0 +1,18 @@
+/**
+ * @file
+ *
+ * Cheap, synchronous "is this PID still running?" probe.
+ *
+ * Signal `0` performs the permission and existence checks without delivering a
+ * signal, on Windows as well as POSIX, so it costs nothing at teardown-poll
+ * frequency. `EPERM` means the process exists but is owned by another user —
+ * still alive, and the distinction matters: reading it as dead is how a
+ * teardown convinces itself a process it could not touch is gone.
+ */
+/**
+ * Checks whether a process is still running.
+ *
+ * @param pid - The PID to probe.
+ * @returns `true` when the process exists.
+ */
+export declare function checkIsProcessAlive(pid: number): boolean;

package/dist/lib/esm/process-liveness.mjs

@@ -0,0 +1,17 @@
+import process from "node:process";
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+function checkIsProcessAlive(pid) {
+  try {
+    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+export {
+  checkIsProcessAlive
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3Byb2Nlc3MtbGl2ZW5lc3MudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDaGVhcCwgc3luY2hyb25vdXMgXCJpcyB0aGlzIFBJRCBzdGlsbCBydW5uaW5nP1wiIHByb2JlLlxuICpcbiAqIFNpZ25hbCBgMGAgcGVyZm9ybXMgdGhlIHBlcm1pc3Npb24gYW5kIGV4aXN0ZW5jZSBjaGVja3Mgd2l0aG91dCBkZWxpdmVyaW5nIGFcbiAqIHNpZ25hbCwgb24gV2luZG93cyBhcyB3ZWxsIGFzIFBPU0lYLCBzbyBpdCBjb3N0cyBub3RoaW5nIGF0IHRlYXJkb3duLXBvbGxcbiAqIGZyZXF1ZW5jeS4gYEVQRVJNYCBtZWFucyB0aGUgcHJvY2VzcyBleGlzdHMgYnV0IGlzIG93bmVkIGJ5IGFub3RoZXIgdXNlciBcdTIwMTRcbiAqIHN0aWxsIGFsaXZlLCBhbmQgdGhlIGRpc3RpbmN0aW9uIG1hdHRlcnM6IHJlYWRpbmcgaXQgYXMgZGVhZCBpcyBob3cgYVxuICogdGVhcmRvd24gY29udmluY2VzIGl0c2VsZiBhIHByb2Nlc3MgaXQgY291bGQgbm90IHRvdWNoIGlzIGdvbmUuXG4gKi9cblxuaW1wb3J0IHByb2Nlc3MgZnJvbSAnbm9kZTpwcm9jZXNzJztcblxuY29uc3QgUFJPQ0VTU19FWElTVEVOQ0VfUFJPQkVfU0lHTkFMID0gMDtcblxuLyoqXG4gKiBDaGVja3Mgd2hldGhlciBhIHByb2Nlc3MgaXMgc3RpbGwgcnVubmluZy5cbiAqXG4gKiBAcGFyYW0gcGlkIC0gVGhlIFBJRCB0byBwcm9iZS5cbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIHRoZSBwcm9jZXNzIGV4aXN0cy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNoZWNrSXNQcm9jZXNzQWxpdmUocGlkOiBudW1iZXIpOiBib29sZWFuIHtcbiAgdHJ5IHtcbiAgICBwcm9jZXNzLmtpbGwocGlkLCBQUk9DRVNTX0VYSVNURU5DRV9QUk9CRV9TSUdOQUwpO1xuICAgIHJldHVybiB0cnVlO1xuICB9IGNhdGNoIChlcnJvcjogdW5rbm93bikge1xuICAgIHJldHVybiBnZXRFcnJvckNvZGUoZXJyb3IpID09PSAnRVBFUk0nO1xuICB9XG59XG5cbmZ1bmN0aW9uIGdldEVycm9yQ29kZShlcnJvcjogdW5rbm93bik6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiB0eXBlb2YgZXJyb3IgPT09ICdvYmplY3QnICYmIGVycm9yICE9PSBudWxsICYmICdjb2RlJyBpbiBlcnJvciA/IFN0cmluZyhlcnJvci5jb2RlKSA6IHVuZGVmaW5lZDtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQVlBLE9BQU8sYUFBYTtBQUVwQixNQUFNLGlDQUFpQztBQVFoQyxTQUFTLG9CQUFvQixLQUFzQjtBQUN4RCxNQUFJO0FBQ0YsWUFBUSxLQUFLLEtBQUssOEJBQThCO0FBQ2hELFdBQU87QUFBQSxFQUNULFNBQVMsT0FBZ0I7QUFDdkIsV0FBTyxhQUFhLEtBQUssTUFBTTtBQUFBLEVBQ2pDO0FBQ0Y7QUFFQSxTQUFTLGFBQWEsT0FBb0M7QUFDeEQsU0FBTyxPQUFPLFVBQVUsWUFBWSxVQUFVLFFBQVEsVUFBVSxRQUFRLE9BQU8sTUFBTSxJQUFJLElBQUk7QUFDL0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

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

@@ -32,7 +32,7 @@ export interface RunObsidianVersionMatrixParams {
      * so an env var can be passed straight through.
      *
      * Each accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.
-     * Defaults to both ends of the supported range (G99) when omitted or empty, and
+     * Defaults to both ends of the supported range when omitted or empty, and
      * the list is always de-duplicated on the **resolved** version — so when public
      * has caught up to catalyst, the suites run once.
      */

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

@@ -45,4 +45,4 @@ function logPlan(resolvedSpecs, entries) {
 export {
   runObsidianVersionMatrix
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/teardown-verdict.d.mts

@@ -0,0 +1,69 @@
+/**
+ * @file
+ *
+ * Pure verdict + message building for the auto-started-process teardown.
+ *
+ * The teardown used to log `Auto-started Appium server stopped.` on the
+ * **attempt** — printed unconditionally right after the kill was issued, with
+ * nothing asserting the process had actually exited. On 2026-09-02 both the
+ * server and the emulator were still serving ten minutes after that line was
+ * written, and the next run adopted them and died two seconds into its session
+ * as they finally finished dying. A log that says the machine is clean when it
+ * is not does not merely fail to help — it sends the next reader away from the
+ * cause.
+ *
+ * So a stop is a claim that has to be earned: only {@link resolveTeardownOutcome}
+ * may decide one was, and only the `stopped` outcomes are allowed to say so.
+ */
+/**
+ * Parameters for {@link buildTeardownMessage}.
+ */
+export interface BuildTeardownMessageParams {
+    /**
+    What was checked, as a noun phrase — e.g. `port 4723`, `AVD "obsidian_test" on device emulator-5554`.
+     */
+    readonly evidence: string;
+    /**
+    The verdict from {@link resolveTeardownOutcome}.
+     */
+    readonly outcome: TeardownOutcome;
+    /**
+    What was being stopped — e.g. `Auto-started Appium server`.
+     */
+    readonly subject: string;
+    /**
+    The budget the stop was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Parameters for {@link resolveTeardownOutcome}.
+ */
+export interface ResolveTeardownOutcomeParams {
+    /**
+    Whether the first kill was followed by a second, harder one.
+     */
+    readonly hasEscalated: boolean;
+    /**
+    Whether the process was **observed** to be gone, rather than merely asked to go.
+     */
+    readonly isStopped: boolean;
+}
+/**
+ * What the teardown actually achieved.
+ */
+export type TeardownOutcome = 'still-running' | 'stopped-after-escalation' | 'stopped';
+/**
+ * Builds the line the teardown logs for an outcome.
+ *
+ * @param params - The outcome plus what was being stopped and what proved it.
+ * @returns The log line.
+ */
+export declare function buildTeardownMessage(params: BuildTeardownMessageParams): string;
+/**
+ * Decides what the teardown achieved, from what was observed after the kill.
+ *
+ * @param params - Whether the process is gone, and whether it took an escalation.
+ * @returns The outcome.
+ */
+export declare function resolveTeardownOutcome(params: ResolveTeardownOutcomeParams): TeardownOutcome;

package/dist/lib/esm/teardown-verdict.mjs

@@ -0,0 +1,28 @@
+import { assertNever } from "./type-guards.mjs";
+function buildTeardownMessage(params) {
+  switch (params.outcome) {
+    case "still-running": {
+      return `WARNING: ${params.subject} did not exit within ${String(params.timeoutInMilliseconds)}ms and still holds ${params.evidence}; a later run may adopt it. Kill it before the next Android run.`;
+    }
+    case "stopped": {
+      return `${params.subject} stopped (verified: ${params.evidence} released).`;
+    }
+    case "stopped-after-escalation": {
+      return `${params.subject} stopped after escalation (verified: ${params.evidence} released).`;
+    }
+    default: {
+      return assertNever(params.outcome);
+    }
+  }
+}
+function resolveTeardownOutcome(params) {
+  if (!params.isStopped) {
+    return "still-running";
+  }
+  return params.hasEscalated ? "stopped-after-escalation" : "stopped";
+}
+export {
+  buildTeardownMessage,
+  resolveTeardownOutcome
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/temporary-vault.d.mts

@@ -21,13 +21,32 @@ export type PopulateFileContent = string | Uint8Array | undefined;
  * All other paths are written as files.
  */
 export type PopulateFilesParams = Record<string, PopulateFileContent>;
+/**
+ * Options for the {@link TemporaryVault} constructor.
+ */
+export interface TemporaryVaultOptions {
+    /**
+     * Whether {@link TemporaryVault.dispose} removes the vault **directory**.
+     *
+     * When omitted, defaults to whether this instance created that directory — `true` for a temp
+     * directory the constructor made (no `path` argument), `false` for a directory handed to it as an
+     * explicit `path`. A handle over somebody else's directory unregisters the vault but leaves the
+     * files alone, so wrapping a directory cannot destroy it. Set explicitly to override.
+     */
+    readonly shouldRemoveDirectoryOnDispose?: boolean;
+}
 /**
  * A temporary Obsidian vault for integration tests.
  *
  * Creates a temp directory and registers it in the running Obsidian instance
  * so that the Obsidian CLI can target it via `cwd`.
+ *
+ * A handle **owns** the directory only when it created it. {@link TemporaryVault.dispose} deletes an
+ * owned directory and leaves a borrowed one in place — see
+ * {@link TemporaryVaultOptions.shouldRemoveDirectoryOnDispose}, which overrides that default.
  */
 export declare class TemporaryVault {
+    #private;
     /**
      * The absolute path to the temporary vault.
      */
@@ -36,29 +55,50 @@ export declare class TemporaryVault {
      * Creates a new temp vault.
      *
      * @param path - An explicit vault path. If omitted, a temp directory is created.
+     * @param options - Vault options.
      */
-    constructor(path?: string);
+    constructor(path?: string, options?: TemporaryVaultOptions);
     /**
-     * Unregisters the vault from Obsidian and deletes the temp directory.
+     * Unregisters the vault from Obsidian and, when this handle owns the directory, deletes it.
+     *
+     * The directory is removed only when this instance created it, or when
+     * {@link TemporaryVaultOptions.shouldRemoveDirectoryOnDispose} said so explicitly. That is what
+     * makes a handle over a directory somebody else owns — the run's shared setup vault, say, which
+     * `getTemporaryVault()` wraps — safe to dispose from a consumer's `afterAll`.
      *
      * @param transportOverride - An explicit transport to use when unregistering.
      *   When omitted, falls back to the transport configured via the context provider.
      */
     dispose(transportOverride?: ObsidianTransport): Promise<void>;
     /**
-     * Writes files and folders into the vault directory.
+     * Writes files and folders into the vault directory **on the host**.
      * Parent directories are created automatically.
      *
      * - `string` values are written as UTF-8 text files.
      * - `Uint8Array` values (including `Buffer`) are written as binary files.
      * - Paths ending with `/` are treated as empty folders (value must be `undefined`).
      *
+     * The write is always host-local — {@link TemporaryVault.path} is a host path, and on a mobile
+     * transport the vault the app opens lives on the device instead. {@link TemporaryVault.register}
+     * carries the directory across before it registers, so populate-then-register is all a caller
+     * needs; {@link TemporaryVault.syncToDevice} is the seam that does the carrying.
+     *
      * @param files - Map of file/folder paths to content.
      */
     populate(files: PopulateFilesParams): void;
     /**
      * Registers this vault in the running Obsidian instance so the CLI can target it.
      *
+     * Pushes the vault directory to the target device first, via
+     * {@link TemporaryVault.syncToDevice} — a no-op on a transport whose app already reads the host
+     * filesystem. That ordering used to be the caller's to remember, and a caller who forgot got a
+     * silently **empty** vault rather than an error: every pre-registration
+     * {@link TemporaryVault.populate} write stayed on the host while the app opened the device's copy.
+     * Folding it in here makes populate-then-register correct on every transport.
+     *
+     * The transport is resolved once and handed to both steps, so a push and the registration that
+     * follows it can never land on two different transports.
+     *
      * @param transportOverride - An explicit transport to use. When omitted,
      *   falls back to the transport configured via the context provider.
      */
@@ -76,8 +116,10 @@ export declare class TemporaryVault {
      * On desktop transports this is a no-op (files are already local).
      * On mobile transports (Appium) this pushes files to the device.
      *
-     * Call this after {@link populate} and before {@link register} when using
-     * a mobile transport.
+     * {@link TemporaryVault.register} calls this itself, so a populate-then-register sequence needs
+     * nothing extra. Call it directly only to carry across files written **after** registration: the
+     * host directory is not mirrored, so a later write into {@link TemporaryVault.path} stays on the
+     * host until this runs again.
      *
      * @param transportOverride - An explicit transport to use. When omitted,
      *   falls back to the transport configured via the context provider.

package/dist/lib/esm/temporary-vault.mjs

@@ -16,6 +16,7 @@ import {
 } from "node:path";
 import { getTransportOptions } from "./context-provider.mjs";
 import { TEMP_VAULT_DIR_PREFIX } from "./leftover-cleanup.mjs";
+import { log } from "./log.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
 import {
   registerVault,
@@ -28,16 +29,27 @@ class TemporaryVault {
    * The absolute path to the temporary vault.
    */
   path;
+  /**
+   * Whether {@link TemporaryVault.dispose} removes {@link TemporaryVault.path} from disk.
+   */
+  #shouldRemoveDirectoryOnDispose;
   /**
    * Creates a new temp vault.
    *
    * @param path - An explicit vault path. If omitted, a temp directory is created.
+   * @param options - Vault options.
    */
-  constructor(path) {
+  constructor(path, options) {
     this.path = path ?? mkdtempSync(join(tmpdir(), TEMP_VAULT_DIR_PREFIX));
+    this.#shouldRemoveDirectoryOnDispose = options?.shouldRemoveDirectoryOnDispose ?? path === void 0;
   }
   /**
-   * Unregisters the vault from Obsidian and deletes the temp directory.
+   * Unregisters the vault from Obsidian and, when this handle owns the directory, deletes it.
+   *
+   * The directory is removed only when this instance created it, or when
+   * {@link TemporaryVaultOptions.shouldRemoveDirectoryOnDispose} said so explicitly. That is what
+   * makes a handle over a directory somebody else owns — the run's shared setup vault, say, which
+   * `getTemporaryVault()` wraps — safe to dispose from a consumer's `afterAll`.
    *
    * @param transportOverride - An explicit transport to use when unregistering.
    *   When omitted, falls back to the transport configured via the context provider.
@@ -46,17 +58,26 @@ class TemporaryVault {
     try {
       await unregisterVault(this.path, transportOverride);
     } finally {
-      await retryRm(this.path);
+      if (this.#shouldRemoveDirectoryOnDispose) {
+        await retryRm(this.path);
+      } else {
+        log(`[temporary-vault] Unregistered but kept the vault directory, which this handle does not own: ${this.path}`);
+      }
     }
   }
   /**
-   * Writes files and folders into the vault directory.
+   * Writes files and folders into the vault directory **on the host**.
    * Parent directories are created automatically.
    *
    * - `string` values are written as UTF-8 text files.
    * - `Uint8Array` values (including `Buffer`) are written as binary files.
    * - Paths ending with `/` are treated as empty folders (value must be `undefined`).
    *
+   * The write is always host-local — {@link TemporaryVault.path} is a host path, and on a mobile
+   * transport the vault the app opens lives on the device instead. {@link TemporaryVault.register}
+   * carries the directory across before it registers, so populate-then-register is all a caller
+   * needs; {@link TemporaryVault.syncToDevice} is the seam that does the carrying.
+   *
    * @param files - Map of file/folder paths to content.
    */
   populate(files) {
@@ -79,11 +100,23 @@ class TemporaryVault {
   /**
    * Registers this vault in the running Obsidian instance so the CLI can target it.
    *
+   * Pushes the vault directory to the target device first, via
+   * {@link TemporaryVault.syncToDevice} — a no-op on a transport whose app already reads the host
+   * filesystem. That ordering used to be the caller's to remember, and a caller who forgot got a
+   * silently **empty** vault rather than an error: every pre-registration
+   * {@link TemporaryVault.populate} write stayed on the host while the app opened the device's copy.
+   * Folding it in here makes populate-then-register correct on every transport.
+   *
+   * The transport is resolved once and handed to both steps, so a push and the registration that
+   * follows it can never land on two different transports.
+   *
    * @param transportOverride - An explicit transport to use. When omitted,
    *   falls back to the transport configured via the context provider.
    */
   async register(transportOverride) {
-    await registerVault(this.path, transportOverride);
+    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());
+    await this.syncToDevice(transport);
+    await registerVault(this.path, transport);
   }
   /**
    * Async disposable support for `await using`.
@@ -101,8 +134,10 @@ class TemporaryVault {
    * On desktop transports this is a no-op (files are already local).
    * On mobile transports (Appium) this pushes files to the device.
    *
-   * Call this after {@link populate} and before {@link register} when using
-   * a mobile transport.
+   * {@link TemporaryVault.register} calls this itself, so a populate-then-register sequence needs
+   * nothing extra. Call it directly only to carry across files written **after** registration: the
+   * host directory is not mirrored, so a later write into {@link TemporaryVault.path} stays on the
+   * host until this runs again.
    *
    * @param transportOverride - An explicit transport to use. When omitted,
    *   falls back to the transport configured via the context provider.
@@ -154,4 +189,4 @@ async function retryRm(path) {
 export {
   TemporaryVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temporary-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Manages temporary vault lifecycle for integration tests.\n */\n\nimport {\n  mkdirSync,\n  mkdtempSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  readdir,\n  readFile,\n  rm\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  dirname,\n  join,\n  relative\n} from 'node:path';\n\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\n\n/**\n * Content value for a single entry in a {@link PopulateFiles} map.\n *\n * - `string` \u2014 text file (written as UTF-8).\n * - `Uint8Array` \u2014 binary file (written as raw bytes; `Buffer` is accepted\n *   because `Buffer extends Uint8Array`).\n * - `undefined` \u2014 empty folder (the key **must** end with `/`).\n */\nexport type PopulateFileContent = string | Uint8Array | undefined;\n\n/**\n * A map of vault-relative paths to their content, used by\n * {@link TemporaryVault.populate}.\n *\n * Paths ending with `/` denote folders and **must** have an `undefined` value.\n * All other paths are written as files.\n */\nexport type PopulateFilesParams = Record<string, PopulateFileContent>;\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * A temporary Obsidian vault for integration tests.\n *\n * Creates a temp directory and registers it in the running Obsidian instance\n * so that the Obsidian CLI can target it via `cwd`.\n */\nexport class TemporaryVault {\n  /**\n   * The absolute path to the temporary vault.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a new temp vault.\n   *\n   * @param path - An explicit vault path. If omitted, a temp directory is created.\n   */\n  public constructor(path?: string) {\n    this.path = path ?? mkdtempSync(join(tmpdir(), TEMP_VAULT_DIR_PREFIX));\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and deletes the temp directory.\n   *\n   * @param transportOverride - An explicit transport to use when unregistering.\n   *   When omitted, falls back to the transport configured via the context provider.\n   */\n  public async dispose(transportOverride?: ObsidianTransport): Promise<void> {\n    try {\n      await unregisterVault(this.path, transportOverride);\n    } finally {\n      await retryRm(this.path);\n    }\n  }\n\n  /**\n   * Writes files and folders into the vault directory.\n   * Parent directories are created automatically.\n   *\n   * - `string` values are written as UTF-8 text files.\n   * - `Uint8Array` values (including `Buffer`) are written as binary files.\n   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: PopulateFilesParams): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== undefined) {\n          throw new Error(`Folder path \"${filePath}\" must have undefined content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        if (content === undefined) {\n          throw new Error(`File path \"${filePath}\" must have defined content; use a trailing \"/\" for folders`);\n        }\n        mkdirSync(dirname(fullPath), { recursive: true });\n        writeFileSync(fullPath, content);\n      }\n    }\n  }\n\n  /**\n   * Registers this vault in the running Obsidian instance so the CLI can target it.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async register(transportOverride?: ObsidianTransport): Promise<void> {\n    await registerVault(this.path, transportOverride);\n  }\n\n  /**\n   * Async disposable support for `await using`.\n   *\n   * @returns A promise that resolves when the vault is disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    return this.dispose();\n  }\n\n  /* v8 ignore start -- Integration-time code that requires a running transport. */\n\n  /**\n   * Pushes all files from the local staging directory to the target device\n   * via the active transport's `pushFiles()`.\n   *\n   * On desktop transports this is a no-op (files are already local).\n   * On mobile transports (Appium) this pushes files to the device.\n   *\n   * Call this after {@link populate} and before {@link register} when using\n   * a mobile transport.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async syncToDevice(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n    if (!transport.pushFiles) {\n      return;\n    }\n\n    const files = await this.collectFiles(this.path);\n    await transport.pushFiles(this.path, files);\n  }\n\n  /**\n   * Recursively reads all files from a directory into a flat map.\n   *\n   * @param directory - The directory to read.\n   * @returns A map of relative file paths to content buffers.\n   */\n  private async collectFiles(directory: string): Promise<Record<string, Uint8Array>> {\n    const result: Record<string, Uint8Array> = {};\n    const entries = await readdir(directory, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(directory, entry.name);\n      const relativePath = relative(this.path, fullPath);\n\n      if (entry.isDirectory()) {\n        Object.assign(result, await this.collectFiles(fullPath));\n      } else {\n        result[relativePath] = await readFile(fullPath);\n      }\n    }\n\n    return result;\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Retries `rm` until it succeeds or times out.\n * Obsidian may hold file locks briefly after a window is destroyed.\n *\n * @param path - The path to the directory to remove.\n * @returns A promise that resolves when the directory is removed.\n */\nasync function retryRm(path: string): Promise<void> {\n  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      await rm(path, { force: true, recursive: true });\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);\n      });\n    }\n  }\n  // Final attempt \u2014 let it throw.\n  await rm(path, { force: true, recursive: true });\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temporary-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Manages temporary vault lifecycle for integration tests.\n */\n\nimport {\n  mkdirSync,\n  mkdtempSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  readdir,\n  readFile,\n  rm\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  dirname,\n  join,\n  relative\n} from 'node:path';\n\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.mjs';\n\n/**\n * Content value for a single entry in a {@link PopulateFiles} map.\n *\n * - `string` \u2014 text file (written as UTF-8).\n * - `Uint8Array` \u2014 binary file (written as raw bytes; `Buffer` is accepted\n *   because `Buffer extends Uint8Array`).\n * - `undefined` \u2014 empty folder (the key **must** end with `/`).\n */\nexport type PopulateFileContent = string | Uint8Array | undefined;\n\n/**\n * A map of vault-relative paths to their content, used by\n * {@link TemporaryVault.populate}.\n *\n * Paths ending with `/` denote folders and **must** have an `undefined` value.\n * All other paths are written as files.\n */\nexport type PopulateFilesParams = Record<string, PopulateFileContent>;\n\n/**\n * Options for the {@link TemporaryVault} constructor.\n */\nexport interface TemporaryVaultOptions {\n  /**\n   * Whether {@link TemporaryVault.dispose} removes the vault **directory**.\n   *\n   * When omitted, defaults to whether this instance created that directory \u2014 `true` for a temp\n   * directory the constructor made (no `path` argument), `false` for a directory handed to it as an\n   * explicit `path`. A handle over somebody else's directory unregisters the vault but leaves the\n   * files alone, so wrapping a directory cannot destroy it. Set explicitly to override.\n   */\n  readonly shouldRemoveDirectoryOnDispose?: boolean;\n}\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * A temporary Obsidian vault for integration tests.\n *\n * Creates a temp directory and registers it in the running Obsidian instance\n * so that the Obsidian CLI can target it via `cwd`.\n *\n * A handle **owns** the directory only when it created it. {@link TemporaryVault.dispose} deletes an\n * owned directory and leaves a borrowed one in place \u2014 see\n * {@link TemporaryVaultOptions.shouldRemoveDirectoryOnDispose}, which overrides that default.\n */\nexport class TemporaryVault {\n  /**\n   * The absolute path to the temporary vault.\n   */\n  public readonly path: string;\n\n  /**\n   * Whether {@link TemporaryVault.dispose} removes {@link TemporaryVault.path} from disk.\n   */\n  readonly #shouldRemoveDirectoryOnDispose: boolean;\n\n  /**\n   * Creates a new temp vault.\n   *\n   * @param path - An explicit vault path. If omitted, a temp directory is created.\n   * @param options - Vault options.\n   */\n  public constructor(path?: string, options?: TemporaryVaultOptions) {\n    this.path = path ?? mkdtempSync(join(tmpdir(), TEMP_VAULT_DIR_PREFIX));\n    this.#shouldRemoveDirectoryOnDispose = options?.shouldRemoveDirectoryOnDispose ?? path === undefined;\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and, when this handle owns the directory, deletes it.\n   *\n   * The directory is removed only when this instance created it, or when\n   * {@link TemporaryVaultOptions.shouldRemoveDirectoryOnDispose} said so explicitly. That is what\n   * makes a handle over a directory somebody else owns \u2014 the run's shared setup vault, say, which\n   * `getTemporaryVault()` wraps \u2014 safe to dispose from a consumer's `afterAll`.\n   *\n   * @param transportOverride - An explicit transport to use when unregistering.\n   *   When omitted, falls back to the transport configured via the context provider.\n   */\n  public async dispose(transportOverride?: ObsidianTransport): Promise<void> {\n    try {\n      await unregisterVault(this.path, transportOverride);\n    } finally {\n      if (this.#shouldRemoveDirectoryOnDispose) {\n        await retryRm(this.path);\n      } else {\n        log(`[temporary-vault] Unregistered but kept the vault directory, which this handle does not own: ${this.path}`);\n      }\n    }\n  }\n\n  /**\n   * Writes files and folders into the vault directory **on the host**.\n   * Parent directories are created automatically.\n   *\n   * - `string` values are written as UTF-8 text files.\n   * - `Uint8Array` values (including `Buffer`) are written as binary files.\n   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).\n   *\n   * The write is always host-local \u2014 {@link TemporaryVault.path} is a host path, and on a mobile\n   * transport the vault the app opens lives on the device instead. {@link TemporaryVault.register}\n   * carries the directory across before it registers, so populate-then-register is all a caller\n   * needs; {@link TemporaryVault.syncToDevice} is the seam that does the carrying.\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: PopulateFilesParams): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== undefined) {\n          throw new Error(`Folder path \"${filePath}\" must have undefined content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        if (content === undefined) {\n          throw new Error(`File path \"${filePath}\" must have defined content; use a trailing \"/\" for folders`);\n        }\n        mkdirSync(dirname(fullPath), { recursive: true });\n        writeFileSync(fullPath, content);\n      }\n    }\n  }\n\n  /**\n   * Registers this vault in the running Obsidian instance so the CLI can target it.\n   *\n   * Pushes the vault directory to the target device first, via\n   * {@link TemporaryVault.syncToDevice} \u2014 a no-op on a transport whose app already reads the host\n   * filesystem. That ordering used to be the caller's to remember, and a caller who forgot got a\n   * silently **empty** vault rather than an error: every pre-registration\n   * {@link TemporaryVault.populate} write stayed on the host while the app opened the device's copy.\n   * Folding it in here makes populate-then-register correct on every transport.\n   *\n   * The transport is resolved once and handed to both steps, so a push and the registration that\n   * follows it can never land on two different transports.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async register(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n    await this.syncToDevice(transport);\n    await registerVault(this.path, transport);\n  }\n\n  /**\n   * Async disposable support for `await using`.\n   *\n   * @returns A promise that resolves when the vault is disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    return this.dispose();\n  }\n\n  /* v8 ignore start -- Integration-time code that requires a running transport. */\n\n  /**\n   * Pushes all files from the local staging directory to the target device\n   * via the active transport's `pushFiles()`.\n   *\n   * On desktop transports this is a no-op (files are already local).\n   * On mobile transports (Appium) this pushes files to the device.\n   *\n   * {@link TemporaryVault.register} calls this itself, so a populate-then-register sequence needs\n   * nothing extra. Call it directly only to carry across files written **after** registration: the\n   * host directory is not mirrored, so a later write into {@link TemporaryVault.path} stays on the\n   * host until this runs again.\n   *\n   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async syncToDevice(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n    if (!transport.pushFiles) {\n      return;\n    }\n\n    const files = await this.collectFiles(this.path);\n    await transport.pushFiles(this.path, files);\n  }\n\n  /**\n   * Recursively reads all files from a directory into a flat map.\n   *\n   * @param directory - The directory to read.\n   * @returns A map of relative file paths to content buffers.\n   */\n  private async collectFiles(directory: string): Promise<Record<string, Uint8Array>> {\n    const result: Record<string, Uint8Array> = {};\n    const entries = await readdir(directory, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(directory, entry.name);\n      const relativePath = relative(this.path, fullPath);\n\n      if (entry.isDirectory()) {\n        Object.assign(result, await this.collectFiles(fullPath));\n      } else {\n        result[relativePath] = await readFile(fullPath);\n      }\n    }\n\n    return result;\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Retries `rm` until it succeeds or times out.\n * Obsidian may hold file locks briefly after a window is destroyed.\n *\n * @param path - The path to the directory to remove.\n * @returns A promise that resolves when the directory is removed.\n */\nasync function retryRm(path: string): Promise<void> {\n  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      await rm(path, { force: true, recursive: true });\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);\n      });\n    }\n  }\n  // Final attempt \u2014 let it throw.\n  await rm(path, { force: true, recursive: true });\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/transport-appium.d.mts

@@ -63,6 +63,14 @@ export interface AppiumTransportConfig {
      * Defaults to `'md.obsidian'`.
      */
     appId?: string;
+    /**
+     * Timeout in milliseconds for Obsidian Mobile to get as far as `globalThis.app`
+     * existing after the vault is (re)opened, before the tighter
+     * {@link layoutReadyTimeoutInMilliseconds} clock starts.
+     *
+     * @default `180000`
+     */
+    appStartTimeoutInMilliseconds?: number;
     /**
      * The Appium browser/driver instance.
      * Created by the consumer via e.g. WebDriverIO's `remote()`.
@@ -84,8 +92,9 @@ export interface AppiumTransportConfig {
      */
     isSessionOwner?: boolean;
     /**
-     * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after
-     * the vault is (re)opened.
+     * Timeout in milliseconds for waiting for `app.workspace.layoutReady`, counted
+     * from the moment {@link appStartTimeoutInMilliseconds} is satisfied — not from
+     * the reload, so a cold app start is not charged against it.
      *
      * @default `90000`
      */
@@ -141,6 +150,7 @@ export declare class AppiumTransport implements ObsidianTransport {
      */
     readonly isMobile = true;
     private readonly appId;
+    private readonly appStartTimeoutInMilliseconds;
     private readonly browser;
     private readonly deviceId;
     /**
@@ -280,7 +290,8 @@ export declare class AppiumTransport implements ObsidianTransport {
      * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
      *    `enable-plugin-<path>`)
      * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault
-     * 5. Wait for `app.workspace.layoutReady`
+     * 5. Wait for `globalThis.app` to exist (the app's cold start), then — on a
+     *    separate, tighter budget — for `app.workspace.layoutReady`
      *
      * Existing vault registrations in localStorage are preserved (append, not
      * overwrite) — except the **harness's own** `temp-vault-*` registrations from
@@ -352,6 +363,16 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param payload - The raw JSON payload the binding was called with.
      */
     private handleInputRequest;
+    /**
+     * Probes the WebView once for how far Obsidian's startup has got.
+     *
+     * A probe that throws is reported as `undefined` rather than propagated: the
+     * page is mid-`location.reload()` for most of the app-start phase, and a
+     * WebView that cannot answer yet is the *expected* reading there, not an error.
+     *
+     * @returns What the probe saw, or `undefined` when it could not run.
+     */
+    private probeStartup;
     /**
      * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.
      *
@@ -385,8 +406,37 @@ export declare class AppiumTransport implements ObsidianTransport {
      * stack a listener per reconnect.
      */
     private unregisterInputChannelExitHandler;
+    /**
+     * Polls until `globalThis.app` exists in the WebView — the app has finished
+     * its cold start and Obsidian's own boot has begun.
+     *
+     * This is the **first** of the two budgets spent after `location.reload()`,
+     * and the generous one. Everything it pays for is outside Obsidian's control:
+     * the WebView reloading, and a guest that may still be optimizing packages.
+     * Keeping it separate is the point of the split — the old single wall clock
+     * started here and left the tight layout budget paying for a cold start.
+     */
+    private waitForAppStarted;
     /**
      * Polls until `app.workspace.layoutReady` is `true` in the WebView.
+     *
+     * The **second** budget, and the tight one: by the time it starts, the app is
+     * already up, so all it covers is Obsidian opening the vault and loading
+     * plugins — ~1s in practice, ≤8.4s under heavy host stress (**L19**).
      */
     private waitForLayoutReady;
+    /**
+     * Polls the WebView until a startup phase's milestone is satisfied, tracking
+     * the evidence that tells a slow Obsidian from a contended guest.
+     *
+     * Each poll costs exactly one `browser.execute` round-trip — deliberately not
+     * an {@link ensureWebViewContext} call, whose `getContexts()` runs
+     * `adb shell cat /proc/net/unix` and was measured at ~17s per **L19**. The
+     * round-trip is timed, and the slowest one is reported on timeout: a phase
+     * that ran out after a handful of probes each taking tens of seconds was
+     * starved by the guest, not by Obsidian.
+     *
+     * @param params - The phase, its budget, and the predicate that ends it.
+     */
+    private waitForStartupMilestone;
 }