obsidian-integration-testing 12.0.0 → 12.1.0

package/dist/lib/cjs/process-liveness.d.cts

@@ -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/cjs/run-version-matrix.cjs

@@ -61,4 +61,4 @@ function logPlan(resolvedSpecs, entries) {
 0 && (module.exports = {
   runObsidianVersionMatrix
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3J1bi12ZXJzaW9uLW1hdHJpeC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEludGVncmF0aW9uLXRpbWUgcnVubmVyIHRoYXQgZXhlY3V0ZXMgYSBzdWl0ZSBvbmNlIHBlciAqKmRpc3RpbmN0Kiogc3VwcG9ydGVkXG4gKiBPYnNpZGlhbiB2ZXJzaW9uLlxuICpcbiAqIFRoaW4gZ2x1ZSBvdmVyIHRoZSBwdXJlIGB2ZXJzaW9uLW1hdHJpeC50c2AgZGVjaXNpb24gbGF5ZXI6IHRoZSBvbmx5IHRoaW5nc1xuICogdGhhdCBoYXBwZW4gaGVyZSBhcmUgdGhlIHNpbmdsZSBtYW5pZmVzdCBmZXRjaCBhbmQgdGhlIGxvZ2dpbmcuIEV2ZXJ5dGhpbmdcbiAqIHRoYXQgZGVjaWRlcyBcdTIwMTQgbm9ybWFsaXppbmcgdGhlIHJlcXVlc3RlZCBzcGVjaWZpZXJzLCByZXNvbHZpbmcgdGhlbSxcbiAqIGRlLWR1cGxpY2F0aW5nIG9uIHRoZSByZXNvbHZlZCB2ZXJzaW9uLCBzZXF1ZW5jaW5nIHRoZSBydW5zLCBhbmQgYnVpbGRpbmcgdGhlXG4gKiBmYWlsdXJlIHN1bW1hcnkgXHUyMDE0IGlzIHB1cmUgYW5kIHVuaXQtdGVzdGVkIG5leHQgZG9vci5cbiAqXG4gKiBUaGUgbG9vcCBsaXZlcyBhYm92ZSB0aGUgdHJhbnNwb3J0IHJhdGhlciB0aGFuIGluc2lkZSBpdCBiZWNhdXNlIGEgdGVzdFxuICogZnJhbWV3b3JrJ3MgZ2xvYmFsIHNldHVwIGNhbm5vdCByZS1ydW4gaXRzIG93biB0ZXN0IGZpbGVzOiBpdCBsYXVuY2hlcyBvbmVcbiAqIGluc3RhbmNlIGZvciBvbmUgcnVuLiBLZWVwaW5nIHRoZSBsb29wIGZyYW1ld29yay1hZ25vc3RpYyAodGhlIGNhbGxlciBzdXBwbGllc1xuICogYHJ1bmApIGlzIHdoYXQgbGV0cyBWaXRlc3QsIEplc3QsIGFuZCBtYW51YWwgY29uc3VtZXJzIGFsbCBpbmhlcml0IGl0IChMNikuXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIEludGVncmF0aW9uLXRpbWUgZ2x1ZSAobmV0d29yayBmZXRjaCArIGxvZ2dpbmcpIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuVmVyc2lvbk1hdHJpeEVudHJ5LFxuICBSZXNvbHZlZFZlcnNpb25TcGVjXG59IGZyb20gJy4vdmVyc2lvbi1tYXRyaXguY2pzJztcblxuaW1wb3J0IHsgbG9nIH0gZnJvbSAnLi9sb2cuY2pzJztcbmltcG9ydCB7IGZldGNoRGVza3RvcFJlbGVhc2VzTWFuaWZlc3QgfSBmcm9tICcuL29ic2lkaWFuLXZlcnNpb24tc3dpdGNoLmNqcyc7XG5pbXBvcnQge1xuICBidWlsZFZlcnNpb25NYXRyaXgsXG4gIGZvcm1hdFZlcnNpb25NYXRyaXhQbGFuLFxuICBmb3JtYXRWZXJzaW9uTWF0cml4UnVuSGVhZGVyLFxuICBoYXNDaGFubmVsU3BlYyxcbiAgcmVzb2x2ZVJlcXVlc3RlZFNwZWNzLFxuICByZXNvbHZlVmVyc2lvblNwZWNzLFxuICBydW5WZXJzaW9uTWF0cml4RW50cmllc1xufSBmcm9tICcuL3ZlcnNpb24tbWF0cml4LmNqcyc7XG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIHJ1bk9ic2lkaWFuVmVyc2lvbk1hdHJpeH0uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4UGFyYW1zIHtcbiAgLyoqXG4gICAqIFJ1bnMgdGhlIHN1aXRlcyBhZ2FpbnN0IG9uZSBjb25jcmV0ZSBPYnNpZGlhbiB2ZXJzaW9uLCB0aHJvd2luZyBvbiBmYWlsdXJlLlxuICAgKlxuICAgKiBUaGUgZW50cnkncyBgdmVyc2lvbmAgaXMgdGhlIGNvbmNyZXRlIGB4LnkuemAgdG8gcGluIFx1MjAxNCB0eXBpY2FsbHkgZm9yd2FyZGVkIHRvXG4gICAqIHRoZSB0ZXN0LXJ1bm5lciBjaGlsZCBhcyBgT0JTSURJQU5fVkVSU0lPTmAuXG4gICAqL1xuICByZWFkb25seSBydW46IChlbnRyeTogT2JzaWRpYW5WZXJzaW9uTWF0cml4RW50cnkpID0+IFByb21pc2U8dm9pZD4gfCB2b2lkO1xuXG4gIC8qKlxuICAgKiBUaGUgdmVyc2lvbiBzcGVjaWZpZXJzIHRvIHJ1biBhZ2FpbnN0OiBhbiBhcnJheSwgb3IgYSBjb21tYS1zZXBhcmF0ZWQgc3RyaW5nXG4gICAqIHNvIGFuIGVudiB2YXIgY2FuIGJlIHBhc3NlZCBzdHJhaWdodCB0aHJvdWdoLlxuICAgKlxuICAgKiBFYWNoIGFjY2VwdHMgYW4gZXhwbGljaXQgYCd4LnkueidgLCBgJ3B1YmxpYy1sYXRlc3QnYCwgb3IgYCdjYXRhbHlzdC1sYXRlc3QnYC5cbiAgICogRGVmYXVsdHMgdG8gYm90aCBlbmRzIG9mIHRoZSBzdXBwb3J0ZWQgcmFuZ2Ugd2hlbiBvbWl0dGVkIG9yIGVtcHR5LCBhbmRcbiAgICogdGhlIGxpc3QgaXMgYWx3YXlzIGRlLWR1cGxpY2F0ZWQgb24gdGhlICoqcmVzb2x2ZWQqKiB2ZXJzaW9uIFx1MjAxNCBzbyB3aGVuIHB1YmxpY1xuICAgKiBoYXMgY2F1Z2h0IHVwIHRvIGNhdGFseXN0LCB0aGUgc3VpdGVzIHJ1biBvbmNlLlxuICAgKi9cbiAgcmVhZG9ubHkgdmVyc2lvbnM/OiByZWFkb25seSBzdHJpbmdbXSB8IHN0cmluZyB8IHVuZGVmaW5lZDtcbn1cblxuLyoqXG4gKiBSdW5zIGEgc3VpdGUgb25jZSBwZXIgZGlzdGluY3Qgc3VwcG9ydGVkIE9ic2lkaWFuIHZlcnNpb24uXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBwZXItdmVyc2lvbiBydW5uZXIgYW5kIHRoZSByZXF1ZXN0ZWQgdmVyc2lvbnMuXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIG9uY2UgZXZlcnkgdmVyc2lvbiBoYXMgcnVuIHN1Y2Nlc3NmdWxseS5cbiAqIEB0aHJvd3MgRXJyb3IgaWYgbm8gdmVyc2lvbiBjb3VsZCBiZSByZXNvbHZlZCwgb3IgYW4ge0BsaW5rIEFnZ3JlZ2F0ZUVycm9yfVxuICogICBuYW1pbmcgZXZlcnkgdmVyc2lvbiB3aG9zZSBydW4gZmFpbGVkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4KHBhcmFtczogUnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4UGFyYW1zKTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IHsgcnVuLCB2ZXJzaW9ucyB9ID0gcGFyYW1zO1xuXG4gIGNvbnN0IHsgaXNEZWZhdWx0LCBzcGVjcyB9ID0gcmVzb2x2ZVJlcXVlc3RlZFNwZWNzKHZlcnNpb25zKTtcbiAgY29uc3QgbWFuaWZlc3QgPSBoYXNDaGFubmVsU3BlYyhzcGVjcykgPyBhd2FpdCBmZXRjaERlc2t0b3BSZWxlYXNlc01hbmlmZXN0KCkgOiB1bmRlZmluZWQ7XG4gIGNvbnN0IHsgZHJvcHBlZFNwZWNzLCByZXNvbHZlZFNwZWNzIH0gPSByZXNvbHZlVmVyc2lvblNwZWNzKHtcbiAgICBtYW5pZmVzdCxcbiAgICAvLyBUaGUgZGVmYXVsdCBsaXN0IG11c3Qgbm90IGJyZWFrIGV2ZXJ5IGNvbnN1bWVyJ3MgZ2F0ZSB3aGVuIGEgY2hhbm5lbCBpc1xuICAgIC8vIE1vbWVudGFyaWx5IGFic2VudCBmcm9tIHRoZSBtYW5pZmVzdDsgYW4gZXhwbGljaXRseSByZXF1ZXN0ZWQgc3BlY2lmaWVyXG4gICAgLy8gVGhhdCBjYW5ub3QgcmVzb2x2ZSBpcyBhIHJlYWwgZXJyb3IuXG4gICAgc2hvdWxkVG9sZXJhdGVVbnJlc29sdmFibGVTcGVjczogaXNEZWZhdWx0LFxuICAgIHNwZWNzXG4gIH0pO1xuXG4gIGZvciAoY29uc3QgeyByZWFzb24sIHNwZWMgfSBvZiBkcm9wcGVkU3BlY3MpIHtcbiAgICBsb2dNYXRyaXgoYFNraXBwaW5nIFwiJHtzcGVjfVwiOiAke3JlYXNvbn1gKTtcbiAgfVxuXG4gIGNvbnN0IGVudHJpZXMgPSBidWlsZFZlcnNpb25NYXRyaXgocmVzb2x2ZWRTcGVjcyk7XG4gIGxvZ1BsYW4ocmVzb2x2ZWRTcGVjcywgZW50cmllcyk7XG5cbiAgYXdhaXQgcnVuVmVyc2lvbk1hdHJpeEVudHJpZXMoe1xuICAgIGVudHJpZXMsXG4gICAgb25FbnRyeVN0YXJ0OiAoaGVhZGVyUGFyYW1zKSA9PiB7XG4gICAgICBsb2dNYXRyaXgoZm9ybWF0VmVyc2lvbk1hdHJpeFJ1bkhlYWRlcihoZWFkZXJQYXJhbXMpKTtcbiAgICB9LFxuICAgIHJ1blxuICB9KTtcbn1cblxuLyoqXG4gKiBMb2dzIGEgbWF0cml4IG1lc3NhZ2UgdW5kZXIgYSBjb25zaXN0ZW50IHByZWZpeC5cbiAqXG4gKiBAcGFyYW0gbWVzc2FnZSAtIFRoZSBtZXNzYWdlIHRvIGxvZy5cbiAqL1xuZnVuY3Rpb24gbG9nTWF0cml4KG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQge1xuICBsb2coYFt2ZXJzaW9uLW1hdHJpeF0gJHttZXNzYWdlfWApO1xufVxuXG4vKipcbiAqIExvZ3Mgd2hhdCB0aGUgc3BlY2lmaWVycyByZXNvbHZlZCB0byBhbmQgaG93IG1hbnkgcnVucyB0aGF0IGltcGxpZXMuXG4gKlxuICogQHBhcmFtIHJlc29sdmVkU3BlY3MgLSBUaGUgcmVzb2x2ZWQgc3BlY2lmaWVycywgaW4gcmVxdWVzdGVkIG9yZGVyLlxuICogQHBhcmFtIGVudHJpZXMgLSBUaGUgZGUtZHVwbGljYXRlZCBtYXRyaXguXG4gKi9cbmZ1bmN0aW9uIGxvZ1BsYW4ocmVzb2x2ZWRTcGVjczogcmVhZG9ubHkgUmVzb2x2ZWRWZXJzaW9uU3BlY1tdLCBlbnRyaWVzOiByZWFkb25seSBPYnNpZGlhblZlcnNpb25NYXRyaXhFbnRyeVtdKTogdm9pZCB7XG4gIGZvciAoY29uc3QgbGluZSBvZiBmb3JtYXRWZXJzaW9uTWF0cml4UGxhbih7IGVudHJpZXMsIHJlc29sdmVkU3BlY3MgfSkpIHtcbiAgICBsb2dNYXRyaXgobGluZSk7XG4gIH1cbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUF5QkEsaUJBQW9CO0FBQ3BCLHFDQUE2QztBQUM3Qyw0QkFRTztBQWtDUCxlQUFzQix5QkFBeUIsUUFBdUQ7QUFDcEcsUUFBTSxFQUFFLEtBQUssU0FBUyxJQUFJO0FBRTFCLFFBQU0sRUFBRSxXQUFXLE1BQU0sUUFBSSw2Q0FBc0IsUUFBUTtBQUMzRCxRQUFNLGVBQVcsc0NBQWUsS0FBSyxJQUFJLFVBQU0sNkRBQTZCLElBQUk7QUFDaEYsUUFBTSxFQUFFLGNBQWMsY0FBYyxRQUFJLDJDQUFvQjtBQUFBLElBQzFEO0FBQUE7QUFBQTtBQUFBO0FBQUEsSUFJQSxpQ0FBaUM7QUFBQSxJQUNqQztBQUFBLEVBQ0YsQ0FBQztBQUVELGFBQVcsRUFBRSxRQUFRLEtBQUssS0FBSyxjQUFjO0FBQzNDLGNBQVUsYUFBYSxJQUFJLE1BQU0sTUFBTSxFQUFFO0FBQUEsRUFDM0M7QUFFQSxRQUFNLGNBQVUsMENBQW1CLGFBQWE7QUFDaEQsVUFBUSxlQUFlLE9BQU87QUFFOUIsWUFBTSwrQ0FBd0I7QUFBQSxJQUM1QjtBQUFBLElBQ0EsY0FBYyxDQUFDLGlCQUFpQjtBQUM5QixvQkFBVSxvREFBNkIsWUFBWSxDQUFDO0FBQUEsSUFDdEQ7QUFBQSxJQUNBO0FBQUEsRUFDRixDQUFDO0FBQ0g7QUFPQSxTQUFTLFVBQVUsU0FBdUI7QUFDeEMsc0JBQUksb0JBQW9CLE9BQU8sRUFBRTtBQUNuQztBQVFBLFNBQVMsUUFBUSxlQUErQyxTQUFzRDtBQUNwSCxhQUFXLFlBQVEsK0NBQXdCLEVBQUUsU0FBUyxjQUFjLENBQUMsR0FBRztBQUN0RSxjQUFVLElBQUk7QUFBQSxFQUNoQjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/run-version-matrix.d.cts

@@ -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/cjs/teardown-verdict.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var teardown_verdict_exports = {};
+__export(teardown_verdict_exports, {
+  buildTeardownMessage: () => buildTeardownMessage,
+  resolveTeardownOutcome: () => resolveTeardownOutcome
+});
+module.exports = __toCommonJS(teardown_verdict_exports);
+var import_type_guards = require("./type-guards.cjs");
+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 (0, import_type_guards.assertNever)(params.outcome);
+    }
+  }
+}
+function resolveTeardownOutcome(params) {
+  if (!params.isStopped) {
+    return "still-running";
+  }
+  return params.hasEscalated ? "stopped-after-escalation" : "stopped";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTeardownMessage,
+  resolveTeardownOutcome
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/teardown-verdict.d.cts

@@ -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/cjs/temporary-vault.cjs

@@ -27,6 +27,7 @@ var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_context_provider = require("./context-provider.cjs");
 var import_leftover_cleanup = require("./leftover-cleanup.cjs");
+var import_log = require("./log.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
 var import_vault_registry = require("./vault-registry.cjs");
 const RM_RETRY_DELAY_IN_MILLISECONDS = 500;
@@ -36,16 +37,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 ?? (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os.tmpdir)(), import_leftover_cleanup.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.
@@ -54,17 +66,26 @@ class TemporaryVault {
     try {
       await (0, import_vault_registry.unregisterVault)(this.path, transportOverride);
     } finally {
-      await retryRm(this.path);
+      if (this.#shouldRemoveDirectoryOnDispose) {
+        await retryRm(this.path);
+      } else {
+        (0, import_log.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) {
@@ -87,11 +108,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 (0, import_vault_registry.registerVault)(this.path, transportOverride);
+    const transport = transportOverride ?? await (0, import_transport_factory.getOrCreateTransport)((0, import_context_provider.getTransportOptions)());
+    await this.syncToDevice(transport);
+    await (0, import_vault_registry.registerVault)(this.path, transport);
   }
   /**
    * Async disposable support for `await using`.
@@ -109,8 +142,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.
@@ -163,4 +198,4 @@ async function retryRm(path) {
 0 && (module.exports = {
   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.cjs';\n\nimport { getTransportOptions } from './context-provider.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\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.cjs';\n\nimport { getTransportOptions } from './context-provider.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\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/cjs/temporary-vault.d.cts

@@ -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.