obsidian-integration-testing 8.3.0 → 9.0.0

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

@@ -9,6 +9,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { gunzipSync } from "node:zlib";
 import { log } from "./log.mjs";
+import { getVersionMetadata } from "./obsidian-metadata.mjs";
 import {
   compareVersions,
   DESKTOP_RELEASES_MANIFEST_URL,
@@ -100,10 +101,12 @@ async function downloadAndDecompressAsar(url) {
 }
 function getAsarDownloadUrls(version) {
   const asarGzFileName = `${getVersionAsarFileName(version)}.gz`;
-  return [
+  const fallbackUrls = [
     `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
     `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
   ];
+  const bakedUrl = getVersionMetadata(version)?.downloads?.asar;
+  return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;
 }
 export {
   copyAsarIntoUserData,
@@ -113,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 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.mjs';\n\nimport { log } from './log.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  /** 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.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  /** 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/esm/owned-vault-seed.d.mts

@@ -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/esm/owned-vault-seed.mjs

@@ -0,0 +1,14 @@
+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 }
+    }
+  };
+}
+export {
+  buildOwnedObsidianJson
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/process-exit-message.d.mts

@@ -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/esm/process-exit-message.mjs

@@ -0,0 +1,23 @@
+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)}`;
+}
+export {
+  buildProcessExitMessage
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/silent-asar-fallback-error.d.mts

@@ -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);
+}

package/dist/lib/esm/silent-asar-fallback-error.mjs

@@ -0,0 +1,24 @@
+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;
+  }
+}
+export {
+  SilentAsarFallbackError
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/transport-desktop-cdp.d.mts

@@ -16,6 +16,7 @@
  *
  * Requirements: Node.js 22+ (uses built-in `WebSocket` and `fetch` globals).
  */
+import type { AsarFallback } from './asar-fallback-detection.mjs';
 import type { ElectronCompatibility } from './electron-compatibility.mjs';
 import type { InstallerCompatibility } from './installer-compatibility.mjs';
 import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
@@ -75,6 +76,16 @@ export interface DesktopCdpTransportConfig {
      * @default `false`
      */
     shouldDisableSandbox?: boolean;
+    /**
+     * Whether a post-boot **silent asar fallback** (the running app version differs
+     * from the swapped-in pin) fails fast with {@link SilentAsarFallbackError}. The
+     * verdict is always computed and surfaced via
+     * {@link DesktopCdpTransport.getAsarFallback}; this gates only the throw. Only
+     * meaningful in owned mode running a swapped-in asar.
+     *
+     * @default `true`
+     */
+    shouldThrowOnSilentAsarFallback?: boolean;
     /**
      * Whether the post-boot runtime-Electron compatibility nag warning is emitted
      * when the live Electron is below the app's recommended minimum. The verdict is
@@ -141,6 +152,7 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      */
     readonly isMobile = false;
     private activeVaultPath;
+    private asarFallback;
     private readonly cdpHost;
     private cdpPort;
     private cdpUrl;
@@ -153,6 +165,7 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
     private readonly ownedConfig;
     private ownedInstance;
     private readonly shouldDisableSandbox;
+    private readonly shouldThrowOnSilentAsarFallback;
     private readonly shouldWarnOnCompatibilityIssues;
     private ws;
     /**
@@ -185,6 +198,19 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @returns The normalized result string.
      */
     evaluate(expression: string, options: TransportEvalOptions): Promise<string>;
+    /**
+     * Returns the silent-asar-fallback verdict for this owned instance — whether the
+     * app version it is actually running matches the swapped-in pin, or the installer
+     * silently reverted to its own bundled asar (read live post-boot). Returns
+     * `undefined` when this is not an owned instance, the instance has not booted
+     * yet, or the verdict could not be determined (no asar was swapped, or the live
+     * version was unreadable). A `'fallback'` verdict reaches this surface only when
+     * the throw is disabled ({@link DesktopCdpTransportConfig.shouldThrowOnSilentAsarFallback}
+     * `false`); otherwise it throws `SilentAsarFallbackError`.
+     *
+     * @returns The silent-asar-fallback verdict, or `undefined`.
+     */
+    getAsarFallback(): AsarFallback | undefined;
     /**
      * Returns the resolved installer↔app compatibility verdict for this owned
      * instance, so callers can assert on it. Returns `undefined` when this is not
@@ -239,24 +265,46 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      */
     unregisterVault(vaultPath: string): Promise<void>;
     /**
-     * Best-effort tier-2 runtime nag: reads the live Electron version and running
-     * app version from the booted owned renderer and warns when the Electron the
-     * instance is actually running is older than the app's recommended minimum.
-     * Stores the verdict on {@link getElectronCompatibility}.
-     *
-     * The app version is read **live** — the running app version from the main
-     * process (`ipcRenderer.sendSync('version')`, the same IPC channel the namespace
-     * bootstrap uses) rather than from the resolved config — so the nag reflects the
-     * version genuinely running across every owned sub-path (asar-swap / downgrade /
-     * own-installer) and stays truthful even under a silent asar fallback.
-     * `process.versions.electron` gives the shell's live Electron. Both are read at
-     * the renderer top level (no `require('obsidian')`, which resolves only inside a
-     * plugin-load context). Never throws — a read failure is logged and ignored, so
-     * it cannot break an otherwise-ready boot.
+     * Computes and stores the runtime-Electron compatibility verdict (on
+     * {@link getElectronCompatibility}) from an already-read version pair, warning
+     * when the live Electron is below the app's recommended minimum. Never throws; a
+     * boot whose running app version was unreadable is skipped (nothing to judge).
+     *
+     * @param appVersion - The live running app version, or `undefined` when unreadable.
+     * @param actualElectronVersion - The live Electron version, or `undefined` when unreadable.
+     */
+    private applyElectronCompatibility;
+    /**
+     * Verifies the running app (asar) version matches the swapped-in pin, storing the
+     * verdict on {@link getAsarFallback}. On a **silent fallback** (the installer ran
+     * its own bundled asar instead of the pin) it throws {@link SilentAsarFallbackError}
+     * when the throw is enabled, otherwise warns (when warnings are on) and lets the
+     * boot proceed. A boot with no swapped-in asar, or an unreadable running version,
+     * is `'unknown'` — nothing is thrown or warned. This is the healthy-UI companion to
+     * the black-screen {@link RendererFailedToInitializeError} dead-boot fast-fail.
+     *
+     * @param runningApiVersion - The live running app version, or `undefined` when unreadable.
+     */
+    private checkRuntimeAsarFallback;
+    /**
+     * Runs the post-boot runtime compatibility checks for an owned instance, once the
+     * vault is ready. Reads the live running app version and Electron version **once**
+     * from the booted renderer's main process, then: (1) verifies the running app
+     * version matches the swapped-in pin — throwing {@link SilentAsarFallbackError} on
+     * a silent fallback (when enabled); and (2) runs the best-effort runtime-Electron
+     * nag. Only the asar-fallback check can throw, so this must run outside the
+     * readiness poll's try/catch (a swallowed throw would loop until timeout).
+     *
+     * Both are read at the renderer top level: `ipcRenderer.sendSync('version')` (the
+     * running app version, truthful even under a silent asar fallback) and
+     * `process.versions.electron` (the live shell Electron); neither uses
+     * `require('obsidian')`, which resolves only inside a plugin-load context. A read
+     * failure leaves both unknown (logged, non-fatal) — an unreadable running version
+     * cannot be judged a fallback, so the boot is not broken by a flaky read.
      *
      * @param vaultPath - The vault path to evaluate in.
      */
-    private checkRuntimeElectronCompatibility;
+    private checkRuntimeCompatibility;
     /**
      * Connects to a CDP target's WebSocket endpoint.
      *
@@ -320,6 +368,17 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @returns The list of page targets.
      */
     private getPageTargets;
+    /**
+     * Kills the currently-running owned instance (if any) and waits for it to exit,
+     * so the next launch gets a pristine single-window instance.
+     *
+     * Relaunching over a live instance is forwarded by Electron's single-instance
+     * lock on the shared user-data dir and surfaces the vault picker, and opening a
+     * second window via IPC leaves stale windows that break vault-target routing —
+     * hence a full kill + wait-for-exit (releasing the lock) between launches. A
+     * no-op on the first attempt, when no instance is running yet.
+     */
+    private killRunningOwnedInstance;
     /**
      * Moves the owned instance's window off-screen so a hidden run never steals
      * focus. Uses Electron's remote bridge (`window.electron.remote`) — the only