obsidian-integration-testing 11.0.0 → 12.1.0

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

@@ -1,14 +1,32 @@
 /**
  * @file
  *
- * Pure builder for the diagnostic message describing an auto-started child
- * process (the Android emulator or the Appium server) that died during startup,
- * appending the captured output tail when available.
+ * Pure builders for the diagnostic message describing an auto-started child
+ * process (the Android emulator or the Appium server) that failed during
+ * startup, appending the captured output tail when available.
+ *
+ * A startup fails two ways — the process **dies**, or it **hangs** past a
+ * budget — and the captured tail is equally the explanation in both. So the
+ * tail-appending half is its own export, used by the timeout throws that once
+ * reported only the budget they blew.
  *
  * Kept separate from the integration-only `transport-factory` (excluded from
  * unit tests) so the message formatting stays unit-testable — the launchers
  * themselves spawn real processes.
  */
+/**
+ * Parameters for {@link appendProcessOutputTail}.
+ */
+export interface AppendProcessOutputTailParams {
+    /**
+    The captured stdout+stderr tail (empty when none was captured).
+     */
+    readonly output: string;
+    /**
+    Label for the captured output section (e.g. `"Emulator output"`).
+     */
+    readonly outputLabel: string;
+}
 /**
  * Parameters for {@link buildProcessExitMessage}.
  */
@@ -51,6 +69,22 @@ export interface ProcessExitInfo {
      */
     readonly spawnError?: string;
 }
+/**
+ * Appends a process's captured output tail to a message, when there is one.
+ *
+ * Split out of {@link buildProcessExitMessage} so the **timeout** failures can
+ * carry the tail too. A process that dies gets its output attached; one that
+ * hangs used to get `No new emulator device appeared within 300000ms.` and
+ * nothing else — even though the line that explains it (`FATAL | Running
+ * multiple emulators with the same AVD is an experimental feature`) had already
+ * been captured. The emulator writing its own diagnosis is worth nothing if the
+ * harness reads it on only one of the two ways a startup can fail.
+ *
+ * @param message - The failure message to extend.
+ * @param params - The captured tail and its label.
+ * @returns The message, with the tail appended when non-empty.
+ */
+export declare function appendProcessOutputTail(message: string, params: AppendProcessOutputTailParams): string;
 /**
  * Builds a descriptive error message for an auto-started child process that
  * exited (or failed to spawn) during startup, appending the captured output

package/dist/lib/cjs/process-liveness.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var process_liveness_exports = {};
+__export(process_liveness_exports, {
+  checkIsProcessAlive: () => checkIsProcessAlive
+});
+module.exports = __toCommonJS(process_liveness_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+function checkIsProcessAlive(pid) {
+  try {
+    import_node_process.default.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsProcessAlive
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/process-liveness.d.cts

@@ -0,0 +1,18 @@
+/**
+ * @file
+ *
+ * Cheap, synchronous "is this PID still running?" probe.
+ *
+ * Signal `0` performs the permission and existence checks without delivering a
+ * signal, on Windows as well as POSIX, so it costs nothing at teardown-poll
+ * frequency. `EPERM` means the process exists but is owned by another user —
+ * still alive, and the distinction matters: reading it as dead is how a
+ * teardown convinces itself a process it could not touch is gone.
+ */
+/**
+ * Checks whether a process is still running.
+ *
+ * @param pid - The PID to probe.
+ * @returns `true` when the process exists.
+ */
+export declare function checkIsProcessAlive(pid: number): boolean;

package/dist/lib/cjs/release-catalog.cjs

@@ -0,0 +1,73 @@
+"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 release_catalog_exports = {};
+__export(release_catalog_exports, {
+  CATALYST_ASAR_RELEASE_BASE_URL: () => CATALYST_ASAR_RELEASE_BASE_URL,
+  buildCatalystAsarUrl: () => buildCatalystAsarUrl,
+  resolveReleaseChannel: () => resolveReleaseChannel,
+  selectReleaseDownloads: () => selectReleaseDownloads
+});
+module.exports = __toCommonJS(release_catalog_exports);
+var import_installer_asset = require("./installer-asset.cjs");
+var import_obsidian_version = require("./obsidian-version.cjs");
+const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
+const INSTALLER_KEYS_BY_PLATFORM = [
+  ["dmg", "darwin"],
+  ["exe", "win32"],
+  ["tar", "linux"]
+];
+function buildCatalystAsarUrl(version) {
+  return `${CATALYST_ASAR_RELEASE_BASE_URL}/${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`;
+}
+function resolveReleaseChannel(params) {
+  if (params.hasPublicRelease) {
+    return params.hasPublicPage && params.hasCatalystPage ? "public+catalyst" : "public";
+  }
+  return params.hasCatalystPage ? "catalyst" : void 0;
+}
+function selectReleaseDownloads(params) {
+  const { assets, version } = params;
+  const assetNames = assets.map((asset) => asset.name);
+  const urlByName = new Map(assets.map((asset) => [asset.name, asset.url]));
+  const downloads = {};
+  const apkUrl = urlByName.get(`Obsidian-${version}.apk`);
+  if (apkUrl !== void 0) {
+    downloads["apk"] = apkUrl;
+  }
+  const asarUrl = urlByName.get(`${(0, import_obsidian_version.getVersionAsarFileName)(version)}.gz`);
+  if (asarUrl !== void 0) {
+    downloads["asar"] = asarUrl;
+  }
+  for (const [key, platform] of INSTALLER_KEYS_BY_PLATFORM) {
+    const assetName = (0, import_installer_asset.selectInstallerAssetName)({ assetNames, platform, version });
+    const url = assetName === void 0 ? void 0 : urlByName.get(assetName);
+    if (url !== void 0) {
+      downloads[key] = url;
+    }
+  }
+  return Object.keys(downloads).length > 0 ? downloads : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CATALYST_ASAR_RELEASE_BASE_URL,
+  buildCatalystAsarUrl,
+  resolveReleaseChannel,
+  selectReleaseDownloads
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/release-catalog.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for building the repo-root `metadata.json` catalog from Obsidian's\n * **own** publication endpoints, with no third-party catalog in the loop.\n *\n * `scripts/refresh-metadata.ts` drives the network side (the\n * `obsidianmd/obsidian-releases` GitHub Releases API, `obsidian.md/changelog.xml`\n * and `desktop-releases.json`); everything decidable without the network lives\n * here so it stays unit-tested.\n *\n * Three decisions are encoded:\n *\n * - **Which release assets become `downloads` keys.** A release's real asset list\n *   is matched rather than templated, reusing {@link selectInstallerAssetName} for\n *   the desktop installers so the historical dot-vs-hyphen separator rename (and\n *   the `-universal` dmg infix) is handled in exactly one place. The 32-bit,\n *   arm64, AppImage, deb and snap siblings are deliberately not carried \u2014 this\n *   harness downloads only the x64 installer, the app asar and the Android apk.\n * - **Which channel a version belongs to**, derived from which changelog pages\n *   the feed published for it (see {@link resolveReleaseChannel}).\n * - **Where a catalyst asar lives** ({@link buildCatalystAsarUrl}) \u2014 the one asset\n *   with no listing API behind it, so its URL must be constructed and probed.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';\n\nimport { selectInstallerAssetName } from './installer-asset.cjs';\nimport { getVersionAsarFileName } from './obsidian-version.cjs';\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), and the endpoint\n * is Cloudflare-gated against non-browser clients, so a probe needs a browser\n * `User-Agent`.\n */\nexport const CATALYST_ASAR_RELEASE_BASE_URL = 'https://releases.obsidian.md/release';\n\n/**\n * One asset of a GitHub release, reduced to what the catalog needs.\n */\nexport interface ReleaseAsset {\n  /**\n  The published asset file name, e.g. `Obsidian-1.13.7.exe`.\n   */\n  readonly name: string;\n\n  /**\n  The asset's direct download URL (`browser_download_url`).\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link resolveReleaseChannel}.\n */\nexport interface ResolveReleaseChannelParams {\n  /**\n  Whether the changelog feed published a catalyst (\"Early access\") desktop page.\n   */\n  readonly hasCatalystPage: boolean;\n\n  /**\n  Whether the changelog feed published a public desktop page.\n   */\n  readonly hasPublicPage: boolean;\n\n  /**\n   * Whether the version was published as a GitHub release \u2014 the evidence that it\n   * shipped on the public channel, since catalyst builds are served only from\n   * the `releases.obsidian.md` CDN.\n   */\n  readonly hasPublicRelease: boolean;\n}\n\n/**\n * Parameters for {@link selectReleaseDownloads}.\n */\nexport interface SelectReleaseDownloadsParams {\n  /**\n  The release's published assets.\n   */\n  readonly assets: readonly ReleaseAsset[];\n\n  /**\n  The concrete `x.y.z` version the release publishes.\n   */\n  readonly version: string;\n}\n\n/**\n * The desktop-installer `downloads` keys, paired with the platform whose asset\n * shape {@link selectInstallerAssetName} resolves for them.\n */\nconst INSTALLER_KEYS_BY_PLATFORM: readonly (readonly [key: 'dmg' | 'exe' | 'tar', platform: NodeJS.Platform])[] = [\n  ['dmg', 'darwin'],\n  ['exe', 'win32'],\n  ['tar', 'linux']\n];\n\n/**\n * Builds the catalyst asar URL for a version.\n *\n * Catalyst builds are not published as GitHub release assets, and the CDN that\n * serves them has no listing API, so this URL is constructed rather than\n * discovered \u2014 the caller probes it before recording it.\n *\n * @param version - The concrete `x.y.z` version.\n * @returns The `releases.obsidian.md` asar URL for the version.\n */\nexport function buildCatalystAsarUrl(version: string): string {\n  return `${CATALYST_ASAR_RELEASE_BASE_URL}/${getVersionAsarFileName(version)}.gz`;\n}\n\n/**\n * Derives a version's release channel from where it was published and which\n * changelog pages the feed carries for it.\n *\n * **Publication is the primary evidence, not the feed's title marker.** The feed\n * tags each entry `(Public)` or `(Early access)`, but through the pre-1.0 era it\n * tagged *everything* early-access \u2014 the whole app was \u2014 so 61 versions that\n * shipped as ordinary GitHub releases carry only a catalyst page. Trusting the\n * marker alone therefore relabels a large slice of public history as catalyst.\n * A GitHub release is unambiguous the other way round: catalyst builds are\n * served only from the `releases.obsidian.md` CDN, never as release assets.\n *\n * So a version that was published on GitHub is public, and it is recorded as the\n * combined `'public+catalyst'` only when the feed carries *both* desktop pages \u2014\n * the shape every version already labelled `'public+catalyst'` has.\n *\n * @param params - The publication evidence and the desktop pages the feed published.\n * @returns The channel, or `undefined` when there is no evidence either way (the\n *   caller then keeps whatever the version already carries).\n */\nexport function resolveReleaseChannel(params: ResolveReleaseChannelParams): string | undefined {\n  if (params.hasPublicRelease) {\n    return params.hasPublicPage && params.hasCatalystPage ? 'public+catalyst' : 'public';\n  }\n\n  return params.hasCatalystPage ? 'catalyst' : undefined;\n}\n\n/**\n * Picks the assets this harness downloads out of a GitHub release's real asset\n * list: the x64 desktop installers, the app asar and the Android apk.\n *\n * Assets are matched against the **release's own version**, so an early-access\n * tag whose assets carry the base version instead (`v1.1.8-E21` publishing\n * `Obsidian.1.1.8.exe`, `v1.6.3-e30` publishing `Obsidian.1.6.3.exe`) matches\n * nothing and is skipped \u2014 deliberately, since those assets are the base\n * version's, not the tag's.\n *\n * @param params - The release's assets and its version.\n * @returns The distilled download URLs, or `undefined` when the release\n *   publishes none of them.\n */\nexport function selectReleaseDownloads(params: SelectReleaseDownloadsParams): ObsidianVersionDownloads | undefined {\n  const { assets, version } = params;\n  const assetNames = assets.map((asset) => asset.name);\n  const urlByName = new Map(assets.map((asset) => [asset.name, asset.url]));\n  const downloads: Record<string, string> = {};\n\n  const apkUrl = urlByName.get(`Obsidian-${version}.apk`);\n  if (apkUrl !== undefined) {\n    downloads['apk'] = apkUrl;\n  }\n\n  const asarUrl = urlByName.get(`${getVersionAsarFileName(version)}.gz`);\n  if (asarUrl !== undefined) {\n    downloads['asar'] = asarUrl;\n  }\n\n  for (const [key, platform] of INSTALLER_KEYS_BY_PLATFORM) {\n    const assetName = selectInstallerAssetName({ assetNames, platform, version });\n    const url = assetName === undefined ? undefined : urlByName.get(assetName);\n    if (url !== undefined) {\n      downloads[key] = url;\n    }\n  }\n\n  return Object.keys(downloads).length > 0 ? downloads : undefined;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,6BAAyC;AACzC,8BAAuC;AAShC,MAAM,iCAAiC;AA0D9C,MAAM,6BAA4G;AAAA,EAChH,CAAC,OAAO,QAAQ;AAAA,EAChB,CAAC,OAAO,OAAO;AAAA,EACf,CAAC,OAAO,OAAO;AACjB;AAYO,SAAS,qBAAqB,SAAyB;AAC5D,SAAO,GAAG,8BAA8B,QAAI,gDAAuB,OAAO,CAAC;AAC7E;AAsBO,SAAS,sBAAsB,QAAyD;AAC7F,MAAI,OAAO,kBAAkB;AAC3B,WAAO,OAAO,iBAAiB,OAAO,kBAAkB,oBAAoB;AAAA,EAC9E;AAEA,SAAO,OAAO,kBAAkB,aAAa;AAC/C;AAgBO,SAAS,uBAAuB,QAA4E;AACjH,QAAM,EAAE,QAAQ,QAAQ,IAAI;AAC5B,QAAM,aAAa,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;AACnD,QAAM,YAAY,IAAI,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC;AACxE,QAAM,YAAoC,CAAC;AAE3C,QAAM,SAAS,UAAU,IAAI,YAAY,OAAO,MAAM;AACtD,MAAI,WAAW,QAAW;AACxB,cAAU,KAAK,IAAI;AAAA,EACrB;AAEA,QAAM,UAAU,UAAU,IAAI,OAAG,gDAAuB,OAAO,CAAC,KAAK;AACrE,MAAI,YAAY,QAAW;AACzB,cAAU,MAAM,IAAI;AAAA,EACtB;AAEA,aAAW,CAAC,KAAK,QAAQ,KAAK,4BAA4B;AACxD,UAAM,gBAAY,iDAAyB,EAAE,YAAY,UAAU,QAAQ,CAAC;AAC5E,UAAM,MAAM,cAAc,SAAY,SAAY,UAAU,IAAI,SAAS;AACzE,QAAI,QAAQ,QAAW;AACrB,gBAAU,GAAG,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,IAAI,YAAY;AACzD;",
  "names": []
}


package/dist/lib/cjs/release-catalog.d.cts

@@ -0,0 +1,125 @@
+/**
+ * @file
+ *
+ * Pure helpers for building the repo-root `metadata.json` catalog from Obsidian's
+ * **own** publication endpoints, with no third-party catalog in the loop.
+ *
+ * `scripts/refresh-metadata.ts` drives the network side (the
+ * `obsidianmd/obsidian-releases` GitHub Releases API, `obsidian.md/changelog.xml`
+ * and `desktop-releases.json`); everything decidable without the network lives
+ * here so it stays unit-tested.
+ *
+ * Three decisions are encoded:
+ *
+ * - **Which release assets become `downloads` keys.** A release's real asset list
+ *   is matched rather than templated, reusing {@link selectInstallerAssetName} for
+ *   the desktop installers so the historical dot-vs-hyphen separator rename (and
+ *   the `-universal` dmg infix) is handled in exactly one place. The 32-bit,
+ *   arm64, AppImage, deb and snap siblings are deliberately not carried — this
+ *   harness downloads only the x64 installer, the app asar and the Android apk.
+ * - **Which channel a version belongs to**, derived from which changelog pages
+ *   the feed published for it (see {@link resolveReleaseChannel}).
+ * - **Where a catalyst asar lives** ({@link buildCatalystAsarUrl}) — the one asset
+ *   with no listing API behind it, so its URL must be constructed and probed.
+ */
+import type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';
+/**
+ * Base URL for **catalyst** (early access / insider) release asars, served from
+ * the Obsidian CDN as `.../release/obsidian-<version>.asar.gz`. Public versions
+ * are NOT hosted here (the CDN returns an empty body for them), and the endpoint
+ * is Cloudflare-gated against non-browser clients, so a probe needs a browser
+ * `User-Agent`.
+ */
+export declare const CATALYST_ASAR_RELEASE_BASE_URL = "https://releases.obsidian.md/release";
+/**
+ * One asset of a GitHub release, reduced to what the catalog needs.
+ */
+export interface ReleaseAsset {
+    /**
+    The published asset file name, e.g. `Obsidian-1.13.7.exe`.
+     */
+    readonly name: string;
+    /**
+    The asset's direct download URL (`browser_download_url`).
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link resolveReleaseChannel}.
+ */
+export interface ResolveReleaseChannelParams {
+    /**
+    Whether the changelog feed published a catalyst ("Early access") desktop page.
+     */
+    readonly hasCatalystPage: boolean;
+    /**
+    Whether the changelog feed published a public desktop page.
+     */
+    readonly hasPublicPage: boolean;
+    /**
+     * Whether the version was published as a GitHub release — the evidence that it
+     * shipped on the public channel, since catalyst builds are served only from
+     * the `releases.obsidian.md` CDN.
+     */
+    readonly hasPublicRelease: boolean;
+}
+/**
+ * Parameters for {@link selectReleaseDownloads}.
+ */
+export interface SelectReleaseDownloadsParams {
+    /**
+    The release's published assets.
+     */
+    readonly assets: readonly ReleaseAsset[];
+    /**
+    The concrete `x.y.z` version the release publishes.
+     */
+    readonly version: string;
+}
+/**
+ * Builds the catalyst asar URL for a version.
+ *
+ * Catalyst builds are not published as GitHub release assets, and the CDN that
+ * serves them has no listing API, so this URL is constructed rather than
+ * discovered — the caller probes it before recording it.
+ *
+ * @param version - The concrete `x.y.z` version.
+ * @returns The `releases.obsidian.md` asar URL for the version.
+ */
+export declare function buildCatalystAsarUrl(version: string): string;
+/**
+ * Derives a version's release channel from where it was published and which
+ * changelog pages the feed carries for it.
+ *
+ * **Publication is the primary evidence, not the feed's title marker.** The feed
+ * tags each entry `(Public)` or `(Early access)`, but through the pre-1.0 era it
+ * tagged *everything* early-access — the whole app was — so 61 versions that
+ * shipped as ordinary GitHub releases carry only a catalyst page. Trusting the
+ * marker alone therefore relabels a large slice of public history as catalyst.
+ * A GitHub release is unambiguous the other way round: catalyst builds are
+ * served only from the `releases.obsidian.md` CDN, never as release assets.
+ *
+ * So a version that was published on GitHub is public, and it is recorded as the
+ * combined `'public+catalyst'` only when the feed carries *both* desktop pages —
+ * the shape every version already labelled `'public+catalyst'` has.
+ *
+ * @param params - The publication evidence and the desktop pages the feed published.
+ * @returns The channel, or `undefined` when there is no evidence either way (the
+ *   caller then keeps whatever the version already carries).
+ */
+export declare function resolveReleaseChannel(params: ResolveReleaseChannelParams): string | undefined;
+/**
+ * Picks the assets this harness downloads out of a GitHub release's real asset
+ * list: the x64 desktop installers, the app asar and the Android apk.
+ *
+ * Assets are matched against the **release's own version**, so an early-access
+ * tag whose assets carry the base version instead (`v1.1.8-E21` publishing
+ * `Obsidian.1.1.8.exe`, `v1.6.3-e30` publishing `Obsidian.1.6.3.exe`) matches
+ * nothing and is skipped — deliberately, since those assets are the base
+ * version's, not the tag's.
+ *
+ * @param params - The release's assets and its version.
+ * @returns The distilled download URLs, or `undefined` when the release
+ *   publishes none of them.
+ */
+export declare function selectReleaseDownloads(params: SelectReleaseDownloadsParams): ObsidianVersionDownloads | undefined;

package/dist/lib/cjs/run-version-matrix.cjs

@@ -61,4 +61,4 @@ function logPlan(resolvedSpecs, entries) {
 0 && (module.exports = {
   runObsidianVersionMatrix
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/run-version-matrix.d.cts

@@ -32,7 +32,7 @@ export interface RunObsidianVersionMatrixParams {
      * so an env var can be passed straight through.
      *
      * Each accepts an explicit `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`.
-     * Defaults to both ends of the supported range (G99) when omitted or empty, and
+     * Defaults to both ends of the supported range when omitted or empty, and
      * the list is always de-duplicated on the **resolved** version — so when public
      * has caught up to catalyst, the suites run once.
      */

package/dist/lib/cjs/teardown-verdict.cjs

@@ -0,0 +1,53 @@
+"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 teardown_verdict_exports = {};
+__export(teardown_verdict_exports, {
+  buildTeardownMessage: () => buildTeardownMessage,
+  resolveTeardownOutcome: () => resolveTeardownOutcome
+});
+module.exports = __toCommonJS(teardown_verdict_exports);
+var import_type_guards = require("./type-guards.cjs");
+function buildTeardownMessage(params) {
+  switch (params.outcome) {
+    case "still-running": {
+      return `WARNING: ${params.subject} did not exit within ${String(params.timeoutInMilliseconds)}ms and still holds ${params.evidence}; a later run may adopt it. Kill it before the next Android run.`;
+    }
+    case "stopped": {
+      return `${params.subject} stopped (verified: ${params.evidence} released).`;
+    }
+    case "stopped-after-escalation": {
+      return `${params.subject} stopped after escalation (verified: ${params.evidence} released).`;
+    }
+    default: {
+      return (0, import_type_guards.assertNever)(params.outcome);
+    }
+  }
+}
+function resolveTeardownOutcome(params) {
+  if (!params.isStopped) {
+    return "still-running";
+  }
+  return params.hasEscalated ? "stopped-after-escalation" : "stopped";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTeardownMessage,
+  resolveTeardownOutcome
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/teardown-verdict.d.cts

@@ -0,0 +1,69 @@
+/**
+ * @file
+ *
+ * Pure verdict + message building for the auto-started-process teardown.
+ *
+ * The teardown used to log `Auto-started Appium server stopped.` on the
+ * **attempt** — printed unconditionally right after the kill was issued, with
+ * nothing asserting the process had actually exited. On 2026-09-02 both the
+ * server and the emulator were still serving ten minutes after that line was
+ * written, and the next run adopted them and died two seconds into its session
+ * as they finally finished dying. A log that says the machine is clean when it
+ * is not does not merely fail to help — it sends the next reader away from the
+ * cause.
+ *
+ * So a stop is a claim that has to be earned: only {@link resolveTeardownOutcome}
+ * may decide one was, and only the `stopped` outcomes are allowed to say so.
+ */
+/**
+ * Parameters for {@link buildTeardownMessage}.
+ */
+export interface BuildTeardownMessageParams {
+    /**
+    What was checked, as a noun phrase — e.g. `port 4723`, `AVD "obsidian_test" on device emulator-5554`.
+     */
+    readonly evidence: string;
+    /**
+    The verdict from {@link resolveTeardownOutcome}.
+     */
+    readonly outcome: TeardownOutcome;
+    /**
+    What was being stopped — e.g. `Auto-started Appium server`.
+     */
+    readonly subject: string;
+    /**
+    The budget the stop was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Parameters for {@link resolveTeardownOutcome}.
+ */
+export interface ResolveTeardownOutcomeParams {
+    /**
+    Whether the first kill was followed by a second, harder one.
+     */
+    readonly hasEscalated: boolean;
+    /**
+    Whether the process was **observed** to be gone, rather than merely asked to go.
+     */
+    readonly isStopped: boolean;
+}
+/**
+ * What the teardown actually achieved.
+ */
+export type TeardownOutcome = 'still-running' | 'stopped-after-escalation' | 'stopped';
+/**
+ * Builds the line the teardown logs for an outcome.
+ *
+ * @param params - The outcome plus what was being stopped and what proved it.
+ * @returns The log line.
+ */
+export declare function buildTeardownMessage(params: BuildTeardownMessageParams): string;
+/**
+ * Decides what the teardown achieved, from what was observed after the kill.
+ *
+ * @param params - Whether the process is gone, and whether it took an escalation.
+ * @returns The outcome.
+ */
+export declare function resolveTeardownOutcome(params: ResolveTeardownOutcomeParams): TeardownOutcome;