obsidian-integration-testing 5.1.1 → 5.2.0

package/dist/lib/cjs/obsidian-version-switch.cjs

@@ -22,6 +22,7 @@ __export(obsidian_version_switch_exports, {
   ensureAsarCached: () => ensureAsarCached,
   fetchDesktopReleasesManifest: () => fetchDesktopReleasesManifest,
   findNewestAsar: () => findNewestAsar,
+  getCachedAsarPath: () => getCachedAsarPath,
   resolveConcreteVersion: () => resolveConcreteVersion
 });
 module.exports = __toCommonJS(obsidian_version_switch_exports);
@@ -32,6 +33,8 @@ var import_node_zlib = require("node:zlib");
 var import_log = require("./log.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
 const DOWNLOAD_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+const PUBLIC_ASAR_RELEASE_BASE_URL = "https://github.com/obsidianmd/obsidian-releases/releases/download";
+const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
 const CACHE_ROOT = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "obsidian-integration-testing");
 const ASAR_CACHE_DIR = (0, import_node_path.join)(CACHE_ROOT, "asar-cache");
 const ASAR_FILE_PATTERN = /^obsidian-(?<version>\d+\.\d+\.\d+)\.asar$/;
@@ -43,21 +46,23 @@ function copyAsarIntoUserData(asarPath, version, userDataDir) {
 }
 async function ensureAsarCached(version) {
   (0, import_node_fs.mkdirSync)(ASAR_CACHE_DIR, { recursive: true });
-  const cachedPath = (0, import_node_path.join)(ASAR_CACHE_DIR, (0, import_obsidian_version.getVersionAsarFileName)(version));
+  const cachedPath = getCachedAsarPath(version);
   if ((0, import_node_fs.existsSync)(cachedPath)) {
     (0, import_log.log)(`[version-switch] Using cached asar for ${version}.`);
     return cachedPath;
   }
-  const url = `https://releases.obsidian.md/release/${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
-  (0, import_log.log)(`[version-switch] Downloading asar ${version} from ${url} ...`);
-  const response = await fetch(url, { headers: { "User-Agent": DOWNLOAD_USER_AGENT } });
-  if (!response.ok) {
-    throw new Error(`Failed to download Obsidian asar ${version}: HTTP ${String(response.status)} from ${url}`);
+  const errors = [];
+  for (const url of getAsarDownloadUrls(version)) {
+    try {
+      const asar = await downloadAndDecompressAsar(url);
+      (0, import_node_fs.writeFileSync)(cachedPath, asar);
+      (0, import_log.log)(`[version-switch] Cached asar ${version} (${String(asar.length)} bytes) -> ${cachedPath}`);
+      return cachedPath;
+    } catch (error) {
+      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  const gz = Buffer.from(await response.arrayBuffer());
-  (0, import_node_fs.writeFileSync)(cachedPath, (0, import_node_zlib.gunzipSync)(gz));
-  (0, import_log.log)(`[version-switch] Cached asar ${version} (${String(gz.length)} bytes compressed) -> ${cachedPath}`);
-  return cachedPath;
+  throw new Error(`Failed to download Obsidian asar ${version}. Attempts: ${errors.join("; ")}`);
 }
 async function fetchDesktopReleasesManifest() {
   const response = await fetch(import_obsidian_version.DESKTOP_RELEASES_MANIFEST_URL);
@@ -86,6 +91,9 @@ function findNewestAsar(dir) {
   }
   return newest;
 }
+function getCachedAsarPath(version) {
+  return (0, import_node_path.join)(ASAR_CACHE_DIR, (0, import_obsidian_version.getVersionAsarFileName)(version));
+}
 async function resolveConcreteVersion(spec) {
   const parsed = (0, import_obsidian_version.parseVersionSpec)(spec);
   if (parsed.kind === "explicit") {
@@ -94,12 +102,32 @@ async function resolveConcreteVersion(spec) {
   const manifest = await fetchDesktopReleasesManifest();
   return (0, import_obsidian_version.resolveVersionFromManifest)(manifest, parsed.channel);
 }
+async function downloadAndDecompressAsar(url) {
+  (0, import_log.log)(`[version-switch] Downloading asar from ${url} ...`);
+  const response = await fetch(url, { headers: { "User-Agent": DOWNLOAD_USER_AGENT } });
+  if (!response.ok) {
+    throw new Error(`HTTP ${String(response.status)}`);
+  }
+  const gz = Buffer.from(await response.arrayBuffer());
+  if (gz.length === 0) {
+    throw new Error("empty response body");
+  }
+  return (0, import_node_zlib.gunzipSync)(gz);
+}
+function getAsarDownloadUrls(version) {
+  const asarGzFileName = `${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
+  return [
+    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
+    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
+  ];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   copyAsarIntoUserData,
   ensureAsarCached,
   fetchDesktopReleasesManifest,
   findNewestAsar,
+  getCachedAsarPath,
   resolveConcreteVersion
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-version-switch.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Integration-time helpers for provisioning a specific Obsidian **asar** (the\n * app code) into an isolated user-data dir.\n *\n * Obsidian's bootstrap loads the highest of (its shell's bundled\n * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the\n * user-data dir). So placing an asar here only takes effect when its version is\n * **>= the shell's bundled version** (upgrade-only \u2014 confirmed by the Phase 0\n * spike). Running an older version requires pinning the installer/shell instead\n * (see `obsidian-installer.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/filesystem glue covered by integration tests, not unit tests. */\n\nimport {\n  copyFileSync,\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { gunzipSync } from 'node:zlib';\n\nimport type { DesktopReleasesManifest } from './obsidian-version.cjs';\n\nimport { log } from './log.cjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.cjs';\n\n/**\n * Browser User-Agent required to fetch asar packages from\n * `releases.obsidian.md` (the endpoint is Cloudflare-gated against non-browser\n * clients). Matches the UA documented in the obsidian-versions repo.\n */\nconst DOWNLOAD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36';\n\nconst CACHE_ROOT = join(tmpdir(), 'obsidian-integration-testing');\nconst ASAR_CACHE_DIR = join(CACHE_ROOT, 'asar-cache');\nconst ASAR_FILE_PATTERN = /^obsidian-(?<version>\\d+\\.\\d+\\.\\d+)\\.asar$/;\n\n/**\n * A discovered `obsidian-<version>.asar` file.\n */\nexport interface DiscoveredAsar {\n  /** Absolute path to the asar file. */\n  readonly path: string;\n\n  /** The `x.y.z` version parsed from the file name. */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data dir under its canonical\n * `obsidian-<version>.asar` name.\n *\n * @param asarPath - Source asar path.\n * @param version - The asar's version (used for the destination file name).\n * @param userDataDir - Destination user-data dir.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void {\n  mkdirSync(userDataDir, { recursive: true });\n  const dest = join(userDataDir, getVersionAsarFileName(version));\n  copyFileSync(asarPath, dest);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDir}.`);\n}\n\n/**\n * Ensures the asar for a concrete version is present in the local cache,\n * downloading and decompressing it if necessary.\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path to the cached asar.\n * @throws Error if the download fails.\n */\nexport async function ensureAsarCached(version: string): Promise<string> {\n  mkdirSync(ASAR_CACHE_DIR, { recursive: true });\n  const cachedPath = join(ASAR_CACHE_DIR, getVersionAsarFileName(version));\n  if (existsSync(cachedPath)) {\n    log(`[version-switch] Using cached asar for ${version}.`);\n    return cachedPath;\n  }\n\n  const url = `https://releases.obsidian.md/release/${getVersionAsarFileName(version)}.gz`;\n  log(`[version-switch] Downloading asar ${version} from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(`Failed to download Obsidian asar ${version}: HTTP ${String(response.status)} from ${url}`);\n  }\n\n  const gz = Buffer.from(await response.arrayBuffer());\n  writeFileSync(cachedPath, gunzipSync(gz));\n  log(`[version-switch] Cached asar ${version} (${String(gz.length)} bytes compressed) -> ${cachedPath}`);\n  return cachedPath;\n}\n\n/**\n * Fetches and parses Obsidian's desktop releases manifest.\n *\n * @returns The parsed manifest.\n * @throws Error if the manifest cannot be fetched.\n */\nexport async function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest> {\n  const response = await fetch(DESKTOP_RELEASES_MANIFEST_URL);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);\n  }\n  return await response.json() as DesktopReleasesManifest;\n}\n\n/**\n * Finds the newest `obsidian-<version>.asar` in a directory.\n *\n * @param dir - The directory to scan (e.g. the user's Obsidian config dir).\n * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.\n */\nexport function findNewestAsar(dir: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(dir);\n  } catch {\n    return undefined;\n  }\n\n  let newest: DiscoveredAsar | undefined;\n  for (const entry of entries) {\n    const match = ASAR_FILE_PATTERN.exec(entry);\n    if (!match) {\n      continue;\n    }\n    const version = match.groups?.['version'] ?? '';\n    if (!newest || compareVersions(version, newest.version) > 0) {\n      newest = { path: join(dir, entry), version };\n    }\n  }\n  return newest;\n}\n\n/**\n * Resolves a version specifier (explicit or channel alias) to a concrete\n * `x.y.z` version, fetching the manifest only when a channel alias is used.\n *\n * @param spec - The version specifier.\n * @returns The concrete version.\n */\nexport async function resolveConcreteVersion(spec: string): Promise<string> {\n  const parsed = parseVersionSpec(spec);\n  if (parsed.kind === 'explicit') {\n    return parsed.version;\n  }\n  const manifest = await fetchDesktopReleasesManifest();\n  return resolveVersionFromManifest(manifest, parsed.channel);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,qBAMO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,uBAA2B;AAI3B,iBAAoB;AACpB,8BAMO;AAOP,MAAM,sBAAsB;AAE5B,MAAM,iBAAa,2BAAK,uBAAO,GAAG,8BAA8B;AAChE,MAAM,qBAAiB,uBAAK,YAAY,YAAY;AACpD,MAAM,oBAAoB;AAqBnB,SAAS,qBAAqB,UAAkB,SAAiB,aAA2B;AACjG,gCAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAC1C,QAAM,WAAO,uBAAK,iBAAa,gDAAuB,OAAO,CAAC;AAC9D,mCAAa,UAAU,IAAI;AAC3B,sBAAI,oCAAgC,gDAAuB,OAAO,CAAC,SAAS,WAAW,GAAG;AAC5F;AAUA,eAAsB,iBAAiB,SAAkC;AACvE,gCAAU,gBAAgB,EAAE,WAAW,KAAK,CAAC;AAC7C,QAAM,iBAAa,uBAAK,oBAAgB,gDAAuB,OAAO,CAAC;AACvE,UAAI,2BAAW,UAAU,GAAG;AAC1B,wBAAI,0CAA0C,OAAO,GAAG;AACxD,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,4CAAwC,gDAAuB,OAAO,CAAC;AACnF,sBAAI,qCAAqC,OAAO,SAAS,GAAG,MAAM;AAClE,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS,EAAE,cAAc,oBAAoB,EAAE,CAAC;AACpF,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,oCAAoC,OAAO,UAAU,OAAO,SAAS,MAAM,CAAC,SAAS,GAAG,EAAE;AAAA,EAC5G;AAEA,QAAM,KAAK,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC;AACnD,oCAAc,gBAAY,6BAAW,EAAE,CAAC;AACxC,sBAAI,gCAAgC,OAAO,KAAK,OAAO,GAAG,MAAM,CAAC,yBAAyB,UAAU,EAAE;AACtG,SAAO;AACT;AAQA,eAAsB,+BAAiE;AACrF,QAAM,WAAW,MAAM,MAAM,qDAA6B;AAC1D,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,mDAAmD,OAAO,SAAS,MAAM,CAAC,EAAE;AAAA,EAC9F;AACA,SAAO,MAAM,SAAS,KAAK;AAC7B;AAQO,SAAS,eAAe,KAAyC;AACtE,MAAI;AACJ,MAAI;AACF,kBAAU,4BAAY,GAAG;AAAA,EAC3B,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,aAAW,SAAS,SAAS;AAC3B,UAAM,QAAQ,kBAAkB,KAAK,KAAK;AAC1C,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AACA,UAAM,UAAU,MAAM,SAAS,SAAS,KAAK;AAC7C,QAAI,CAAC,cAAU,yCAAgB,SAAS,OAAO,OAAO,IAAI,GAAG;AAC3D,eAAS,EAAE,UAAM,uBAAK,KAAK,KAAK,GAAG,QAAQ;AAAA,IAC7C;AAAA,EACF;AACA,SAAO;AACT;AASA,eAAsB,uBAAuB,MAA+B;AAC1E,QAAM,aAAS,0CAAiB,IAAI;AACpC,MAAI,OAAO,SAAS,YAAY;AAC9B,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,WAAW,MAAM,6BAA6B;AACpD,aAAO,oDAA2B,UAAU,OAAO,OAAO;AAC5D;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-version-switch.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Integration-time helpers for provisioning a specific Obsidian **asar** (the\n * app code) into an isolated user-data dir.\n *\n * Obsidian's bootstrap loads the highest of (its shell's bundled\n * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the\n * user-data dir). So placing an asar here only takes effect when its version is\n * **>= the shell's bundled version** (upgrade-only \u2014 confirmed by the Phase 0\n * spike). Running an older version requires pinning the installer/shell instead\n * (see `obsidian-installer.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/filesystem glue covered by integration tests, not unit tests. */\n\nimport {\n  copyFileSync,\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { gunzipSync } from 'node:zlib';\n\nimport type { DesktopReleasesManifest } from './obsidian-version.cjs';\n\nimport { log } from './log.cjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.cjs';\n\n/**\n * Browser User-Agent required to fetch asar packages from\n * `releases.obsidian.md` (the endpoint is Cloudflare-gated against non-browser\n * clients). Matches the UA documented in the obsidian-versions repo.\n */\nconst DOWNLOAD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36';\n\n/**\n * Base URL for **public** (stable) release asars, published as GitHub release\n * assets under `.../download/v<version>/obsidian-<version>.asar.gz`.\n */\nconst PUBLIC_ASAR_RELEASE_BASE_URL = 'https://github.com/obsidianmd/obsidian-releases/releases/download';\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).\n */\nconst CATALYST_ASAR_RELEASE_BASE_URL = 'https://releases.obsidian.md/release';\n\nconst CACHE_ROOT = join(tmpdir(), 'obsidian-integration-testing');\nconst ASAR_CACHE_DIR = join(CACHE_ROOT, 'asar-cache');\nconst ASAR_FILE_PATTERN = /^obsidian-(?<version>\\d+\\.\\d+\\.\\d+)\\.asar$/;\n\n/**\n * A discovered `obsidian-<version>.asar` file.\n */\nexport interface DiscoveredAsar {\n  /** Absolute path to the asar file. */\n  readonly path: string;\n\n  /** The `x.y.z` version parsed from the file name. */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data dir under its canonical\n * `obsidian-<version>.asar` name.\n *\n * @param asarPath - Source asar path.\n * @param version - The asar's version (used for the destination file name).\n * @param userDataDir - Destination user-data dir.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void {\n  mkdirSync(userDataDir, { recursive: true });\n  const dest = join(userDataDir, getVersionAsarFileName(version));\n  copyFileSync(asarPath, dest);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDir}.`);\n}\n\n/**\n * Ensures the asar for a concrete version is present in the local cache,\n * downloading and decompressing it if necessary.\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path to the cached asar.\n * @throws Error if the download fails.\n */\nexport async function ensureAsarCached(version: string): Promise<string> {\n  mkdirSync(ASAR_CACHE_DIR, { recursive: true });\n  const cachedPath = getCachedAsarPath(version);\n  if (existsSync(cachedPath)) {\n    log(`[version-switch] Using cached asar for ${version}.`);\n    return cachedPath;\n  }\n\n  // A version's asar.gz lives on exactly one host depending on its channel\n  // (public \u2192 GitHub release assets, catalyst \u2192 the Obsidian CDN). The concrete\n  // Version alone does not tell us which, so try both and use the first that\n  // Returns a valid archive.\n  const errors: string[] = [];\n  for (const url of getAsarDownloadUrls(version)) {\n    try {\n      const asar = await downloadAndDecompressAsar(url);\n      writeFileSync(cachedPath, asar);\n      log(`[version-switch] Cached asar ${version} (${String(asar.length)} bytes) -> ${cachedPath}`);\n      return cachedPath;\n    } catch (error) {\n      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  throw new Error(`Failed to download Obsidian asar ${version}. Attempts: ${errors.join('; ')}`);\n}\n\n/**\n * Fetches and parses Obsidian's desktop releases manifest.\n *\n * @returns The parsed manifest.\n * @throws Error if the manifest cannot be fetched.\n */\nexport async function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest> {\n  const response = await fetch(DESKTOP_RELEASES_MANIFEST_URL);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);\n  }\n  return await response.json() as DesktopReleasesManifest;\n}\n\n/**\n * Finds the newest `obsidian-<version>.asar` in a directory.\n *\n * @param dir - The directory to scan (e.g. the user's Obsidian config dir).\n * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.\n */\nexport function findNewestAsar(dir: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(dir);\n  } catch {\n    return undefined;\n  }\n\n  let newest: DiscoveredAsar | undefined;\n  for (const entry of entries) {\n    const match = ASAR_FILE_PATTERN.exec(entry);\n    if (!match) {\n      continue;\n    }\n    const version = match.groups?.['version'] ?? '';\n    if (!newest || compareVersions(version, newest.version) > 0) {\n      newest = { path: join(dir, entry), version };\n    }\n  }\n  return newest;\n}\n\n/**\n * Returns the local cache path for a concrete version's asar (the file may not\n * yet exist).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path the asar is cached at.\n */\nexport function getCachedAsarPath(version: string): string {\n  return join(ASAR_CACHE_DIR, getVersionAsarFileName(version));\n}\n\n/**\n * Resolves a version specifier (explicit or channel alias) to a concrete\n * `x.y.z` version, fetching the manifest only when a channel alias is used.\n *\n * @param spec - The version specifier.\n * @returns The concrete version.\n */\nexport async function resolveConcreteVersion(spec: string): Promise<string> {\n  const parsed = parseVersionSpec(spec);\n  if (parsed.kind === 'explicit') {\n    return parsed.version;\n  }\n  const manifest = await fetchDesktopReleasesManifest();\n  return resolveVersionFromManifest(manifest, parsed.channel);\n}\n\n/**\n * Downloads a gzip-compressed asar from a URL and decompresses it.\n *\n * @param url - The `.asar.gz` URL.\n * @returns The decompressed asar bytes.\n * @throws Error if the request fails, the body is empty, or decompression fails.\n */\nasync function downloadAndDecompressAsar(url: string): Promise<Buffer> {\n  log(`[version-switch] Downloading asar from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(`HTTP ${String(response.status)}`);\n  }\n\n  const gz = Buffer.from(await response.arrayBuffer());\n  if (gz.length === 0) {\n    throw new Error('empty response body');\n  }\n  return gunzipSync(gz);\n}\n\n/**\n * Returns the candidate `.asar.gz` download URLs for a concrete version, public\n * (GitHub) first, then catalyst (CDN).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The URLs to try, in order.\n */\nfunction getAsarDownloadUrls(version: string): string[] {\n  const asarGzFileName = `${getVersionAsarFileName(version)}.gz`;\n  return [\n    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,\n    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`\n  ];\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,qBAMO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,uBAA2B;AAI3B,iBAAoB;AACpB,8BAMO;AAOP,MAAM,sBAAsB;AAM5B,MAAM,+BAA+B;AAOrC,MAAM,iCAAiC;AAEvC,MAAM,iBAAa,2BAAK,uBAAO,GAAG,8BAA8B;AAChE,MAAM,qBAAiB,uBAAK,YAAY,YAAY;AACpD,MAAM,oBAAoB;AAqBnB,SAAS,qBAAqB,UAAkB,SAAiB,aAA2B;AACjG,gCAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAC1C,QAAM,WAAO,uBAAK,iBAAa,gDAAuB,OAAO,CAAC;AAC9D,mCAAa,UAAU,IAAI;AAC3B,sBAAI,oCAAgC,gDAAuB,OAAO,CAAC,SAAS,WAAW,GAAG;AAC5F;AAUA,eAAsB,iBAAiB,SAAkC;AACvE,gCAAU,gBAAgB,EAAE,WAAW,KAAK,CAAC;AAC7C,QAAM,aAAa,kBAAkB,OAAO;AAC5C,UAAI,2BAAW,UAAU,GAAG;AAC1B,wBAAI,0CAA0C,OAAO,GAAG;AACxD,WAAO;AAAA,EACT;AAMA,QAAM,SAAmB,CAAC;AAC1B,aAAW,OAAO,oBAAoB,OAAO,GAAG;AAC9C,QAAI;AACF,YAAM,OAAO,MAAM,0BAA0B,GAAG;AAChD,wCAAc,YAAY,IAAI;AAC9B,0BAAI,gCAAgC,OAAO,KAAK,OAAO,KAAK,MAAM,CAAC,cAAc,UAAU,EAAE;AAC7F,aAAO;AAAA,IACT,SAAS,OAAO;AACd,aAAO,KAAK,GAAG,GAAG,KAAK,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC,EAAE;AAAA,IACjF;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,oCAAoC,OAAO,eAAe,OAAO,KAAK,IAAI,CAAC,EAAE;AAC/F;AAQA,eAAsB,+BAAiE;AACrF,QAAM,WAAW,MAAM,MAAM,qDAA6B;AAC1D,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,mDAAmD,OAAO,SAAS,MAAM,CAAC,EAAE;AAAA,EAC9F;AACA,SAAO,MAAM,SAAS,KAAK;AAC7B;AAQO,SAAS,eAAe,KAAyC;AACtE,MAAI;AACJ,MAAI;AACF,kBAAU,4BAAY,GAAG;AAAA,EAC3B,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,aAAW,SAAS,SAAS;AAC3B,UAAM,QAAQ,kBAAkB,KAAK,KAAK;AAC1C,QAAI,CAAC,OAAO;AACV;AAAA,IACF;AACA,UAAM,UAAU,MAAM,SAAS,SAAS,KAAK;AAC7C,QAAI,CAAC,cAAU,yCAAgB,SAAS,OAAO,OAAO,IAAI,GAAG;AAC3D,eAAS,EAAE,UAAM,uBAAK,KAAK,KAAK,GAAG,QAAQ;AAAA,IAC7C;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,kBAAkB,SAAyB;AACzD,aAAO,uBAAK,oBAAgB,gDAAuB,OAAO,CAAC;AAC7D;AASA,eAAsB,uBAAuB,MAA+B;AAC1E,QAAM,aAAS,0CAAiB,IAAI;AACpC,MAAI,OAAO,SAAS,YAAY;AAC9B,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,WAAW,MAAM,6BAA6B;AACpD,aAAO,oDAA2B,UAAU,OAAO,OAAO;AAC5D;AASA,eAAe,0BAA0B,KAA8B;AACrE,sBAAI,0CAA0C,GAAG,MAAM;AACvD,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS,EAAE,cAAc,oBAAoB,EAAE,CAAC;AACpF,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,QAAQ,OAAO,SAAS,MAAM,CAAC,EAAE;AAAA,EACnD;AAEA,QAAM,KAAK,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC;AACnD,MAAI,GAAG,WAAW,GAAG;AACnB,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AACA,aAAO,6BAAW,EAAE;AACtB;AASA,SAAS,oBAAoB,SAA2B;AACtD,QAAM,iBAAiB,OAAG,gDAAuB,OAAO,CAAC;AACzD,SAAO;AAAA,IACL,GAAG,4BAA4B,KAAK,OAAO,IAAI,cAAc;AAAA,IAC7D,GAAG,8BAA8B,IAAI,cAAc;AAAA,EACrD;AACF;",
  "names": []
}


package/dist/lib/cjs/obsidian-version-switch.d.cts

@@ -53,6 +53,14 @@ export declare function fetchDesktopReleasesManifest(): Promise<DesktopReleasesM
  * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.
  */
 export declare function findNewestAsar(dir: string): DiscoveredAsar | undefined;
+/**
+ * Returns the local cache path for a concrete version's asar (the file may not
+ * yet exist).
+ *
+ * @param version - A concrete `x.y.z` version.
+ * @returns The absolute path the asar is cached at.
+ */
+export declare function getCachedAsarPath(version: string): string;
 /**
  * Resolves a version specifier (explicit or channel alias) to a concrete
  * `x.y.z` version, fetching the manifest only when a channel alias is used.

package/dist/lib/esm/cli.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file
+ *
+ * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled
+ * Obsidian instance with the runtime helper namespace bootstrapped, prints the
+ * chosen CDP port/URL, and stays alive until interrupted so an external tool
+ * (raw CDP `ws`, DevTools, …) can attach.
+ */
+/**
+ * Parses CLI arguments, opens the connection, prints its endpoint, and blocks
+ * until `SIGINT`/`SIGTERM`, disposing the connection on shutdown.
+ *
+ * @returns A {@link Promise} that resolves once the connection has been disposed.
+ */
+export declare function main(): Promise<void>;

package/dist/lib/esm/cli.mjs

@@ -0,0 +1,61 @@
+import process from "node:process";
+import { parseArgs } from "node:util";
+import { connectToCdp } from "./connect-to-cdp.mjs";
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      "command-timeout": { type: "string" },
+      "host": { type: "string" },
+      "no-remove-vault": { type: "boolean" },
+      "obsidian-installer-version": { type: "string" },
+      "obsidian-version": { type: "string" },
+      "port": { type: "string" },
+      "vault": { type: "string" }
+    }
+  });
+  const connection = await connectToCdp(buildOptions(values));
+  process.stdout.write(
+    `Obsidian CDP ready.
+  port:   ${String(connection.port)}
+  cdpUrl: ${connection.cdpUrl}
+  vault:  ${connection.vault.path}
+Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.
+Press Ctrl+C to stop.
+`
+  );
+  await waitForShutdownSignal();
+  process.stdout.write("\nShutting down\u2026\n");
+  await connection.dispose();
+}
+function buildOptions(values) {
+  return {
+    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
+    ...values.host !== void 0 && { host: values.host },
+    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
+    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
+    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
+    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
+    ...values.vault !== void 0 && { vault: values.vault }
+  };
+}
+function parseNumber(flag, raw) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new Error(`--${flag} must be a number, got: ${raw}`);
+  }
+  return value;
+}
+function waitForShutdownSignal() {
+  return new Promise((resolve) => {
+    process.once("SIGINT", () => {
+      resolve();
+    });
+    process.once("SIGTERM", () => {
+      resolve();
+    });
+  });
+}
+export {
+  main
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/connect-to-cdp.d.mts

@@ -0,0 +1,130 @@
+/**
+ * @file
+ *
+ * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance
+ * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.
+ *
+ * A single {@link connectToCdp} call resolves the owned-instance config, opens a
+ * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,
+ * `typeIntoEditor`, `serializeError`, `getObsidianModule`, … are available), then
+ * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a
+ * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
+ */
+import type { Except } from 'type-fest';
+import type { ContextId } from './context-id.mjs';
+import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.mjs';
+import { TempVault } from './temp-vault.mjs';
+/**
+ * A live connection to a CDP-enabled Obsidian instance with the runtime helper
+ * namespace bootstrapped.
+ *
+ * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(…)`
+ * disposes it (killing an owned instance and — for a throw-away temp vault —
+ * removing its directory) automatically.
+ */
+export interface CdpConnection extends AsyncDisposable {
+    /**
+     * The base CDP URL, e.g. `http://localhost:51888`.
+     */
+    readonly cdpUrl: string;
+    /**
+     * Disposes the connection: kills an owned instance and removes its isolated
+     * user-data dir. The vault directory is removed only when it is a throw-away
+     * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a
+     * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.
+     *
+     * @returns A {@link Promise} that resolves once disposal completes.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Evaluates a self-contained function inside Obsidian via the rich helper
+     * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any
+     * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault
+     * path pre-bound to this connection.
+     *
+     * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).
+     * @returns A {@link Promise} that resolves to the return value of `fn`.
+     */
+    evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
+    /**
+     * Evaluates a raw JavaScript expression inside Obsidian and returns the
+     * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).
+     *
+     * @param expression - A self-contained JavaScript expression.
+     * @returns A {@link Promise} that resolves to the raw result string.
+     */
+    invoke(expression: string): Promise<string>;
+    /**
+     * The CDP port the instance is reachable on (the free port chosen for an
+     * owned instance, or the attached {@link ConnectToCdpOptions.port}).
+     */
+    readonly port: number;
+    /**
+     * The opened vault. Exposes `path` and `populate(...)` for seeding files.
+     */
+    readonly vault: TempVault;
+}
+/**
+ * Options for {@link connectToCdp}.
+ */
+export interface ConnectToCdpOptions {
+    /**
+     * Timeout in milliseconds for individual CDP commands.
+     *
+     * @default `30000`
+     */
+    readonly commandTimeoutInMilliseconds?: number;
+    /**
+     * CDP host.
+     *
+     * @default `'localhost'`
+     */
+    readonly host?: string;
+    /**
+     * Pins the Electron shell (installer build) the owned instance runs. Accepts
+     * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when
+     * {@link port} (attach mode) is set. When omitted, the installed shell is used.
+     *
+     * @default `undefined`
+     */
+    readonly obsidianInstallerVersion?: string;
+    /**
+     * Pins the Obsidian app version (asar) the owned instance runs. Accepts
+     * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when
+     * {@link port} (attach mode) is set. When omitted, the installed version is used.
+     *
+     * @default `undefined`
+     */
+    readonly obsidianVersion?: string;
+    /**
+     * CDP port of an already-running Obsidian to **attach** to. When omitted, an
+     * isolated instance is launched on an automatically chosen free port.
+     *
+     * @default `undefined`
+     */
+    readonly port?: number;
+    /**
+     * Whether to remove the vault directory on {@link CdpConnection.dispose}.
+     *
+     * When omitted, defaults to `true` for an implicit throw-away temp vault
+     * ({@link vault} not given) and `false` when a {@link vault} path is given, so
+     * a real vault is never deleted. Set explicitly to override.
+     */
+    readonly shouldRemoveVaultOnDispose?: boolean;
+    /**
+     * Absolute path to an existing vault to open. When omitted, an empty temporary
+     * vault is created (and removed on dispose unless
+     * {@link shouldRemoveVaultOnDispose} says otherwise).
+     *
+     * @default `undefined`
+     */
+    readonly vault?: string;
+}
+/**
+ * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and
+ * bootstraps the runtime helper namespace, returning a disposable connection.
+ *
+ * @param options - Connection options.
+ * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.
+ */
+export declare function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection>;

package/dist/lib/esm/connect-to-cdp.mjs

@@ -0,0 +1,63 @@
+import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { TempVault } from "./temp-vault.mjs";
+import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
+import { createTransportFromOptions } from "./transport-factory.mjs";
+const DEFAULT_CDP_HOST = "localhost";
+async function connectToCdp(options) {
+  const transportOptions = {
+    type: "obsidian-cdp",
+    ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
+    ...options?.host !== void 0 && { host: options.host },
+    ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
+    ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
+    ...options?.port !== void 0 && { port: options.port }
+  };
+  const transport = await createTransportFromOptions(transportOptions);
+  const vault = new TempVault(options?.vault);
+  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
+  await vault.register(transport);
+  const { host, port } = resolveEndpoint(transport, options);
+  const cdpUrl = `http://${host}:${String(port)}`;
+  const connection = {
+    cdpUrl,
+    async dispose() {
+      try {
+        if (shouldRemoveVaultOnDispose) {
+          await vault.dispose(transport);
+        } else {
+          await transport.unregisterVault(vault.path);
+        }
+      } finally {
+        await transport.dispose?.();
+      }
+    },
+    async evalInObsidian(params) {
+      return evalInObsidian({ ...params, transport, vaultPath: vault.path });
+    },
+    async invoke(expression) {
+      return transport.evaluate(expression, { cwd: vault.path });
+    },
+    port,
+    async [Symbol.asyncDispose]() {
+      await connection.dispose();
+    },
+    vault
+  };
+  return connection;
+}
+function resolveEndpoint(transport, options) {
+  if (transport instanceof DesktopCdpTransport) {
+    const endpoint = transport.getOwnedInstanceEndpoint();
+    if (endpoint) {
+      return { host: endpoint.host, port: endpoint.port };
+    }
+  }
+  if (options?.port !== void 0) {
+    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };
+  }
+  throw new Error("connectToCdp: could not determine the CDP port.");
+}
+export {
+  connectToCdp
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * `typeIntoEditor`, `serializeError`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, obsidianModule, typeIntoEditor, context }` plus any\n   * `args`. Mirrors the top-level `evalInObsidian`, with the transport and vault\n   * path pre-bound to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AA0IzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -3,6 +3,8 @@
  *
  * Contains the entry point for the integration testing module.
  */
+export type { CdpConnection, ConnectToCdpOptions } from './connect-to-cdp.mjs';
+export { connectToCdp } from './connect-to-cdp.mjs';
 export { ContextId } from './context-id.mjs';
 export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.mjs';
 export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.mjs';

package/dist/lib/esm/index.mjs

@@ -1,3 +1,4 @@
+import { connectToCdp } from "./connect-to-cdp.mjs";
 import { ContextId } from "./context-id.mjs";
 import {
   setTransportOptionsResolver,
@@ -17,6 +18,7 @@ export {
   ContextId,
   DesktopCdpTransport,
   TempVault,
+  connectToCdp,
   createTransportFromOptions,
   evalInObsidian,
   registerVault,
@@ -24,4 +26,4 @@ export {
   setVaultPathResolver,
   unregisterVault
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

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

package/dist/lib/esm/obsidian-installer.d.mts

@@ -43,3 +43,11 @@ export declare function detectInstalledShellVersion(exePath: string): string | u
  * @throws Error if the asset cannot be downloaded or extracted.
  */
 export declare function ensureShellCached(version: string): Promise<string>;
+/**
+ * Returns the cache directory a version's extracted shell lives in (the
+ * directory may not yet exist).
+ *
+ * @param version - A concrete public `x.y.z` version.
+ * @returns The absolute shell cache directory for the version.
+ */
+export declare function getCachedShellDir(version: string): string;