obsidian-integration-testing 8.3.0 → 9.0.0

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

@@ -16,6 +16,56 @@
  * into the output, with no runtime file read and no `bundle`-time JSON import that
  * `bundle: false` cannot inline).
  */
+/**
+ * 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.
+ *
+ * The index signature carries every key `process.versions` exposes for that
+ * Electron build — beyond the four well-known ones below, that typically includes
+ * `ares`, `brotli`, `cldr`, `icu`, `llhttp`, `modules`, `napi`, `nghttp2`,
+ * `openssl`, `tz`, `unicode`, `uv`, `zlib` (and, on newer Electron, `ada`,
+ * `simdjson`, …). The exact set varies by Electron version, which is why it is
+ * captured wholesale rather than as a fixed field list.
+ */
+export interface ObsidianRuntimeVersions {
+    /** The bundled Chromium version, e.g. `'114.0.5735.289'`. */
+    readonly chrome: string;
+    /** The bundled Electron version, e.g. `'25.8.1'`. */
+    readonly electron: string;
+    /** The bundled Node.js version, e.g. `'18.15.0'`. */
+    readonly node: string;
+    /** Every `process.versions` key the Electron build exposes. */
+    readonly [key: string]: string;
+    /** The bundled V8 version, e.g. `'11.4.183.23'`. */
+    readonly v8: string;
+}
+/**
+ * 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`).
+ *
+ * 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
+ * historical dot-vs-hyphen asset-name guessing. Only the assets this library
+ * actually downloads are carried: the app `asar` and the x64 desktop installers.
+ * A field is absent when the version publishes no such asset (e.g. a catalyst
+ * build ships only the `asar`), in which case the caller falls back to its
+ * hand-rolled resolution.
+ */
+export interface ObsidianVersionDownloads {
+    /** The `obsidian-<version>.asar.gz` package URL. */
+    readonly asar?: string;
+    /** The macOS (universal) `.dmg` installer URL. */
+    readonly dmg?: string;
+    /** The Windows x64 `.exe` installer URL. */
+    readonly exe?: string;
+    /** The Linux x64 `.tar.gz` portable-build URL. */
+    readonly tar?: string;
+}
 /**
  * The subset of a `metadata.json` per-version entry this library reads.
  *
@@ -29,6 +79,21 @@ export interface ObsidianVersionMetadata {
     readonly changelogUrl?: string;
     /** The release channel: `'public'`, `'catalyst'`, or `'public+catalyst'`. */
     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
+     * in the catalog (the caller then falls back to hand-rolled resolution).
+     */
+    readonly downloads?: ObsidianVersionDownloads;
+    /**
+     * The highest ECMAScript edition (e.g. `'ES2022'`) fully supported by this
+     * version's bundled Chromium, derived from {@link ObsidianRuntimeVersions.chrome}
+     * (see `deriveEcmaScriptVersion`). Baked alongside {@link runtimeVersions}, so a
+     * consumer pinning this installer knows offline which ES level a serialized
+     * `evalInObsidian` closure may safely use. Absent when the version has no
+     * collected runtime versions.
+     */
+    readonly ecmaScriptVersion?: string;
     /**
      * The app's hardcoded required-minimum Electron version (e.g. `'28.2.3'`). An
      * Electron version, not an installer version — comparing against it needs the
@@ -46,6 +111,12 @@ export interface ObsidianVersionMetadata {
      * renderer dead-boots.
      */
     readonly minRunnableInstallerVersion?: string;
+    /**
+     * The concrete JS runtime versions this version's Electron shell ships, read
+     * empirically from `process.versions`. Absent until collected (see
+     * {@link ObsidianRuntimeVersions} and `scripts/collect-runtime-versions.ts`).
+     */
+    readonly runtimeVersions?: ObsidianRuntimeVersions;
 }
 /**
  * Looks up the metadata entry for a concrete Obsidian app version.

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

@@ -31,6 +31,7 @@ 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_metadata = require("./obsidian-metadata.cjs");
 var import_obsidian_version = require("./obsidian-version.cjs");
 const DOWNLOAD_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
 const PUBLIC_ASAR_RELEASE_BASE_URL = "https://github.com/obsidianmd/obsidian-releases/releases/download";
@@ -116,10 +117,12 @@ async function downloadAndDecompressAsar(url) {
 }
 function getAsarDownloadUrls(version) {
   const asarGzFileName = `${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
-  return [
+  const fallbackUrls = [
     `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
     `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
   ];
+  const bakedUrl = (0, import_obsidian_metadata.getVersionMetadata)(version)?.downloads?.asar;
+  return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -130,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 dir.\n *\n * Obsidian's bootstrap loads the highest of (its shell's bundled\n * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the\n * user-data dir). So placing an asar here only takes effect when its version is\n * **>= the shell's bundled version** (upgrade-only \u2014 confirmed by the Phase 0\n * spike). Running an older version requires pinning the installer/shell instead\n * (see `obsidian-installer.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/filesystem glue covered by integration tests, not unit tests. */\n\nimport {\n  copyFileSync,\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { gunzipSync } from 'node:zlib';\n\nimport type { DesktopReleasesManifest } from './obsidian-version.cjs';\n\nimport { log } from './log.cjs';\nimport {\n  compareVersions,\n  DESKTOP_RELEASES_MANIFEST_URL,\n  getVersionAsarFileName,\n  parseVersionSpec,\n  resolveVersionFromManifest\n} from './obsidian-version.cjs';\n\n/**\n * Browser User-Agent required to fetch asar packages from\n * `releases.obsidian.md` (the endpoint is Cloudflare-gated against non-browser\n * clients). Matches the UA documented in the obsidian-versions repo.\n */\nconst DOWNLOAD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36';\n\n/**\n * Base URL for **public** (stable) release asars, published as GitHub release\n * assets under `.../download/v<version>/obsidian-<version>.asar.gz`.\n */\nconst PUBLIC_ASAR_RELEASE_BASE_URL = 'https://github.com/obsidianmd/obsidian-releases/releases/download';\n\n/**\n * Base URL for **catalyst** (early access / insider) release asars, served from\n * the Obsidian CDN as `.../release/obsidian-<version>.asar.gz`. Public versions\n * are NOT hosted here (the CDN returns an empty body for them).\n */\nconst CATALYST_ASAR_RELEASE_BASE_URL = 'https://releases.obsidian.md/release';\n\nconst CACHE_ROOT = join(tmpdir(), 'obsidian-integration-testing');\nconst ASAR_CACHE_DIR = join(CACHE_ROOT, 'asar-cache');\nconst ASAR_FILE_PATTERN = /^obsidian-(?<version>\\d+\\.\\d+\\.\\d+)\\.asar$/;\n\n/**\n * A discovered `obsidian-<version>.asar` file.\n */\nexport interface DiscoveredAsar {\n  /** Absolute path to the asar file. */\n  readonly path: string;\n\n  /** The `x.y.z` version parsed from the file name. */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data dir under its canonical\n * `obsidian-<version>.asar` name.\n *\n * @param asarPath - Source asar path.\n * @param version - The asar's version (used for the destination file name).\n * @param userDataDir - Destination user-data dir.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void {\n  mkdirSync(userDataDir, { recursive: true });\n  const dest = join(userDataDir, getVersionAsarFileName(version));\n  copyFileSync(asarPath, dest);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDir}.`);\n}\n\n/**\n * Ensures the asar for a concrete version is present in the local cache,\n * downloading and decompressing it if necessary.\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path to the cached asar.\n * @throws Error if the download fails.\n */\nexport async function ensureAsarCached(version: string): Promise<string> {\n  mkdirSync(ASAR_CACHE_DIR, { recursive: true });\n  const cachedPath = getCachedAsarPath(version);\n  if (existsSync(cachedPath)) {\n    log(`[version-switch] Using cached asar for ${version}.`);\n    return cachedPath;\n  }\n\n  // A version's asar.gz lives on exactly one host depending on its channel\n  // (public \u2192 GitHub release assets, catalyst \u2192 the Obsidian CDN). The concrete\n  // Version alone does not tell us which, so try both and use the first that\n  // Returns a valid archive.\n  const errors: string[] = [];\n  for (const url of getAsarDownloadUrls(version)) {\n    try {\n      const asar = await downloadAndDecompressAsar(url);\n      writeFileSync(cachedPath, asar);\n      log(`[version-switch] Cached asar ${version} (${String(asar.length)} bytes) -> ${cachedPath}`);\n      return cachedPath;\n    } catch (error) {\n      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  throw new Error(`Failed to download Obsidian asar ${version}. Attempts: ${errors.join('; ')}`);\n}\n\n/**\n * Fetches and parses Obsidian's desktop releases manifest.\n *\n * @returns The parsed manifest.\n * @throws Error if the manifest cannot be fetched.\n */\nexport async function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest> {\n  const response = await fetch(DESKTOP_RELEASES_MANIFEST_URL);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);\n  }\n  return await response.json() as DesktopReleasesManifest;\n}\n\n/**\n * Finds the newest `obsidian-<version>.asar` in a directory.\n *\n * @param dir - The directory to scan (e.g. the user's Obsidian config dir).\n * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.\n */\nexport function findNewestAsar(dir: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(dir);\n  } catch {\n    return undefined;\n  }\n\n  let newest: DiscoveredAsar | undefined;\n  for (const entry of entries) {\n    const match = ASAR_FILE_PATTERN.exec(entry);\n    if (!match) {\n      continue;\n    }\n    const version = match.groups?.['version'] ?? '';\n    if (!newest || compareVersions(version, newest.version) > 0) {\n      newest = { path: join(dir, entry), version };\n    }\n  }\n  return newest;\n}\n\n/**\n * Returns the local cache path for a concrete version's asar (the file may not\n * yet exist).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path the asar is cached at.\n */\nexport function getCachedAsarPath(version: string): string {\n  return join(ASAR_CACHE_DIR, getVersionAsarFileName(version));\n}\n\n/**\n * Resolves a version specifier (explicit or channel alias) to a concrete\n * `x.y.z` version, fetching the manifest only when a channel alias is used.\n *\n * @param spec - The version specifier.\n * @returns The concrete version.\n */\nexport async function resolveConcreteVersion(spec: string): Promise<string> {\n  const parsed = parseVersionSpec(spec);\n  if (parsed.kind === 'explicit') {\n    return parsed.version;\n  }\n  const manifest = await fetchDesktopReleasesManifest();\n  return resolveVersionFromManifest(manifest, parsed.channel);\n}\n\n/**\n * Downloads a gzip-compressed asar from a URL and decompresses it.\n *\n * @param url - The `.asar.gz` URL.\n * @returns The decompressed asar bytes.\n * @throws Error if the request fails, the body is empty, or decompression fails.\n */\nasync function downloadAndDecompressAsar(url: string): Promise<Buffer> {\n  log(`[version-switch] Downloading asar from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(`HTTP ${String(response.status)}`);\n  }\n\n  const gz = Buffer.from(await response.arrayBuffer());\n  if (gz.length === 0) {\n    throw new Error('empty response body');\n  }\n  return gunzipSync(gz);\n}\n\n/**\n * Returns the candidate `.asar.gz` download URLs for a concrete version, public\n * (GitHub) first, then catalyst (CDN).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The URLs to try, in order.\n */\nfunction getAsarDownloadUrls(version: string): string[] {\n  const asarGzFileName = `${getVersionAsarFileName(version)}.gz`;\n  return [\n    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,\n    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`\n  ];\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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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 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 { 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  /** Absolute path to the asar file. */\n  readonly path: string;\n\n  /** The `x.y.z` version parsed from the file name. */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data dir under its canonical\n * `obsidian-<version>.asar` name.\n *\n * @param asarPath - Source asar path.\n * @param version - The asar's version (used for the destination file name).\n * @param userDataDir - Destination user-data dir.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void {\n  mkdirSync(userDataDir, { recursive: true });\n  const dest = join(userDataDir, getVersionAsarFileName(version));\n  copyFileSync(asarPath, dest);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDir}.`);\n}\n\n/**\n * Ensures the asar for a concrete version is present in the local cache,\n * downloading and decompressing it if necessary.\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path to the cached asar.\n * @throws Error if the download fails.\n */\nexport async function ensureAsarCached(version: string): Promise<string> {\n  mkdirSync(ASAR_CACHE_DIR, { recursive: true });\n  const cachedPath = getCachedAsarPath(version);\n  if (existsSync(cachedPath)) {\n    log(`[version-switch] Using cached asar for ${version}.`);\n    return cachedPath;\n  }\n\n  // A version's asar.gz lives on exactly one host depending on its channel\n  // (public \u2192 GitHub release assets, catalyst \u2192 the Obsidian CDN). The concrete\n  // Version alone does not tell us which, so try both and use the first that\n  // Returns a valid archive.\n  const errors: string[] = [];\n  for (const url of getAsarDownloadUrls(version)) {\n    try {\n      const asar = await downloadAndDecompressAsar(url);\n      writeFileSync(cachedPath, asar);\n      log(`[version-switch] Cached asar ${version} (${String(asar.length)} bytes) -> ${cachedPath}`);\n      return cachedPath;\n    } catch (error) {\n      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  throw new Error(`Failed to download Obsidian asar ${version}. Attempts: ${errors.join('; ')}`);\n}\n\n/**\n * Fetches and parses Obsidian's desktop releases manifest.\n *\n * @returns The parsed manifest.\n * @throws Error if the manifest cannot be fetched.\n */\nexport async function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest> {\n  const response = await fetch(DESKTOP_RELEASES_MANIFEST_URL);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);\n  }\n  return await response.json() as DesktopReleasesManifest;\n}\n\n/**\n * Finds the newest `obsidian-<version>.asar` in a directory.\n *\n * @param dir - The directory to scan (e.g. the user's Obsidian config dir).\n * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.\n */\nexport function findNewestAsar(dir: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(dir);\n  } catch {\n    return undefined;\n  }\n\n  let newest: DiscoveredAsar | undefined;\n  for (const entry of entries) {\n    const match = ASAR_FILE_PATTERN.exec(entry);\n    if (!match) {\n      continue;\n    }\n    const version = match.groups?.['version'] ?? '';\n    if (!newest || compareVersions(version, newest.version) > 0) {\n      newest = { path: join(dir, entry), version };\n    }\n  }\n  return newest;\n}\n\n/**\n * Returns the local cache path for a concrete version's asar (the file may not\n * yet exist).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path the asar is cached at.\n */\nexport function getCachedAsarPath(version: string): string {\n  return join(ASAR_CACHE_DIR, getVersionAsarFileName(version));\n}\n\n/**\n * Resolves a version specifier (explicit or channel alias) to a concrete\n * `x.y.z` version, fetching the manifest only when a channel alias is used.\n *\n * @param spec - The version specifier.\n * @returns The concrete version.\n */\nexport async function resolveConcreteVersion(spec: string): Promise<string> {\n  const parsed = parseVersionSpec(spec);\n  if (parsed.kind === 'explicit') {\n    return parsed.version;\n  }\n  const manifest = await fetchDesktopReleasesManifest();\n  return resolveVersionFromManifest(manifest, parsed.channel);\n}\n\n/**\n * Downloads a gzip-compressed asar from a URL and decompresses it.\n *\n * @param url - The `.asar.gz` URL.\n * @returns The decompressed asar bytes.\n * @throws Error if the request fails, the body is empty, or decompression fails.\n */\nasync function downloadAndDecompressAsar(url: string): Promise<Buffer> {\n  log(`[version-switch] Downloading asar from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(`HTTP ${String(response.status)}`);\n  }\n\n  const gz = Buffer.from(await response.arrayBuffer());\n  if (gz.length === 0) {\n    throw new Error('empty response body');\n  }\n  return gunzipSync(gz);\n}\n\n/**\n * Returns the candidate `.asar.gz` download URLs for a concrete version.\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": []
}


package/dist/lib/cjs/owned-vault-seed.cjs

@@ -0,0 +1,38 @@
+"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 owned_vault_seed_exports = {};
+__export(owned_vault_seed_exports, {
+  buildOwnedObsidianJson: () => buildOwnedObsidianJson
+});
+module.exports = __toCommonJS(owned_vault_seed_exports);
+function buildOwnedObsidianJson(params) {
+  return {
+    // eslint-disable-next-line camelcase -- Obsidian's own obsidian.json field name (old versions' auto-open marker).
+    last_open: params.vaultId,
+    updateDisabled: true,
+    vaults: {
+      [params.vaultId]: { open: true, path: params.vaultPath, ts: params.ts }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildOwnedObsidianJson
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/owned-vault-seed.d.cts

@@ -0,0 +1,67 @@
+/**
+ * @file
+ *
+ * Builds the isolated `obsidian.json` the harness pre-seeds into an owned
+ * instance's temp `--user-data-dir` so Obsidian opens the harness vault directly
+ * instead of showing the first-run vault-selector (the `starter-screen`).
+ *
+ * The auto-open marker changed across Obsidian's history, so the seed carries
+ * BOTH forms and each version reads the one it understands (ignoring the other
+ * unknown key) — no per-version branching:
+ *
+ * - **Old versions** (confirmed 0.6.4) auto-open from a **top-level `last_open`**
+ *   holding the vault id (`main.js`: `if (id && vaults.hasOwnProperty(id))
+ *   createWindow(id); else openStarter();`), and store each vault entry as just
+ *   `{ path, ts }`. Without `last_open` they fall through to the vault-selector.
+ * - **Newer versions** (confirmed 0.14.5+) dropped `last_open` and auto-open from
+ *   the per-entry **`open: true`** flag.
+ *
+ * Seeding both was verified to open the vault directly (no selector) on 0.6.4,
+ * 0.9.20, 0.12.19, 0.13.19, 0.14.5 and 1.12.7. `updateDisabled` suppresses the
+ * throwaway instance's self-update.
+ */
+/**
+ * Parameters for {@link buildOwnedObsidianJson}.
+ */
+export interface BuildOwnedObsidianJsonParams {
+    /** Last-access timestamp to stamp on the vault entry. */
+    readonly ts: number;
+    /** The randomly-generated vault id used as the registry key and `last_open`. */
+    readonly vaultId: string;
+    /** Absolute path to the harness vault folder. */
+    readonly vaultPath: string;
+}
+/**
+ * The `obsidian.json` structure the harness seeds for an owned instance.
+ */
+export interface OwnedObsidianJson {
+    /**
+     * Top-level auto-open marker (vault id) honored by old Obsidian versions;
+     * ignored as an unknown key by newer versions that use the per-entry `open`.
+     */
+    readonly last_open: string;
+    /** Disables the throwaway instance's self-update. */
+    readonly updateDisabled: true;
+    /** Vault registry keyed by vault id. */
+    readonly vaults: Readonly<Record<string, OwnedObsidianVaultEntry>>;
+}
+/**
+ * A single vault entry in the seeded `obsidian.json`.
+ */
+export interface OwnedObsidianVaultEntry {
+    /** Per-entry auto-open flag honored by newer Obsidian versions. */
+    readonly open: true;
+    /** Absolute path to the harness vault folder. */
+    readonly path: string;
+    /** Last-access timestamp. */
+    readonly ts: number;
+}
+/**
+ * Builds the isolated `obsidian.json` that force-opens the owned vault across all
+ * supported Obsidian versions (see the file overview for the dual-marker
+ * rationale).
+ *
+ * @param params - The vault id, path, and timestamp to seed.
+ * @returns The `obsidian.json` object to write into the owned user-data dir.
+ */
+export declare function buildOwnedObsidianJson(params: BuildOwnedObsidianJsonParams): OwnedObsidianJson;

package/dist/lib/cjs/process-exit-message.cjs

@@ -0,0 +1,47 @@
+"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 process_exit_message_exports = {};
+__export(process_exit_message_exports, {
+  buildProcessExitMessage: () => buildProcessExitMessage
+});
+module.exports = __toCommonJS(process_exit_message_exports);
+function buildProcessExitMessage(params) {
+  const { exitInfo, output, outputLabel, subject } = params;
+  const reason = resolveReason(exitInfo);
+  const trimmedOutput = output.trim();
+  const details = trimmedOutput.length > 0 ? `
+
+${outputLabel} (tail):
+${trimmedOutput}` : "";
+  return `${subject} ${reason} during startup.${details}`;
+}
+function resolveReason(exitInfo) {
+  if (exitInfo.spawnError !== void 0) {
+    return `failed to start (${exitInfo.spawnError})`;
+  }
+  if (exitInfo.signal !== null) {
+    return `was terminated by signal ${exitInfo.signal}`;
+  }
+  return `exited prematurely with code ${exitInfo.code === null ? "(null)" : String(exitInfo.code)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildProcessExitMessage
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/process-exit-message.d.cts

@@ -0,0 +1,48 @@
+/**
+ * @file
+ *
+ * Pure builder for the diagnostic message describing an auto-started child
+ * process (the Android emulator or the Appium server) that died during startup,
+ * appending the captured output tail when available.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the message formatting stays unit-testable — the launchers
+ * themselves spawn real processes.
+ */
+/**
+ * Parameters for {@link buildProcessExitMessage}.
+ */
+export interface BuildProcessExitMessageParams {
+    /** The process's exit / spawn-failure details. */
+    readonly exitInfo: ProcessExitInfo;
+    /** The captured stdout+stderr tail (empty when none was captured). */
+    readonly output: string;
+    /** Label for the captured output section (e.g. `"Emulator output"`). */
+    readonly outputLabel: string;
+    /** Human-readable subject of the process (e.g. `"Android emulator"`). */
+    readonly subject: string;
+}
+/**
+ * Details of a spawned child process that has exited or failed to spawn.
+ *
+ * A normal exit sets `code`/`signal` (exactly one is non-`null`); a spawn
+ * failure (e.g. `ENOENT` for a missing binary) leaves both `null` and sets
+ * `spawnError` to the failure message.
+ */
+export interface ProcessExitInfo {
+    /** Exit code, or `null` when terminated by a signal or when it failed to spawn. */
+    readonly code: null | number;
+    /** Terminating signal, or `null` when it exited normally or failed to spawn. */
+    readonly signal: NodeJS.Signals | null;
+    /** The spawn-failure message when the process never started (e.g. `ENOENT`), otherwise absent. */
+    readonly spawnError?: string;
+}
+/**
+ * Builds a descriptive error message for an auto-started child process that
+ * exited (or failed to spawn) during startup, appending the captured output
+ * tail when available.
+ *
+ * @param params - The subject, exit details, and captured output.
+ * @returns A human-readable error message.
+ */
+export declare function buildProcessExitMessage(params: BuildProcessExitMessageParams): string;

package/dist/lib/cjs/silent-asar-fallback-error.cjs

@@ -0,0 +1,48 @@
+"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 silent_asar_fallback_error_exports = {};
+__export(silent_asar_fallback_error_exports, {
+  SilentAsarFallbackError: () => SilentAsarFallbackError
+});
+module.exports = __toCommonJS(silent_asar_fallback_error_exports);
+class SilentAsarFallbackError extends Error {
+  /** The pinned Obsidian app (asar) version that was requested. */
+  requestedVersion;
+  /** The Obsidian app (asar) version the instance is actually running. */
+  runningApiVersion;
+  /**
+   * Creates the error from the pinned and actually-running versions.
+   *
+   * @param params - The requested pin and the version actually running.
+   */
+  constructor(params) {
+    const { requestedVersion, runningApiVersion } = params;
+    super(
+      `Obsidian was pinned to app version ${requestedVersion} but is actually running ${runningApiVersion} \u2014 the installer shell is too old for the pin and silently fell back to its own bundled asar. Pin an obsidianInstallerVersion at or above ${requestedVersion}'s run floor so the pinned version runs.`
+    );
+    this.name = "SilentAsarFallbackError";
+    this.requestedVersion = requestedVersion;
+    this.runningApiVersion = runningApiVersion;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SilentAsarFallbackError
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3NpbGVudC1hc2FyLWZhbGxiYWNrLWVycm9yLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVGhlIGRpc3RpbmN0IGVycm9yIHRocm93biB3aGVuIGEgYm9vdGVkIG93bmVkIE9ic2lkaWFuIGluc3RhbmNlIGlzICoqbm90KipcbiAqIHJ1bm5pbmcgdGhlIHBpbm5lZCBhcHAgKGFzYXIpIHZlcnNpb24gXHUyMDE0IHRoZSBpbnN0YWxsZXIgc2hlbGwgc2lsZW50bHkgZmVsbCBiYWNrXG4gKiB0byBpdHMgb3duIGJ1bmRsZWQgYXNhciBpbnN0ZWFkIG9mIHJ1bm5pbmcgdGhlIHN3YXBwZWQtaW4gcGluIChzZWVcbiAqIGBhc2FyLWZhbGxiYWNrLWRldGVjdGlvbmApLiBVbmxpa2UgYFJlbmRlcmVyRmFpbGVkVG9Jbml0aWFsaXplRXJyb3JgIChhXG4gKiBibGFjay1zY3JlZW4gZGVhZCBib290KSB0aGlzIGZpcmVzIG9uIGEgKmhlYWx0aHkqIHJlbmRlcmVyIHJ1bm5pbmcgdGhlIHdyb25nXG4gKiAob2xkZXIpIHZlcnNpb24sIHNvIGl0IGlzIGRpc2NvdmVyZWQgcG9zdC1ib290IGZyb20gdGhlIGxpdmUgcnVubmluZyB2ZXJzaW9uXG4gKiByYXRoZXIgdGhhbiBmcm9tIGFuIGVtcHR5IGA8Ym9keT5gLiBJdCBpcyBleHBvcnRlZCBzbyBjYWxsZXJzIG9mIGBjb25uZWN0VG9DZHBgXG4gKiAvIHRoZSB0cmFuc3BvcnQgY2FuIGBpbnN0YW5jZW9mYC1tYXRjaCB0aGlzIHNwZWNpZmljIGZhaWx1cmUuXG4gKi9cblxuLyoqXG4gKiBQYXJhbWV0ZXJzIGZvciB0aGUge0BsaW5rIFNpbGVudEFzYXJGYWxsYmFja0Vycm9yfSBjb25zdHJ1Y3Rvci5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTaWxlbnRBc2FyRmFsbGJhY2tFcnJvckNvbnN0cnVjdG9yUGFyYW1zIHtcbiAgLyoqIFRoZSBwaW5uZWQgT2JzaWRpYW4gYXBwIChhc2FyKSB2ZXJzaW9uIHRoYXQgd2FzIHJlcXVlc3RlZC4gKi9cbiAgcmVhZG9ubHkgcmVxdWVzdGVkVmVyc2lvbjogc3RyaW5nO1xuXG4gIC8qKiBUaGUgT2JzaWRpYW4gYXBwIChhc2FyKSB2ZXJzaW9uIHRoZSBpbnN0YW5jZSBpcyBhY3R1YWxseSBydW5uaW5nLiAqL1xuICByZWFkb25seSBydW5uaW5nQXBpVmVyc2lvbjogc3RyaW5nO1xufVxuXG4vKipcbiAqIFRocm93biB3aGVuIGEgYm9vdGVkIG93bmVkIGluc3RhbmNlIGlzIHJ1bm5pbmcgYSBkaWZmZXJlbnQgYXBwIChhc2FyKSB2ZXJzaW9uXG4gKiB0aGFuIHRoZSBwaW5uZWQge0BsaW5rIFNpbGVudEFzYXJGYWxsYmFja0Vycm9yQ29uc3RydWN0b3JQYXJhbXMucmVxdWVzdGVkVmVyc2lvbn0gXHUyMDE0XG4gKiB0aGUgaW5zdGFsbGVyIHNoZWxsIHdhcyB0b28gb2xkIGZvciB0aGUgcGluIGFuZCBzaWxlbnRseSByZXZlcnRlZCB0byBpdHMgb3duXG4gKiBidW5kbGVkIGFzYXIuIENhcnJpZXMgYm90aCB2ZXJzaW9ucyBzbyBjYWxsZXJzIGNhbiBgaW5zdGFuY2VvZmAtbWF0Y2ggYW5kXG4gKiBzdXJmYWNlIGFuIGFjdGlvbmFibGUgcmVtZWR5IChwaW4gYSBuZXdlciBpbnN0YWxsZXIpLlxuICovXG5leHBvcnQgY2xhc3MgU2lsZW50QXNhckZhbGxiYWNrRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIC8qKiBUaGUgcGlubmVkIE9ic2lkaWFuIGFwcCAoYXNhcikgdmVyc2lvbiB0aGF0IHdhcyByZXF1ZXN0ZWQuICovXG4gIHB1YmxpYyByZWFkb25seSByZXF1ZXN0ZWRWZXJzaW9uOiBzdHJpbmc7XG5cbiAgLyoqIFRoZSBPYnNpZGlhbiBhcHAgKGFzYXIpIHZlcnNpb24gdGhlIGluc3RhbmNlIGlzIGFjdHVhbGx5IHJ1bm5pbmcuICovXG4gIHB1YmxpYyByZWFkb25seSBydW5uaW5nQXBpVmVyc2lvbjogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBDcmVhdGVzIHRoZSBlcnJvciBmcm9tIHRoZSBwaW5uZWQgYW5kIGFjdHVhbGx5LXJ1bm5pbmcgdmVyc2lvbnMuXG4gICAqXG4gICAqIEBwYXJhbSBwYXJhbXMgLSBUaGUgcmVxdWVzdGVkIHBpbiBhbmQgdGhlIHZlcnNpb24gYWN0dWFsbHkgcnVubmluZy5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihwYXJhbXM6IFNpbGVudEFzYXJGYWxsYmFja0Vycm9yQ29uc3RydWN0b3JQYXJhbXMpIHtcbiAgICBjb25zdCB7IHJlcXVlc3RlZFZlcnNpb24sIHJ1bm5pbmdBcGlWZXJzaW9uIH0gPSBwYXJhbXM7XG4gICAgc3VwZXIoXG4gICAgICBgT2JzaWRpYW4gd2FzIHBpbm5lZCB0byBhcHAgdmVyc2lvbiAke3JlcXVlc3RlZFZlcnNpb259IGJ1dCBpcyBhY3R1YWxseSBydW5uaW5nICR7cnVubmluZ0FwaVZlcnNpb259IFx1MjAxNCBgXG4gICAgICAgICsgJ3RoZSBpbnN0YWxsZXIgc2hlbGwgaXMgdG9vIG9sZCBmb3IgdGhlIHBpbiBhbmQgc2lsZW50bHkgZmVsbCBiYWNrIHRvIGl0cyBvd24gYnVuZGxlZCBhc2FyLiAnXG4gICAgICAgICsgYFBpbiBhbiBvYnNpZGlhbkluc3RhbGxlclZlcnNpb24gYXQgb3IgYWJvdmUgJHtyZXF1ZXN0ZWRWZXJzaW9ufSdzIHJ1biBmbG9vciBzbyB0aGUgcGlubmVkIHZlcnNpb24gcnVucy5gXG4gICAgKTtcbiAgICB0aGlzLm5hbWUgPSAnU2lsZW50QXNhckZhbGxiYWNrRXJyb3InO1xuICAgIHRoaXMucmVxdWVzdGVkVmVyc2lvbiA9IHJlcXVlc3RlZFZlcnNpb247XG4gICAgdGhpcy5ydW5uaW5nQXBpVmVyc2lvbiA9IHJ1bm5pbmdBcGlWZXJzaW9uO1xuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBK0JPLE1BQU0sZ0NBQWdDLE1BQU07QUFBQTtBQUFBLEVBRWpDO0FBQUE7QUFBQSxFQUdBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT1QsWUFBWSxRQUFrRDtBQUNuRSxVQUFNLEVBQUUsa0JBQWtCLGtCQUFrQixJQUFJO0FBQ2hEO0FBQUEsTUFDRSxzQ0FBc0MsZ0JBQWdCLDRCQUE0QixpQkFBaUIsa0pBRWhELGdCQUFnQjtBQUFBLElBQ3JFO0FBQ0EsU0FBSyxPQUFPO0FBQ1osU0FBSyxtQkFBbUI7QUFDeEIsU0FBSyxvQkFBb0I7QUFBQSxFQUMzQjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/silent-asar-fallback-error.d.cts

@@ -0,0 +1,40 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when a booted owned Obsidian instance is **not**
+ * running the pinned app (asar) version — the installer shell silently fell back
+ * to its own bundled asar instead of running the swapped-in pin (see
+ * `asar-fallback-detection`). Unlike `RendererFailedToInitializeError` (a
+ * black-screen dead boot) this fires on a *healthy* renderer running the wrong
+ * (older) version, so it is discovered post-boot from the live running version
+ * rather than from an empty `<body>`. It is exported so callers of `connectToCdp`
+ * / the transport can `instanceof`-match this specific failure.
+ */
+/**
+ * Parameters for the {@link SilentAsarFallbackError} constructor.
+ */
+export interface SilentAsarFallbackErrorConstructorParams {
+    /** The pinned Obsidian app (asar) version that was requested. */
+    readonly requestedVersion: string;
+    /** The Obsidian app (asar) version the instance is actually running. */
+    readonly runningApiVersion: string;
+}
+/**
+ * Thrown when a booted owned instance is running a different app (asar) version
+ * than the pinned {@link SilentAsarFallbackErrorConstructorParams.requestedVersion} —
+ * the installer shell was too old for the pin and silently reverted to its own
+ * bundled asar. Carries both versions so callers can `instanceof`-match and
+ * surface an actionable remedy (pin a newer installer).
+ */
+export declare class SilentAsarFallbackError extends Error {
+    /** The pinned Obsidian app (asar) version that was requested. */
+    readonly requestedVersion: string;
+    /** The Obsidian app (asar) version the instance is actually running. */
+    readonly runningApiVersion: string;
+    /**
+     * Creates the error from the pinned and actually-running versions.
+     *
+     * @param params - The requested pin and the version actually running.
+     */
+    constructor(params: SilentAsarFallbackErrorConstructorParams);
+}