obsidian-integration-testing 11.0.0 → 12.0.0

package/dist/lib/cjs/obsidian-metadata.d.cts

@@ -20,9 +20,19 @@
  * The concrete JS runtime versions an installer's Electron shell ships — the
  * **entire** `process.versions` object, read empirically by booting that
  * installer over CDP (see `scripts/collect-runtime-versions.ts`). Absent for
- * versions not yet collected (or that could not be booted). Electron bundles the
- * same runtime on every OS for a given Electron version, so these are
- * platform-invariant.
+ * versions not yet collected (or that could not be booted).
+ *
+ * **These are the WINDOWS (`.exe`) values, and that matters.** A given Electron
+ * version does bundle the same Node / V8 / Chromium everywhere — but the Electron
+ * version itself is a property of the *installer*, not of the release, and two
+ * installers of the same Obsidian version can differ: `1.12.4` shipped Electron
+ * `39.6.0` in its `.exe` and `39.7.0` in every other installer, and `1.8.10`
+ * shipped `34.2.0` vs `34.5.2`. This field carries one flat value, measured on
+ * the `.exe` — the installer that, with the `.dmg`, is published for all 106
+ * installer-bearing releases. So a consumer pinning a macOS or Linux installer
+ * should treat `electron` as accurate to the patch only for the 104 releases
+ * where the platforms agree. The collection workflow boots all three platforms
+ * and reports any new divergence.
  *
  * The index signature carries every key `process.versions` exposes for that
  * Electron build — beyond the four well-known ones below, that typically includes
@@ -90,8 +100,9 @@ export interface ObsidianVersionChangelogUrls {
 }
 /**
  * The pre-resolved asset download URLs for a version, baked into `metadata.json`
- * from the upstream `obsidian-versions.json` catalog (see the `metadata.json`
- * section in `CLAUDE.md`).
+ * from the `obsidianmd/obsidian-releases` release assets — plus, for catalyst
+ * builds, the `releases.obsidian.md` CDN, which publishes no listing and so is
+ * probed (see the `metadata.json` section in `CLAUDE.md`).
  *
  * These are the exact URLs the version's assets are published at, so the
  * integration-time download paths can skip the GitHub release-API lookup and the
@@ -156,7 +167,7 @@ export interface ObsidianVersionMetadata {
     readonly channel?: string;
     /**
      * The pre-resolved asset download URLs for the version, baked from the
-     * upstream `obsidian-versions.json` catalog. Absent for versions not present
+     * `obsidianmd/obsidian-releases` release assets. Absent for versions not present
      * in the catalog (the caller then falls back to hand-rolled resolution).
      */
     readonly downloads?: ObsidianVersionDownloads;

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

@@ -33,9 +33,9 @@ var import_node_zlib = require("node:zlib");
 var import_log = require("./log.cjs");
 var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
+var import_release_catalog = require("./release-catalog.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$/;
@@ -119,7 +119,7 @@ function getAsarDownloadUrls(version) {
   const asarGzFileName = `${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
   const fallbackUrls = [
     `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
-    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
+    (0, import_release_catalog.buildCatalystAsarUrl)(version)
   ];
   const bakedUrl = (0, import_obsidian_metadata.getVersionMetadata)(version)?.downloads?.asar;
   return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;
@@ -133,4 +133,4 @@ function getAsarDownloadUrls(version) {
   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 directory.\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 directory). 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 { getVersionMetadata } from './obsidian-metadata.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  /**\n  Absolute path to the asar file.\n   */\n  readonly path: string;\n\n  /**\n  The `x.y.z` version parsed from the file name.\n   */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data directory 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 userDataDirectory - Destination user-data directory.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDirectory: string): void {\n  mkdirSync(userDataDirectory, { recursive: true });\n  const destination = join(userDataDirectory, getVersionAsarFileName(version));\n  copyFileSync(asarPath, destination);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDirectory}.`);\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 directory - The directory to scan (e.g. the user's Obsidian config directory).\n * @returns The newest discovered asar, or `undefined` if none / the directory is unreadable.\n */\nexport function findNewestAsar(directory: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(directory);\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(directory, 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.\n *\n * The version's exact URL baked into the `metadata.json` catalog (from upstream\n * `obsidian-versions.json`) is tried first when present; the hand-rolled public\n * (GitHub) and catalyst (CDN) guesses follow as a fallback for versions absent\n * from the catalog (or a stale catalog).\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  const fallbackUrls = [\n    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,\n    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`\n  ];\n\n  const bakedUrl = getVersionMetadata(version)?.downloads?.asar;\n  return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;\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,+BAAmC;AACnC,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;AAyBnB,SAAS,qBAAqB,UAAkB,SAAiB,mBAAiC;AACvG,gCAAU,mBAAmB,EAAE,WAAW,KAAK,CAAC;AAChD,QAAM,kBAAc,uBAAK,uBAAmB,gDAAuB,OAAO,CAAC;AAC3E,mCAAa,UAAU,WAAW;AAClC,sBAAI,oCAAgC,gDAAuB,OAAO,CAAC,SAAS,iBAAiB,GAAG;AAClG;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,WAA+C;AAC5E,MAAI;AACJ,MAAI;AACF,kBAAU,4BAAY,SAAS;AAAA,EACjC,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,WAAW,KAAK,GAAG,QAAQ;AAAA,IACnD;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;AAaA,SAAS,oBAAoB,SAA2B;AACtD,QAAM,iBAAiB,OAAG,gDAAuB,OAAO,CAAC;AACzD,QAAM,eAAe;AAAA,IACnB,GAAG,4BAA4B,KAAK,OAAO,IAAI,cAAc;AAAA,IAC7D,GAAG,8BAA8B,IAAI,cAAc;AAAA,EACrD;AAEA,QAAM,eAAW,6CAAmB,OAAO,GAAG,WAAW;AACzD,SAAO,WAAW,CAAC,UAAU,GAAG,YAAY,IAAI;AAClD;",
  "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 directory.\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 directory). 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 { getVersionMetadata } from './obsidian-metadata.cjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.cjs';\nimport { buildCatalystAsarUrl } from './release-catalog.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). The same UA the catalog refresh sends when probing the CDN.\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\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  /**\n  Absolute path to the asar file.\n   */\n  readonly path: string;\n\n  /**\n  The `x.y.z` version parsed from the file name.\n   */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data directory 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 userDataDirectory - Destination user-data directory.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDirectory: string): void {\n  mkdirSync(userDataDirectory, { recursive: true });\n  const destination = join(userDataDirectory, getVersionAsarFileName(version));\n  copyFileSync(asarPath, destination);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDirectory}.`);\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 directory - The directory to scan (e.g. the user's Obsidian config directory).\n * @returns The newest discovered asar, or `undefined` if none / the directory is unreadable.\n */\nexport function findNewestAsar(directory: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(directory);\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(directory, 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.\n *\n * The version's exact URL baked into the `metadata.json` catalog (from the\n * `obsidianmd/obsidian-releases` assets) is tried first when present; the hand-rolled public\n * (GitHub) and catalyst (CDN) guesses follow as a fallback for versions absent\n * from the catalog (or a stale catalog).\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  const fallbackUrls = [\n    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,\n    buildCatalystAsarUrl(version)\n  ];\n\n  const bakedUrl = getVersionMetadata(version)?.downloads?.asar;\n  return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/release-catalog.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var release_catalog_exports = {};
+__export(release_catalog_exports, {
+  CATALYST_ASAR_RELEASE_BASE_URL: () => CATALYST_ASAR_RELEASE_BASE_URL,
+  buildCatalystAsarUrl: () => buildCatalystAsarUrl,
+  resolveReleaseChannel: () => resolveReleaseChannel,
+  selectReleaseDownloads: () => selectReleaseDownloads
+});
+module.exports = __toCommonJS(release_catalog_exports);
+var import_installer_asset = require("./installer-asset.cjs");
+var import_obsidian_version = require("./obsidian-version.cjs");
+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}/${(0, import_obsidian_version.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(`${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`);
+  if (asarUrl !== void 0) {
+    downloads["asar"] = asarUrl;
+  }
+  for (const [key, platform] of INSTALLER_KEYS_BY_PLATFORM) {
+    const assetName = (0, import_installer_asset.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\n\nimport { selectInstallerAssetName } from './installer-asset.cjs';\nimport { getVersionAsarFileName } from './obsidian-version.cjs';\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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,6BAAyC;AACzC,8BAAuC;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,QAAI,gDAAuB,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,OAAG,gDAAuB,OAAO,CAAC,KAAK;AACrE,MAAI,YAAY,QAAW;AACzB,cAAU,MAAM,IAAI;AAAA,EACtB;AAEA,aAAW,CAAC,KAAK,QAAQ,KAAK,4BAA4B;AACxD,UAAM,gBAAY,iDAAyB,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/cjs/release-catalog.d.cts

@@ -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.cjs';
+/**
+ * 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;