obsidian-integration-testing 8.0.0 → 8.1.0

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

@@ -38,8 +38,11 @@ var import_node_fs = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
+var import_installer_asset = require("./installer-asset.cjs");
 var import_log = require("./log.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 RELEASE_DOWNLOAD_BASE_URL = "https://github.com/obsidianmd/obsidian-releases/releases/download";
+const RELEASE_API_TAG_URL = "https://api.github.com/repos/obsidianmd/obsidian-releases/releases/tags";
 const CACHE_ROOT = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "obsidian-integration-testing");
 const SHELL_CACHE_DIR = (0, import_node_path.join)(CACHE_ROOT, "shell-cache");
 const MAC_PLIST_VERSION_PATTERN = /<key>CFBundleShortVersionString<\/key>\s*<string>(?<version>[^<]+)<\/string>/;
@@ -60,9 +63,8 @@ async function ensureShellCached(version) {
     return exePath;
   }
   (0, import_node_fs.mkdirSync)(shellDir, { recursive: true });
-  const assetName = getInstallerAssetName(version);
-  const assetPath = (0, import_node_path.join)(shellDir, assetName);
-  await downloadReleaseAsset(version, assetName, assetPath);
+  const assetUrls = await resolveInstallerAssetUrls(version);
+  const assetPath = await downloadInstallerAsset(assetUrls, shellDir, version);
   extractShell(assetPath, shellDir);
   (0, import_node_fs.rmSync)(assetPath, { force: true });
   if (!(0, import_node_fs.existsSync)(exePath)) {
@@ -108,17 +110,29 @@ function detectWindowsFileVersion(exePath) {
     return void 0;
   }
 }
-async function downloadReleaseAsset(version, assetName, dest) {
-  const url = `https://github.com/obsidianmd/obsidian-releases/releases/download/v${version}/${assetName}`;
-  (0, import_log.log)(`[installer] Downloading installer ${version} from ${url} ...`);
+async function downloadAsset(url, dest) {
+  (0, import_log.log)(`[installer] Downloading installer from ${url} ...`);
   const response = await fetch(url, { headers: { "User-Agent": DOWNLOAD_USER_AGENT } });
   if (!response.ok) {
-    throw new Error(
-      `Failed to download Obsidian installer ${version}: HTTP ${String(response.status)} from ${url}. Catalyst/beta versions have no public installer \u2014 pin an asar version on a public/installed shell instead.`
-    );
+    throw new Error(`HTTP ${String(response.status)}`);
   }
   (0, import_node_fs.writeFileSync)(dest, Buffer.from(await response.arrayBuffer()));
 }
+async function downloadInstallerAsset(urls, shellDir, version) {
+  const errors = [];
+  for (const url of urls) {
+    const assetPath = (0, import_node_path.join)(shellDir, (0, import_node_path.basename)(url));
+    try {
+      await downloadAsset(url, assetPath);
+      return assetPath;
+    } catch (error) {
+      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  throw new Error(
+    `Failed to download Obsidian installer ${version}. Attempts: ${errors.join("; ")}. Catalyst/beta versions have no public installer \u2014 pin an asar version on a public/installed shell instead.`
+  );
+}
 function extractLinuxShell(assetPath, shellDir) {
   run("tar", ["xzf", assetPath, "-C", shellDir, "--strip-components=1"]);
 }
@@ -152,6 +166,22 @@ function extractWindowsShell(assetPath, shellDir) {
   run("7z", ["x", "-y", `-o${shellDir}`, innerArchive]);
   (0, import_node_fs.rmSync)(nsisExtractDir, { force: true, recursive: true });
 }
+async function fetchReleaseAssetNames(version) {
+  try {
+    const response = await fetch(`${RELEASE_API_TAG_URL}/v${version}`, {
+      headers: { "Accept": "application/vnd.github+json", "User-Agent": DOWNLOAD_USER_AGENT }
+    });
+    if (!response.ok) {
+      (0, import_log.log)(`[installer] Release API for ${version} returned HTTP ${String(response.status)}; falling back to templated asset names.`);
+      return void 0;
+    }
+    const release = await response.json();
+    return release.assets.map((asset) => asset.name);
+  } catch (error) {
+    (0, import_log.log)(`[installer] Release API for ${version} unavailable (${error instanceof Error ? error.message : String(error)}); falling back to templated asset names.`);
+    return void 0;
+  }
+}
 function getCachedShellExePath(shellDir) {
   if (import_node_process.default.platform === "win32") {
     return (0, import_node_path.join)(shellDir, "Obsidian.exe");
@@ -161,14 +191,16 @@ function getCachedShellExePath(shellDir) {
   }
   return (0, import_node_path.join)(shellDir, "obsidian");
 }
-function getInstallerAssetName(version) {
-  if (import_node_process.default.platform === "win32") {
-    return `Obsidian-${version}.exe`;
-  }
-  if (import_node_process.default.platform === "darwin") {
-    return `Obsidian-${version}.dmg`;
-  }
-  return `obsidian-${version}.tar.gz`;
+async function resolveInstallerAssetUrls(version) {
+  const assetNames = await fetchReleaseAssetNames(version);
+  if (assetNames) {
+    const selected = (0, import_installer_asset.selectInstallerAssetName)({ assetNames, platform: import_node_process.default.platform, version });
+    if (selected !== void 0) {
+      return [`${RELEASE_DOWNLOAD_BASE_URL}/v${version}/${selected}`];
+    }
+    (0, import_log.log)(`[installer] No installer asset matched for ${version}; falling back to templated asset names.`);
+  }
+  return (0, import_installer_asset.buildInstallerAssetNameCandidates)({ platform: import_node_process.default.platform, version }).map((name) => `${RELEASE_DOWNLOAD_BASE_URL}/v${version}/${name}`);
 }
 function run(command, args) {
   const result = (0, import_node_child_process.spawnSync)(command, args, { stdio: "ignore" });
@@ -182,4 +214,4 @@ function run(command, args) {
   ensureShellCached,
   getCachedShellDir
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-installer.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Integration-time helpers for resolving the Obsidian **shell** (the Electron\n * runtime / installer build) to launch.\n *\n * By default the harness uses the installed shell. When a specific installer\n * version is requested, it downloads that version's GitHub release asset and\n * extracts a portable shell into a cache, returning the executable to launch.\n *\n * GitHub release assets exist for **public** releases only; catalyst (beta)\n * builds publish only the asar, so installer-pinning supports public versions.\n * The extracted shell's bundled `resources/obsidian.asar` is that version, so\n * pinning the installer is how you run a version **older** than the installed\n * shell (asar-swap is upgrade-only \u2014 see `obsidian-version-switch.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/extraction glue covered by integration tests, not unit tests. */\n\nimport {\n  execFileSync,\n  spawnSync\n} from 'node:child_process';\nimport {\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport {\n  basename,\n  dirname,\n  join\n} from 'node:path';\nimport process from 'node:process';\n\nimport { log } from './log.cjs';\n\n/**\n * Browser User-Agent for downloading release assets (Cloudflare-gated).\n */\nconst DOWNLOAD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36';\n\nconst CACHE_ROOT = join(tmpdir(), 'obsidian-integration-testing');\nconst SHELL_CACHE_DIR = join(CACHE_ROOT, 'shell-cache');\nconst MAC_PLIST_VERSION_PATTERN = /<key>CFBundleShortVersionString<\\/key>\\s*<string>(?<version>[^<]+)<\\/string>/;\n\n/**\n * A resolved Obsidian shell executable.\n */\nexport interface ResolvedShell {\n  /** Absolute path to the Obsidian executable to launch. */\n  readonly exePath: string;\n\n  /** The shell's version, or `undefined` if it could not be detected. */\n  readonly version: string | undefined;\n}\n\n/**\n * Detects the version of an installed Obsidian shell from its executable.\n *\n * - Windows: the executable's PE `FileVersion`.\n * - macOS: `CFBundleShortVersionString` from the app bundle's `Info.plist`.\n * - Linux: best-effort parse from the executable path (often `undefined`).\n *\n * @param exePath - Absolute path to the Obsidian executable.\n * @returns The `x.y.z` version, or `undefined` if it cannot be determined.\n */\nexport function detectInstalledShellVersion(exePath: string): string | undefined {\n  if (process.platform === 'win32') {\n    return detectWindowsFileVersion(exePath);\n  }\n\n  if (process.platform === 'darwin') {\n    return detectMacBundleVersion(exePath);\n  }\n\n  return detectVersionFromPath(exePath);\n}\n\n/**\n * Ensures a portable Obsidian shell for the given version is extracted into the\n * cache, downloading and extracting its GitHub release asset if necessary.\n *\n * @param version - A concrete public `x.y.z` version.\n * @returns The absolute path to the cached shell executable.\n * @throws Error if the asset cannot be downloaded or extracted.\n */\nexport async function ensureShellCached(version: string): Promise<string> {\n  const shellDir = getCachedShellDir(version);\n  const exePath = getCachedShellExePath(shellDir);\n  if (existsSync(exePath)) {\n    log(`[installer] Using cached shell for ${version}.`);\n    return exePath;\n  }\n\n  mkdirSync(shellDir, { recursive: true });\n  const assetName = getInstallerAssetName(version);\n  const assetPath = join(shellDir, assetName);\n  await downloadReleaseAsset(version, assetName, assetPath);\n  extractShell(assetPath, shellDir);\n  rmSync(assetPath, { force: true });\n\n  if (!existsSync(exePath)) {\n    throw new Error(`Extracted Obsidian shell ${version} but executable not found at ${exePath}.`);\n  }\n  log(`[installer] Extracted shell ${version} -> ${exePath}`);\n  return exePath;\n}\n\n/**\n * Returns the cache directory a version's extracted shell lives in (the\n * directory may not yet exist).\n *\n * @param version - A concrete public `x.y.z` version.\n * @returns The absolute shell cache directory for the version.\n */\nexport function getCachedShellDir(version: string): string {\n  return join(SHELL_CACHE_DIR, version);\n}\n\n/**\n * Throws a descriptive error if a required command is not on `PATH`.\n *\n * @param command - The command name.\n * @param hint - Actionable guidance appended to the error.\n */\nfunction assertCommandAvailable(command: string, hint: string): void {\n  const probe = process.platform === 'win32' ? 'where.exe' : 'which';\n  const result = spawnSync(probe, [command], { stdio: 'ignore' });\n  if (result.status !== 0) {\n    throw new Error(`Required command \"${command}\" was not found on PATH. ${hint}`);\n  }\n}\n\n/**\n * Reads `CFBundleShortVersionString` from a macOS app bundle's `Info.plist`.\n *\n * @param exePath - Path to `.../Obsidian.app/Contents/MacOS/Obsidian`.\n * @returns The `x.y.z` version, or `undefined`.\n */\nfunction detectMacBundleVersion(exePath: string): string | undefined {\n  try {\n    const contentsDir = dirname(dirname(exePath));\n    const plist = readFileSync(join(contentsDir, 'Info.plist'), 'utf-8');\n    const match = MAC_PLIST_VERSION_PATTERN.exec(plist);\n    return match?.groups?.['version'];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Best-effort parse of an `x.y.z` version embedded in a path.\n *\n * @param value - The path or string to scan.\n * @returns The first `x.y.z` match, or `undefined`.\n */\nfunction detectVersionFromPath(value: string): string | undefined {\n  const match = /(?<version>\\d+\\.\\d+\\.\\d+)/.exec(value);\n  return match?.groups?.['version'];\n}\n\n/**\n * Reads the PE `FileVersion` of a Windows executable via PowerShell.\n *\n * @param exePath - Absolute path to the executable.\n * @returns The `x.y.z` version, or `undefined`.\n */\nfunction detectWindowsFileVersion(exePath: string): string | undefined {\n  try {\n    const output = execFileSync(\n      'powershell',\n      ['-NoProfile', '-Command', `(Get-Item -LiteralPath ${JSON.stringify(exePath)}).VersionInfo.FileVersion`],\n      { encoding: 'utf-8' }\n    );\n    const version = output.trim();\n    return version.length > 0 ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Downloads a GitHub release asset for a version to a destination file.\n *\n * @param version - The release version (tag `v<version>`).\n * @param assetName - The asset file name.\n * @param dest - Destination file path.\n * @throws Error if the download fails (e.g. no public installer for the version).\n */\nasync function downloadReleaseAsset(version: string, assetName: string, dest: string): Promise<void> {\n  const url = `https://github.com/obsidianmd/obsidian-releases/releases/download/v${version}/${assetName}`;\n  log(`[installer] Downloading installer ${version} from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(\n      `Failed to download Obsidian installer ${version}: HTTP ${String(response.status)} from ${url}. `\n        + 'Catalyst/beta versions have no public installer \u2014 pin an asar version on a public/installed shell instead.'\n    );\n  }\n  writeFileSync(dest, Buffer.from(await response.arrayBuffer()));\n}\n\n/**\n * Extracts a Linux `.tar.gz` portable build.\n *\n * @param assetPath - Path to the downloaded `.tar.gz`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractLinuxShell(assetPath: string, shellDir: string): void {\n  run('tar', ['xzf', assetPath, '-C', shellDir, '--strip-components=1']);\n}\n\n/**\n * Extracts a macOS `.dmg` by mounting it and copying the app bundle.\n *\n * @param assetPath - Path to the downloaded `.dmg`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractMacShell(assetPath: string, shellDir: string): void {\n  const mountPoint = join(shellDir, '__mnt');\n  mkdirSync(mountPoint, { recursive: true });\n  run('hdiutil', ['attach', '-nobrowse', '-mountpoint', mountPoint, assetPath]);\n  try {\n    run('cp', ['-R', join(mountPoint, 'Obsidian.app'), shellDir]);\n  } finally {\n    run('hdiutil', ['detach', mountPoint]);\n  }\n  rmSync(mountPoint, { force: true, recursive: true });\n}\n\n/**\n * Extracts a downloaded installer asset into a shell directory, per platform.\n *\n * @param assetPath - The downloaded asset path.\n * @param shellDir - The destination shell directory.\n */\nfunction extractShell(assetPath: string, shellDir: string): void {\n  if (process.platform === 'win32') {\n    extractWindowsShell(assetPath, shellDir);\n    return;\n  }\n\n  if (process.platform === 'darwin') {\n    extractMacShell(assetPath, shellDir);\n    return;\n  }\n\n  extractLinuxShell(assetPath, shellDir);\n}\n\n/**\n * Extracts a Windows NSIS installer's inner app payload via 7-Zip.\n *\n * The `Obsidian-<v>.exe` NSIS installer contains `$PLUGINSDIR/app-64.7z`, which\n * holds the portable app (mirrors how the scoop manifest installs Obsidian).\n *\n * @param assetPath - Path to the downloaded `.exe`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractWindowsShell(assetPath: string, shellDir: string): void {\n  assertCommandAvailable('7z', 'Install 7-Zip (e.g. `scoop install 7zip`) to extract a pinned Obsidian installer.');\n  const nsisExtractDir = join(shellDir, '__nsis');\n  run('7z', ['x', '-y', `-o${nsisExtractDir}`, assetPath]);\n  const innerArchive = join(nsisExtractDir, '$PLUGINSDIR', 'app-64.7z');\n  run('7z', ['x', '-y', `-o${shellDir}`, innerArchive]);\n  rmSync(nsisExtractDir, { force: true, recursive: true });\n}\n\n/**\n * Returns the expected cached shell executable path for the current platform.\n *\n * @param shellDir - The shell cache directory for a version.\n * @returns The executable path.\n */\nfunction getCachedShellExePath(shellDir: string): string {\n  if (process.platform === 'win32') {\n    return join(shellDir, 'Obsidian.exe');\n  }\n\n  if (process.platform === 'darwin') {\n    return join(shellDir, 'Obsidian.app', 'Contents', 'MacOS', 'Obsidian');\n  }\n\n  return join(shellDir, 'obsidian');\n}\n\n/**\n * Returns the GitHub release asset name for the current platform.\n *\n * @param version - The release version.\n * @returns The asset file name.\n */\nfunction getInstallerAssetName(version: string): string {\n  if (process.platform === 'win32') {\n    return `Obsidian-${version}.exe`;\n  }\n\n  if (process.platform === 'darwin') {\n    return `Obsidian-${version}.dmg`;\n  }\n\n  return `obsidian-${version}.tar.gz`;\n}\n\n/**\n * Runs a command synchronously, throwing on a non-zero exit.\n *\n * @param command - The command.\n * @param args - The arguments.\n */\nfunction run(command: string, args: string[]): void {\n  const result = spawnSync(command, args, { stdio: 'ignore' });\n  if (result.status !== 0) {\n    throw new Error(`Command failed: ${command} ${args.map((arg) => basename(arg)).join(' ')} (exit ${String(result.status)})`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-installer.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Integration-time helpers for resolving the Obsidian **shell** (the Electron\n * runtime / installer build) to launch.\n *\n * By default the harness uses the installed shell. When a specific installer\n * version is requested, it downloads that version's GitHub release asset and\n * extracts a portable shell into a cache, returning the executable to launch.\n *\n * GitHub release assets exist for **public** releases only; catalyst (beta)\n * builds publish only the asar, so installer-pinning supports public versions.\n * The extracted shell's bundled `resources/obsidian.asar` is that version, so\n * pinning the installer is how you run a version **older** than the installed\n * shell (asar-swap is upgrade-only \u2014 see `obsidian-version-switch.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/extraction glue covered by integration tests, not unit tests. */\n\nimport {\n  execFileSync,\n  spawnSync\n} from 'node:child_process';\nimport {\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport {\n  basename,\n  dirname,\n  join\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  buildInstallerAssetNameCandidates,\n  selectInstallerAssetName\n} from './installer-asset.cjs';\nimport { log } from './log.cjs';\n\n/**\n * Browser User-Agent for downloading release assets (Cloudflare-gated).\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/** Base URL for `obsidian-releases` release assets (`.../download/v<ver>/<asset>`). */\nconst RELEASE_DOWNLOAD_BASE_URL = 'https://github.com/obsidianmd/obsidian-releases/releases/download';\n\n/** GitHub REST endpoint listing a release's assets by tag (`.../releases/tags/v<ver>`). */\nconst RELEASE_API_TAG_URL = 'https://api.github.com/repos/obsidianmd/obsidian-releases/releases/tags';\n\n/** The subset of the GitHub release API response this module reads. */\ninterface GitHubRelease {\n  /** The release's downloadable assets. */\n  readonly assets: readonly GitHubReleaseAsset[];\n}\n\n/** The subset of a GitHub release's asset object this module reads. */\ninterface GitHubReleaseAsset {\n  /** The asset file name, e.g. `Obsidian.0.14.5.exe`. */\n  readonly name: string;\n}\n\nconst CACHE_ROOT = join(tmpdir(), 'obsidian-integration-testing');\nconst SHELL_CACHE_DIR = join(CACHE_ROOT, 'shell-cache');\nconst MAC_PLIST_VERSION_PATTERN = /<key>CFBundleShortVersionString<\\/key>\\s*<string>(?<version>[^<]+)<\\/string>/;\n\n/**\n * A resolved Obsidian shell executable.\n */\nexport interface ResolvedShell {\n  /** Absolute path to the Obsidian executable to launch. */\n  readonly exePath: string;\n\n  /** The shell's version, or `undefined` if it could not be detected. */\n  readonly version: string | undefined;\n}\n\n/**\n * Detects the version of an installed Obsidian shell from its executable.\n *\n * - Windows: the executable's PE `FileVersion`.\n * - macOS: `CFBundleShortVersionString` from the app bundle's `Info.plist`.\n * - Linux: best-effort parse from the executable path (often `undefined`).\n *\n * @param exePath - Absolute path to the Obsidian executable.\n * @returns The `x.y.z` version, or `undefined` if it cannot be determined.\n */\nexport function detectInstalledShellVersion(exePath: string): string | undefined {\n  if (process.platform === 'win32') {\n    return detectWindowsFileVersion(exePath);\n  }\n\n  if (process.platform === 'darwin') {\n    return detectMacBundleVersion(exePath);\n  }\n\n  return detectVersionFromPath(exePath);\n}\n\n/**\n * Ensures a portable Obsidian shell for the given version is extracted into the\n * cache, downloading and extracting its GitHub release asset if necessary.\n *\n * @param version - A concrete public `x.y.z` version.\n * @returns The absolute path to the cached shell executable.\n * @throws Error if the asset cannot be downloaded or extracted.\n */\nexport async function ensureShellCached(version: string): Promise<string> {\n  const shellDir = getCachedShellDir(version);\n  const exePath = getCachedShellExePath(shellDir);\n  if (existsSync(exePath)) {\n    log(`[installer] Using cached shell for ${version}.`);\n    return exePath;\n  }\n\n  mkdirSync(shellDir, { recursive: true });\n  const assetUrls = await resolveInstallerAssetUrls(version);\n  const assetPath = await downloadInstallerAsset(assetUrls, shellDir, version);\n  extractShell(assetPath, shellDir);\n  rmSync(assetPath, { force: true });\n\n  if (!existsSync(exePath)) {\n    throw new Error(`Extracted Obsidian shell ${version} but executable not found at ${exePath}.`);\n  }\n  log(`[installer] Extracted shell ${version} -> ${exePath}`);\n  return exePath;\n}\n\n/**\n * Returns the cache directory a version's extracted shell lives in (the\n * directory may not yet exist).\n *\n * @param version - A concrete public `x.y.z` version.\n * @returns The absolute shell cache directory for the version.\n */\nexport function getCachedShellDir(version: string): string {\n  return join(SHELL_CACHE_DIR, version);\n}\n\n/**\n * Throws a descriptive error if a required command is not on `PATH`.\n *\n * @param command - The command name.\n * @param hint - Actionable guidance appended to the error.\n */\nfunction assertCommandAvailable(command: string, hint: string): void {\n  const probe = process.platform === 'win32' ? 'where.exe' : 'which';\n  const result = spawnSync(probe, [command], { stdio: 'ignore' });\n  if (result.status !== 0) {\n    throw new Error(`Required command \"${command}\" was not found on PATH. ${hint}`);\n  }\n}\n\n/**\n * Reads `CFBundleShortVersionString` from a macOS app bundle's `Info.plist`.\n *\n * @param exePath - Path to `.../Obsidian.app/Contents/MacOS/Obsidian`.\n * @returns The `x.y.z` version, or `undefined`.\n */\nfunction detectMacBundleVersion(exePath: string): string | undefined {\n  try {\n    const contentsDir = dirname(dirname(exePath));\n    const plist = readFileSync(join(contentsDir, 'Info.plist'), 'utf-8');\n    const match = MAC_PLIST_VERSION_PATTERN.exec(plist);\n    return match?.groups?.['version'];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Best-effort parse of an `x.y.z` version embedded in a path.\n *\n * @param value - The path or string to scan.\n * @returns The first `x.y.z` match, or `undefined`.\n */\nfunction detectVersionFromPath(value: string): string | undefined {\n  const match = /(?<version>\\d+\\.\\d+\\.\\d+)/.exec(value);\n  return match?.groups?.['version'];\n}\n\n/**\n * Reads the PE `FileVersion` of a Windows executable via PowerShell.\n *\n * @param exePath - Absolute path to the executable.\n * @returns The `x.y.z` version, or `undefined`.\n */\nfunction detectWindowsFileVersion(exePath: string): string | undefined {\n  try {\n    const output = execFileSync(\n      'powershell',\n      ['-NoProfile', '-Command', `(Get-Item -LiteralPath ${JSON.stringify(exePath)}).VersionInfo.FileVersion`],\n      { encoding: 'utf-8' }\n    );\n    const version = output.trim();\n    return version.length > 0 ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Downloads a single release asset for a version to a destination file.\n *\n * @param url - The asset download URL.\n * @param dest - Destination file path.\n * @throws Error if the request fails.\n */\nasync function downloadAsset(url: string, dest: string): Promise<void> {\n  log(`[installer] Downloading installer 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  writeFileSync(dest, Buffer.from(await response.arrayBuffer()));\n}\n\n/**\n * Downloads the first reachable installer asset from an ordered list of\n * candidate URLs, returning the path it was saved to.\n *\n * @param urls - Candidate asset URLs, in priority order.\n * @param shellDir - The destination shell directory.\n * @param version - The release version (for error messages).\n * @returns The downloaded asset's path.\n * @throws Error if none of the candidates can be downloaded.\n */\nasync function downloadInstallerAsset(urls: string[], shellDir: string, version: string): Promise<string> {\n  const errors: string[] = [];\n  for (const url of urls) {\n    const assetPath = join(shellDir, basename(url));\n    try {\n      await downloadAsset(url, assetPath);\n      return assetPath;\n    } catch (error) {\n      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  throw new Error(\n    `Failed to download Obsidian installer ${version}. Attempts: ${errors.join('; ')}. `\n      + 'Catalyst/beta versions have no public installer \u2014 pin an asar version on a public/installed shell instead.'\n  );\n}\n\n/**\n * Extracts a Linux `.tar.gz` portable build.\n *\n * @param assetPath - Path to the downloaded `.tar.gz`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractLinuxShell(assetPath: string, shellDir: string): void {\n  run('tar', ['xzf', assetPath, '-C', shellDir, '--strip-components=1']);\n}\n\n/**\n * Extracts a macOS `.dmg` by mounting it and copying the app bundle.\n *\n * @param assetPath - Path to the downloaded `.dmg`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractMacShell(assetPath: string, shellDir: string): void {\n  const mountPoint = join(shellDir, '__mnt');\n  mkdirSync(mountPoint, { recursive: true });\n  run('hdiutil', ['attach', '-nobrowse', '-mountpoint', mountPoint, assetPath]);\n  try {\n    run('cp', ['-R', join(mountPoint, 'Obsidian.app'), shellDir]);\n  } finally {\n    run('hdiutil', ['detach', mountPoint]);\n  }\n  rmSync(mountPoint, { force: true, recursive: true });\n}\n\n/**\n * Extracts a downloaded installer asset into a shell directory, per platform.\n *\n * @param assetPath - The downloaded asset path.\n * @param shellDir - The destination shell directory.\n */\nfunction extractShell(assetPath: string, shellDir: string): void {\n  if (process.platform === 'win32') {\n    extractWindowsShell(assetPath, shellDir);\n    return;\n  }\n\n  if (process.platform === 'darwin') {\n    extractMacShell(assetPath, shellDir);\n    return;\n  }\n\n  extractLinuxShell(assetPath, shellDir);\n}\n\n/**\n * Extracts a Windows NSIS installer's inner app payload via 7-Zip.\n *\n * The NSIS installer `.exe` contains `$PLUGINSDIR/app-64.7z`, which holds the\n * portable app (mirrors how the scoop manifest installs Obsidian).\n *\n * @param assetPath - Path to the downloaded `.exe`.\n * @param shellDir - Destination shell directory.\n */\nfunction extractWindowsShell(assetPath: string, shellDir: string): void {\n  assertCommandAvailable('7z', 'Install 7-Zip (e.g. `scoop install 7zip`) to extract a pinned Obsidian installer.');\n  const nsisExtractDir = join(shellDir, '__nsis');\n  run('7z', ['x', '-y', `-o${nsisExtractDir}`, assetPath]);\n  const innerArchive = join(nsisExtractDir, '$PLUGINSDIR', 'app-64.7z');\n  run('7z', ['x', '-y', `-o${shellDir}`, innerArchive]);\n  rmSync(nsisExtractDir, { force: true, recursive: true });\n}\n\n/**\n * Fetches a release's asset names from the GitHub API.\n *\n * @param version - The release version (tag `v<version>`).\n * @returns The asset names, or `undefined` if the API is unavailable.\n */\nasync function fetchReleaseAssetNames(version: string): Promise<string[] | undefined> {\n  try {\n    const response = await fetch(`${RELEASE_API_TAG_URL}/v${version}`, {\n      headers: { 'Accept': 'application/vnd.github+json', 'User-Agent': DOWNLOAD_USER_AGENT }\n    });\n    if (!response.ok) {\n      log(`[installer] Release API for ${version} returned HTTP ${String(response.status)}; falling back to templated asset names.`);\n      return undefined;\n    }\n    const release = await response.json() as GitHubRelease;\n    return release.assets.map((asset) => asset.name);\n  } catch (error) {\n    log(`[installer] Release API for ${version} unavailable (${error instanceof Error ? error.message : String(error)}); falling back to templated asset names.`);\n    return undefined;\n  }\n}\n\n/**\n * Returns the expected cached shell executable path for the current platform.\n *\n * @param shellDir - The shell cache directory for a version.\n * @returns The executable path.\n */\nfunction getCachedShellExePath(shellDir: string): string {\n  if (process.platform === 'win32') {\n    return join(shellDir, 'Obsidian.exe');\n  }\n\n  if (process.platform === 'darwin') {\n    return join(shellDir, 'Obsidian.app', 'Contents', 'MacOS', 'Obsidian');\n  }\n\n  return join(shellDir, 'obsidian');\n}\n\n/**\n * Resolves the ordered installer asset download URLs to try for a version.\n *\n * The release's real asset list is queried first so the platform-correct asset\n * is picked regardless of the historical dot-vs-hyphen naming; if that call is\n * unavailable it falls back to trying both templated separator forms.\n *\n * @param version - The concrete `x.y.z` version.\n * @returns Candidate asset URLs, in priority order.\n */\nasync function resolveInstallerAssetUrls(version: string): Promise<string[]> {\n  const assetNames = await fetchReleaseAssetNames(version);\n  if (assetNames) {\n    const selected = selectInstallerAssetName({ assetNames, platform: process.platform, version });\n    if (selected !== undefined) {\n      return [`${RELEASE_DOWNLOAD_BASE_URL}/v${version}/${selected}`];\n    }\n    log(`[installer] No installer asset matched for ${version}; falling back to templated asset names.`);\n  }\n\n  return buildInstallerAssetNameCandidates({ platform: process.platform, version })\n    .map((name) => `${RELEASE_DOWNLOAD_BASE_URL}/v${version}/${name}`);\n}\n\n/**\n * Runs a command synchronously, throwing on a non-zero exit.\n *\n * @param command - The command.\n * @param args - The arguments.\n */\nfunction run(command: string, args: string[]): void {\n  const result = spawnSync(command, args, { stdio: 'ignore' });\n  if (result.status !== 0) {\n    throw new Error(`Command failed: ${command} ${args.map((arg) => basename(arg)).join(' ')} (exit ${String(result.status)})`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}


package/dist/lib/cjs/renderer-boot-detection.cjs

@@ -0,0 +1,49 @@
+"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 renderer_boot_detection_exports = {};
+__export(renderer_boot_detection_exports, {
+  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS: () => DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
+  checkRendererBootState: () => checkRendererBootState,
+  resolveDeadBootGraceInMilliseconds: () => resolveDeadBootGraceInMilliseconds
+});
+module.exports = __toCommonJS(renderer_boot_detection_exports);
+const DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS = 1e4;
+function checkRendererBootState(params) {
+  const { bodyChildElementCount, hasGraceElapsed, hasWindowApp, isDocumentComplete } = params;
+  if (hasWindowApp) {
+    return "pending";
+  }
+  if (!hasGraceElapsed) {
+    return "pending";
+  }
+  if (isDocumentComplete && bodyChildElementCount === 0) {
+    return "dead";
+  }
+  return "pending";
+}
+function resolveDeadBootGraceInMilliseconds(options) {
+  return options?.deadBootGraceInMilliseconds ?? DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS,
+  checkRendererBootState,
+  resolveDeadBootGraceInMilliseconds
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3JlbmRlcmVyLWJvb3QtZGV0ZWN0aW9uLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUHVyZSBkZXRlY3Rpb24gb2YgYSB0ZXJtaW5hbCBcImRlYWQgYm9vdFwiIG9mIHRoZSBvd25lZCBPYnNpZGlhbiByZW5kZXJlciwgcGx1c1xuICogcmVzb2x2aW5nIHRoZSBmYXN0LWZhaWwgZ3JhY2Ugd2luZG93IGZyb20gdGhlIHRyYW5zcG9ydCBvcHRpb25zLiBLZXB0IHNlcGFyYXRlXG4gKiBmcm9tIHRoZSBpbnRlZ3JhdGlvbi1vbmx5IGB0cmFuc3BvcnQtZGVza3RvcC1jZHBgICh3aGljaCBkcml2ZXMgcmVhbCBDRFAgYW5kIGlzXG4gKiBleGNsdWRlZCBmcm9tIHVuaXQgdGVzdHMpIHNvIHRoZSB2ZXJkaWN0IGxvZ2ljIGFuZCBkZWZhdWx0IHJlc29sdXRpb24gc3RheVxuICogdW5pdC10ZXN0YWJsZS5cbiAqXG4gKiBXaGVuIGFuIE9ic2lkaWFuIGFzYXIgY2Fubm90IHJ1biBvbiB0aGUgbGF1bmNoZWQgRWxlY3Ryb24gc2hlbGwgKHRoZSBpbnN0YWxsZXJcbiAqIHZlcnNpb24gaXMgdG9vIG9sZCBmb3IgdGhhdCBhcHAgdmVyc2lvbiksIHRoZSByZW5kZXJlciBsb2FkcyBgaW5kZXguaHRtbGBcbiAqIChgZG9jdW1lbnQucmVhZHlTdGF0ZWAgcmVhY2hlcyBgJ2NvbXBsZXRlJ2ApIGJ1dCB0aGUgYXBwIG5ldmVyIGJvb3RzdHJhcHM6XG4gKiBgZG9jdW1lbnQuYm9keWAgc3RheXMgZW1wdHkgYW5kIGB3aW5kb3cuYXBwYCByZW1haW5zIGB1bmRlZmluZWRgIFx1MjAxNCB2aXN1YWxseSBhXG4gKiBibGFjayBzY3JlZW4uIFRoZSBvd25lZC12YXVsdCByZWFkaW5lc3MgcG9sbCBjYW5ub3QgdGVsbCB0aGlzIHRlcm1pbmFsIHN0YXRlXG4gKiBhcGFydCBmcm9tIFwic3RpbGwgbG9hZGluZ1wiLCBzbyB3aXRob3V0IGEgZGV0ZWN0b3IgaXQgd2FpdHMgb3V0IHRoZSB3aG9sZVxuICogcmVhZGluZXNzIHRpbWVvdXQgYmVmb3JlIGZhaWxpbmcuIFRoaXMgbW9kdWxlIGVuY29kZXMgdGhlIHNpZ25hbCB0aGF0XG4gKiBkaXN0aW5ndWlzaGVzIHRoZSB0d286IG9uY2UgdGhlIHJlbmRlcmVyIGhhcyBiZWVuIGBjb21wbGV0ZWAgZm9yIGEgc2hvcnQgZ3JhY2VcbiAqIHdpbmRvdyB3aXRoIG5vIGB3aW5kb3cuYXBwYCBhbmQgYW4gZW1wdHkgYDxib2R5PmAsIGl0IGlzIGRlYWQsIG5vdCBzbG93LlxuICovXG5cbmltcG9ydCB0eXBlIHsgT2JzaWRpYW5DZHBUcmFuc3BvcnRPcHRpb25zIH0gZnJvbSAnLi90cmFuc3BvcnQtb3B0aW9ucy5janMnO1xuXG4vKipcbiAqIERlZmF1bHQgZm9yIHtAbGluayBPYnNpZGlhbkNkcFRyYW5zcG9ydE9wdGlvbnMuZGVhZEJvb3RHcmFjZUluTWlsbGlzZWNvbmRzfS5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfREVBRF9CT09UX0dSQUNFX0lOX01JTExJU0VDT05EUyA9IDEwMDAwO1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHtAbGluayBjaGVja1JlbmRlcmVyQm9vdFN0YXRlfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDaGVja1JlbmRlcmVyQm9vdFN0YXRlUGFyYW1zIGV4dGVuZHMgUmVuZGVyZXJCb290T2JzZXJ2YXRpb24ge1xuICAvKipcbiAgICogV2hldGhlciB0aGUgYm9vdHN0cmFwIGdyYWNlIHdpbmRvdyBoYXMgZWxhcHNlZCBzaW5jZSB0aGUgcmVuZGVyZXIgZmlyc3RcbiAgICogcmVhY2hlZCBgZG9jdW1lbnQucmVhZHlTdGF0ZWAgYCdjb21wbGV0ZSdgLiBUaGUgYCdkZWFkJ2AgdmVyZGljdCBpcyB3aXRoaGVsZFxuICAgKiB1bnRpbCB0aGlzIGlzIGB0cnVlYCBzbyBhIGdlbnVpbmVseSBzbG93IGJvb3QgaXMgbmV2ZXIgbWlzanVkZ2VkLlxuICAgKi9cbiAgcmVhZG9ubHkgaGFzR3JhY2VFbGFwc2VkOiBib29sZWFuO1xufVxuXG4vKipcbiAqIEEgc2FtcGxlIG9mIHRoZSBvd25lZCByZW5kZXJlcidzIGJvb3RzdHJhcCBzdGF0ZSwgdGFrZW4gZnJvbSB0aGUgdmF1bHQgcGFnZVxuICogdGFyZ2V0IHZpYSBhIHNpbmdsZSBDRFAgZXZhbHVhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZW5kZXJlckJvb3RPYnNlcnZhdGlvbiB7XG4gIC8qKlxuICAgKiBgZG9jdW1lbnQuYm9keS5jaGlsZEVsZW1lbnRDb3VudGAgaW4gdGhlIHZhdWx0IHJlbmRlcmVyIChgMGAgd2hlbiBgYm9keWAgaXNcbiAgICogYWJzZW50KS4gQSBkZWFkIGJvb3QgbGVhdmVzIHRoZSBib2R5IGVtcHR5OyBhIHNsb3ctYnV0LXZhbGlkIGJvb3QgcmVuZGVycyBhdFxuICAgKiBsZWFzdCBhIGxvYWRpbmcgc2hlbGwuXG4gICAqL1xuICByZWFkb25seSBib2R5Q2hpbGRFbGVtZW50Q291bnQ6IG51bWJlcjtcblxuICAvKiogV2hldGhlciBgd2luZG93LmFwcGAgaXMgZGVmaW5lZCBpbiB0aGUgdmF1bHQgcmVuZGVyZXIuICovXG4gIHJlYWRvbmx5IGhhc1dpbmRvd0FwcDogYm9vbGVhbjtcblxuICAvKiogV2hldGhlciB0aGUgdmF1bHQgcmVuZGVyZXIncyBgZG9jdW1lbnQucmVhZHlTdGF0ZWAgaXMgYCdjb21wbGV0ZSdgLiAqL1xuICByZWFkb25seSBpc0RvY3VtZW50Q29tcGxldGU6IGJvb2xlYW47XG59XG5cbi8qKlxuICogVmVyZGljdCBmcm9tIHtAbGluayBjaGVja1JlbmRlcmVyQm9vdFN0YXRlfTogYCdkZWFkJ2Agd2hlbiB0aGUgcmVuZGVyZXIgaGFzXG4gKiB0ZXJtaW5hbGx5IGZhaWxlZCB0byBpbml0aWFsaXplLCBgJ3BlbmRpbmcnYCB3aGVuIGl0IG1heSBzdGlsbCBiZSBib290aW5nLlxuICovXG5leHBvcnQgdHlwZSBSZW5kZXJlckJvb3RWZXJkaWN0ID0gJ2RlYWQnIHwgJ3BlbmRpbmcnO1xuXG4vKipcbiAqIERlY2lkZXMgd2hldGhlciB0aGUgb3duZWQgcmVuZGVyZXIgaGFzIHRlcm1pbmFsbHkgZmFpbGVkIHRvIGluaXRpYWxpemUuXG4gKlxuICogVGhlIHZlcmRpY3QgaXMgYCdkZWFkJ2Agb25seSB3aGVuIGFsbCBvZiB0aGUgZm9sbG93aW5nIGhvbGQ6IHRoZSBncmFjZSB3aW5kb3dcbiAqIGhhcyBlbGFwc2VkLCBgd2luZG93LmFwcGAgaXMgc3RpbGwgdW5kZWZpbmVkLCB0aGUgZG9jdW1lbnQgaXMgYCdjb21wbGV0ZSdgLFxuICogYW5kIGA8Ym9keT5gIGlzIGVtcHR5LiBUaGlzIGlzIGV4YWN0bHkgdGhlIG9ic2VydmVkIGluY29tcGF0aWJsZS1zaGVsbCBzdGF0ZVxuICogKGFuIGFzYXIgdGhhdCBjYW5ub3QgcnVuIG9uIHRoZSBsYXVuY2hlZCBFbGVjdHJvbiksIGFuZCBpdCBjYW5ub3QgYmUgcmVhY2hlZFxuICogYnkgYSBoZWFsdGh5IGJvb3QgXHUyMDE0IGB3aW5kb3cuYXBwYCBpcyBkZWZpbmVkIGVhcmx5LCBhbmQgYSBzbG93IGJvb3QgcmVuZGVycyBhXG4gKiBub24tZW1wdHkgbG9hZGluZyBzaGVsbCBcdTIwMTQgc28gdGhlcmUgaXMgbm8gZmFsc2UtcG9zaXRpdmUgcGF0aCBvbiBhIHZhbGlkIGJvb3QuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBzYW1wbGVkIG9ic2VydmF0aW9uIHBsdXMgd2hldGhlciB0aGUgZ3JhY2UgaGFzIGVsYXBzZWQuXG4gKiBAcmV0dXJucyBgJ2RlYWQnYCB3aGVuIHRoZSByZW5kZXJlciBpcyB0ZXJtaW5hbGx5IGRlYWQsIG90aGVyd2lzZSBgJ3BlbmRpbmcnYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNoZWNrUmVuZGVyZXJCb290U3RhdGUocGFyYW1zOiBDaGVja1JlbmRlcmVyQm9vdFN0YXRlUGFyYW1zKTogUmVuZGVyZXJCb290VmVyZGljdCB7XG4gIGNvbnN0IHsgYm9keUNoaWxkRWxlbWVudENvdW50LCBoYXNHcmFjZUVsYXBzZWQsIGhhc1dpbmRvd0FwcCwgaXNEb2N1bWVudENvbXBsZXRlIH0gPSBwYXJhbXM7XG5cbiAgaWYgKGhhc1dpbmRvd0FwcCkge1xuICAgIHJldHVybiAncGVuZGluZyc7XG4gIH1cblxuICBpZiAoIWhhc0dyYWNlRWxhcHNlZCkge1xuICAgIHJldHVybiAncGVuZGluZyc7XG4gIH1cblxuICBpZiAoaXNEb2N1bWVudENvbXBsZXRlICYmIGJvZHlDaGlsZEVsZW1lbnRDb3VudCA9PT0gMCkge1xuICAgIHJldHVybiAnZGVhZCc7XG4gIH1cblxuICByZXR1cm4gJ3BlbmRpbmcnO1xufVxuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBkZWFkLWJvb3QgZmFzdC1mYWlsIGdyYWNlIHdpbmRvdywgYXBwbHlpbmcgdGhlIGRlZmF1bHQgd2hlbiB0aGVcbiAqIG9wdGlvbiBpcyBvbWl0dGVkLlxuICpcbiAqIFRoaXMgYm91bmRzIGhvdyBsb25nIHRoZSBvd25lZC12YXVsdCByZWFkaW5lc3MgcG9sbCB3YWl0cyBcdTIwMTQgYWZ0ZXIgdGhlIHJlbmRlcmVyXG4gKiBmaXJzdCByZWFjaGVzIGBkb2N1bWVudC5yZWFkeVN0YXRlYCBgJ2NvbXBsZXRlJ2AgXHUyMDE0IGJlZm9yZSBjb25jbHVkaW5nIHRoZSBib290XG4gKiBpcyBkZWFkIChzZWUge0BsaW5rIGNoZWNrUmVuZGVyZXJCb290U3RhdGV9KS4gQSB2YWx1ZSBvZiBgMGAgZGlzYWJsZXMgZmFzdC1mYWlsXG4gKiBlbnRpcmVseSwgcmVzdG9yaW5nIHRoZSBwbGFpbiB3YWl0LW91dC10aGUtcmVhZGluZXNzLXRpbWVvdXQgYmVoYXZpb3IuXG4gKlxuICogQHBhcmFtIG9wdGlvbnMgLSBUaGUgZGVza3RvcCBDRFAgdHJhbnNwb3J0IG9wdGlvbnMgKG9yIHRoZSByZWxldmFudCBzbGljZSkuXG4gKiBAcmV0dXJucyBUaGUgZ3JhY2Ugd2luZG93IGluIG1pbGxpc2Vjb25kcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVEZWFkQm9vdEdyYWNlSW5NaWxsaXNlY29uZHMoXG4gIG9wdGlvbnM/OiBQaWNrPE9ic2lkaWFuQ2RwVHJhbnNwb3J0T3B0aW9ucywgJ2RlYWRCb290R3JhY2VJbk1pbGxpc2Vjb25kcyc+XG4pOiBudW1iZXIge1xuICByZXR1cm4gb3B0aW9ucz8uZGVhZEJvb3RHcmFjZUluTWlsbGlzZWNvbmRzID8/IERFRkFVTFRfREVBRF9CT09UX0dSQUNFX0lOX01JTExJU0VDT05EUztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBeUJPLE1BQU0sMENBQTBDO0FBb0RoRCxTQUFTLHVCQUF1QixRQUEyRDtBQUNoRyxRQUFNLEVBQUUsdUJBQXVCLGlCQUFpQixjQUFjLG1CQUFtQixJQUFJO0FBRXJGLE1BQUksY0FBYztBQUNoQixXQUFPO0FBQUEsRUFDVDtBQUVBLE1BQUksQ0FBQyxpQkFBaUI7QUFDcEIsV0FBTztBQUFBLEVBQ1Q7QUFFQSxNQUFJLHNCQUFzQiwwQkFBMEIsR0FBRztBQUNyRCxXQUFPO0FBQUEsRUFDVDtBQUVBLFNBQU87QUFDVDtBQWNPLFNBQVMsbUNBQ2QsU0FDUTtBQUNSLFNBQU8sU0FBUywrQkFBK0I7QUFDakQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/renderer-boot-detection.d.cts

@@ -0,0 +1,83 @@
+/**
+ * @file
+ *
+ * Pure detection of a terminal "dead boot" of the owned Obsidian renderer, plus
+ * resolving the fast-fail grace window from the transport options. Kept separate
+ * from the integration-only `transport-desktop-cdp` (which drives real CDP and is
+ * excluded from unit tests) so the verdict logic and default resolution stay
+ * unit-testable.
+ *
+ * When an Obsidian asar cannot run on the launched Electron shell (the installer
+ * version is too old for that app version), the renderer loads `index.html`
+ * (`document.readyState` reaches `'complete'`) but the app never bootstraps:
+ * `document.body` stays empty and `window.app` remains `undefined` — visually a
+ * black screen. The owned-vault readiness poll cannot tell this terminal state
+ * apart from "still loading", so without a detector it waits out the whole
+ * readiness timeout before failing. This module encodes the signal that
+ * distinguishes the two: once the renderer has been `complete` for a short grace
+ * window with no `window.app` and an empty `<body>`, it is dead, not slow.
+ */
+import type { ObsidianCdpTransportOptions } from './transport-options.cjs';
+/**
+ * Default for {@link ObsidianCdpTransportOptions.deadBootGraceInMilliseconds}.
+ */
+export declare const DEFAULT_DEAD_BOOT_GRACE_IN_MILLISECONDS = 10000;
+/**
+ * Parameters for {@link checkRendererBootState}.
+ */
+export interface CheckRendererBootStateParams extends RendererBootObservation {
+    /**
+     * Whether the bootstrap grace window has elapsed since the renderer first
+     * reached `document.readyState` `'complete'`. The `'dead'` verdict is withheld
+     * until this is `true` so a genuinely slow boot is never misjudged.
+     */
+    readonly hasGraceElapsed: boolean;
+}
+/**
+ * A sample of the owned renderer's bootstrap state, taken from the vault page
+ * target via a single CDP evaluation.
+ */
+export interface RendererBootObservation {
+    /**
+     * `document.body.childElementCount` in the vault renderer (`0` when `body` is
+     * absent). A dead boot leaves the body empty; a slow-but-valid boot renders at
+     * least a loading shell.
+     */
+    readonly bodyChildElementCount: number;
+    /** Whether `window.app` is defined in the vault renderer. */
+    readonly hasWindowApp: boolean;
+    /** Whether the vault renderer's `document.readyState` is `'complete'`. */
+    readonly isDocumentComplete: boolean;
+}
+/**
+ * Verdict from {@link checkRendererBootState}: `'dead'` when the renderer has
+ * terminally failed to initialize, `'pending'` when it may still be booting.
+ */
+export type RendererBootVerdict = 'dead' | 'pending';
+/**
+ * Decides whether the owned renderer has terminally failed to initialize.
+ *
+ * The verdict is `'dead'` only when all of the following hold: the grace window
+ * has elapsed, `window.app` is still undefined, the document is `'complete'`,
+ * and `<body>` is empty. This is exactly the observed incompatible-shell state
+ * (an asar that cannot run on the launched Electron), and it cannot be reached
+ * by a healthy boot — `window.app` is defined early, and a slow boot renders a
+ * non-empty loading shell — so there is no false-positive path on a valid boot.
+ *
+ * @param params - The sampled observation plus whether the grace has elapsed.
+ * @returns `'dead'` when the renderer is terminally dead, otherwise `'pending'`.
+ */
+export declare function checkRendererBootState(params: CheckRendererBootStateParams): RendererBootVerdict;
+/**
+ * Resolves the dead-boot fast-fail grace window, applying the default when the
+ * option is omitted.
+ *
+ * This bounds how long the owned-vault readiness poll waits — after the renderer
+ * first reaches `document.readyState` `'complete'` — before concluding the boot
+ * is dead (see {@link checkRendererBootState}). A value of `0` disables fast-fail
+ * entirely, restoring the plain wait-out-the-readiness-timeout behavior.
+ *
+ * @param options - The desktop CDP transport options (or the relevant slice).
+ * @returns The grace window in milliseconds.
+ */
+export declare function resolveDeadBootGraceInMilliseconds(options?: Pick<ObsidianCdpTransportOptions, 'deadBootGraceInMilliseconds'>): number;

package/dist/lib/cjs/renderer-failed-to-initialize-error.cjs

@@ -0,0 +1,41 @@
+"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 renderer_failed_to_initialize_error_exports = {};
+__export(renderer_failed_to_initialize_error_exports, {
+  RendererFailedToInitializeError: () => RendererFailedToInitializeError
+});
+module.exports = __toCommonJS(renderer_failed_to_initialize_error_exports);
+class RendererFailedToInitializeError extends Error {
+  /**
+   * Creates the error for a specific vault.
+   *
+   * @param vaultPath - The vault whose owned renderer failed to initialize.
+   */
+  constructor(vaultPath) {
+    super(
+      `The Obsidian renderer for vault ${vaultPath} did not initialize on this Electron shell. The installer/Electron version is likely too old for this Obsidian app version. Pin a newer obsidianInstallerVersion, or align obsidianVersion with the installed shell.`
+    );
+    this.name = "RendererFailedToInitializeError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RendererFailedToInitializeError
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/renderer-failed-to-initialize-error.d.cts

@@ -0,0 +1,23 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when the owned Obsidian renderer terminally fails to
+ * initialize — the asar could not run on the launched Electron shell (the
+ * installer/Electron version is too old for the Obsidian app version). It is
+ * exported so callers of `connectToCdp` / the transport can `instanceof`-match
+ * this specific failure and distinguish it from a generic readiness timeout.
+ */
+/**
+ * Thrown when the owned Obsidian renderer loads but never bootstraps the app —
+ * an empty `<body>` with no `window.app` after the boot grace window (see
+ * `checkRendererBootState`). The usual cause is an installer/Electron shell too
+ * old for the pinned Obsidian app version.
+ */
+export declare class RendererFailedToInitializeError extends Error {
+    /**
+     * Creates the error for a specific vault.
+     *
+     * @param vaultPath - The vault whose owned renderer failed to initialize.
+     */
+    constructor(vaultPath: string);
+}