obsidian-integration-testing 11.0.0 → 12.1.0

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

@@ -20,9 +20,19 @@
  * 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.
+ * versions not yet collected (or that could not be booted).
+ *
+ * **These are the WINDOWS (`.exe`) values, and that matters.** A given Electron
+ * version does bundle the same Node / V8 / Chromium everywhere — but the Electron
+ * version itself is a property of the *installer*, not of the release, and two
+ * installers of the same Obsidian version can differ: `1.12.4` shipped Electron
+ * `39.6.0` in its `.exe` and `39.7.0` in every other installer, and `1.8.10`
+ * shipped `34.2.0` vs `34.5.2`. This field carries one flat value, measured on
+ * the `.exe` — the installer that, with the `.dmg`, is published for all 106
+ * installer-bearing releases. So a consumer pinning a macOS or Linux installer
+ * should treat `electron` as accurate to the patch only for the 104 releases
+ * where the platforms agree. The collection workflow boots all three platforms
+ * and reports any new divergence.
  *
  * The index signature carries every key `process.versions` exposes for that
  * Electron build — beyond the four well-known ones below, that typically includes
@@ -90,8 +100,9 @@ export interface ObsidianVersionChangelogUrls {
 }
 /**
  * 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`).
+ * from the `obsidianmd/obsidian-releases` release assets — plus, for catalyst
+ * builds, the `releases.obsidian.md` CDN, which publishes no listing and so is
+ * probed (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
@@ -156,7 +167,7 @@ export interface ObsidianVersionMetadata {
     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
+     * `obsidianmd/obsidian-releases` release assets. Absent for versions not present
      * in the catalog (the caller then falls back to hand-rolled resolution).
      */
     readonly downloads?: ObsidianVersionDownloads;

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

@@ -33,9 +33,9 @@ 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");
+var import_release_catalog = require("./release-catalog.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";
-const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
 const CACHE_ROOT = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "obsidian-integration-testing");
 const ASAR_CACHE_DIR = (0, import_node_path.join)(CACHE_ROOT, "asar-cache");
 const ASAR_FILE_PATTERN = /^obsidian-(?<version>\d+\.\d+\.\d+)\.asar$/;
@@ -119,7 +119,7 @@ function getAsarDownloadUrls(version) {
   const asarGzFileName = `${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
   const fallbackUrls = [
     `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,
-    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`
+    (0, import_release_catalog.buildCatalystAsarUrl)(version)
   ];
   const bakedUrl = (0, import_obsidian_metadata.getVersionMetadata)(version)?.downloads?.asar;
   return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;
@@ -133,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 directory.\n *\n * Obsidian's bootstrap loads the highest of (its shell's bundled\n * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the\n * user-data directory). So placing an asar here only takes effect when its version is\n * **>= the shell's bundled version** (upgrade-only \u2014 confirmed by the Phase 0\n * spike). Running an older version requires pinning the installer/shell instead\n * (see `obsidian-installer.ts`).\n */\n\n/* v8 ignore start -- Integration-time download/filesystem glue covered by integration tests, not unit tests. */\n\nimport {\n  copyFileSync,\n  existsSync,\n  mkdirSync,\n  readdirSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { gunzipSync } from 'node:zlib';\n\nimport type { DesktopReleasesManifest } from './obsidian-version.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  /**\n  Absolute path to the asar file.\n   */\n  readonly path: string;\n\n  /**\n  The `x.y.z` version parsed from the file name.\n   */\n  readonly version: string;\n}\n\n/**\n * Copies an asar file into a user-data directory under its canonical\n * `obsidian-<version>.asar` name.\n *\n * @param asarPath - Source asar path.\n * @param version - The asar's version (used for the destination file name).\n * @param userDataDirectory - Destination user-data directory.\n */\nexport function copyAsarIntoUserData(asarPath: string, version: string, userDataDirectory: string): void {\n  mkdirSync(userDataDirectory, { recursive: true });\n  const destination = join(userDataDirectory, getVersionAsarFileName(version));\n  copyFileSync(asarPath, destination);\n  log(`[version-switch] Provisioned ${getVersionAsarFileName(version)} into ${userDataDirectory}.`);\n}\n\n/**\n * Ensures the asar for a concrete version is present in the local cache,\n * downloading and decompressing it if necessary.\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path to the cached asar.\n * @throws Error if the download fails.\n */\nexport async function ensureAsarCached(version: string): Promise<string> {\n  mkdirSync(ASAR_CACHE_DIR, { recursive: true });\n  const cachedPath = getCachedAsarPath(version);\n  if (existsSync(cachedPath)) {\n    log(`[version-switch] Using cached asar for ${version}.`);\n    return cachedPath;\n  }\n\n  // A version's asar.gz lives on exactly one host depending on its channel\n  // (public \u2192 GitHub release assets, catalyst \u2192 the Obsidian CDN). The concrete\n  // Version alone does not tell us which, so try both and use the first that\n  // Returns a valid archive.\n  const errors: string[] = [];\n  for (const url of getAsarDownloadUrls(version)) {\n    try {\n      const asar = await downloadAndDecompressAsar(url);\n      writeFileSync(cachedPath, asar);\n      log(`[version-switch] Cached asar ${version} (${String(asar.length)} bytes) -> ${cachedPath}`);\n      return cachedPath;\n    } catch (error) {\n      errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  throw new Error(`Failed to download Obsidian asar ${version}. Attempts: ${errors.join('; ')}`);\n}\n\n/**\n * Fetches and parses Obsidian's desktop releases manifest.\n *\n * @returns The parsed manifest.\n * @throws Error if the manifest cannot be fetched.\n */\nexport async function fetchDesktopReleasesManifest(): Promise<DesktopReleasesManifest> {\n  const response = await fetch(DESKTOP_RELEASES_MANIFEST_URL);\n  if (!response.ok) {\n    throw new Error(`Failed to fetch desktop releases manifest: HTTP ${String(response.status)}`);\n  }\n  return await response.json() as DesktopReleasesManifest;\n}\n\n/**\n * Finds the newest `obsidian-<version>.asar` in a directory.\n *\n * @param directory - The directory to scan (e.g. the user's Obsidian config directory).\n * @returns The newest discovered asar, or `undefined` if none / the directory is unreadable.\n */\nexport function findNewestAsar(directory: string): DiscoveredAsar | undefined {\n  let entries: string[];\n  try {\n    entries = readdirSync(directory);\n  } catch {\n    return undefined;\n  }\n\n  let newest: DiscoveredAsar | undefined;\n  for (const entry of entries) {\n    const match = ASAR_FILE_PATTERN.exec(entry);\n    if (!match) {\n      continue;\n    }\n    const version = match.groups?.['version'] ?? '';\n    if (!newest || compareVersions(version, newest.version) > 0) {\n      newest = { path: join(directory, entry), version };\n    }\n  }\n  return newest;\n}\n\n/**\n * Returns the local cache path for a concrete version's asar (the file may not\n * yet exist).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The absolute path the asar is cached at.\n */\nexport function getCachedAsarPath(version: string): string {\n  return join(ASAR_CACHE_DIR, getVersionAsarFileName(version));\n}\n\n/**\n * Resolves a version specifier (explicit or channel alias) to a concrete\n * `x.y.z` version, fetching the manifest only when a channel alias is used.\n *\n * @param spec - The version specifier.\n * @returns The concrete version.\n */\nexport async function resolveConcreteVersion(spec: string): Promise<string> {\n  const parsed = parseVersionSpec(spec);\n  if (parsed.kind === 'explicit') {\n    return parsed.version;\n  }\n  const manifest = await fetchDesktopReleasesManifest();\n  return resolveVersionFromManifest(manifest, parsed.channel);\n}\n\n/**\n * Downloads a gzip-compressed asar from a URL and decompresses it.\n *\n * @param url - The `.asar.gz` URL.\n * @returns The decompressed asar bytes.\n * @throws Error if the request fails, the body is empty, or decompression fails.\n */\nasync function downloadAndDecompressAsar(url: string): Promise<Buffer> {\n  log(`[version-switch] Downloading asar from ${url} ...`);\n  const response = await fetch(url, { headers: { 'User-Agent': DOWNLOAD_USER_AGENT } });\n  if (!response.ok) {\n    throw new Error(`HTTP ${String(response.status)}`);\n  }\n\n  const gz = Buffer.from(await response.arrayBuffer());\n  if (gz.length === 0) {\n    throw new Error('empty response body');\n  }\n  return gunzipSync(gz);\n}\n\n/**\n * Returns the candidate `.asar.gz` download URLs for a concrete version.\n *\n * The version's exact URL baked into the `metadata.json` catalog (from upstream\n * `obsidian-versions.json`) is tried first when present; the hand-rolled public\n * (GitHub) and catalyst (CDN) guesses follow as a fallback for versions absent\n * from the catalog (or a stale catalog).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The URLs to try, in order.\n */\nfunction getAsarDownloadUrls(version: string): string[] {\n  const asarGzFileName = `${getVersionAsarFileName(version)}.gz`;\n  const fallbackUrls = [\n    `${PUBLIC_ASAR_RELEASE_BASE_URL}/v${version}/${asarGzFileName}`,\n    `${CATALYST_ASAR_RELEASE_BASE_URL}/${asarGzFileName}`\n  ];\n\n  const bakedUrl = getVersionMetadata(version)?.downloads?.asar;\n  return bakedUrl ? [bakedUrl, ...fallbackUrls] : fallbackUrls;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

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


package/dist/lib/cjs/open-obsidian-settings-tab.cjs

@@ -48,4 +48,4 @@ async function openObsidianSettingsTab(options) {
 0 && (module.exports = {
   openObsidianSettingsTab
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/open-obsidian-settings-tab.d.cts

@@ -33,8 +33,9 @@ export interface OpenObsidianSettingsTabOptions extends OpenSettingsTabParams {
  * actually rendered, resolving the transport and vault from the current test
  * context.
  *
- * See {@link Lib.openSettingsTab} for why simply calling `app.setting.open()`
- * renders nothing, and why the container must be attached **before** it.
+ * See {@link Lib.openSettingsTab} for why `app.setting.open()` can put the modal
+ * in a second Electron window, and why the container is attached **before** it on
+ * a vault that lacks the harness's `settingsPopoutWindow: false` default.
  *
  * Close it again from a callback with `app.setting.close()`; re-opening works,
  * because the attach is idempotent.

package/dist/lib/cjs/owned-instance-exit-marker.cjs

@@ -0,0 +1,99 @@
+"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_instance_exit_marker_exports = {};
+__export(owned_instance_exit_marker_exports, {
+  clearOwnedInstanceExitMarker: () => clearOwnedInstanceExitMarker,
+  readOwnedInstanceExitMarker: () => readOwnedInstanceExitMarker,
+  writeOwnedInstanceExitMarker: () => writeOwnedInstanceExitMarker
+});
+module.exports = __toCommonJS(owned_instance_exit_marker_exports);
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_log = require("./log.cjs");
+const MARKER_DIR_NAME = "obsidian-integration-testing";
+const MARKER_FILE_SUFFIX = ".owned-instance-exit.json";
+function clearOwnedInstanceExitMarker(port) {
+  try {
+    (0, import_node_fs.rmSync)(getMarkerFilePath(port), { force: true });
+  } catch (error) {
+    (0, import_log.log)(`[owned-instance-exit-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);
+  }
+}
+function readOwnedInstanceExitMarker(port) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs.readFileSync)(getMarkerFilePath(port), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  return parseMarker(parsed, port);
+}
+function writeOwnedInstanceExitMarker(params) {
+  const marker = {
+    code: params.code,
+    exitedAtInMilliseconds: Date.now(),
+    outputTail: params.outputTail,
+    pid: params.pid,
+    port: params.port,
+    signal: params.signal,
+    ...params.spawnError !== void 0 && { spawnError: params.spawnError }
+  };
+  try {
+    (0, import_node_fs.mkdirSync)(getMarkerDirectory(), { recursive: true });
+    (0, import_node_fs.writeFileSync)(getMarkerFilePath(marker.port), JSON.stringify(marker));
+  } catch (error) {
+    (0, import_log.log)(`[owned-instance-exit-marker] Could not record the exit on port ${String(marker.port)}: ${getErrorMessage(error)}`);
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getMarkerDirectory() {
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), MARKER_DIR_NAME);
+}
+function getMarkerFilePath(port) {
+  return (0, import_node_path.join)(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);
+}
+function parseMarker(parsed, port) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const { code, exitedAtInMilliseconds, outputTail, pid, port: markedPort, signal, spawnError } = record;
+  if (typeof exitedAtInMilliseconds !== "number" || markedPort !== port) {
+    return void 0;
+  }
+  return {
+    code: typeof code === "number" ? code : null,
+    exitedAtInMilliseconds,
+    outputTail: typeof outputTail === "string" ? outputTail : "",
+    pid: typeof pid === "number" ? pid : void 0,
+    port,
+    signal: typeof signal === "string" ? signal : null,
+    ...typeof spawnError === "string" && { spawnError }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearOwnedInstanceExitMarker,
+  readOwnedInstanceExitMarker,
+  writeOwnedInstanceExitMarker
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/owned-instance-exit-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records that the harness-owned Obsidian instance on a CDP port died, so a\n * process that did not spawn it can still say **why** it is unreachable.\n *\n * Only the process that launched the instance holds the child handle and sees\n * `exit`; the test workers get nothing but the port (see the repo's L9). So the\n * one fact worth having \u2014 the exit code \u2014 has to cross a process boundary, and\n * this is the channel: a small JSON sentinel next to the setup lock\n * (`setup-lock.ts`) and the Appium server marker (`appium-server-marker.ts`),\n * keyed by port.\n *\n * Written **only for a death the harness did not order.** A deliberate kill\n * (teardown, or the relaunch loop killing an instance before starting the next)\n * clears the marker instead, because a marker left behind by a clean run would\n * convict the next run's healthy instance of an exit that never happened.\n *\n * Reads are deliberately tolerant, exactly as the Appium marker's are: missing,\n * unreadable, or describing another port all read as \"no marker\", and the\n * caller falls back to saying only that the instance is gone.\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport { log } from './log.cjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.owned-instance-exit.json';\n\n/**\n * Records the death of the owned instance that was serving CDP on a port.\n */\nexport interface OwnedInstanceExitMarker {\n  /**\n  Exit code, or `null` when terminated by a signal or when it failed to spawn.\n   */\n  readonly code: null | number;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds).\n   */\n  readonly exitedAtInMilliseconds: number;\n\n  /**\n  The tail of everything the instance wrote to stdout/stderr (empty when it wrote nothing).\n   */\n  readonly outputTail: string;\n\n  /**\n  PID of the instance's process, or `undefined` when it never got one.\n   */\n  readonly pid: number | undefined;\n\n  /**\n  The CDP port the dead instance was serving.\n   */\n  readonly port: number;\n\n  /**\n  Terminating signal, or `null` when it exited normally or failed to spawn.\n   */\n  readonly signal: NodeJS.Signals | null;\n\n  /**\n  The spawn-failure message when the instance never started (e.g. `ENOENT`), otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Parameters for {@link writeOwnedInstanceExitMarker}.\n */\nexport interface WriteOwnedInstanceExitMarkerParams {\n  /**\n  Exit code, or `null` when terminated by a signal or when it failed to spawn.\n   */\n  readonly code: null | number;\n\n  /**\n  The tail of everything the instance wrote to stdout/stderr.\n   */\n  readonly outputTail: string;\n\n  /**\n  PID of the instance's process, or `undefined` when it never got one.\n   */\n  readonly pid: number | undefined;\n\n  /**\n  The CDP port the dead instance was serving.\n   */\n  readonly port: number;\n\n  /**\n  Terminating signal, or `null` when it exited normally or failed to spawn.\n   */\n  readonly signal: NodeJS.Signals | null;\n\n  /**\n  The spawn-failure message when the instance never started, otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Removes the marker for a port. Called when an instance is launched on it (a\n * recycled port must not inherit an older instance's death) and whenever the\n * harness kills an instance on purpose.\n *\n * @param port - The CDP port.\n */\nexport function clearOwnedInstanceExitMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[owned-instance-exit-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The CDP port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readOwnedInstanceExitMarker(port: number): OwnedInstanceExitMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records that the instance serving a port has died, stamping it with the\n * current time so a reader can report how long ago it happened.\n *\n * @param params - The dead instance's port, exit details, and output tail.\n */\nexport function writeOwnedInstanceExitMarker(params: WriteOwnedInstanceExitMarkerParams): void {\n  const marker: OwnedInstanceExitMarker = {\n    code: params.code,\n    exitedAtInMilliseconds: Date.now(),\n    outputTail: params.outputTail,\n    pid: params.pid,\n    port: params.port,\n    signal: params.signal,\n    ...(params.spawnError !== undefined && { spawnError: params.spawnError })\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(marker.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[owned-instance-exit-marker] Could not record the exit on port ${String(marker.port)}: ${getErrorMessage(error)}`);\n  }\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): OwnedInstanceExitMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { code, exitedAtInMilliseconds, outputTail, pid, port: markedPort, signal, spawnError } = record;\n\n  if (typeof exitedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return {\n    code: typeof code === 'number' ? code : null,\n    exitedAtInMilliseconds,\n    outputTail: typeof outputTail === 'string' ? outputTail : '',\n    pid: typeof pid === 'number' ? pid : undefined,\n    port,\n    signal: typeof signal === 'string' ? signal as NodeJS.Signals : null,\n    ...(typeof spawnError === 'string' && { spawnError })\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,qBAKO;AACP,qBAAuB;AACvB,uBAAqB;AAErB,iBAAoB;AAEpB,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAoFpB,SAAS,6BAA6B,MAAoB;AAC/D,MAAI;AACF,+BAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,wBAAI,qEAAqE,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;AAQO,SAAS,4BAA4B,MAAmD;AAC7F,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,UAAM,6BAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAQO,SAAS,6BAA6B,QAAkD;AAC7F,QAAM,SAAkC;AAAA,IACtC,MAAM,OAAO;AAAA,IACb,wBAAwB,KAAK,IAAI;AAAA,IACjC,YAAY,OAAO;AAAA,IACnB,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,GAAI,OAAO,eAAe,UAAa,EAAE,YAAY,OAAO,WAAW;AAAA,EACzE;AAEA,MAAI;AACF,kCAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,sCAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,wBAAI,kEAAkE,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACxH;AACF;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,aAAO,2BAAK,uBAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,aAAO,uBAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAAmD;AACvF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,MAAM,wBAAwB,YAAY,KAAK,MAAM,YAAY,QAAQ,WAAW,IAAI;AAEhG,MAAI,OAAO,2BAA2B,YAAY,eAAe,MAAM;AACrE,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,MAAM,OAAO,SAAS,WAAW,OAAO;AAAA,IACxC;AAAA,IACA,YAAY,OAAO,eAAe,WAAW,aAAa;AAAA,IAC1D,KAAK,OAAO,QAAQ,WAAW,MAAM;AAAA,IACrC;AAAA,IACA,QAAQ,OAAO,WAAW,WAAW,SAA2B;AAAA,IAChE,GAAI,OAAO,eAAe,YAAY,EAAE,WAAW;AAAA,EACrD;AACF;",
  "names": []
}


package/dist/lib/cjs/owned-instance-exit-marker.d.cts

@@ -0,0 +1,106 @@
+/**
+ * @file
+ *
+ * Records that the harness-owned Obsidian instance on a CDP port died, so a
+ * process that did not spawn it can still say **why** it is unreachable.
+ *
+ * Only the process that launched the instance holds the child handle and sees
+ * `exit`; the test workers get nothing but the port (see the repo's L9). So the
+ * one fact worth having — the exit code — has to cross a process boundary, and
+ * this is the channel: a small JSON sentinel next to the setup lock
+ * (`setup-lock.ts`) and the Appium server marker (`appium-server-marker.ts`),
+ * keyed by port.
+ *
+ * Written **only for a death the harness did not order.** A deliberate kill
+ * (teardown, or the relaunch loop killing an instance before starting the next)
+ * clears the marker instead, because a marker left behind by a clean run would
+ * convict the next run's healthy instance of an exit that never happened.
+ *
+ * Reads are deliberately tolerant, exactly as the Appium marker's are: missing,
+ * unreadable, or describing another port all read as "no marker", and the
+ * caller falls back to saying only that the instance is gone.
+ */
+/**
+ * Records the death of the owned instance that was serving CDP on a port.
+ */
+export interface OwnedInstanceExitMarker {
+    /**
+    Exit code, or `null` when terminated by a signal or when it failed to spawn.
+     */
+    readonly code: null | number;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds).
+     */
+    readonly exitedAtInMilliseconds: number;
+    /**
+    The tail of everything the instance wrote to stdout/stderr (empty when it wrote nothing).
+     */
+    readonly outputTail: string;
+    /**
+    PID of the instance's process, or `undefined` when it never got one.
+     */
+    readonly pid: number | undefined;
+    /**
+    The CDP port the dead instance was serving.
+     */
+    readonly port: number;
+    /**
+    Terminating signal, or `null` when it exited normally or failed to spawn.
+     */
+    readonly signal: NodeJS.Signals | null;
+    /**
+    The spawn-failure message when the instance never started (e.g. `ENOENT`), otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Parameters for {@link writeOwnedInstanceExitMarker}.
+ */
+export interface WriteOwnedInstanceExitMarkerParams {
+    /**
+    Exit code, or `null` when terminated by a signal or when it failed to spawn.
+     */
+    readonly code: null | number;
+    /**
+    The tail of everything the instance wrote to stdout/stderr.
+     */
+    readonly outputTail: string;
+    /**
+    PID of the instance's process, or `undefined` when it never got one.
+     */
+    readonly pid: number | undefined;
+    /**
+    The CDP port the dead instance was serving.
+     */
+    readonly port: number;
+    /**
+    Terminating signal, or `null` when it exited normally or failed to spawn.
+     */
+    readonly signal: NodeJS.Signals | null;
+    /**
+    The spawn-failure message when the instance never started, otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Removes the marker for a port. Called when an instance is launched on it (a
+ * recycled port must not inherit an older instance's death) and whenever the
+ * harness kills an instance on purpose.
+ *
+ * @param port - The CDP port.
+ */
+export declare function clearOwnedInstanceExitMarker(port: number): void;
+/**
+ * Reads the marker for a port.
+ *
+ * @param port - The CDP port.
+ * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.
+ */
+export declare function readOwnedInstanceExitMarker(port: number): OwnedInstanceExitMarker | undefined;
+/**
+ * Records that the instance serving a port has died, stamping it with the
+ * current time so a reader can report how long ago it happened.
+ *
+ * @param params - The dead instance's port, exit details, and output tail.
+ */
+export declare function writeOwnedInstanceExitMarker(params: WriteOwnedInstanceExitMarkerParams): void;

package/dist/lib/cjs/owned-instance-exited-error.cjs

@@ -0,0 +1,106 @@
+"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_instance_exited_error_exports = {};
+__export(owned_instance_exited_error_exports, {
+  OwnedInstanceExitedError: () => OwnedInstanceExitedError,
+  buildOwnedInstanceExitedErrorFromMarker: () => buildOwnedInstanceExitedErrorFromMarker
+});
+module.exports = __toCommonJS(owned_instance_exited_error_exports);
+var import_process_exit_message = require("./process-exit-message.cjs");
+const MILLISECONDS_PER_SECOND = 1e3;
+class OwnedInstanceExitedError extends Error {
+  /**
+  The CDP URL the dead instance was serving.
+   */
+  cdpUrl;
+  /**
+  Exit code, when known.
+   */
+  code;
+  /**
+  When the instance exited (`Date.now()` epoch milliseconds), when known.
+   */
+  exitedAtInMilliseconds;
+  /**
+  Terminating signal, when known.
+   */
+  signal;
+  /**
+   * Creates the error from whatever is known about the instance's death.
+   *
+   * @param params - The CDP URL, and the exit details when they are available.
+   */
+  constructor(params) {
+    super(buildMessage(params));
+    this.name = "OwnedInstanceExitedError";
+    this.cdpUrl = params.cdpUrl;
+    this.code = params.code;
+    this.exitedAtInMilliseconds = params.exitedAtInMilliseconds;
+    this.signal = params.signal;
+  }
+}
+function buildOwnedInstanceExitedErrorFromMarker(cdpUrl, marker) {
+  if (!marker) {
+    return new OwnedInstanceExitedError({ cdpUrl });
+  }
+  return new OwnedInstanceExitedError({
+    cdpUrl,
+    code: marker.code,
+    exitedAtInMilliseconds: marker.exitedAtInMilliseconds,
+    outputTail: marker.outputTail,
+    pid: marker.pid,
+    signal: marker.signal,
+    spawnError: marker.spawnError
+  });
+}
+function buildMessage(params) {
+  const message = `The harness-owned Obsidian instance at ${params.cdpUrl} is gone: ${describeExit(params)}. Whatever ran after it had no app to talk to, so these failures are not test results \u2014 look for the \`!!! OWNED OBSIDIAN EXITED\` line in the run log for the moment it happened.`;
+  return (0, import_process_exit_message.appendProcessOutputTail)(message, { output: params.outputTail ?? "", outputLabel: "Obsidian output" });
+}
+function describeExit(params) {
+  if (params.spawnError !== void 0) {
+    return `it failed to start (${params.spawnError})`;
+  }
+  if (params.code === void 0 && params.signal === void 0) {
+    return "it exited at some point during this run, and the harness recorded nothing about how (the run that owns it logs the exit code; a worker sees only what the exit marker preserved)";
+  }
+  return `${describeProcess(params)} ${describeReason(params)}${describeWhen(params.exitedAtInMilliseconds)}`;
+}
+function describeProcess(params) {
+  return params.pid === void 0 ? "it" : `its process (pid ${String(params.pid)})`;
+}
+function describeReason(params) {
+  if (params.signal !== void 0 && params.signal !== null) {
+    return `was terminated by signal ${params.signal}`;
+  }
+  return params.code === void 0 || params.code === null ? "exited with no exit code" : `exited with code ${String(params.code)}`;
+}
+function describeWhen(exitedAtInMilliseconds) {
+  if (exitedAtInMilliseconds === void 0) {
+    return "";
+  }
+  const elapsedInSeconds = Math.max(0, Math.round((Date.now() - exitedAtInMilliseconds) / MILLISECONDS_PER_SECOND));
+  return ` ${String(elapsedInSeconds)}s ago, at ${new Date(exitedAtInMilliseconds).toISOString()}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OwnedInstanceExitedError,
+  buildOwnedInstanceExitedErrorFromMarker
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/owned-instance-exited-error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The distinct error thrown when the harness-owned Obsidian instance is gone \u2014\n * it exited, and the CDP endpoint it was serving answers nothing.\n *\n * It exists to replace an anonymous cascade with one named cause. Before it,\n * every test file scheduled after a mid-run death failed in ~60\u201390 ms with\n * `TypeError: fetch failed` wrapping `connect ECONNREFUSED 127.0.0.1:<port>` \u2014\n * measured at **156 such failures across 21 files** in `obsidian-patterns` on\n * 2026-09-05, not one of them a test result. The absence of an app is not a test\n * outcome, and this error says so in the words a reader needs: the instance\n * died, here is its exit code, and these failures are not about your code.\n *\n * Exported so callers can `instanceof`-match it, like `SilentAsarFallbackError`\n * and `RendererFailedToInitializeError`.\n */\n\nimport type { OwnedInstanceExitMarker } from './owned-instance-exit-marker.cjs';\n\nimport { appendProcessOutputTail } from './process-exit-message.cjs';\n\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Parameters for the {@link OwnedInstanceExitedError} constructor.\n *\n * Everything but the URL is optional: the exit details come from the process\n * that launched the instance, and a caller in another process has them only\n * when the exit marker survived (see `owned-instance-exit-marker.ts`).\n */\nexport interface OwnedInstanceExitedErrorConstructorParams {\n  /**\n  The CDP URL the dead instance was serving.\n   */\n  readonly cdpUrl: string;\n\n  /**\n  Exit code, when known.\n   */\n  readonly code?: null | number | undefined;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds), when known.\n   */\n  readonly exitedAtInMilliseconds?: number | undefined;\n\n  /**\n  The tail of what the instance wrote to stdout/stderr, when any was captured.\n   */\n  readonly outputTail?: string | undefined;\n\n  /**\n  PID of the dead instance, when known.\n   */\n  readonly pid?: number | undefined;\n\n  /**\n  Terminating signal, when known.\n   */\n  readonly signal?: NodeJS.Signals | null | undefined;\n\n  /**\n  The spawn-failure message when the instance never started, otherwise absent.\n   */\n  readonly spawnError?: string | undefined;\n}\n\n/**\n * Thrown when the harness-owned Obsidian instance has exited and its CDP\n * endpoint is therefore unreachable. Carries whatever is known about the death\n * \u2014 exit code, signal, when it happened, and the output tail \u2014 so the failure\n * names its own cause instead of a refused connection.\n */\nexport class OwnedInstanceExitedError extends Error {\n  /**\n  The CDP URL the dead instance was serving.\n   */\n  public readonly cdpUrl: string;\n\n  /**\n  Exit code, when known.\n   */\n  public readonly code: null | number | undefined;\n\n  /**\n  When the instance exited (`Date.now()` epoch milliseconds), when known.\n   */\n  public readonly exitedAtInMilliseconds: number | undefined;\n\n  /**\n  Terminating signal, when known.\n   */\n  public readonly signal: NodeJS.Signals | null | undefined;\n\n  /**\n   * Creates the error from whatever is known about the instance's death.\n   *\n   * @param params - The CDP URL, and the exit details when they are available.\n   */\n  public constructor(params: OwnedInstanceExitedErrorConstructorParams) {\n    super(buildMessage(params));\n    this.name = 'OwnedInstanceExitedError';\n    this.cdpUrl = params.cdpUrl;\n    this.code = params.code;\n    this.exitedAtInMilliseconds = params.exitedAtInMilliseconds;\n    this.signal = params.signal;\n  }\n}\n\n/**\n * Builds the error from an exit marker, for a process that did not launch the\n * instance and so has nothing else to go on.\n *\n * A missing marker is expected rather than exceptional \u2014 it is cleared on every\n * deliberate kill, and a hard enough kill records nothing \u2014 so the error is\n * still built, naming the instance without claiming to know how it died.\n *\n * @param cdpUrl - The CDP URL the dead instance was serving.\n * @param marker - The exit marker read for its port, or `undefined` when there is none.\n * @returns The error to throw in place of a refused connection.\n */\nexport function buildOwnedInstanceExitedErrorFromMarker(cdpUrl: string, marker: OwnedInstanceExitMarker | undefined): OwnedInstanceExitedError {\n  if (!marker) {\n    return new OwnedInstanceExitedError({ cdpUrl });\n  }\n\n  return new OwnedInstanceExitedError({\n    cdpUrl,\n    code: marker.code,\n    exitedAtInMilliseconds: marker.exitedAtInMilliseconds,\n    outputTail: marker.outputTail,\n    pid: marker.pid,\n    signal: marker.signal,\n    spawnError: marker.spawnError\n  });\n}\n\nfunction buildMessage(params: OwnedInstanceExitedErrorConstructorParams): string {\n  const message = `The harness-owned Obsidian instance at ${params.cdpUrl} is gone: ${describeExit(params)}. `\n    + 'Whatever ran after it had no app to talk to, so these failures are not test results \u2014 '\n    + 'look for the `!!! OWNED OBSIDIAN EXITED` line in the run log for the moment it happened.';\n\n  return appendProcessOutputTail(message, { output: params.outputTail ?? '', outputLabel: 'Obsidian output' });\n}\n\nfunction describeExit(params: OwnedInstanceExitedErrorConstructorParams): string {\n  if (params.spawnError !== undefined) {\n    return `it failed to start (${params.spawnError})`;\n  }\n\n  if (params.code === undefined && params.signal === undefined) {\n    return 'it exited at some point during this run, and the harness recorded nothing about how '\n      + '(the run that owns it logs the exit code; a worker sees only what the exit marker preserved)';\n  }\n\n  return `${describeProcess(params)} ${describeReason(params)}${describeWhen(params.exitedAtInMilliseconds)}`;\n}\n\nfunction describeProcess(params: OwnedInstanceExitedErrorConstructorParams): string {\n  return params.pid === undefined ? 'it' : `its process (pid ${String(params.pid)})`;\n}\n\nfunction describeReason(params: OwnedInstanceExitedErrorConstructorParams): string {\n  if (params.signal !== undefined && params.signal !== null) {\n    return `was terminated by signal ${params.signal}`;\n  }\n\n  return params.code === undefined || params.code === null ? 'exited with no exit code' : `exited with code ${String(params.code)}`;\n}\n\nfunction describeWhen(exitedAtInMilliseconds: number | undefined): string {\n  if (exitedAtInMilliseconds === undefined) {\n    return '';\n  }\n\n  const elapsedInSeconds = Math.max(0, Math.round((Date.now() - exitedAtInMilliseconds) / MILLISECONDS_PER_SECOND));\n  return ` ${String(elapsedInSeconds)}s ago, at ${new Date(exitedAtInMilliseconds).toISOString()}`;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,kCAAwC;AAExC,MAAM,0BAA0B;AAoDzB,MAAM,iCAAiC,MAAM;AAAA;AAAA;AAAA;AAAA,EAIlC;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,QAAmD;AACpE,UAAM,aAAa,MAAM,CAAC;AAC1B,SAAK,OAAO;AACZ,SAAK,SAAS,OAAO;AACrB,SAAK,OAAO,OAAO;AACnB,SAAK,yBAAyB,OAAO;AACrC,SAAK,SAAS,OAAO;AAAA,EACvB;AACF;AAcO,SAAS,wCAAwC,QAAgB,QAAuE;AAC7I,MAAI,CAAC,QAAQ;AACX,WAAO,IAAI,yBAAyB,EAAE,OAAO,CAAC;AAAA,EAChD;AAEA,SAAO,IAAI,yBAAyB;AAAA,IAClC;AAAA,IACA,MAAM,OAAO;AAAA,IACb,wBAAwB,OAAO;AAAA,IAC/B,YAAY,OAAO;AAAA,IACnB,KAAK,OAAO;AAAA,IACZ,QAAQ,OAAO;AAAA,IACf,YAAY,OAAO;AAAA,EACrB,CAAC;AACH;AAEA,SAAS,aAAa,QAA2D;AAC/E,QAAM,UAAU,0CAA0C,OAAO,MAAM,aAAa,aAAa,MAAM,CAAC;AAIxG,aAAO,qDAAwB,SAAS,EAAE,QAAQ,OAAO,cAAc,IAAI,aAAa,kBAAkB,CAAC;AAC7G;AAEA,SAAS,aAAa,QAA2D;AAC/E,MAAI,OAAO,eAAe,QAAW;AACnC,WAAO,uBAAuB,OAAO,UAAU;AAAA,EACjD;AAEA,MAAI,OAAO,SAAS,UAAa,OAAO,WAAW,QAAW;AAC5D,WAAO;AAAA,EAET;AAEA,SAAO,GAAG,gBAAgB,MAAM,CAAC,IAAI,eAAe,MAAM,CAAC,GAAG,aAAa,OAAO,sBAAsB,CAAC;AAC3G;AAEA,SAAS,gBAAgB,QAA2D;AAClF,SAAO,OAAO,QAAQ,SAAY,OAAO,oBAAoB,OAAO,OAAO,GAAG,CAAC;AACjF;AAEA,SAAS,eAAe,QAA2D;AACjF,MAAI,OAAO,WAAW,UAAa,OAAO,WAAW,MAAM;AACzD,WAAO,4BAA4B,OAAO,MAAM;AAAA,EAClD;AAEA,SAAO,OAAO,SAAS,UAAa,OAAO,SAAS,OAAO,6BAA6B,oBAAoB,OAAO,OAAO,IAAI,CAAC;AACjI;AAEA,SAAS,aAAa,wBAAoD;AACxE,MAAI,2BAA2B,QAAW;AACxC,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,KAAK,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,IAAI,0BAA0B,uBAAuB,CAAC;AAChH,SAAO,IAAI,OAAO,gBAAgB,CAAC,aAAa,IAAI,KAAK,sBAAsB,EAAE,YAAY,CAAC;AAChG;",
  "names": []
}


package/dist/lib/cjs/owned-instance-exited-error.d.cts

@@ -0,0 +1,98 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when the harness-owned Obsidian instance is gone —
+ * it exited, and the CDP endpoint it was serving answers nothing.
+ *
+ * It exists to replace an anonymous cascade with one named cause. Before it,
+ * every test file scheduled after a mid-run death failed in ~60–90 ms with
+ * `TypeError: fetch failed` wrapping `connect ECONNREFUSED 127.0.0.1:<port>` —
+ * measured at **156 such failures across 21 files** in `obsidian-patterns` on
+ * 2026-09-05, not one of them a test result. The absence of an app is not a test
+ * outcome, and this error says so in the words a reader needs: the instance
+ * died, here is its exit code, and these failures are not about your code.
+ *
+ * Exported so callers can `instanceof`-match it, like `SilentAsarFallbackError`
+ * and `RendererFailedToInitializeError`.
+ */
+import type { OwnedInstanceExitMarker } from './owned-instance-exit-marker.cjs';
+/**
+ * Parameters for the {@link OwnedInstanceExitedError} constructor.
+ *
+ * Everything but the URL is optional: the exit details come from the process
+ * that launched the instance, and a caller in another process has them only
+ * when the exit marker survived (see `owned-instance-exit-marker.ts`).
+ */
+export interface OwnedInstanceExitedErrorConstructorParams {
+    /**
+    The CDP URL the dead instance was serving.
+     */
+    readonly cdpUrl: string;
+    /**
+    Exit code, when known.
+     */
+    readonly code?: null | number | undefined;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds), when known.
+     */
+    readonly exitedAtInMilliseconds?: number | undefined;
+    /**
+    The tail of what the instance wrote to stdout/stderr, when any was captured.
+     */
+    readonly outputTail?: string | undefined;
+    /**
+    PID of the dead instance, when known.
+     */
+    readonly pid?: number | undefined;
+    /**
+    Terminating signal, when known.
+     */
+    readonly signal?: NodeJS.Signals | null | undefined;
+    /**
+    The spawn-failure message when the instance never started, otherwise absent.
+     */
+    readonly spawnError?: string | undefined;
+}
+/**
+ * Thrown when the harness-owned Obsidian instance has exited and its CDP
+ * endpoint is therefore unreachable. Carries whatever is known about the death
+ * — exit code, signal, when it happened, and the output tail — so the failure
+ * names its own cause instead of a refused connection.
+ */
+export declare class OwnedInstanceExitedError extends Error {
+    /**
+    The CDP URL the dead instance was serving.
+     */
+    readonly cdpUrl: string;
+    /**
+    Exit code, when known.
+     */
+    readonly code: null | number | undefined;
+    /**
+    When the instance exited (`Date.now()` epoch milliseconds), when known.
+     */
+    readonly exitedAtInMilliseconds: number | undefined;
+    /**
+    Terminating signal, when known.
+     */
+    readonly signal: NodeJS.Signals | null | undefined;
+    /**
+     * Creates the error from whatever is known about the instance's death.
+     *
+     * @param params - The CDP URL, and the exit details when they are available.
+     */
+    constructor(params: OwnedInstanceExitedErrorConstructorParams);
+}
+/**
+ * Builds the error from an exit marker, for a process that did not launch the
+ * instance and so has nothing else to go on.
+ *
+ * A missing marker is expected rather than exceptional — it is cleared on every
+ * deliberate kill, and a hard enough kill records nothing — so the error is
+ * still built, naming the instance without claiming to know how it died.
+ *
+ * @param cdpUrl - The CDP URL the dead instance was serving.
+ * @param marker - The exit marker read for its port, or `undefined` when there is none.
+ * @returns The error to throw in place of a refused connection.
+ */
+export declare function buildOwnedInstanceExitedErrorFromMarker(cdpUrl: string, marker: OwnedInstanceExitMarker | undefined): OwnedInstanceExitedError;