obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/esm/obsidian-version-switch.mjs

@@ -17,9 +17,9 @@ import {
   parseVersionSpec,
   resolveVersionFromManifest
 } from "./obsidian-version.mjs";
+import { buildCatalystAsarUrl } from "./release-catalog.mjs";
 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 = join(tmpdir(), "obsidian-integration-testing");
 const ASAR_CACHE_DIR = join(CACHE_ROOT, "asar-cache");
 const ASAR_FILE_PATTERN = /^obsidian-(?<version>\d+\.\d+\.\d+)\.asar$/;
@@ -103,7 +103,7 @@ function getAsarDownloadUrls(version) {
   const asarGzFileName = `${getVersionAsarFileName(version)}.gz`;
   const fallbackUrls = [
     `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
-    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
+    buildCatalystAsarUrl(version)
   ];
   const bakedUrl = getVersionMetadata(version)?.downloads?.asar;
   return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;
@@ -116,4 +116,4 @@ export {
   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.mjs';\n\nimport { log } from './log.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.mjs';\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": "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",
  "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.mjs';\n\nimport { log } from './log.mjs';\nimport { getVersionMetadata } from './obsidian-metadata.mjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.mjs';\nimport { buildCatalystAsarUrl } from './release-catalog.mjs';\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/esm/open-obsidian-settings-tab.d.mts

@@ -0,0 +1,49 @@
+/**
+ * @file
+ *
+ * Opens Obsidian's settings modal on a given tab in the instance the current
+ * test context is already driving.
+ *
+ * The renderer-side work lives in the injected `lib` bag
+ * (`lib.openSettingsTab`), where a callback that also probes the rendered DOM
+ * can reach it. This is the context-resolving entry point for the far more
+ * common case — a screenshot suite that only wants the tab on screen before it
+ * calls `captureObsidianScreenshot`, and would otherwise write the same
+ * `evalInObsidian` wrapper in every plugin.
+ */
+import type { OpenSettingsTabParams } from './eval-in-obsidian.mjs';
+import type { ObsidianTransport } from './transport.mjs';
+/**
+ * Options for {@link openObsidianSettingsTab}.
+ */
+export interface OpenObsidianSettingsTabOptions extends OpenSettingsTabParams {
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian window to open the settings in. When omitted, the
+     * current test context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Opens Obsidian's settings modal on a given tab and waits until that tab has
+ * actually rendered, resolving the transport and vault from the current test
+ * context.
+ *
+ * See {@link Lib.openSettingsTab} for why simply calling `app.setting.open()`
+ * renders nothing, and why the container must be attached **before** it.
+ *
+ * Close it again from a callback with `app.setting.close()`; re-opening works,
+ * because the attach is idempotent.
+ *
+ * @param options - The tab to open, how long to wait, and transport / vault
+ *   overrides.
+ * @returns A {@link Promise} resolving to the names of the setting rows the tab
+ *   rendered.
+ * @throws Error if no tab carries {@link OpenSettingsTabParams.tabId}, or if the
+ *   tab does not render within the timeout.
+ */
+export declare function openObsidianSettingsTab(options: OpenObsidianSettingsTabOptions): Promise<string[]>;

package/dist/lib/esm/open-obsidian-settings-tab.mjs

@@ -0,0 +1,27 @@
+import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
+async function openObsidianSettingsTab(options) {
+  const {
+    tabId,
+    timeoutInMilliseconds,
+    transport,
+    vaultPath
+  } = options;
+  return await evalInObsidian(normalizeOptionalProperties({
+    async callback({ lib, openParams }) {
+      return await lib.openSettingsTab(openParams);
+    },
+    input: {
+      openParams: normalizeOptionalProperties({
+        tabId,
+        timeoutInMilliseconds
+      })
+    },
+    transport,
+    vaultPath
+  }));
+}
+export {
+  openObsidianSettingsTab
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL29wZW4tb2JzaWRpYW4tc2V0dGluZ3MtdGFiLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogT3BlbnMgT2JzaWRpYW4ncyBzZXR0aW5ncyBtb2RhbCBvbiBhIGdpdmVuIHRhYiBpbiB0aGUgaW5zdGFuY2UgdGhlIGN1cnJlbnRcbiAqIHRlc3QgY29udGV4dCBpcyBhbHJlYWR5IGRyaXZpbmcuXG4gKlxuICogVGhlIHJlbmRlcmVyLXNpZGUgd29yayBsaXZlcyBpbiB0aGUgaW5qZWN0ZWQgYGxpYmAgYmFnXG4gKiAoYGxpYi5vcGVuU2V0dGluZ3NUYWJgKSwgd2hlcmUgYSBjYWxsYmFjayB0aGF0IGFsc28gcHJvYmVzIHRoZSByZW5kZXJlZCBET01cbiAqIGNhbiByZWFjaCBpdC4gVGhpcyBpcyB0aGUgY29udGV4dC1yZXNvbHZpbmcgZW50cnkgcG9pbnQgZm9yIHRoZSBmYXIgbW9yZVxuICogY29tbW9uIGNhc2UgXHUyMDE0IGEgc2NyZWVuc2hvdCBzdWl0ZSB0aGF0IG9ubHkgd2FudHMgdGhlIHRhYiBvbiBzY3JlZW4gYmVmb3JlIGl0XG4gKiBjYWxscyBgY2FwdHVyZU9ic2lkaWFuU2NyZWVuc2hvdGAsIGFuZCB3b3VsZCBvdGhlcndpc2Ugd3JpdGUgdGhlIHNhbWVcbiAqIGBldmFsSW5PYnNpZGlhbmAgd3JhcHBlciBpbiBldmVyeSBwbHVnaW4uXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIEludGVncmF0aW9uLXRpbWUgY29kZSAoZHJpdmVzIGEgbGl2ZSBPYnNpZGlhbikgY292ZXJlZCBieSBpbnRlZ3JhdGlvbiB0ZXN0cywgbm90IHVuaXQgdGVzdHMuICovXG5cbmltcG9ydCB0eXBlIHtcbiAgRXZhbEluT2JzaWRpYW5QYXJhbXMsXG4gIE9wZW5TZXR0aW5nc1RhYlBhcmFtc1xufSBmcm9tICcuL2V2YWwtaW4tb2JzaWRpYW4ubWpzJztcbmltcG9ydCB0eXBlIHsgT2JzaWRpYW5UcmFuc3BvcnQgfSBmcm9tICcuL3RyYW5zcG9ydC5tanMnO1xuXG5pbXBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vZXZhbC1pbi1vYnNpZGlhbi5tanMnO1xuaW1wb3J0IHsgbm9ybWFsaXplT3B0aW9uYWxQcm9wZXJ0aWVzIH0gZnJvbSAnLi9ub3JtYWxpemUtb3B0aW9uYWwtcHJvcGVydGllcy5tanMnO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIHtAbGluayBvcGVuT2JzaWRpYW5TZXR0aW5nc1RhYn0uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgT3Blbk9ic2lkaWFuU2V0dGluZ3NUYWJPcHRpb25zIGV4dGVuZHMgT3BlblNldHRpbmdzVGFiUGFyYW1zIHtcbiAgLyoqXG4gICAqIE92ZXJyaWRlIHRoZSB0cmFuc3BvcnQuIFdoZW4gb21pdHRlZCwgdGhlIHRyYW5zcG9ydCB0aGUgY3VycmVudCB0ZXN0XG4gICAqIGNvbnRleHQgaXMgZHJpdmluZyBpcyB1c2VkLlxuICAgKi9cbiAgcmVhZG9ubHkgdHJhbnNwb3J0PzogT2JzaWRpYW5UcmFuc3BvcnQ7XG5cbiAgLyoqXG4gICAqIFRoZSB2YXVsdCB3aG9zZSBPYnNpZGlhbiB3aW5kb3cgdG8gb3BlbiB0aGUgc2V0dGluZ3MgaW4uIFdoZW4gb21pdHRlZCwgdGhlXG4gICAqIGN1cnJlbnQgdGVzdCBjb250ZXh0J3MgdmF1bHQgaXMgdXNlZC5cbiAgICovXG4gIHJlYWRvbmx5IHZhdWx0UGF0aD86IHN0cmluZztcbn1cblxuLyoqXG4gKiBUaGUgc2VyaWFsaXplZCBwYXlsb2FkIGhhbmRlZCB0byB0aGUgY2FsbGJhY2sgXHUyMDE0IHRoZSB3aG9sZVxuICoge0BsaW5rIE9wZW5TZXR0aW5nc1RhYlBhcmFtc30gYmFnIGluIG9uZSBKU09OLXNhZmUgZmllbGQuXG4gKi9cbnR5cGUgT3BlblNldHRpbmdzVGFiSW5wdXQgPSBSZWNvcmQ8J29wZW5QYXJhbXMnLCBPcGVuU2V0dGluZ3NUYWJQYXJhbXM+O1xuXG4vKipcbiAqIE9wZW5zIE9ic2lkaWFuJ3Mgc2V0dGluZ3MgbW9kYWwgb24gYSBnaXZlbiB0YWIgYW5kIHdhaXRzIHVudGlsIHRoYXQgdGFiIGhhc1xuICogYWN0dWFsbHkgcmVuZGVyZWQsIHJlc29sdmluZyB0aGUgdHJhbnNwb3J0IGFuZCB2YXVsdCBmcm9tIHRoZSBjdXJyZW50IHRlc3RcbiAqIGNvbnRleHQuXG4gKlxuICogU2VlIHtAbGluayBMaWIub3BlblNldHRpbmdzVGFifSBmb3Igd2h5IHNpbXBseSBjYWxsaW5nIGBhcHAuc2V0dGluZy5vcGVuKClgXG4gKiByZW5kZXJzIG5vdGhpbmcsIGFuZCB3aHkgdGhlIGNvbnRhaW5lciBtdXN0IGJlIGF0dGFjaGVkICoqYmVmb3JlKiogaXQuXG4gKlxuICogQ2xvc2UgaXQgYWdhaW4gZnJvbSBhIGNhbGxiYWNrIHdpdGggYGFwcC5zZXR0aW5nLmNsb3NlKClgOyByZS1vcGVuaW5nIHdvcmtzLFxuICogYmVjYXVzZSB0aGUgYXR0YWNoIGlzIGlkZW1wb3RlbnQuXG4gKlxuICogQHBhcmFtIG9wdGlvbnMgLSBUaGUgdGFiIHRvIG9wZW4sIGhvdyBsb25nIHRvIHdhaXQsIGFuZCB0cmFuc3BvcnQgLyB2YXVsdFxuICogICBvdmVycmlkZXMuXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSByZXNvbHZpbmcgdG8gdGhlIG5hbWVzIG9mIHRoZSBzZXR0aW5nIHJvd3MgdGhlIHRhYlxuICogICByZW5kZXJlZC5cbiAqIEB0aHJvd3MgRXJyb3IgaWYgbm8gdGFiIGNhcnJpZXMge0BsaW5rIE9wZW5TZXR0aW5nc1RhYlBhcmFtcy50YWJJZH0sIG9yIGlmIHRoZVxuICogICB0YWIgZG9lcyBub3QgcmVuZGVyIHdpdGhpbiB0aGUgdGltZW91dC5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIG9wZW5PYnNpZGlhblNldHRpbmdzVGFiKG9wdGlvbnM6IE9wZW5PYnNpZGlhblNldHRpbmdzVGFiT3B0aW9ucyk6IFByb21pc2U8c3RyaW5nW10+IHtcbiAgY29uc3Qge1xuICAgIHRhYklkLFxuICAgIHRpbWVvdXRJbk1pbGxpc2Vjb25kcyxcbiAgICB0cmFuc3BvcnQsXG4gICAgdmF1bHRQYXRoXG4gIH0gPSBvcHRpb25zO1xuXG4gIHJldHVybiBhd2FpdCBldmFsSW5PYnNpZGlhbihub3JtYWxpemVPcHRpb25hbFByb3BlcnRpZXM8RXZhbEluT2JzaWRpYW5QYXJhbXM8T3BlblNldHRpbmdzVGFiSW5wdXQsIHN0cmluZ1tdPj4oe1xuICAgIGFzeW5jIGNhbGxiYWNrKHsgbGliLCBvcGVuUGFyYW1zIH0pOiBQcm9taXNlPHN0cmluZ1tdPiB7XG4gICAgICByZXR1cm4gYXdhaXQgbGliLm9wZW5TZXR0aW5nc1RhYihvcGVuUGFyYW1zKTtcbiAgICB9LFxuICAgIGlucHV0OiB7XG4gICAgICBvcGVuUGFyYW1zOiBub3JtYWxpemVPcHRpb25hbFByb3BlcnRpZXM8T3BlblNldHRpbmdzVGFiUGFyYW1zPih7XG4gICAgICAgIHRhYklkLFxuICAgICAgICB0aW1lb3V0SW5NaWxsaXNlY29uZHNcbiAgICAgIH0pXG4gICAgfSxcbiAgICB0cmFuc3BvcnQsXG4gICAgdmF1bHRQYXRoXG4gIH0pKTtcbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQXNCQSxTQUFTLHNCQUFzQjtBQUMvQixTQUFTLG1DQUFtQztBQTJDNUMsZUFBc0Isd0JBQXdCLFNBQTREO0FBQ3hHLFFBQU07QUFBQSxJQUNKO0FBQUEsSUFDQTtBQUFBLElBQ0E7QUFBQSxJQUNBO0FBQUEsRUFDRixJQUFJO0FBRUosU0FBTyxNQUFNLGVBQWUsNEJBQWtGO0FBQUEsSUFDNUcsTUFBTSxTQUFTLEVBQUUsS0FBSyxXQUFXLEdBQXNCO0FBQ3JELGFBQU8sTUFBTSxJQUFJLGdCQUFnQixVQUFVO0FBQUEsSUFDN0M7QUFBQSxJQUNBLE9BQU87QUFBQSxNQUNMLFlBQVksNEJBQW1EO0FBQUEsUUFDN0Q7QUFBQSxRQUNBO0FBQUEsTUFDRixDQUFDO0FBQUEsSUFDSDtBQUFBLElBQ0E7QUFBQSxJQUNBO0FBQUEsRUFDRixDQUFDLENBQUM7QUFDSjsiLAogICJuYW1lcyI6IFtdCn0K

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

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

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

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


package/dist/lib/esm/transport-appium.d.mts

@@ -143,6 +143,20 @@ export declare class AppiumTransport implements ObsidianTransport {
     private readonly appId;
     private readonly browser;
     private readonly deviceId;
+    /**
+     * The `process.on('exit')` handler that tears the channel down when nothing else will.
+     */
+    private disposeInputChannelOnExit;
+    /**
+     * The host half of the trusted-input channel: a CDP connection to the WebView, independent of the
+     * Appium session, opened lazily on first evaluate and reused (see **L39**).
+     */
+    private inputChannel;
+    /**
+     * Set once the trusted-input channel is known not to be openable here (iOS, a remote hub, no local
+     * `adb`), so the attempt is not repeated on every evaluate.
+     */
+    private isInputChannelUnavailable;
     /**
      * Tracks whether the driver is currently switched to the WebView context.
      *
@@ -201,6 +215,14 @@ export declare class AppiumTransport implements ObsidianTransport {
      * deletion so the session remains available for the owning process.
      */
     dispose(): Promise<void>;
+    /**
+     * Synchronous teardown for `process.on('exit')` handlers.
+     *
+     * Only the trusted-input channel needs it: the Appium session is the owning process's to end, and an
+     * abrupt exit is exactly when the async {@link AppiumTransport.dispose} never runs — which would strand
+     * the adb port forward on the device.
+     */
+    disposeSync(): void;
     /**
      * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.
      *
@@ -287,6 +309,19 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param vaultPath - The absolute path to the vault on the host machine.
      */
     unregisterVault(vaultPath: string): Promise<void>;
+    /**
+     * Closes the trusted-input channel, if one is open.
+     */
+    private disposeInputChannel;
+    /**
+     * Opens the trusted-input channel if it is not already open, and re-opens it if the WebView went away.
+     *
+     * Installs a `Runtime.addBinding` function on the page and services every call to it for the life of the
+     * connection. The binding is exposed on *every* execution context of the page, so it survives the
+     * `location.reload()` that {@link AppiumTransport.registerVault} performs; only a full app restart, which
+     * destroys the WebView target, needs the reconnect below.
+     */
+    private ensureInputChannel;
     /**
      * Switches the driver to the `WEBVIEW_md.obsidian` context.
      *
@@ -306,6 +341,17 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @returns The device-side vault path.
      */
     private getDeviceVaultPath;
+    /**
+     * Services one input request from the renderer: inject, then resolve the renderer's promise.
+     *
+     * Every failure path still resolves that promise — with an error message the renderer re-throws — because
+     * a request that is silently dropped would hang the closure until the whole run times out, and report
+     * nothing about why.
+     *
+     * @param connection - The channel the request arrived on.
+     * @param payload - The raw JSON payload the binding was called with.
+     */
+    private handleInputRequest;
     /**
      * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.
      *
@@ -334,6 +380,11 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param deviceVaultPath - The device-side vault directory path.
      */
     private removeDeviceVaultDirectory;
+    /**
+     * Drops the `process.on('exit')` handler that would otherwise close an already-closed channel, and would
+     * stack a listener per reconnect.
+     */
+    private unregisterInputChannelExitHandler;
     /**
      * Polls until `app.workspace.layoutReady` is `true` in the WebView.
      */