obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/esm/release-catalog.d.mts

@@ -0,0 +1,125 @@
+/**
+ * @file
+ *
+ * Pure helpers for building the repo-root `metadata.json` catalog from Obsidian's
+ * **own** publication endpoints, with no third-party catalog in the loop.
+ *
+ * `scripts/refresh-metadata.ts` drives the network side (the
+ * `obsidianmd/obsidian-releases` GitHub Releases API, `obsidian.md/changelog.xml`
+ * and `desktop-releases.json`); everything decidable without the network lives
+ * here so it stays unit-tested.
+ *
+ * Three decisions are encoded:
+ *
+ * - **Which release assets become `downloads` keys.** A release's real asset list
+ *   is matched rather than templated, reusing {@link selectInstallerAssetName} for
+ *   the desktop installers so the historical dot-vs-hyphen separator rename (and
+ *   the `-universal` dmg infix) is handled in exactly one place. The 32-bit,
+ *   arm64, AppImage, deb and snap siblings are deliberately not carried — this
+ *   harness downloads only the x64 installer, the app asar and the Android apk.
+ * - **Which channel a version belongs to**, derived from which changelog pages
+ *   the feed published for it (see {@link resolveReleaseChannel}).
+ * - **Where a catalyst asar lives** ({@link buildCatalystAsarUrl}) — the one asset
+ *   with no listing API behind it, so its URL must be constructed and probed.
+ */
+import type { ObsidianVersionDownloads } from './obsidian-metadata.mjs';
+/**
+ * Base URL for **catalyst** (early access / insider) release asars, served from
+ * the Obsidian CDN as `.../release/obsidian-<version>.asar.gz`. Public versions
+ * are NOT hosted here (the CDN returns an empty body for them), and the endpoint
+ * is Cloudflare-gated against non-browser clients, so a probe needs a browser
+ * `User-Agent`.
+ */
+export declare const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
+/**
+ * One asset of a GitHub release, reduced to what the catalog needs.
+ */
+export interface ReleaseAsset {
+    /**
+    The published asset file name, e.g. `Obsidian-1.13.7.exe`.
+     */
+    readonly name: string;
+    /**
+    The asset's direct download URL (`browser_download_url`).
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link resolveReleaseChannel}.
+ */
+export interface ResolveReleaseChannelParams {
+    /**
+    Whether the changelog feed published a catalyst ("Early access") desktop page.
+     */
+    readonly hasCatalystPage: boolean;
+    /**
+    Whether the changelog feed published a public desktop page.
+     */
+    readonly hasPublicPage: boolean;
+    /**
+     * Whether the version was published as a GitHub release — the evidence that it
+     * shipped on the public channel, since catalyst builds are served only from
+     * the `releases.obsidian.md` CDN.
+     */
+    readonly hasPublicRelease: boolean;
+}
+/**
+ * Parameters for {@link selectReleaseDownloads}.
+ */
+export interface SelectReleaseDownloadsParams {
+    /**
+    The release's published assets.
+     */
+    readonly assets: readonly ReleaseAsset[];
+    /**
+    The concrete `x.y.z` version the release publishes.
+     */
+    readonly version: string;
+}
+/**
+ * Builds the catalyst asar URL for a version.
+ *
+ * Catalyst builds are not published as GitHub release assets, and the CDN that
+ * serves them has no listing API, so this URL is constructed rather than
+ * discovered — the caller probes it before recording it.
+ *
+ * @param version - The concrete `x.y.z` version.
+ * @returns The `releases.obsidian.md` asar URL for the version.
+ */
+export declare function buildCatalystAsarUrl(version: string): string;
+/**
+ * Derives a version's release channel from where it was published and which
+ * changelog pages the feed carries for it.
+ *
+ * **Publication is the primary evidence, not the feed's title marker.** The feed
+ * tags each entry `(Public)` or `(Early access)`, but through the pre-1.0 era it
+ * tagged *everything* early-access — the whole app was — so 61 versions that
+ * shipped as ordinary GitHub releases carry only a catalyst page. Trusting the
+ * marker alone therefore relabels a large slice of public history as catalyst.
+ * A GitHub release is unambiguous the other way round: catalyst builds are
+ * served only from the `releases.obsidian.md` CDN, never as release assets.
+ *
+ * So a version that was published on GitHub is public, and it is recorded as the
+ * combined `'public+catalyst'` only when the feed carries *both* desktop pages —
+ * the shape every version already labelled `'public+catalyst'` has.
+ *
+ * @param params - The publication evidence and the desktop pages the feed published.
+ * @returns The channel, or `undefined` when there is no evidence either way (the
+ *   caller then keeps whatever the version already carries).
+ */
+export declare function resolveReleaseChannel(params: ResolveReleaseChannelParams): string | undefined;
+/**
+ * Picks the assets this harness downloads out of a GitHub release's real asset
+ * list: the x64 desktop installers, the app asar and the Android apk.
+ *
+ * Assets are matched against the **release's own version**, so an early-access
+ * tag whose assets carry the base version instead (`v1.1.8-E21` publishing
+ * `Obsidian.1.1.8.exe`, `v1.6.3-e30` publishing `Obsidian.1.6.3.exe`) matches
+ * nothing and is skipped — deliberately, since those assets are the base
+ * version's, not the tag's.
+ *
+ * @param params - The release's assets and its version.
+ * @returns The distilled download URLs, or `undefined` when the release
+ *   publishes none of them.
+ */
+export declare function selectReleaseDownloads(params: SelectReleaseDownloadsParams): ObsidianVersionDownloads | undefined;

package/dist/lib/esm/release-catalog.mjs

@@ -0,0 +1,46 @@
+import { selectInstallerAssetName } from "./installer-asset.mjs";
+import { getVersionAsarFileName } from "./obsidian-version.mjs";
+const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
+const INSTALLER_KEYS_BY_PLATFORM = [
+  ["dmg", "darwin"],
+  ["exe", "win32"],
+  ["tar", "linux"]
+];
+function buildCatalystAsarUrl(version) {
+  return `${CATALYST_ASAR_RELEASE_BASE_URL}/${getVersionAsarFileName(version)}.gz`;
+}
+function resolveReleaseChannel(params) {
+  if (params.hasPublicRelease) {
+    return params.hasPublicPage && params.hasCatalystPage ? "public+catalyst" : "public";
+  }
+  return params.hasCatalystPage ? "catalyst" : void 0;
+}
+function selectReleaseDownloads(params) {
+  const { assets, version } = params;
+  const assetNames = assets.map((asset) => asset.name);
+  const urlByName = new Map(assets.map((asset) => [asset.name, asset.url]));
+  const downloads = {};
+  const apkUrl = urlByName.get(`Obsidian-${version}.apk`);
+  if (apkUrl !== void 0) {
+    downloads["apk"] = apkUrl;
+  }
+  const asarUrl = urlByName.get(`${getVersionAsarFileName(version)}.gz`);
+  if (asarUrl !== void 0) {
+    downloads["asar"] = asarUrl;
+  }
+  for (const [key, platform] of INSTALLER_KEYS_BY_PLATFORM) {
+    const assetName = selectInstallerAssetName({ assetNames, platform, version });
+    const url = assetName === void 0 ? void 0 : urlByName.get(assetName);
+    if (url !== void 0) {
+      downloads[key] = url;
+    }
+  }
+  return Object.keys(downloads).length > 0 ? downloads : void 0;
+}
+export {
+  CATALYST_ASAR_RELEASE_BASE_URL,
+  buildCatalystAsarUrl,
+  resolveReleaseChannel,
+  selectReleaseDownloads
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/release-catalog.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for building the repo-root `metadata.json` catalog from Obsidian's\n * **own** publication endpoints, with no third-party catalog in the loop.\n *\n * `scripts/refresh-metadata.ts` drives the network side (the\n * `obsidianmd/obsidian-releases` GitHub Releases API, `obsidian.md/changelog.xml`\n * and `desktop-releases.json`); everything decidable without the network lives\n * here so it stays unit-tested.\n *\n * Three decisions are encoded:\n *\n * - **Which release assets become `downloads` keys.** A release's real asset list\n *   is matched rather than templated, reusing {@link selectInstallerAssetName} for\n *   the desktop installers so the historical dot-vs-hyphen separator rename (and\n *   the `-universal` dmg infix) is handled in exactly one place. The 32-bit,\n *   arm64, AppImage, deb and snap siblings are deliberately not carried \u2014 this\n *   harness downloads only the x64 installer, the app asar and the Android apk.\n * - **Which channel a version belongs to**, derived from which changelog pages\n *   the feed published for it (see {@link resolveReleaseChannel}).\n * - **Where a catalyst asar lives** ({@link buildCatalystAsarUrl}) \u2014 the one asset\n *   with no listing API behind it, so its URL must be constructed and probed.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.mjs';\n\nimport { selectInstallerAssetName } from './installer-asset.mjs';\nimport { getVersionAsarFileName } from './obsidian-version.mjs';\n\n/**\n * Base URL for **catalyst** (early access / insider) release asars, served from\n * the Obsidian CDN as `.../release/obsidian-<version>.asar.gz`. Public versions\n * are NOT hosted here (the CDN returns an empty body for them), and the endpoint\n * is Cloudflare-gated against non-browser clients, so a probe needs a browser\n * `User-Agent`.\n */\nexport const CATALYST_ASAR_RELEASE_BASE_URL = 'https://releases.obsidian.md/release';\n\n/**\n * One asset of a GitHub release, reduced to what the catalog needs.\n */\nexport interface ReleaseAsset {\n  /**\n  The published asset file name, e.g. `Obsidian-1.13.7.exe`.\n   */\n  readonly name: string;\n\n  /**\n  The asset's direct download URL (`browser_download_url`).\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link resolveReleaseChannel}.\n */\nexport interface ResolveReleaseChannelParams {\n  /**\n  Whether the changelog feed published a catalyst (\"Early access\") desktop page.\n   */\n  readonly hasCatalystPage: boolean;\n\n  /**\n  Whether the changelog feed published a public desktop page.\n   */\n  readonly hasPublicPage: boolean;\n\n  /**\n   * Whether the version was published as a GitHub release \u2014 the evidence that it\n   * shipped on the public channel, since catalyst builds are served only from\n   * the `releases.obsidian.md` CDN.\n   */\n  readonly hasPublicRelease: boolean;\n}\n\n/**\n * Parameters for {@link selectReleaseDownloads}.\n */\nexport interface SelectReleaseDownloadsParams {\n  /**\n  The release's published assets.\n   */\n  readonly assets: readonly ReleaseAsset[];\n\n  /**\n  The concrete `x.y.z` version the release publishes.\n   */\n  readonly version: string;\n}\n\n/**\n * The desktop-installer `downloads` keys, paired with the platform whose asset\n * shape {@link selectInstallerAssetName} resolves for them.\n */\nconst INSTALLER_KEYS_BY_PLATFORM: readonly (readonly [key: 'dmg' | 'exe' | 'tar', platform: NodeJS.Platform])[] = [\n  ['dmg', 'darwin'],\n  ['exe', 'win32'],\n  ['tar', 'linux']\n];\n\n/**\n * Builds the catalyst asar URL for a version.\n *\n * Catalyst builds are not published as GitHub release assets, and the CDN that\n * serves them has no listing API, so this URL is constructed rather than\n * discovered \u2014 the caller probes it before recording it.\n *\n * @param version - The concrete `x.y.z` version.\n * @returns The `releases.obsidian.md` asar URL for the version.\n */\nexport function buildCatalystAsarUrl(version: string): string {\n  return `${CATALYST_ASAR_RELEASE_BASE_URL}/${getVersionAsarFileName(version)}.gz`;\n}\n\n/**\n * Derives a version's release channel from where it was published and which\n * changelog pages the feed carries for it.\n *\n * **Publication is the primary evidence, not the feed's title marker.** The feed\n * tags each entry `(Public)` or `(Early access)`, but through the pre-1.0 era it\n * tagged *everything* early-access \u2014 the whole app was \u2014 so 61 versions that\n * shipped as ordinary GitHub releases carry only a catalyst page. Trusting the\n * marker alone therefore relabels a large slice of public history as catalyst.\n * A GitHub release is unambiguous the other way round: catalyst builds are\n * served only from the `releases.obsidian.md` CDN, never as release assets.\n *\n * So a version that was published on GitHub is public, and it is recorded as the\n * combined `'public+catalyst'` only when the feed carries *both* desktop pages \u2014\n * the shape every version already labelled `'public+catalyst'` has.\n *\n * @param params - The publication evidence and the desktop pages the feed published.\n * @returns The channel, or `undefined` when there is no evidence either way (the\n *   caller then keeps whatever the version already carries).\n */\nexport function resolveReleaseChannel(params: ResolveReleaseChannelParams): string | undefined {\n  if (params.hasPublicRelease) {\n    return params.hasPublicPage && params.hasCatalystPage ? 'public+catalyst' : 'public';\n  }\n\n  return params.hasCatalystPage ? 'catalyst' : undefined;\n}\n\n/**\n * Picks the assets this harness downloads out of a GitHub release's real asset\n * list: the x64 desktop installers, the app asar and the Android apk.\n *\n * Assets are matched against the **release's own version**, so an early-access\n * tag whose assets carry the base version instead (`v1.1.8-E21` publishing\n * `Obsidian.1.1.8.exe`, `v1.6.3-e30` publishing `Obsidian.1.6.3.exe`) matches\n * nothing and is skipped \u2014 deliberately, since those assets are the base\n * version's, not the tag's.\n *\n * @param params - The release's assets and its version.\n * @returns The distilled download URLs, or `undefined` when the release\n *   publishes none of them.\n */\nexport function selectReleaseDownloads(params: SelectReleaseDownloadsParams): ObsidianVersionDownloads | undefined {\n  const { assets, version } = params;\n  const assetNames = assets.map((asset) => asset.name);\n  const urlByName = new Map(assets.map((asset) => [asset.name, asset.url]));\n  const downloads: Record<string, string> = {};\n\n  const apkUrl = urlByName.get(`Obsidian-${version}.apk`);\n  if (apkUrl !== undefined) {\n    downloads['apk'] = apkUrl;\n  }\n\n  const asarUrl = urlByName.get(`${getVersionAsarFileName(version)}.gz`);\n  if (asarUrl !== undefined) {\n    downloads['asar'] = asarUrl;\n  }\n\n  for (const [key, platform] of INSTALLER_KEYS_BY_PLATFORM) {\n    const assetName = selectInstallerAssetName({ assetNames, platform, version });\n    const url = assetName === undefined ? undefined : urlByName.get(assetName);\n    if (url !== undefined) {\n      downloads[key] = url;\n    }\n  }\n\n  return Object.keys(downloads).length > 0 ? downloads : undefined;\n}\n"],
  "mappings": "AA2BA,SAAS,gCAAgC;AACzC,SAAS,8BAA8B;AAShC,MAAM,iCAAiC;AA0D9C,MAAM,6BAA4G;AAAA,EAChH,CAAC,OAAO,QAAQ;AAAA,EAChB,CAAC,OAAO,OAAO;AAAA,EACf,CAAC,OAAO,OAAO;AACjB;AAYO,SAAS,qBAAqB,SAAyB;AAC5D,SAAO,GAAG,8BAA8B,IAAI,uBAAuB,OAAO,CAAC;AAC7E;AAsBO,SAAS,sBAAsB,QAAyD;AAC7F,MAAI,OAAO,kBAAkB;AAC3B,WAAO,OAAO,iBAAiB,OAAO,kBAAkB,oBAAoB;AAAA,EAC9E;AAEA,SAAO,OAAO,kBAAkB,aAAa;AAC/C;AAgBO,SAAS,uBAAuB,QAA4E;AACjH,QAAM,EAAE,QAAQ,QAAQ,IAAI;AAC5B,QAAM,aAAa,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;AACnD,QAAM,YAAY,IAAI,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC;AACxE,QAAM,YAAoC,CAAC;AAE3C,QAAM,SAAS,UAAU,IAAI,YAAY,OAAO,MAAM;AACtD,MAAI,WAAW,QAAW;AACxB,cAAU,KAAK,IAAI;AAAA,EACrB;AAEA,QAAM,UAAU,UAAU,IAAI,GAAG,uBAAuB,OAAO,CAAC,KAAK;AACrE,MAAI,YAAY,QAAW;AACzB,cAAU,MAAM,IAAI;AAAA,EACtB;AAEA,aAAW,CAAC,KAAK,QAAQ,KAAK,4BAA4B;AACxD,UAAM,YAAY,yBAAyB,EAAE,YAAY,UAAU,QAAQ,CAAC;AAC5E,UAAM,MAAM,cAAc,SAAY,SAAY,UAAU,IAAI,SAAS;AACzE,QAAI,QAAQ,QAAW;AACrB,gBAAU,GAAG,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,IAAI,YAAY;AACzD;",
  "names": []
}


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,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3J1bi12ZXJzaW9uLW1hdHJpeC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEludGVncmF0aW9uLXRpbWUgcnVubmVyIHRoYXQgZXhlY3V0ZXMgYSBzdWl0ZSBvbmNlIHBlciAqKmRpc3RpbmN0Kiogc3VwcG9ydGVkXG4gKiBPYnNpZGlhbiB2ZXJzaW9uLlxuICpcbiAqIFRoaW4gZ2x1ZSBvdmVyIHRoZSBwdXJlIGB2ZXJzaW9uLW1hdHJpeC50c2AgZGVjaXNpb24gbGF5ZXI6IHRoZSBvbmx5IHRoaW5nc1xuICogdGhhdCBoYXBwZW4gaGVyZSBhcmUgdGhlIHNpbmdsZSBtYW5pZmVzdCBmZXRjaCBhbmQgdGhlIGxvZ2dpbmcuIEV2ZXJ5dGhpbmdcbiAqIHRoYXQgZGVjaWRlcyBcdTIwMTQgbm9ybWFsaXppbmcgdGhlIHJlcXVlc3RlZCBzcGVjaWZpZXJzLCByZXNvbHZpbmcgdGhlbSxcbiAqIGRlLWR1cGxpY2F0aW5nIG9uIHRoZSByZXNvbHZlZCB2ZXJzaW9uLCBzZXF1ZW5jaW5nIHRoZSBydW5zLCBhbmQgYnVpbGRpbmcgdGhlXG4gKiBmYWlsdXJlIHN1bW1hcnkgXHUyMDE0IGlzIHB1cmUgYW5kIHVuaXQtdGVzdGVkIG5leHQgZG9vci5cbiAqXG4gKiBUaGUgbG9vcCBsaXZlcyBhYm92ZSB0aGUgdHJhbnNwb3J0IHJhdGhlciB0aGFuIGluc2lkZSBpdCBiZWNhdXNlIGEgdGVzdFxuICogZnJhbWV3b3JrJ3MgZ2xvYmFsIHNldHVwIGNhbm5vdCByZS1ydW4gaXRzIG93biB0ZXN0IGZpbGVzOiBpdCBsYXVuY2hlcyBvbmVcbiAqIGluc3RhbmNlIGZvciBvbmUgcnVuLiBLZWVwaW5nIHRoZSBsb29wIGZyYW1ld29yay1hZ25vc3RpYyAodGhlIGNhbGxlciBzdXBwbGllc1xuICogYHJ1bmApIGlzIHdoYXQgbGV0cyBWaXRlc3QsIEplc3QsIGFuZCBtYW51YWwgY29uc3VtZXJzIGFsbCBpbmhlcml0IGl0IChMNikuXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIEludGVncmF0aW9uLXRpbWUgZ2x1ZSAobmV0d29yayBmZXRjaCArIGxvZ2dpbmcpIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuVmVyc2lvbk1hdHJpeEVudHJ5LFxuICBSZXNvbHZlZFZlcnNpb25TcGVjXG59IGZyb20gJy4vdmVyc2lvbi1tYXRyaXgubWpzJztcblxuaW1wb3J0IHsgbG9nIH0gZnJvbSAnLi9sb2cubWpzJztcbmltcG9ydCB7IGZldGNoRGVza3RvcFJlbGVhc2VzTWFuaWZlc3QgfSBmcm9tICcuL29ic2lkaWFuLXZlcnNpb24tc3dpdGNoLm1qcyc7XG5pbXBvcnQge1xuICBidWlsZFZlcnNpb25NYXRyaXgsXG4gIGZvcm1hdFZlcnNpb25NYXRyaXhQbGFuLFxuICBmb3JtYXRWZXJzaW9uTWF0cml4UnVuSGVhZGVyLFxuICBoYXNDaGFubmVsU3BlYyxcbiAgcmVzb2x2ZVJlcXVlc3RlZFNwZWNzLFxuICByZXNvbHZlVmVyc2lvblNwZWNzLFxuICBydW5WZXJzaW9uTWF0cml4RW50cmllc1xufSBmcm9tICcuL3ZlcnNpb24tbWF0cml4Lm1qcyc7XG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIHJ1bk9ic2lkaWFuVmVyc2lvbk1hdHJpeH0uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4UGFyYW1zIHtcbiAgLyoqXG4gICAqIFJ1bnMgdGhlIHN1aXRlcyBhZ2FpbnN0IG9uZSBjb25jcmV0ZSBPYnNpZGlhbiB2ZXJzaW9uLCB0aHJvd2luZyBvbiBmYWlsdXJlLlxuICAgKlxuICAgKiBUaGUgZW50cnkncyBgdmVyc2lvbmAgaXMgdGhlIGNvbmNyZXRlIGB4LnkuemAgdG8gcGluIFx1MjAxNCB0eXBpY2FsbHkgZm9yd2FyZGVkIHRvXG4gICAqIHRoZSB0ZXN0LXJ1bm5lciBjaGlsZCBhcyBgT0JTSURJQU5fVkVSU0lPTmAuXG4gICAqL1xuICByZWFkb25seSBydW46IChlbnRyeTogT2JzaWRpYW5WZXJzaW9uTWF0cml4RW50cnkpID0+IFByb21pc2U8dm9pZD4gfCB2b2lkO1xuXG4gIC8qKlxuICAgKiBUaGUgdmVyc2lvbiBzcGVjaWZpZXJzIHRvIHJ1biBhZ2FpbnN0OiBhbiBhcnJheSwgb3IgYSBjb21tYS1zZXBhcmF0ZWQgc3RyaW5nXG4gICAqIHNvIGFuIGVudiB2YXIgY2FuIGJlIHBhc3NlZCBzdHJhaWdodCB0aHJvdWdoLlxuICAgKlxuICAgKiBFYWNoIGFjY2VwdHMgYW4gZXhwbGljaXQgYCd4LnkueidgLCBgJ3B1YmxpYy1sYXRlc3QnYCwgb3IgYCdjYXRhbHlzdC1sYXRlc3QnYC5cbiAgICogRGVmYXVsdHMgdG8gYm90aCBlbmRzIG9mIHRoZSBzdXBwb3J0ZWQgcmFuZ2UgKEc5OSkgd2hlbiBvbWl0dGVkIG9yIGVtcHR5LCBhbmRcbiAgICogdGhlIGxpc3QgaXMgYWx3YXlzIGRlLWR1cGxpY2F0ZWQgb24gdGhlICoqcmVzb2x2ZWQqKiB2ZXJzaW9uIFx1MjAxNCBzbyB3aGVuIHB1YmxpY1xuICAgKiBoYXMgY2F1Z2h0IHVwIHRvIGNhdGFseXN0LCB0aGUgc3VpdGVzIHJ1biBvbmNlLlxuICAgKi9cbiAgcmVhZG9ubHkgdmVyc2lvbnM/OiByZWFkb25seSBzdHJpbmdbXSB8IHN0cmluZyB8IHVuZGVmaW5lZDtcbn1cblxuLyoqXG4gKiBSdW5zIGEgc3VpdGUgb25jZSBwZXIgZGlzdGluY3Qgc3VwcG9ydGVkIE9ic2lkaWFuIHZlcnNpb24uXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBwZXItdmVyc2lvbiBydW5uZXIgYW5kIHRoZSByZXF1ZXN0ZWQgdmVyc2lvbnMuXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIG9uY2UgZXZlcnkgdmVyc2lvbiBoYXMgcnVuIHN1Y2Nlc3NmdWxseS5cbiAqIEB0aHJvd3MgRXJyb3IgaWYgbm8gdmVyc2lvbiBjb3VsZCBiZSByZXNvbHZlZCwgb3IgYW4ge0BsaW5rIEFnZ3JlZ2F0ZUVycm9yfVxuICogICBuYW1pbmcgZXZlcnkgdmVyc2lvbiB3aG9zZSBydW4gZmFpbGVkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4KHBhcmFtczogUnVuT2JzaWRpYW5WZXJzaW9uTWF0cml4UGFyYW1zKTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IHsgcnVuLCB2ZXJzaW9ucyB9ID0gcGFyYW1zO1xuXG4gIGNvbnN0IHsgaXNEZWZhdWx0LCBzcGVjcyB9ID0gcmVzb2x2ZVJlcXVlc3RlZFNwZWNzKHZlcnNpb25zKTtcbiAgY29uc3QgbWFuaWZlc3QgPSBoYXNDaGFubmVsU3BlYyhzcGVjcykgPyBhd2FpdCBmZXRjaERlc2t0b3BSZWxlYXNlc01hbmlmZXN0KCkgOiB1bmRlZmluZWQ7XG4gIGNvbnN0IHsgZHJvcHBlZFNwZWNzLCByZXNvbHZlZFNwZWNzIH0gPSByZXNvbHZlVmVyc2lvblNwZWNzKHtcbiAgICBtYW5pZmVzdCxcbiAgICAvLyBUaGUgZGVmYXVsdCBsaXN0IG11c3Qgbm90IGJyZWFrIGV2ZXJ5IGNvbnN1bWVyJ3MgZ2F0ZSB3aGVuIGEgY2hhbm5lbCBpc1xuICAgIC8vIE1vbWVudGFyaWx5IGFic2VudCBmcm9tIHRoZSBtYW5pZmVzdDsgYW4gZXhwbGljaXRseSByZXF1ZXN0ZWQgc3BlY2lmaWVyXG4gICAgLy8gVGhhdCBjYW5ub3QgcmVzb2x2ZSBpcyBhIHJlYWwgZXJyb3IuXG4gICAgc2hvdWxkVG9sZXJhdGVVbnJlc29sdmFibGVTcGVjczogaXNEZWZhdWx0LFxuICAgIHNwZWNzXG4gIH0pO1xuXG4gIGZvciAoY29uc3QgeyByZWFzb24sIHNwZWMgfSBvZiBkcm9wcGVkU3BlY3MpIHtcbiAgICBsb2dNYXRyaXgoYFNraXBwaW5nIFwiJHtzcGVjfVwiOiAke3JlYXNvbn1gKTtcbiAgfVxuXG4gIGNvbnN0IGVudHJpZXMgPSBidWlsZFZlcnNpb25NYXRyaXgocmVzb2x2ZWRTcGVjcyk7XG4gIGxvZ1BsYW4ocmVzb2x2ZWRTcGVjcywgZW50cmllcyk7XG5cbiAgYXdhaXQgcnVuVmVyc2lvbk1hdHJpeEVudHJpZXMoe1xuICAgIGVudHJpZXMsXG4gICAgb25FbnRyeVN0YXJ0OiAoaGVhZGVyUGFyYW1zKSA9PiB7XG4gICAgICBsb2dNYXRyaXgoZm9ybWF0VmVyc2lvbk1hdHJpeFJ1bkhlYWRlcihoZWFkZXJQYXJhbXMpKTtcbiAgICB9LFxuICAgIHJ1blxuICB9KTtcbn1cblxuLyoqXG4gKiBMb2dzIGEgbWF0cml4IG1lc3NhZ2UgdW5kZXIgYSBjb25zaXN0ZW50IHByZWZpeC5cbiAqXG4gKiBAcGFyYW0gbWVzc2FnZSAtIFRoZSBtZXNzYWdlIHRvIGxvZy5cbiAqL1xuZnVuY3Rpb24gbG9nTWF0cml4KG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQge1xuICBsb2coYFt2ZXJzaW9uLW1hdHJpeF0gJHttZXNzYWdlfWApO1xufVxuXG4vKipcbiAqIExvZ3Mgd2hhdCB0aGUgc3BlY2lmaWVycyByZXNvbHZlZCB0byBhbmQgaG93IG1hbnkgcnVucyB0aGF0IGltcGxpZXMuXG4gKlxuICogQHBhcmFtIHJlc29sdmVkU3BlY3MgLSBUaGUgcmVzb2x2ZWQgc3BlY2lmaWVycywgaW4gcmVxdWVzdGVkIG9yZGVyLlxuICogQHBhcmFtIGVudHJpZXMgLSBUaGUgZGUtZHVwbGljYXRlZCBtYXRyaXguXG4gKi9cbmZ1bmN0aW9uIGxvZ1BsYW4ocmVzb2x2ZWRTcGVjczogcmVhZG9ubHkgUmVzb2x2ZWRWZXJzaW9uU3BlY1tdLCBlbnRyaWVzOiByZWFkb25seSBPYnNpZGlhblZlcnNpb25NYXRyaXhFbnRyeVtdKTogdm9pZCB7XG4gIGZvciAoY29uc3QgbGluZSBvZiBmb3JtYXRWZXJzaW9uTWF0cml4UGxhbih7IGVudHJpZXMsIHJlc29sdmVkU3BlY3MgfSkpIHtcbiAgICBsb2dNYXRyaXgobGluZSk7XG4gIH1cbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQXlCQSxTQUFTLFdBQVc7QUFDcEIsU0FBUyxvQ0FBb0M7QUFDN0M7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsT0FDSztBQWtDUCxlQUFzQix5QkFBeUIsUUFBdUQ7QUFDcEcsUUFBTSxFQUFFLEtBQUssU0FBUyxJQUFJO0FBRTFCLFFBQU0sRUFBRSxXQUFXLE1BQU0sSUFBSSxzQkFBc0IsUUFBUTtBQUMzRCxRQUFNLFdBQVcsZUFBZSxLQUFLLElBQUksTUFBTSw2QkFBNkIsSUFBSTtBQUNoRixRQUFNLEVBQUUsY0FBYyxjQUFjLElBQUksb0JBQW9CO0FBQUEsSUFDMUQ7QUFBQTtBQUFBO0FBQUE7QUFBQSxJQUlBLGlDQUFpQztBQUFBLElBQ2pDO0FBQUEsRUFDRixDQUFDO0FBRUQsYUFBVyxFQUFFLFFBQVEsS0FBSyxLQUFLLGNBQWM7QUFDM0MsY0FBVSxhQUFhLElBQUksTUFBTSxNQUFNLEVBQUU7QUFBQSxFQUMzQztBQUVBLFFBQU0sVUFBVSxtQkFBbUIsYUFBYTtBQUNoRCxVQUFRLGVBQWUsT0FBTztBQUU5QixRQUFNLHdCQUF3QjtBQUFBLElBQzVCO0FBQUEsSUFDQSxjQUFjLENBQUMsaUJBQWlCO0FBQzlCLGdCQUFVLDZCQUE2QixZQUFZLENBQUM7QUFBQSxJQUN0RDtBQUFBLElBQ0E7QUFBQSxFQUNGLENBQUM7QUFDSDtBQU9BLFNBQVMsVUFBVSxTQUF1QjtBQUN4QyxNQUFJLG9CQUFvQixPQUFPLEVBQUU7QUFDbkM7QUFRQSxTQUFTLFFBQVEsZUFBK0MsU0FBc0Q7QUFDcEgsYUFBVyxRQUFRLHdCQUF3QixFQUFFLFNBQVMsY0FBYyxDQUFDLEdBQUc7QUFDdEUsY0FBVSxJQUFJO0FBQUEsRUFDaEI7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# 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": []
}
