obsidian-integration-testing 4.4.0 → 5.1.0

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

@@ -0,0 +1,45 @@
+/**
+ * @file
+ *
+ * Integration-time helpers for resolving the Obsidian **shell** (the Electron
+ * runtime / installer build) to launch.
+ *
+ * By default the harness uses the installed shell. When a specific installer
+ * version is requested, it downloads that version's GitHub release asset and
+ * extracts a portable shell into a cache, returning the executable to launch.
+ *
+ * GitHub release assets exist for **public** releases only; catalyst (beta)
+ * builds publish only the asar, so installer-pinning supports public versions.
+ * The extracted shell's bundled `resources/obsidian.asar` is that version, so
+ * pinning the installer is how you run a version **older** than the installed
+ * shell (asar-swap is upgrade-only — see `obsidian-version-switch.ts`).
+ */
+/**
+ * A resolved Obsidian shell executable.
+ */
+export interface ResolvedShell {
+    /** Absolute path to the Obsidian executable to launch. */
+    readonly exePath: string;
+    /** The shell's version, or `undefined` if it could not be detected. */
+    readonly version: string | undefined;
+}
+/**
+ * Detects the version of an installed Obsidian shell from its executable.
+ *
+ * - Windows: the executable's PE `FileVersion`.
+ * - macOS: `CFBundleShortVersionString` from the app bundle's `Info.plist`.
+ * - Linux: best-effort parse from the executable path (often `undefined`).
+ *
+ * @param exePath - Absolute path to the Obsidian executable.
+ * @returns The `x.y.z` version, or `undefined` if it cannot be determined.
+ */
+export declare function detectInstalledShellVersion(exePath: string): string | undefined;
+/**
+ * Ensures a portable Obsidian shell for the given version is extracted into the
+ * cache, downloading and extracting its GitHub release asset if necessary.
+ *
+ * @param version - A concrete public `x.y.z` version.
+ * @returns The absolute path to the cached shell executable.
+ * @throws Error if the asset cannot be downloaded or extracted.
+ */
+export declare function ensureShellCached(version: string): Promise<string>;

package/dist/lib/cjs/obsidian-instance.cjs

@@ -0,0 +1,100 @@
+"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 obsidian_instance_exports = {};
+__export(obsidian_instance_exports, {
+  launchOwnedObsidianInstance: () => launchOwnedObsidianInstance,
+  pickFreePort: () => pickFreePort
+});
+module.exports = __toCommonJS(obsidian_instance_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_net = require("node:net");
+var import_kill_process_tree = require("./kill-process-tree.cjs");
+var import_log = require("./log.cjs");
+const DEFAULT_CDP_HOST = "127.0.0.1";
+const CDP_READY_POLL_INTERVAL_IN_MILLISECONDS = 1e3;
+const CDP_READY_TIMEOUT_IN_MILLISECONDS = 6e4;
+async function launchOwnedObsidianInstance(params) {
+  const cdpHost = params.cdpHost ?? DEFAULT_CDP_HOST;
+  const port = await pickFreePort();
+  const cdpUrl = `http://${cdpHost}:${String(port)}`;
+  (0, import_log.log)(`[obsidian-instance] Launching owned Obsidian: userData=${params.userDataDir}, cdpPort=${String(port)}`);
+  const child = (0, import_node_child_process.spawn)(
+    params.exePath,
+    [`--user-data-dir=${params.userDataDir}`, `--remote-debugging-port=${String(port)}`],
+    { detached: true, stdio: "ignore" }
+  );
+  child.unref();
+  try {
+    await waitForCdpReady(cdpUrl);
+    (0, import_log.log)(`[obsidian-instance] Owned Obsidian is serving CDP at ${cdpUrl}.`);
+    return { cdpUrl, kill, port };
+  } catch (error) {
+    kill();
+    throw error;
+  }
+  function kill() {
+    (0, import_kill_process_tree.killProcessTree)(child);
+  }
+}
+function pickFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = (0, import_node_net.createServer)();
+    server.once("error", reject);
+    server.listen(0, DEFAULT_CDP_HOST, () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to determine a free port."));
+        return;
+      }
+      const { port } = address;
+      server.close(() => {
+        resolve(port);
+      });
+    });
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function waitForCdpReady(cdpUrl) {
+  const deadline = Date.now() + CDP_READY_TIMEOUT_IN_MILLISECONDS;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`${cdpUrl}/json`);
+      const targets = await response.json();
+      if (targets.some((target) => target.type === "page")) {
+        return;
+      }
+    } catch {
+    }
+    await delay(CDP_READY_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+  throw new Error(
+    `Owned Obsidian instance did not expose CDP at ${cdpUrl} within ${String(CDP_READY_TIMEOUT_IN_MILLISECONDS)}ms.`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchOwnedObsidianInstance,
+  pickFreePort
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-instance.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Launches and manages a harness-owned, isolated Obsidian desktop instance.\n *\n * The instance runs against a dedicated `--user-data-dir` (so it never touches\n * the user's Obsidian config, registry, or running window) and exposes CDP on a\n * dedicated `--remote-debugging-port`. Because Electron's single-instance lock\n * is keyed to the user-data dir, the owned instance runs in parallel with the\n * user's own Obsidian. Confirmed by the Phase 0 spike (see the project plan).\n */\n\n/* v8 ignore start -- Integration-time process management covered by integration tests, not unit tests. */\n\nimport { spawn } from 'node:child_process';\nimport { createServer } from 'node:net';\n\nimport { killProcessTree } from './kill-process-tree.cjs';\nimport { log } from './log.cjs';\n\n/**\n * Parameters for {@link launchOwnedObsidianInstance}.\n */\nexport interface LaunchOwnedObsidianInstanceParams {\n  /**\n   * CDP host to bind/poll.\n   *\n   * @default `'127.0.0.1'`\n   */\n  readonly cdpHost?: string;\n\n  /** Absolute path to the Obsidian executable (shell) to launch. */\n  readonly exePath: string;\n\n  /** Absolute path to the isolated user-data dir to pass via `--user-data-dir`. */\n  readonly userDataDir: string;\n}\n\n/**\n * A running, harness-owned Obsidian instance.\n */\nexport interface OwnedObsidianInstance {\n  /** Base CDP URL, e.g. `http://127.0.0.1:51888`. */\n  readonly cdpUrl: string;\n\n  /** Kills the instance and its entire process tree. */\n  kill(): void;\n\n  /** The CDP remote-debugging port the instance was launched with. */\n  readonly port: number;\n}\n\nconst DEFAULT_CDP_HOST = '127.0.0.1';\nconst CDP_READY_POLL_INTERVAL_IN_MILLISECONDS = 1000;\nconst CDP_READY_TIMEOUT_IN_MILLISECONDS = 60000;\n\ninterface CdpTarget {\n  type: string;\n}\n\n/**\n * Launches an isolated, harness-owned Obsidian instance and waits until its CDP\n * endpoint is serving page targets.\n *\n * @param params - Launch parameters.\n * @returns The running owned instance.\n * @throws Error if CDP does not become reachable within the timeout.\n */\nexport async function launchOwnedObsidianInstance(\n  params: LaunchOwnedObsidianInstanceParams\n): Promise<OwnedObsidianInstance> {\n  const cdpHost = params.cdpHost ?? DEFAULT_CDP_HOST;\n  const port = await pickFreePort();\n  const cdpUrl = `http://${cdpHost}:${String(port)}`;\n\n  log(`[obsidian-instance] Launching owned Obsidian: userData=${params.userDataDir}, cdpPort=${String(port)}`);\n  const child = spawn(\n    params.exePath,\n    [`--user-data-dir=${params.userDataDir}`, `--remote-debugging-port=${String(port)}`],\n    { detached: true, stdio: 'ignore' }\n  );\n  child.unref();\n\n  try {\n    await waitForCdpReady(cdpUrl);\n    log(`[obsidian-instance] Owned Obsidian is serving CDP at ${cdpUrl}.`);\n    return { cdpUrl, kill, port };\n  } catch (error: unknown) {\n    kill();\n    throw error;\n  }\n\n  function kill(): void {\n    killProcessTree(child);\n  }\n}\n\n/**\n * Picks a free TCP port by binding to port `0` and reading the assigned port.\n *\n * There is a small time-of-check/time-of-use window between releasing the port\n * here and Obsidian binding it; in practice it is negligible for test runs.\n *\n * @returns A free TCP port.\n */\nexport function pickFreePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once('error', reject);\n    server.listen(0, DEFAULT_CDP_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine a free port.'));\n        return;\n      }\n      const { port } = address;\n      server.close(() => {\n        resolve(port);\n      });\n    });\n  });\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Polls the CDP `/json` endpoint until at least one page target appears.\n *\n * @param cdpUrl - The base CDP URL.\n */\nasync function waitForCdpReady(cdpUrl: string): Promise<void> {\n  const deadline = Date.now() + CDP_READY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      const response = await fetch(`${cdpUrl}/json`);\n      const targets = await response.json() as CdpTarget[];\n      if (targets.some((target) => target.type === 'page')) {\n        return;\n      }\n    } catch {\n      // Endpoint not up yet \u2014 keep polling.\n    }\n    await delay(CDP_READY_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n  throw new Error(\n    `Owned Obsidian instance did not expose CDP at ${cdpUrl} within ${String(CDP_READY_TIMEOUT_IN_MILLISECONDS)}ms.`\n  );\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,gCAAsB;AACtB,sBAA6B;AAE7B,+BAAgC;AAChC,iBAAoB;AAkCpB,MAAM,mBAAmB;AACzB,MAAM,0CAA0C;AAChD,MAAM,oCAAoC;AAc1C,eAAsB,4BACpB,QACgC;AAChC,QAAM,UAAU,OAAO,WAAW;AAClC,QAAM,OAAO,MAAM,aAAa;AAChC,QAAM,SAAS,UAAU,OAAO,IAAI,OAAO,IAAI,CAAC;AAEhD,sBAAI,0DAA0D,OAAO,WAAW,aAAa,OAAO,IAAI,CAAC,EAAE;AAC3G,QAAM,YAAQ;AAAA,IACZ,OAAO;AAAA,IACP,CAAC,mBAAmB,OAAO,WAAW,IAAI,2BAA2B,OAAO,IAAI,CAAC,EAAE;AAAA,IACnF,EAAE,UAAU,MAAM,OAAO,SAAS;AAAA,EACpC;AACA,QAAM,MAAM;AAEZ,MAAI;AACF,UAAM,gBAAgB,MAAM;AAC5B,wBAAI,wDAAwD,MAAM,GAAG;AACrE,WAAO,EAAE,QAAQ,MAAM,KAAK;AAAA,EAC9B,SAAS,OAAgB;AACvB,SAAK;AACL,UAAM;AAAA,EACR;AAEA,WAAS,OAAa;AACpB,kDAAgB,KAAK;AAAA,EACvB;AACF;AAUO,SAAS,eAAgC;AAC9C,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,aAAS,8BAAa;AAC5B,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,kBAAkB,MAAM;AACvC,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,kCAAkC,CAAC;AACpD;AAAA,MACF;AACA,YAAM,EAAE,KAAK,IAAI;AACjB,aAAO,MAAM,MAAM;AACjB,gBAAQ,IAAI;AAAA,MACd,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;AAQA,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,EAAE;AAAA,EACxB,CAAC;AACH;AAOA,eAAe,gBAAgB,QAA+B;AAC5D,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,YAAM,WAAW,MAAM,MAAM,GAAG,MAAM,OAAO;AAC7C,YAAM,UAAU,MAAM,SAAS,KAAK;AACpC,UAAI,QAAQ,KAAK,CAAC,WAAW,OAAO,SAAS,MAAM,GAAG;AACpD;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AACA,UAAM,MAAM,uCAAuC;AAAA,EACrD;AACA,QAAM,IAAI;AAAA,IACR,iDAAiD,MAAM,WAAW,OAAO,iCAAiC,CAAC;AAAA,EAC7G;AACF;",
  "names": []
}


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

@@ -0,0 +1,55 @@
+/**
+ * @file
+ *
+ * Launches and manages a harness-owned, isolated Obsidian desktop instance.
+ *
+ * The instance runs against a dedicated `--user-data-dir` (so it never touches
+ * the user's Obsidian config, registry, or running window) and exposes CDP on a
+ * dedicated `--remote-debugging-port`. Because Electron's single-instance lock
+ * is keyed to the user-data dir, the owned instance runs in parallel with the
+ * user's own Obsidian. Confirmed by the Phase 0 spike (see the project plan).
+ */
+/**
+ * Parameters for {@link launchOwnedObsidianInstance}.
+ */
+export interface LaunchOwnedObsidianInstanceParams {
+    /**
+     * CDP host to bind/poll.
+     *
+     * @default `'127.0.0.1'`
+     */
+    readonly cdpHost?: string;
+    /** Absolute path to the Obsidian executable (shell) to launch. */
+    readonly exePath: string;
+    /** Absolute path to the isolated user-data dir to pass via `--user-data-dir`. */
+    readonly userDataDir: string;
+}
+/**
+ * A running, harness-owned Obsidian instance.
+ */
+export interface OwnedObsidianInstance {
+    /** Base CDP URL, e.g. `http://127.0.0.1:51888`. */
+    readonly cdpUrl: string;
+    /** Kills the instance and its entire process tree. */
+    kill(): void;
+    /** The CDP remote-debugging port the instance was launched with. */
+    readonly port: number;
+}
+/**
+ * Launches an isolated, harness-owned Obsidian instance and waits until its CDP
+ * endpoint is serving page targets.
+ *
+ * @param params - Launch parameters.
+ * @returns The running owned instance.
+ * @throws Error if CDP does not become reachable within the timeout.
+ */
+export declare function launchOwnedObsidianInstance(params: LaunchOwnedObsidianInstanceParams): Promise<OwnedObsidianInstance>;
+/**
+ * Picks a free TCP port by binding to port `0` and reading the assigned port.
+ *
+ * There is a small time-of-check/time-of-use window between releasing the port
+ * here and Obsidian binding it; in practice it is negligible for test runs.
+ *
+ * @returns A free TCP port.
+ */
+export declare function pickFreePort(): Promise<number>;

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

@@ -0,0 +1,105 @@
+"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 obsidian_version_switch_exports = {};
+__export(obsidian_version_switch_exports, {
+  copyAsarIntoUserData: () => copyAsarIntoUserData,
+  ensureAsarCached: () => ensureAsarCached,
+  fetchDesktopReleasesManifest: () => fetchDesktopReleasesManifest,
+  findNewestAsar: () => findNewestAsar,
+  resolveConcreteVersion: () => resolveConcreteVersion
+});
+module.exports = __toCommonJS(obsidian_version_switch_exports);
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+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 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$/;
+function copyAsarIntoUserData(asarPath, version, userDataDir) {
+  (0, import_node_fs.mkdirSync)(userDataDir, { recursive: true });
+  const dest = (0, import_node_path.join)(userDataDir, (0, import_obsidian_version.getVersionAsarFileName)(version));
+  (0, import_node_fs.copyFileSync)(asarPath, dest);
+  (0, import_log.log)(`[version-switch] Provisioned ${(0, import_obsidian_version.getVersionAsarFileName)(version)} into ${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));
+  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 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;
+}
+async function fetchDesktopReleasesManifest() {
+  const response = await fetch(import_obsidian_version.DESKTOP_RELEASES_MANIFEST_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);
+  }
+  return await response.json();
+}
+function findNewestAsar(dir) {
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return void 0;
+  }
+  let newest;
+  for (const entry of entries) {
+    const match = ASAR_FILE_PATTERN.exec(entry);
+    if (!match) {
+      continue;
+    }
+    const version = match.groups?.["version"] ?? "";
+    if (!newest || (0, import_obsidian_version.compareVersions)(version, newest.version) > 0) {
+      newest = { path: (0, import_node_path.join)(dir, entry), version };
+    }
+  }
+  return newest;
+}
+async function resolveConcreteVersion(spec) {
+  const parsed = (0, import_obsidian_version.parseVersionSpec)(spec);
+  if (parsed.kind === "explicit") {
+    return parsed.version;
+  }
+  const manifest = await fetchDesktopReleasesManifest();
+  return (0, import_obsidian_version.resolveVersionFromManifest)(manifest, parsed.channel);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyAsarIntoUserData,
+  ensureAsarCached,
+  fetchDesktopReleasesManifest,
+  findNewestAsar,
+  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": []
}


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

@@ -0,0 +1,63 @@
+/**
+ * @file
+ *
+ * Integration-time helpers for provisioning a specific Obsidian **asar** (the
+ * app code) into an isolated user-data dir.
+ *
+ * Obsidian's bootstrap loads the highest of (its shell's bundled
+ * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the
+ * user-data dir). So placing an asar here only takes effect when its version is
+ * **>= the shell's bundled version** (upgrade-only — confirmed by the Phase 0
+ * spike). Running an older version requires pinning the installer/shell instead
+ * (see `obsidian-installer.ts`).
+ */
+import type { DesktopReleasesManifest } from './obsidian-version.cjs';
+/**
+ * A discovered `obsidian-<version>.asar` file.
+ */
+export interface DiscoveredAsar {
+    /** Absolute path to the asar file. */
+    readonly path: string;
+    /** The `x.y.z` version parsed from the file name. */
+    readonly version: string;
+}
+/**
+ * Copies an asar file into a user-data dir under its canonical
+ * `obsidian-<version>.asar` name.
+ *
+ * @param asarPath - Source asar path.
+ * @param version - The asar's version (used for the destination file name).
+ * @param userDataDir - Destination user-data dir.
+ */
+export declare function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void;
+/**
+ * Ensures the asar for a concrete version is present in the local cache,
+ * downloading and decompressing it if necessary.
+ *
+ * @param version - A concrete `x.y.z` version.
+ * @returns The absolute path to the cached asar.
+ * @throws Error if the download fails.
+ */
+export declare function ensureAsarCached(version: string): Promise<string>;
+/**
+ * Fetches and parses Obsidian's desktop releases manifest.
+ *
+ * @returns The parsed manifest.
+ * @throws Error if the manifest cannot be fetched.
+ */
+export declare function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest>;
+/**
+ * Finds the newest `obsidian-<version>.asar` in a directory.
+ *
+ * @param dir - The directory to scan (e.g. the user's Obsidian config dir).
+ * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.
+ */
+export declare function findNewestAsar(dir: string): DiscoveredAsar | undefined;
+/**
+ * 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.
+ *
+ * @param spec - The version specifier.
+ * @returns The concrete version.
+ */
+export declare function resolveConcreteVersion(spec: string): Promise<string>;

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

@@ -0,0 +1,85 @@
+"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 obsidian_version_exports = {};
+__export(obsidian_version_exports, {
+  CATALYST_LATEST: () => CATALYST_LATEST,
+  DESKTOP_RELEASES_MANIFEST_URL: () => DESKTOP_RELEASES_MANIFEST_URL,
+  PUBLIC_LATEST: () => PUBLIC_LATEST,
+  compareVersions: () => compareVersions,
+  getVersionAsarFileName: () => getVersionAsarFileName,
+  parseVersionSpec: () => parseVersionSpec,
+  resolveVersionFromManifest: () => resolveVersionFromManifest
+});
+module.exports = __toCommonJS(obsidian_version_exports);
+const PUBLIC_LATEST = "public-latest";
+const CATALYST_LATEST = "catalyst-latest";
+const DESKTOP_RELEASES_MANIFEST_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json";
+const EXPLICIT_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+const VERSION_SEGMENT_COUNT = 3;
+function compareVersions(a, b) {
+  const aSegments = parseVersionSegments(a);
+  const bSegments = parseVersionSegments(b);
+  for (let i = 0; i < VERSION_SEGMENT_COUNT; i++) {
+    const diff = (aSegments[i] ?? 0) - (bSegments[i] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+function getVersionAsarFileName(version) {
+  return `obsidian-${version}.asar`;
+}
+function parseVersionSpec(spec) {
+  if (spec === PUBLIC_LATEST) {
+    return { channel: "public", kind: "channel" };
+  }
+  if (spec === CATALYST_LATEST) {
+    return { channel: "catalyst", kind: "channel" };
+  }
+  if (EXPLICIT_VERSION_PATTERN.test(spec)) {
+    return { kind: "explicit", version: spec };
+  }
+  throw new Error(
+    `Invalid Obsidian version "${spec}". Expected an "x.y.z" version, "${PUBLIC_LATEST}", or "${CATALYST_LATEST}".`
+  );
+}
+function resolveVersionFromManifest(manifest, channel) {
+  if (channel === "public") {
+    return manifest.latestVersion;
+  }
+  if (!manifest.beta) {
+    throw new Error("Desktop releases manifest has no catalyst (beta) release.");
+  }
+  return manifest.beta.latestVersion;
+}
+function parseVersionSegments(version) {
+  return version.split(".").map((segment) => Number.parseInt(segment, 10));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CATALYST_LATEST,
+  DESKTOP_RELEASES_MANIFEST_URL,
+  PUBLIC_LATEST,
+  compareVersions,
+  getVersionAsarFileName,
+  parseVersionSpec,
+  resolveVersionFromManifest
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-version.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving Obsidian desktop version specifiers.\n *\n * A version specifier is either an explicit `x.y.z` string or one of the\n * channel aliases {@link PUBLIC_LATEST} / {@link CATALYST_LATEST}, which resolve\n * against Obsidian's published desktop releases manifest.\n *\n * The network call that fetches the manifest lives in the integration-time\n * version-switch module; everything here is pure and unit-tested.\n */\n\n/**\n * Version specifier alias resolving to the latest **public** desktop release\n * (the manifest's `latestVersion`).\n */\nexport const PUBLIC_LATEST = 'public-latest';\n\n/**\n * Version specifier alias resolving to the latest **catalyst** (early access /\n * insider) desktop release (the manifest's `beta.latestVersion`).\n */\nexport const CATALYST_LATEST = 'catalyst-latest';\n\n/**\n * URL of Obsidian's desktop releases manifest (raw JSON).\n */\nexport const DESKTOP_RELEASES_MANIFEST_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json';\n\nconst EXPLICIT_VERSION_PATTERN = /^\\d+\\.\\d+\\.\\d+$/;\nconst VERSION_SEGMENT_COUNT = 3;\n\n/**\n * A version specifier resolved against a release channel.\n */\nexport interface ChannelVersionSpec {\n  /** The channel to resolve against the manifest. */\n  readonly channel: ReleaseChannel;\n\n  /** Discriminant. */\n  readonly kind: 'channel';\n}\n\n/**\n * The `beta` (catalyst) entry of {@link DesktopReleasesManifest}.\n */\nexport interface DesktopReleasesBeta {\n  /** The latest catalyst version, e.g. `'1.13.1'`. */\n  readonly latestVersion: string;\n}\n\n/**\n * The subset of Obsidian's `desktop-releases.json` this library reads.\n */\nexport interface DesktopReleasesManifest {\n  /**\n   * The latest catalyst (early access / insider) release, when present.\n   */\n  readonly beta?: DesktopReleasesBeta;\n\n  /**\n   * The latest public (stable) version, e.g. `'1.12.7'`.\n   */\n  readonly latestVersion: string;\n}\n\n/**\n * A version specifier naming a concrete `x.y.z` version.\n */\nexport interface ExplicitVersionSpec {\n  /** Discriminant. */\n  readonly kind: 'explicit';\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * A release channel resolved from a channel-alias specifier.\n *\n * - `public` \u2014 the latest stable release.\n * - `catalyst` \u2014 the latest early access / insider release.\n */\nexport type ReleaseChannel = 'catalyst' | 'public';\n\n/**\n * The parsed form of a version specifier.\n *\n * - `explicit` \u2014 a concrete `x.y.z` version.\n * - `channel` \u2014 a channel alias to be resolved against the manifest.\n */\nexport type VersionSpec = ChannelVersionSpec | ExplicitVersionSpec;\n\n/**\n * Compares two `x.y.z` version strings numerically, segment by segment.\n *\n * @param a - The first version.\n * @param b - The second version.\n * @returns A negative number if `a < b`, `0` if equal, a positive number if `a > b`.\n */\nexport function compareVersions(a: string, b: string): number {\n  const aSegments = parseVersionSegments(a);\n  const bSegments = parseVersionSegments(b);\n\n  for (let i = 0; i < VERSION_SEGMENT_COUNT; i++) {\n    const diff = (aSegments[i] ?? 0) - (bSegments[i] ?? 0);\n    if (diff !== 0) {\n      return diff;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Returns the user-data asar file name for a given version, matching the name\n * Obsidian itself uses when it downloads an update (`obsidian-<version>.asar`).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The asar file name.\n */\nexport function getVersionAsarFileName(version: string): string {\n  return `obsidian-${version}.asar`;\n}\n\n/**\n * Parses a version specifier into either an explicit version or a channel alias.\n *\n * @param spec - The specifier: an `x.y.z` string, {@link PUBLIC_LATEST}, or {@link CATALYST_LATEST}.\n * @returns The parsed {@link VersionSpec}.\n * @throws Error if the specifier is neither a valid `x.y.z` version nor a known alias.\n */\nexport function parseVersionSpec(spec: string): VersionSpec {\n  if (spec === PUBLIC_LATEST) {\n    return { channel: 'public', kind: 'channel' };\n  }\n\n  if (spec === CATALYST_LATEST) {\n    return { channel: 'catalyst', kind: 'channel' };\n  }\n\n  if (EXPLICIT_VERSION_PATTERN.test(spec)) {\n    return { kind: 'explicit', version: spec };\n  }\n\n  throw new Error(\n    `Invalid Obsidian version \"${spec}\". Expected an \"x.y.z\" version, \"${PUBLIC_LATEST}\", or \"${CATALYST_LATEST}\".`\n  );\n}\n\n/**\n * Resolves a channel to a concrete version using a desktop releases manifest.\n *\n * @param manifest - The parsed manifest.\n * @param channel - The channel to resolve.\n * @returns The concrete `x.y.z` version for the channel.\n * @throws Error if the catalyst channel is requested but the manifest has no `beta` entry.\n */\nexport function resolveVersionFromManifest(manifest: DesktopReleasesManifest, channel: ReleaseChannel): string {\n  if (channel === 'public') {\n    return manifest.latestVersion;\n  }\n\n  if (!manifest.beta) {\n    throw new Error('Desktop releases manifest has no catalyst (beta) release.');\n  }\n\n  return manifest.beta.latestVersion;\n}\n\n/**\n * Splits an `x.y.z` version into its numeric segments.\n *\n * @param version - The version string.\n * @returns The numeric segments.\n */\nfunction parseVersionSegments(version: string): number[] {\n  return version.split('.').map((segment) => Number.parseInt(segment, 10));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,MAAM,gBAAgB;AAMtB,MAAM,kBAAkB;AAKxB,MAAM,gCAAgC;AAE7C,MAAM,2BAA2B;AACjC,MAAM,wBAAwB;AAsEvB,SAAS,gBAAgB,GAAW,GAAmB;AAC5D,QAAM,YAAY,qBAAqB,CAAC;AACxC,QAAM,YAAY,qBAAqB,CAAC;AAExC,WAAS,IAAI,GAAG,IAAI,uBAAuB,KAAK;AAC9C,UAAM,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,CAAC,KAAK;AACpD,QAAI,SAAS,GAAG;AACd,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AASO,SAAS,uBAAuB,SAAyB;AAC9D,SAAO,YAAY,OAAO;AAC5B;AASO,SAAS,iBAAiB,MAA2B;AAC1D,MAAI,SAAS,eAAe;AAC1B,WAAO,EAAE,SAAS,UAAU,MAAM,UAAU;AAAA,EAC9C;AAEA,MAAI,SAAS,iBAAiB;AAC5B,WAAO,EAAE,SAAS,YAAY,MAAM,UAAU;AAAA,EAChD;AAEA,MAAI,yBAAyB,KAAK,IAAI,GAAG;AACvC,WAAO,EAAE,MAAM,YAAY,SAAS,KAAK;AAAA,EAC3C;AAEA,QAAM,IAAI;AAAA,IACR,6BAA6B,IAAI,oCAAoC,aAAa,UAAU,eAAe;AAAA,EAC7G;AACF;AAUO,SAAS,2BAA2B,UAAmC,SAAiC;AAC7G,MAAI,YAAY,UAAU;AACxB,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AAEA,SAAO,SAAS,KAAK;AACvB;AAQA,SAAS,qBAAqB,SAA2B;AACvD,SAAO,QAAQ,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,OAAO,SAAS,SAAS,EAAE,CAAC;AACzE;",
  "names": []
}


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

@@ -0,0 +1,111 @@
+/**
+ * @file
+ *
+ * Pure helpers for resolving Obsidian desktop version specifiers.
+ *
+ * A version specifier is either an explicit `x.y.z` string or one of the
+ * channel aliases {@link PUBLIC_LATEST} / {@link CATALYST_LATEST}, which resolve
+ * against Obsidian's published desktop releases manifest.
+ *
+ * The network call that fetches the manifest lives in the integration-time
+ * version-switch module; everything here is pure and unit-tested.
+ */
+/**
+ * Version specifier alias resolving to the latest **public** desktop release
+ * (the manifest's `latestVersion`).
+ */
+export declare const PUBLIC_LATEST = "public-latest";
+/**
+ * Version specifier alias resolving to the latest **catalyst** (early access /
+ * insider) desktop release (the manifest's `beta.latestVersion`).
+ */
+export declare const CATALYST_LATEST = "catalyst-latest";
+/**
+ * URL of Obsidian's desktop releases manifest (raw JSON).
+ */
+export declare const DESKTOP_RELEASES_MANIFEST_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json";
+/**
+ * A version specifier resolved against a release channel.
+ */
+export interface ChannelVersionSpec {
+    /** The channel to resolve against the manifest. */
+    readonly channel: ReleaseChannel;
+    /** Discriminant. */
+    readonly kind: 'channel';
+}
+/**
+ * The `beta` (catalyst) entry of {@link DesktopReleasesManifest}.
+ */
+export interface DesktopReleasesBeta {
+    /** The latest catalyst version, e.g. `'1.13.1'`. */
+    readonly latestVersion: string;
+}
+/**
+ * The subset of Obsidian's `desktop-releases.json` this library reads.
+ */
+export interface DesktopReleasesManifest {
+    /**
+     * The latest catalyst (early access / insider) release, when present.
+     */
+    readonly beta?: DesktopReleasesBeta;
+    /**
+     * The latest public (stable) version, e.g. `'1.12.7'`.
+     */
+    readonly latestVersion: string;
+}
+/**
+ * A version specifier naming a concrete `x.y.z` version.
+ */
+export interface ExplicitVersionSpec {
+    /** Discriminant. */
+    readonly kind: 'explicit';
+    /** The concrete `x.y.z` version. */
+    readonly version: string;
+}
+/**
+ * A release channel resolved from a channel-alias specifier.
+ *
+ * - `public` — the latest stable release.
+ * - `catalyst` — the latest early access / insider release.
+ */
+export type ReleaseChannel = 'catalyst' | 'public';
+/**
+ * The parsed form of a version specifier.
+ *
+ * - `explicit` — a concrete `x.y.z` version.
+ * - `channel` — a channel alias to be resolved against the manifest.
+ */
+export type VersionSpec = ChannelVersionSpec | ExplicitVersionSpec;
+/**
+ * Compares two `x.y.z` version strings numerically, segment by segment.
+ *
+ * @param a - The first version.
+ * @param b - The second version.
+ * @returns A negative number if `a < b`, `0` if equal, a positive number if `a > b`.
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Returns the user-data asar file name for a given version, matching the name
+ * Obsidian itself uses when it downloads an update (`obsidian-<version>.asar`).
+ *
+ * @param version - A concrete `x.y.z` version.
+ * @returns The asar file name.
+ */
+export declare function getVersionAsarFileName(version: string): string;
+/**
+ * Parses a version specifier into either an explicit version or a channel alias.
+ *
+ * @param spec - The specifier: an `x.y.z` string, {@link PUBLIC_LATEST}, or {@link CATALYST_LATEST}.
+ * @returns The parsed {@link VersionSpec}.
+ * @throws Error if the specifier is neither a valid `x.y.z` version nor a known alias.
+ */
+export declare function parseVersionSpec(spec: string): VersionSpec;
+/**
+ * Resolves a channel to a concrete version using a desktop releases manifest.
+ *
+ * @param manifest - The parsed manifest.
+ * @param channel - The channel to resolve.
+ * @returns The concrete `x.y.z` version for the channel.
+ * @throws Error if the catalyst channel is requested but the manifest has no `beta` entry.
+ */
+export declare function resolveVersionFromManifest(manifest: DesktopReleasesManifest, channel: ReleaseChannel): string;