obsidian-integration-testing 11.0.0 → 12.1.0

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.