obsidian-integration-testing 9.2.1 → 10.0.0

package/dist/lib/esm/obsidian-namespace.d.mts

@@ -9,21 +9,31 @@
  * Parameters for the registered `evalWrapper` function.
  */
 export interface EvalWrapperNamespaceParams {
-    /** User-supplied arguments to pass to `fn`. */
-    readonly args: Record<string, unknown>;
-    /** Optional context ID for persistent storage. */
+    /**
+    The user function to evaluate.
+     */
+    callback(input: Record<string, unknown>): unknown;
+    /**
+    Optional context ID for persistent storage.
+     */
     readonly contextId?: string;
-    /** The user function to evaluate. */
-    fn(args: Record<string, unknown>): unknown;
+    /**
+    User-supplied arguments to pass to `callback`.
+     */
+    readonly input: Record<string, unknown>;
 }
 /**
  * Parameters for {@link ObsidianIntegrationTestingNamespace.ipcSendSync}.
  */
 export interface IpcSendSyncNamespaceParams {
-    /** The IPC arguments. */
-    readonly args: unknown[];
-    /** The IPC channel name. */
+    /**
+    The IPC channel name.
+     */
     readonly channel: string;
+    /**
+    The IPC arguments.
+     */
+    readonly channelArguments: unknown[];
 }
 /**
  * Holder interface for type-safe access to `window.__obsidianIntegrationTesting`.
@@ -65,7 +75,7 @@ export interface ObsidianIntegrationTestingNamespace {
      * The top-level wrapper that sets up context, resolves the obsidian module,
      * calls the user's function, and returns a JSON envelope.
      *
-     * @param params - Parameters including the user's function, args, and context ID.
+     * @param params - Parameters including the user's function, input, and context ID.
      * @returns A JSON-stringified result envelope.
      */
     evalWrapper(params: EvalWrapperNamespaceParams): Promise<string>;
@@ -107,8 +117,12 @@ export interface ObsidianIntegrationTestingNamespace {
  * Parameters for {@link ObsidianIntegrationTestingNamespace.setLocalStorageItem}.
  */
 export interface SetLocalStorageItemNamespaceParams {
-    /** The localStorage key. */
+    /**
+    The localStorage key.
+     */
     readonly key: string;
-    /** The localStorage value. */
+    /**
+    The localStorage value.
+     */
     readonly value: string;
 }

package/dist/lib/esm/obsidian-version-switch.d.mts

@@ -2,11 +2,11 @@
  * @file
  *
  * Integration-time helpers for provisioning a specific Obsidian **asar** (the
- * app code) into an isolated user-data dir.
+ * app code) into an isolated user-data directory.
  *
  * Obsidian's bootstrap loads the highest of (its shell's bundled
  * `resources/obsidian.asar`, the `obsidian-<version>.asar` files in the
- * user-data dir). So placing an asar here only takes effect when its version is
+ * user-data directory). So placing an asar here only takes effect when its version is
  * **>= the shell's bundled version** (upgrade-only — confirmed by the Phase 0
  * spike). Running an older version requires pinning the installer/shell instead
  * (see `obsidian-installer.ts`).
@@ -16,20 +16,24 @@ import type { DesktopReleasesManifest } from './obsidian-version.mjs';
  * A discovered `obsidian-<version>.asar` file.
  */
 export interface DiscoveredAsar {
-    /** Absolute path to the asar file. */
+    /**
+    Absolute path to the asar file.
+     */
     readonly path: string;
-    /** The `x.y.z` version parsed from the file name. */
+    /**
+    The `x.y.z` version parsed from the file name.
+     */
     readonly version: string;
 }
 /**
- * Copies an asar file into a user-data dir under its canonical
+ * Copies an asar file into a user-data directory under its canonical
  * `obsidian-<version>.asar` name.
  *
  * @param asarPath - Source asar path.
  * @param version - The asar's version (used for the destination file name).
- * @param userDataDir - Destination user-data dir.
+ * @param userDataDirectory - Destination user-data directory.
  */
-export declare function copyAsarIntoUserData(asarPath: string, version: string, userDataDir: string): void;
+export declare function copyAsarIntoUserData(asarPath: string, version: string, userDataDirectory: string): void;
 /**
  * Ensures the asar for a concrete version is present in the local cache,
  * downloading and decompressing it if necessary.
@@ -49,10 +53,10 @@ export declare function fetchDesktopReleasesManifest(): Promise<DesktopReleasesM
 /**
  * Finds the newest `obsidian-<version>.asar` in a directory.
  *
- * @param dir - The directory to scan (e.g. the user's Obsidian config dir).
- * @returns The newest discovered asar, or `undefined` if none / the dir is unreadable.
+ * @param directory - The directory to scan (e.g. the user's Obsidian config directory).
+ * @returns The newest discovered asar, or `undefined` if none / the directory is unreadable.
  */
-export declare function findNewestAsar(dir: string): DiscoveredAsar | undefined;
+export declare function findNewestAsar(directory: string): DiscoveredAsar | undefined;
 /**
  * Returns the local cache path for a concrete version's asar (the file may not
  * yet exist).

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

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

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


package/dist/lib/esm/obsidian-version.d.mts

@@ -28,16 +28,22 @@ export declare const DESKTOP_RELEASES_MANIFEST_URL = "https://raw.githubusercont
  * A version specifier resolved against a release channel.
  */
 export interface ChannelVersionSpec {
-    /** The channel to resolve against the manifest. */
+    /**
+    The channel to resolve against the manifest.
+     */
     readonly channel: ReleaseChannel;
-    /** Discriminant. */
+    /**
+    Discriminant.
+     */
     readonly kind: 'channel';
 }
 /**
  * The `beta` (catalyst) entry of {@link DesktopReleasesManifest}.
  */
 export interface DesktopReleasesBeta {
-    /** The latest catalyst version, e.g. `'1.13.1'`. */
+    /**
+    The latest catalyst version, e.g. `'1.13.1'`.
+     */
     readonly latestVersion: string;
 }
 /**
@@ -57,9 +63,13 @@ export interface DesktopReleasesManifest {
  * A version specifier naming a concrete `x.y.z` version.
  */
 export interface ExplicitVersionSpec {
-    /** Discriminant. */
+    /**
+    Discriminant.
+     */
     readonly kind: 'explicit';
-    /** The concrete `x.y.z` version. */
+    /**
+    The concrete `x.y.z` version.
+     */
     readonly version: string;
 }
 /**

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

@@ -6,8 +6,8 @@ const VERSION_SEGMENT_COUNT = 3;
 function compareVersions(a, b) {
   const aSegments = parseVersionSegments(a);
   const bSegments = parseVersionSegments(b);
-  for (let i = 0; i < VERSION_SEGMENT_COUNT; i++) {
-    const diff = (aSegments[i] ?? 0) - (bSegments[i] ?? 0);
+  for (let index = 0; index < VERSION_SEGMENT_COUNT; index++) {
+    const diff = (aSegments[index] ?? 0) - (bSegments[index] ?? 0);
     if (diff !== 0) {
       return diff;
     }
@@ -52,4 +52,4 @@ export {
   parseVersionSpec,
   resolveVersionFromManifest
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-version.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving Obsidian desktop version specifiers.\n *\n * A version specifier is either an explicit `x.y.z` string or one of the\n * channel aliases {@link PUBLIC_LATEST} / {@link CATALYST_LATEST}, which resolve\n * against Obsidian's published desktop releases manifest.\n *\n * The network call that fetches the manifest lives in the integration-time\n * version-switch module; everything here is pure and unit-tested.\n */\n\n/**\n * Version specifier alias resolving to the latest **public** desktop release\n * (the manifest's `latestVersion`).\n */\nexport const PUBLIC_LATEST = 'public-latest';\n\n/**\n * Version specifier alias resolving to the latest **catalyst** (early access /\n * insider) desktop release (the manifest's `beta.latestVersion`).\n */\nexport const CATALYST_LATEST = 'catalyst-latest';\n\n/**\n * URL of Obsidian's desktop releases manifest (raw JSON).\n */\nexport const DESKTOP_RELEASES_MANIFEST_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json';\n\nconst EXPLICIT_VERSION_PATTERN = /^\\d+\\.\\d+\\.\\d+$/;\nconst VERSION_SEGMENT_COUNT = 3;\n\n/**\n * A version specifier resolved against a release channel.\n */\nexport interface ChannelVersionSpec {\n  /** The channel to resolve against the manifest. */\n  readonly channel: ReleaseChannel;\n\n  /** Discriminant. */\n  readonly kind: 'channel';\n}\n\n/**\n * The `beta` (catalyst) entry of {@link DesktopReleasesManifest}.\n */\nexport interface DesktopReleasesBeta {\n  /** The latest catalyst version, e.g. `'1.13.1'`. */\n  readonly latestVersion: string;\n}\n\n/**\n * The subset of Obsidian's `desktop-releases.json` this library reads.\n */\nexport interface DesktopReleasesManifest {\n  /**\n   * The latest catalyst (early access / insider) release, when present.\n   */\n  readonly beta?: DesktopReleasesBeta;\n\n  /**\n   * The latest public (stable) version, e.g. `'1.12.7'`.\n   */\n  readonly latestVersion: string;\n}\n\n/**\n * A version specifier naming a concrete `x.y.z` version.\n */\nexport interface ExplicitVersionSpec {\n  /** Discriminant. */\n  readonly kind: 'explicit';\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * A release channel resolved from a channel-alias specifier.\n *\n * - `public` \u2014 the latest stable release.\n * - `catalyst` \u2014 the latest early access / insider release.\n */\nexport type ReleaseChannel = 'catalyst' | 'public';\n\n/**\n * The parsed form of a version specifier.\n *\n * - `explicit` \u2014 a concrete `x.y.z` version.\n * - `channel` \u2014 a channel alias to be resolved against the manifest.\n */\nexport type VersionSpec = ChannelVersionSpec | ExplicitVersionSpec;\n\n/**\n * Compares two `x.y.z` version strings numerically, segment by segment.\n *\n * @param a - The first version.\n * @param b - The second version.\n * @returns A negative number if `a < b`, `0` if equal, a positive number if `a > b`.\n */\nexport function compareVersions(a: string, b: string): number {\n  const aSegments = parseVersionSegments(a);\n  const bSegments = parseVersionSegments(b);\n\n  for (let i = 0; i < VERSION_SEGMENT_COUNT; i++) {\n    const diff = (aSegments[i] ?? 0) - (bSegments[i] ?? 0);\n    if (diff !== 0) {\n      return diff;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Returns the user-data asar file name for a given version, matching the name\n * Obsidian itself uses when it downloads an update (`obsidian-<version>.asar`).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The asar file name.\n */\nexport function getVersionAsarFileName(version: string): string {\n  return `obsidian-${version}.asar`;\n}\n\n/**\n * Parses a version specifier into either an explicit version or a channel alias.\n *\n * @param spec - The specifier: an `x.y.z` string, {@link PUBLIC_LATEST}, or {@link CATALYST_LATEST}.\n * @returns The parsed {@link VersionSpec}.\n * @throws Error if the specifier is neither a valid `x.y.z` version nor a known alias.\n */\nexport function parseVersionSpec(spec: string): VersionSpec {\n  if (spec === PUBLIC_LATEST) {\n    return { channel: 'public', kind: 'channel' };\n  }\n\n  if (spec === CATALYST_LATEST) {\n    return { channel: 'catalyst', kind: 'channel' };\n  }\n\n  if (EXPLICIT_VERSION_PATTERN.test(spec)) {\n    return { kind: 'explicit', version: spec };\n  }\n\n  throw new Error(\n    `Invalid Obsidian version \"${spec}\". Expected an \"x.y.z\" version, \"${PUBLIC_LATEST}\", or \"${CATALYST_LATEST}\".`\n  );\n}\n\n/**\n * Resolves a channel to a concrete version using a desktop releases manifest.\n *\n * @param manifest - The parsed manifest.\n * @param channel - The channel to resolve.\n * @returns The concrete `x.y.z` version for the channel.\n * @throws Error if the catalyst channel is requested but the manifest has no `beta` entry.\n */\nexport function resolveVersionFromManifest(manifest: DesktopReleasesManifest, channel: ReleaseChannel): string {\n  if (channel === 'public') {\n    return manifest.latestVersion;\n  }\n\n  if (!manifest.beta) {\n    throw new Error('Desktop releases manifest has no catalyst (beta) release.');\n  }\n\n  return manifest.beta.latestVersion;\n}\n\n/**\n * Splits an `x.y.z` version into its numeric segments.\n *\n * @param version - The version string.\n * @returns The numeric segments.\n */\nfunction parseVersionSegments(version: string): number[] {\n  return version.split('.').map((segment) => Number.parseInt(segment, 10));\n}\n"],
  "mappings": "AAiBO,MAAM,gBAAgB;AAMtB,MAAM,kBAAkB;AAKxB,MAAM,gCAAgC;AAE7C,MAAM,2BAA2B;AACjC,MAAM,wBAAwB;AAsEvB,SAAS,gBAAgB,GAAW,GAAmB;AAC5D,QAAM,YAAY,qBAAqB,CAAC;AACxC,QAAM,YAAY,qBAAqB,CAAC;AAExC,WAAS,IAAI,GAAG,IAAI,uBAAuB,KAAK;AAC9C,UAAM,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,CAAC,KAAK;AACpD,QAAI,SAAS,GAAG;AACd,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AASO,SAAS,uBAAuB,SAAyB;AAC9D,SAAO,YAAY,OAAO;AAC5B;AASO,SAAS,iBAAiB,MAA2B;AAC1D,MAAI,SAAS,eAAe;AAC1B,WAAO,EAAE,SAAS,UAAU,MAAM,UAAU;AAAA,EAC9C;AAEA,MAAI,SAAS,iBAAiB;AAC5B,WAAO,EAAE,SAAS,YAAY,MAAM,UAAU;AAAA,EAChD;AAEA,MAAI,yBAAyB,KAAK,IAAI,GAAG;AACvC,WAAO,EAAE,MAAM,YAAY,SAAS,KAAK;AAAA,EAC3C;AAEA,QAAM,IAAI;AAAA,IACR,6BAA6B,IAAI,oCAAoC,aAAa,UAAU,eAAe;AAAA,EAC7G;AACF;AAUO,SAAS,2BAA2B,UAAmC,SAAiC;AAC7G,MAAI,YAAY,UAAU;AACxB,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AAEA,SAAO,SAAS,KAAK;AACvB;AAQA,SAAS,qBAAqB,SAA2B;AACvD,SAAO,QAAQ,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,OAAO,SAAS,SAAS,EAAE,CAAC;AACzE;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-version.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving Obsidian desktop version specifiers.\n *\n * A version specifier is either an explicit `x.y.z` string or one of the\n * channel aliases {@link PUBLIC_LATEST} / {@link CATALYST_LATEST}, which resolve\n * against Obsidian's published desktop releases manifest.\n *\n * The network call that fetches the manifest lives in the integration-time\n * version-switch module; everything here is pure and unit-tested.\n */\n\n/**\n * Version specifier alias resolving to the latest **public** desktop release\n * (the manifest's `latestVersion`).\n */\nexport const PUBLIC_LATEST = 'public-latest';\n\n/**\n * Version specifier alias resolving to the latest **catalyst** (early access /\n * insider) desktop release (the manifest's `beta.latestVersion`).\n */\nexport const CATALYST_LATEST = 'catalyst-latest';\n\n/**\n * URL of Obsidian's desktop releases manifest (raw JSON).\n */\nexport const DESKTOP_RELEASES_MANIFEST_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/desktop-releases.json';\n\nconst EXPLICIT_VERSION_PATTERN = /^\\d+\\.\\d+\\.\\d+$/;\nconst VERSION_SEGMENT_COUNT = 3;\n\n/**\n * A version specifier resolved against a release channel.\n */\nexport interface ChannelVersionSpec {\n  /**\n  The channel to resolve against the manifest.\n   */\n  readonly channel: ReleaseChannel;\n\n  /**\n  Discriminant.\n   */\n  readonly kind: 'channel';\n}\n\n/**\n * The `beta` (catalyst) entry of {@link DesktopReleasesManifest}.\n */\nexport interface DesktopReleasesBeta {\n  /**\n  The latest catalyst version, e.g. `'1.13.1'`.\n   */\n  readonly latestVersion: string;\n}\n\n/**\n * The subset of Obsidian's `desktop-releases.json` this library reads.\n */\nexport interface DesktopReleasesManifest {\n  /**\n   * The latest catalyst (early access / insider) release, when present.\n   */\n  readonly beta?: DesktopReleasesBeta;\n\n  /**\n   * The latest public (stable) version, e.g. `'1.12.7'`.\n   */\n  readonly latestVersion: string;\n}\n\n/**\n * A version specifier naming a concrete `x.y.z` version.\n */\nexport interface ExplicitVersionSpec {\n  /**\n  Discriminant.\n   */\n  readonly kind: 'explicit';\n\n  /**\n  The concrete `x.y.z` version.\n   */\n  readonly version: string;\n}\n\n/**\n * A release channel resolved from a channel-alias specifier.\n *\n * - `public` \u2014 the latest stable release.\n * - `catalyst` \u2014 the latest early access / insider release.\n */\nexport type ReleaseChannel = 'catalyst' | 'public';\n\n/**\n * The parsed form of a version specifier.\n *\n * - `explicit` \u2014 a concrete `x.y.z` version.\n * - `channel` \u2014 a channel alias to be resolved against the manifest.\n */\nexport type VersionSpec = ChannelVersionSpec | ExplicitVersionSpec;\n\n/**\n * Compares two `x.y.z` version strings numerically, segment by segment.\n *\n * @param a - The first version.\n * @param b - The second version.\n * @returns A negative number if `a < b`, `0` if equal, a positive number if `a > b`.\n */\nexport function compareVersions(a: string, b: string): number {\n  const aSegments = parseVersionSegments(a);\n  const bSegments = parseVersionSegments(b);\n\n  for (let index = 0; index < VERSION_SEGMENT_COUNT; index++) {\n    const diff = (aSegments[index] ?? 0) - (bSegments[index] ?? 0);\n    if (diff !== 0) {\n      return diff;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * Returns the user-data asar file name for a given version, matching the name\n * Obsidian itself uses when it downloads an update (`obsidian-<version>.asar`).\n *\n * @param version - A concrete `x.y.z` version.\n * @returns The asar file name.\n */\nexport function getVersionAsarFileName(version: string): string {\n  return `obsidian-${version}.asar`;\n}\n\n/**\n * Parses a version specifier into either an explicit version or a channel alias.\n *\n * @param spec - The specifier: an `x.y.z` string, {@link PUBLIC_LATEST}, or {@link CATALYST_LATEST}.\n * @returns The parsed {@link VersionSpec}.\n * @throws Error if the specifier is neither a valid `x.y.z` version nor a known alias.\n */\nexport function parseVersionSpec(spec: string): VersionSpec {\n  if (spec === PUBLIC_LATEST) {\n    return { channel: 'public', kind: 'channel' };\n  }\n\n  if (spec === CATALYST_LATEST) {\n    return { channel: 'catalyst', kind: 'channel' };\n  }\n\n  if (EXPLICIT_VERSION_PATTERN.test(spec)) {\n    return { kind: 'explicit', version: spec };\n  }\n\n  throw new Error(\n    `Invalid Obsidian version \"${spec}\". Expected an \"x.y.z\" version, \"${PUBLIC_LATEST}\", or \"${CATALYST_LATEST}\".`\n  );\n}\n\n/**\n * Resolves a channel to a concrete version using a desktop releases manifest.\n *\n * @param manifest - The parsed manifest.\n * @param channel - The channel to resolve.\n * @returns The concrete `x.y.z` version for the channel.\n * @throws Error if the catalyst channel is requested but the manifest has no `beta` entry.\n */\nexport function resolveVersionFromManifest(manifest: DesktopReleasesManifest, channel: ReleaseChannel): string {\n  if (channel === 'public') {\n    return manifest.latestVersion;\n  }\n\n  if (!manifest.beta) {\n    throw new Error('Desktop releases manifest has no catalyst (beta) release.');\n  }\n\n  return manifest.beta.latestVersion;\n}\n\n/**\n * Splits an `x.y.z` version into its numeric segments.\n *\n * @param version - The version string.\n * @returns The numeric segments.\n */\nfunction parseVersionSegments(version: string): number[] {\n  return version.split('.').map((segment) => Number.parseInt(segment, 10));\n}\n"],
  "mappings": "AAiBO,MAAM,gBAAgB;AAMtB,MAAM,kBAAkB;AAKxB,MAAM,gCAAgC;AAE7C,MAAM,2BAA2B;AACjC,MAAM,wBAAwB;AAgFvB,SAAS,gBAAgB,GAAW,GAAmB;AAC5D,QAAM,YAAY,qBAAqB,CAAC;AACxC,QAAM,YAAY,qBAAqB,CAAC;AAExC,WAAS,QAAQ,GAAG,QAAQ,uBAAuB,SAAS;AAC1D,UAAM,QAAQ,UAAU,KAAK,KAAK,MAAM,UAAU,KAAK,KAAK;AAC5D,QAAI,SAAS,GAAG;AACd,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AASO,SAAS,uBAAuB,SAAyB;AAC9D,SAAO,YAAY,OAAO;AAC5B;AASO,SAAS,iBAAiB,MAA2B;AAC1D,MAAI,SAAS,eAAe;AAC1B,WAAO,EAAE,SAAS,UAAU,MAAM,UAAU;AAAA,EAC9C;AAEA,MAAI,SAAS,iBAAiB;AAC5B,WAAO,EAAE,SAAS,YAAY,MAAM,UAAU;AAAA,EAChD;AAEA,MAAI,yBAAyB,KAAK,IAAI,GAAG;AACvC,WAAO,EAAE,MAAM,YAAY,SAAS,KAAK;AAAA,EAC3C;AAEA,QAAM,IAAI;AAAA,IACR,6BAA6B,IAAI,oCAAoC,aAAa,UAAU,eAAe;AAAA,EAC7G;AACF;AAUO,SAAS,2BAA2B,UAAmC,SAAiC;AAC7G,MAAI,YAAY,UAAU;AACxB,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,UAAM,IAAI,MAAM,2DAA2D;AAAA,EAC7E;AAEA,SAAO,SAAS,KAAK;AACvB;AAQA,SAAS,qBAAqB,SAA2B;AACvD,SAAO,QAAQ,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,OAAO,SAAS,SAAS,EAAE,CAAC;AACzE;",
  "names": []
}


package/dist/lib/esm/owned-vault-seed.d.mts

@@ -24,11 +24,17 @@
  * Parameters for {@link buildOwnedObsidianJson}.
  */
 export interface BuildOwnedObsidianJsonParams {
-    /** Last-access timestamp to stamp on the vault entry. */
+    /**
+    Last-access timestamp to stamp on the vault entry.
+     */
     readonly ts: number;
-    /** The randomly-generated vault id used as the registry key and `last_open`. */
+    /**
+    The randomly-generated vault id used as the registry key and `last_open`.
+     */
     readonly vaultId: string;
-    /** Absolute path to the harness vault folder. */
+    /**
+    Absolute path to the harness vault folder.
+     */
     readonly vaultPath: string;
 }
 /**
@@ -40,20 +46,30 @@ export interface OwnedObsidianJson {
      * ignored as an unknown key by newer versions that use the per-entry `open`.
      */
     readonly last_open: string;
-    /** Disables the throwaway instance's self-update. */
+    /**
+    Disables the throwaway instance's self-update.
+     */
     readonly updateDisabled: true;
-    /** Vault registry keyed by vault id. */
+    /**
+    Vault registry keyed by vault id.
+     */
     readonly vaults: Readonly<Record<string, OwnedObsidianVaultEntry>>;
 }
 /**
  * A single vault entry in the seeded `obsidian.json`.
  */
 export interface OwnedObsidianVaultEntry {
-    /** Per-entry auto-open flag honored by newer Obsidian versions. */
+    /**
+    Per-entry auto-open flag honored by newer Obsidian versions.
+     */
     readonly open: true;
-    /** Absolute path to the harness vault folder. */
+    /**
+    Absolute path to the harness vault folder.
+     */
     readonly path: string;
-    /** Last-access timestamp. */
+    /**
+    Last-access timestamp.
+     */
     readonly ts: number;
 }
 /**

package/dist/lib/esm/owned-vault-seed.mjs

@@ -11,4 +11,4 @@ function buildOwnedObsidianJson(params) {
 export {
   buildOwnedObsidianJson
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/parent-liveness.d.mts

@@ -0,0 +1,80 @@
+/**
+ * @file
+ *
+ * Ties a harness-owned Obsidian instance's lifetime to the harness process that
+ * launched it, in the one direction the operating system will not do for us.
+ *
+ * The owned instance is already a child of the harness process, but that link
+ * carries no lifetime guarantee. Windows never propagates a parent's death to
+ * its children — an orphan simply keeps running with a stale parent id — and on
+ * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is
+ * additionally spawned `detached`, so it is not even in the harness's process
+ * group. Teardown therefore relies entirely on the harness running its own
+ * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly
+ * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every
+ * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and
+ * they accumulate: the next run picks a fresh temp dir and a free port, so
+ * nothing collides and nothing complains.
+ *
+ * The guaranteed fix is an OS primitive — a Windows Job Object with
+ * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux —
+ * but neither is reachable from Node without a native addon, which is far too
+ * heavy a dependency for this harness.
+ *
+ * So we use the one cross-platform resource the kernel *does* reclaim
+ * deterministically on process death: a socket. The harness listens on a
+ * loopback port and the instance's renderer connects to it. However the harness
+ * dies — cleanly, `SIGKILL`ed, or crashed — the kernel closes its end, the
+ * renderer sees `close`, and the window destroys itself. No polling, no
+ * heartbeat interval, no timeout to tune.
+ *
+ * Deliberately fail-open: the renderer only arms the destroy handler after the
+ * connection is actually established. A watchdog that cannot reach the harness
+ * leaves the instance running rather than killing a window the developer is
+ * working in.
+ */
+/**
+ * A listening loopback server whose accepted connections act as liveness tokens
+ * for the harness process.
+ */
+export interface ParentLivenessServer {
+    /**
+    Stops listening and drops every accepted connection.
+     */
+    close(): void;
+    /**
+    The loopback port the renderer watchdog should connect back to.
+     */
+    readonly port: number;
+}
+/**
+ * Loopback host the liveness server binds to. Never exposed off-machine.
+ */
+export declare const PARENT_LIVENESS_HOST = "127.0.0.1";
+/**
+ * Builds the expression evaluated in the owned instance's renderer to arm the
+ * watchdog.
+ *
+ * Written in ES5 style (`var`, `function`) with no optional chaining, matching
+ * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the
+ * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).
+ *
+ * Arming is idempotent — a second evaluation finds the stored socket and
+ * returns without opening another connection, so a retried readiness pass does
+ * not pile up sockets.
+ *
+ * @param port - The loopback port returned by {@link startParentLivenessServer}.
+ * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.
+ */
+export declare function buildParentLivenessWatchdogExpression(port: number): string;
+/**
+ * Starts the loopback liveness server the owned instance's renderer connects
+ * back to.
+ *
+ * The server and every accepted socket are `unref`ed, so holding a watchdog
+ * connection open never keeps the harness process alive on its own — the
+ * connection is a token the kernel reclaims, not work to wait on.
+ *
+ * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.
+ */
+export declare function startParentLivenessServer(): Promise<ParentLivenessServer>;

package/dist/lib/esm/parent-liveness.mjs

@@ -0,0 +1,67 @@
+import { createServer } from "node:net";
+const PARENT_LIVENESS_HOST = "127.0.0.1";
+function buildParentLivenessWatchdogExpression(port) {
+  return `(function() {
+  var FLAG = '__obsidianIntegrationTestingParentLiveness';
+  if (window[FLAG]) { return 'already-armed'; }
+  var net;
+  try {
+    net = window.require('node:net');
+  } catch (nodePrefixError) {
+    try {
+      net = window.require('net');
+    } catch (barePrefixError) {
+      return 'unavailable';
+    }
+  }
+  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');
+  window[FLAG] = socket;
+  var isConnected = false;
+  socket.on('connect', function() { isConnected = true; });
+  socket.on('error', function() { /* Handled by the close listener below. */ });
+  socket.on('close', function() {
+    if (!isConnected) { return; }
+    try {
+      window.electronWindow.destroy();
+    } catch (destroyError) {
+      window.close();
+    }
+  });
+  return 'armed';
+})()`;
+}
+async function startParentLivenessServer() {
+  const server = createServer((socket) => {
+    socket.unref();
+    socket.on("error", () => {
+    });
+  });
+  server.unref();
+  const port = await listenOnFreeLoopbackPort(server);
+  return {
+    close() {
+      server.close();
+    },
+    port
+  };
+}
+async function listenOnFreeLoopbackPort(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, PARENT_LIVENESS_HOST, () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to determine the parent-liveness port."));
+        return;
+      }
+      resolve(address.port);
+    });
+  });
+}
+export {
+  PARENT_LIVENESS_HOST,
+  buildParentLivenessWatchdogExpression,
+  startParentLivenessServer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/parent-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Ties a harness-owned Obsidian instance's lifetime to the harness process that\n * launched it, in the one direction the operating system will not do for us.\n *\n * The owned instance is already a child of the harness process, but that link\n * carries no lifetime guarantee. Windows never propagates a parent's death to\n * its children \u2014 an orphan simply keeps running with a stale parent id \u2014 and on\n * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is\n * additionally spawned `detached`, so it is not even in the harness's process\n * group. Teardown therefore relies entirely on the harness running its own\n * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly\n * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every\n * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and\n * they accumulate: the next run picks a fresh temp dir and a free port, so\n * nothing collides and nothing complains.\n *\n * The guaranteed fix is an OS primitive \u2014 a Windows Job Object with\n * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux \u2014\n * but neither is reachable from Node without a native addon, which is far too\n * heavy a dependency for this harness.\n *\n * So we use the one cross-platform resource the kernel *does* reclaim\n * deterministically on process death: a socket. The harness listens on a\n * loopback port and the instance's renderer connects to it. However the harness\n * dies \u2014 cleanly, `SIGKILL`ed, or crashed \u2014 the kernel closes its end, the\n * renderer sees `close`, and the window destroys itself. No polling, no\n * heartbeat interval, no timeout to tune.\n *\n * Deliberately fail-open: the renderer only arms the destroy handler after the\n * connection is actually established. A watchdog that cannot reach the harness\n * leaves the instance running rather than killing a window the developer is\n * working in.\n */\n\nimport type { Server } from 'node:net';\n\nimport { createServer } from 'node:net';\n\n/**\n * A listening loopback server whose accepted connections act as liveness tokens\n * for the harness process.\n */\nexport interface ParentLivenessServer {\n  /**\n  Stops listening and drops every accepted connection.\n   */\n  close(): void;\n\n  /**\n  The loopback port the renderer watchdog should connect back to.\n   */\n  readonly port: number;\n}\n\n/**\n * Loopback host the liveness server binds to. Never exposed off-machine.\n */\nexport const PARENT_LIVENESS_HOST = '127.0.0.1';\n\n/**\n * Builds the expression evaluated in the owned instance's renderer to arm the\n * watchdog.\n *\n * Written in ES5 style (`var`, `function`) with no optional chaining, matching\n * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the\n * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).\n *\n * Arming is idempotent \u2014 a second evaluation finds the stored socket and\n * returns without opening another connection, so a retried readiness pass does\n * not pile up sockets.\n *\n * @param port - The loopback port returned by {@link startParentLivenessServer}.\n * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.\n */\nexport function buildParentLivenessWatchdogExpression(port: number): string {\n  return `(function() {\n  var FLAG = '__obsidianIntegrationTestingParentLiveness';\n  if (window[FLAG]) { return 'already-armed'; }\n  var net;\n  try {\n    net = window.require('node:net');\n  } catch (nodePrefixError) {\n    try {\n      net = window.require('net');\n    } catch (barePrefixError) {\n      return 'unavailable';\n    }\n  }\n  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');\n  window[FLAG] = socket;\n  var isConnected = false;\n  socket.on('connect', function() { isConnected = true; });\n  socket.on('error', function() { /* Handled by the close listener below. */ });\n  socket.on('close', function() {\n    if (!isConnected) { return; }\n    try {\n      window.electronWindow.destroy();\n    } catch (destroyError) {\n      window.close();\n    }\n  });\n  return 'armed';\n})()`;\n}\n\n/**\n * Starts the loopback liveness server the owned instance's renderer connects\n * back to.\n *\n * The server and every accepted socket are `unref`ed, so holding a watchdog\n * connection open never keeps the harness process alive on its own \u2014 the\n * connection is a token the kernel reclaims, not work to wait on.\n *\n * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.\n */\nexport async function startParentLivenessServer(): Promise<ParentLivenessServer> {\n  const server = createServer((socket) => {\n    socket.unref();\n    // The connection carries no data \u2014 it exists only so its close is observable.\n    socket.on('error', () => {\n      // A renderer torn down mid-connection resets rather than closes; not an error here.\n    });\n  });\n  server.unref();\n\n  const port = await listenOnFreeLoopbackPort(server);\n  return {\n    close(): void {\n      server.close();\n    },\n    port\n  };\n}\n\n/**\n * Binds the server to an ephemeral loopback port and reports which one it got.\n *\n * @param server - The server to bind.\n * @returns A {@link Promise} resolving to the assigned port.\n * @throws If the server reports an error before listening, or binds to a pipe rather than a port.\n */\nasync function listenOnFreeLoopbackPort(server: Server): Promise<number> {\n  return new Promise<number>((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(0, PARENT_LIVENESS_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine the parent-liveness port.'));\n        return;\n      }\n      resolve(address.port);\n    });\n  });\n}\n"],
  "mappings": "AAsCA,SAAS,oBAAoB;AAqBtB,MAAM,uBAAuB;AAiB7B,SAAS,sCAAsC,MAAsB;AAC1E,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAaoB,OAAO,IAAI,CAAC,MAAM,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAenE;AAYA,eAAsB,4BAA2D;AAC/E,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,MAAM;AAEb,WAAO,GAAG,SAAS,MAAM;AAAA,IAEzB,CAAC;AAAA,EACH,CAAC;AACD,SAAO,MAAM;AAEb,QAAM,OAAO,MAAM,yBAAyB,MAAM;AAClD,SAAO;AAAA,IACL,QAAc;AACZ,aAAO,MAAM;AAAA,IACf;AAAA,IACA;AAAA,EACF;AACF;AASA,eAAe,yBAAyB,QAAiC;AACvE,SAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,sBAAsB,MAAM;AAC3C,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,+CAA+C,CAAC;AACjE;AAAA,MACF;AACA,cAAQ,QAAQ,IAAI;AAAA,IACtB,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/poll-in-obsidian.d.mts

@@ -17,28 +17,28 @@
  * integration test.
  */
 import type { Promisable } from 'type-fest';
-import type { ContextArgs } from './context-id.mjs';
-import type { CommonArgs, GenericObject } from './eval-in-obsidian.mjs';
+import type { ContextArguments } from './context-id.mjs';
+import type { CommonArguments, GenericObject } from './eval-in-obsidian.mjs';
 import type { ObsidianTransport } from './transport.mjs';
 import { ContextId } from './context-id.mjs';
 /**
  * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for
- * the shared forwarded fields (`args` / `contextId` / `transport` / `vaultPath`);
+ * the shared forwarded fields (`input` / `contextId` / `transport` / `vaultPath`);
  * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side
  * acceptance predicate.
  */
-export interface PollInObsidianParams<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
-    /**
-     * Additional arguments passed to both `start` and `poll` (serialized like
-     * {@link EvalInObsidianParams.args}).
-     */
-    readonly args?: Args;
+export interface PollInObsidianParams<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
     /**
      * A {@link ContextId} shared by `start` and `poll`, so `start` can stash
      * non-serializable state that `poll` later reads. When omitted, each closure
      * gets a fresh empty `context`.
      */
     readonly contextId?: TContextId;
+    /**
+     * Additional arguments passed to both `start` and `poll` (serialized like
+     * {@link EvalInObsidianParams.input}).
+     */
+    readonly input?: Input;
     /**
      * Delay between `poll` attempts, in milliseconds.
      *
@@ -50,13 +50,13 @@ export interface PollInObsidianParams<Args extends GenericObject, PollResult, TC
      * ~30s CDP cap): it should read and return a JSON-serializable status, not
      * await the long operation itself.
      */
-    poll(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<PollResult>;
+    poll(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<PollResult>;
     /**
      * An optional closure run **once** before polling begins, to kick off the
      * long-running work (fire-and-forget from Node's perspective). Keep it short —
      * start the work and return; do not await it to completion here.
      */
-    start?(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<unknown>;
+    start?(this: void, input: CommonArguments & ContextArguments<TContextId> & Input): Promisable<unknown>;
     /**
      * Total budget before the poll rejects, in milliseconds.
      *
@@ -89,4 +89,4 @@ export interface PollInObsidianParams<Args extends GenericObject, PollResult, TC
  * @param params - The poll parameters.
  * @returns A {@link Promise} that resolves with the first accepted `poll` result.
  */
-export declare function pollInObsidian<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Args, PollResult, TContextId>): Promise<PollResult>;
+export declare function pollInObsidian<Input extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Input, PollResult, TContextId>): Promise<PollResult>;