obsidian-integration-testing 8.2.1 → 8.4.0

package/dist/lib/cjs/ecmascript-version.cjs

@@ -0,0 +1,63 @@
+"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 ecmascript_version_exports = {};
+__export(ecmascript_version_exports, {
+  deriveEcmaScriptVersion: () => deriveEcmaScriptVersion
+});
+module.exports = __toCommonJS(ecmascript_version_exports);
+const CHROME_MAJOR_FOR_ES2015 = 51;
+const CHROME_MAJOR_FOR_ES2016 = 52;
+const CHROME_MAJOR_FOR_ES2017 = 58;
+const CHROME_MAJOR_FOR_ES2018 = 64;
+const CHROME_MAJOR_FOR_ES2019 = 73;
+const CHROME_MAJOR_FOR_ES2020 = 80;
+const CHROME_MAJOR_FOR_ES2021 = 85;
+const CHROME_MAJOR_FOR_ES2022 = 94;
+const CHROME_MAJOR_FOR_ES2023 = 110;
+const CHROME_MAJOR_FOR_ES2024 = 122;
+const ECMA_SCRIPT_BREAKPOINTS = [
+  { ecmaScriptVersion: "ES2024", minChromeMajor: CHROME_MAJOR_FOR_ES2024 },
+  { ecmaScriptVersion: "ES2023", minChromeMajor: CHROME_MAJOR_FOR_ES2023 },
+  { ecmaScriptVersion: "ES2022", minChromeMajor: CHROME_MAJOR_FOR_ES2022 },
+  { ecmaScriptVersion: "ES2021", minChromeMajor: CHROME_MAJOR_FOR_ES2021 },
+  { ecmaScriptVersion: "ES2020", minChromeMajor: CHROME_MAJOR_FOR_ES2020 },
+  { ecmaScriptVersion: "ES2019", minChromeMajor: CHROME_MAJOR_FOR_ES2019 },
+  { ecmaScriptVersion: "ES2018", minChromeMajor: CHROME_MAJOR_FOR_ES2018 },
+  { ecmaScriptVersion: "ES2017", minChromeMajor: CHROME_MAJOR_FOR_ES2017 },
+  { ecmaScriptVersion: "ES2016", minChromeMajor: CHROME_MAJOR_FOR_ES2016 },
+  { ecmaScriptVersion: "ES2015", minChromeMajor: CHROME_MAJOR_FOR_ES2015 }
+];
+const DECIMAL_RADIX = 10;
+function deriveEcmaScriptVersion(chromeVersion) {
+  const chromeMajor = Number.parseInt(chromeVersion, DECIMAL_RADIX);
+  if (Number.isNaN(chromeMajor)) {
+    return void 0;
+  }
+  for (const breakpoint of ECMA_SCRIPT_BREAKPOINTS) {
+    if (chromeMajor >= breakpoint.minChromeMajor) {
+      return breakpoint.ecmaScriptVersion;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveEcmaScriptVersion
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/ecmascript-version.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @file
+ *
+ * Pure derivation of the ECMAScript language level supported by a given
+ * Chromium (V8) version, expressed as an ECMAScript-edition string (e.g. `'ES2022'`).
+ *
+ * A serialized `evalInObsidian` closure runs in Obsidian's Chromium renderer, so
+ * the ES features it may safely use are bounded by that shell's Chromium version.
+ * The empirically-collected `runtimeVersions.chrome` (see
+ * {@link ObsidianRuntimeVersions} and `scripts/collect-runtime-versions.ts`) is
+ * fed through {@link deriveEcmaScriptVersion} to bake a per-version
+ * `ecmaScriptVersion` into `metadata.json`, so a consumer pinning an installer can
+ * tell offline which ES level is safe.
+ *
+ * The Chromium-major → ES-year breakpoints below are the Chromium releases at
+ * which each yearly ECMAScript edition became fully supported, per MDN /
+ * caniuse / the ECMAScript compatibility tables. They are a curated table, not
+ * derived from anything else, so this module is pure and unit-tested to the 100% gate.
+ */
+/**
+ * Derives the highest fully-supported ECMAScript edition for a Chromium version.
+ *
+ * @param chromeVersion - A Chromium version string (e.g. `'114.0.5735.289'`);
+ *   only the leading major segment is significant.
+ * @returns The ECMAScript-edition label (e.g. `'ES2022'`), or `undefined` when the
+ *   version cannot be parsed or its Chromium major predates the earliest tracked edition.
+ */
+export declare function deriveEcmaScriptVersion(chromeVersion: string): string | undefined;

package/dist/lib/cjs/electron-compatibility.cjs

@@ -0,0 +1,46 @@
+"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 electron_compatibility_exports = {};
+__export(electron_compatibility_exports, {
+  checkElectronCompatibility: () => checkElectronCompatibility
+});
+module.exports = __toCommonJS(electron_compatibility_exports);
+var import_obsidian_version = require("./obsidian-version.cjs");
+function checkElectronCompatibility(params) {
+  const { actualElectronVersion, appVersion, metadata } = params;
+  const minRecommendedElectronVersion = metadata?.minRecommendedElectronVersion;
+  if (actualElectronVersion === void 0 || minRecommendedElectronVersion === void 0) {
+    return { actualElectronVersion: actualElectronVersion ?? null, appVersion, tier: "unknown" };
+  }
+  if ((0, import_obsidian_version.compareVersions)(actualElectronVersion, minRecommendedElectronVersion) < 0) {
+    return {
+      actualElectronVersion,
+      appVersion,
+      message: `Obsidian ${appVersion} runs on Electron ${actualElectronVersion} but recommends Electron ${minRecommendedElectronVersion} or newer; pin a newer obsidianInstallerVersion for full compatibility.`,
+      minRecommendedElectronVersion,
+      tier: "nagged"
+    };
+  }
+  return { actualElectronVersion, appVersion, minRecommendedElectronVersion, tier: "ok" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkElectronCompatibility
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/electron-compatibility.d.cts

@@ -0,0 +1,74 @@
+/**
+ * @file
+ *
+ * Pure verdict on whether the Electron version an owned Obsidian instance is
+ * actually running is new enough for the resolved app version. Kept separate from
+ * the integration-only `transport-desktop-cdp` (which reads the live version over
+ * CDP and is excluded from unit tests) so the tier logic stays unit-testable —
+ * mirroring the `installer-compatibility` / `renderer-boot-detection` split.
+ *
+ * This is the tier-2 companion to `installer-compatibility`. That one is fully
+ * offline — it compares the resolved installer version against installer-version
+ * thresholds. But the app's real requirement is a **minimum Electron version**
+ * hardcoded inside `app.js` (e.g. `1.13.1` needs Electron `28.2.3`), and the
+ * installer's bundled Electron is not derivable offline (see
+ * {@link ObsidianVersionMetadata.minRecommendedElectronVersion}). So this verdict
+ * takes the **live** `process.versions.electron` read from the booted renderer and
+ * compares it to `minRecommendedElectronVersion` from `metadata.json`.
+ *
+ * An Electron below the recommendation runs but is nagged (`'nagged'`) — Obsidian
+ * would show its "installer too old" recommendation; it never blocks, so there is
+ * no `'unrunnable'` tier here. When the live version is unreadable or the app
+ * version carries no recommended Electron, the verdict is `'unknown'` and nothing
+ * is warned.
+ */
+import type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';
+/**
+ * Parameters for {@link checkElectronCompatibility}.
+ */
+export interface CheckElectronCompatibilityParams {
+    /** The Electron version the instance is actually running, or `undefined` when unreadable. */
+    readonly actualElectronVersion: string | undefined;
+    /** The resolved Obsidian app (asar) version that is running. */
+    readonly appVersion: string;
+    /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */
+    readonly metadata: ObsidianVersionMetadata | undefined;
+}
+/**
+ * The runtime Electron compatibility verdict for a booted owned instance, carried
+ * as data on the transport / connection result so consumers can assert on it.
+ */
+export interface ElectronCompatibility {
+    /** The Electron version the instance is actually running, or `null` when unreadable. */
+    readonly actualElectronVersion: null | string;
+    /** The resolved Obsidian app (asar) version that is running. */
+    readonly appVersion: string;
+    /** A human-readable explanation, present for the `'nagged'` tier. */
+    readonly message?: string;
+    /** The app's recommended-minimum Electron version, when the table carries one. */
+    readonly minRecommendedElectronVersion?: string;
+    /** The resolved compatibility tier. */
+    readonly tier: ElectronCompatibilityTier;
+}
+/**
+ * The runtime Electron compatibility tier for a booted owned instance.
+ *
+ * - `'ok'` — the running Electron is at or above the app's recommended minimum.
+ * - `'nagged'` — the running Electron is below the recommended minimum; Obsidian
+ *   runs but would show its "installer too old" recommendation.
+ * - `'unknown'` — cannot be determined (the live version was unreadable, or the
+ *   app version carries no recommended Electron version in the table).
+ */
+export type ElectronCompatibilityTier = 'nagged' | 'ok' | 'unknown';
+/**
+ * Computes the runtime Electron compatibility verdict for a booted owned instance.
+ *
+ * Only `'nagged'` warrants a warning; `'ok'` and `'unknown'` are silent. An
+ * Electron mismatch never blocks, so there is no error tier. Comparisons are pure
+ * `x.y.z` version compares — no I/O.
+ *
+ * @param params - The running app version, the live Electron version, and the app
+ *   version's metadata entry.
+ * @returns The compatibility verdict.
+ */
+export declare function checkElectronCompatibility(params: CheckElectronCompatibilityParams): ElectronCompatibility;

package/dist/lib/cjs/index.cjs

@@ -23,7 +23,10 @@ __export(index_exports, {
   DesktopCdpTransport: () => import_transport_desktop_cdp.DesktopCdpTransport,
   IncompatibleInstallerVersionError: () => import_incompatible_installer_version_error.IncompatibleInstallerVersionError,
   RendererFailedToInitializeError: () => import_renderer_failed_to_initialize_error.RendererFailedToInitializeError,
+  SilentAsarFallbackError: () => import_silent_asar_fallback_error.SilentAsarFallbackError,
   TempVault: () => import_temp_vault.TempVault,
+  checkAsarFallback: () => import_asar_fallback_detection.checkAsarFallback,
+  checkElectronCompatibility: () => import_electron_compatibility.checkElectronCompatibility,
   checkInstallerCompatibility: () => import_installer_compatibility.checkInstallerCompatibility,
   connectToCdp: () => import_connect_to_cdp.connectToCdp,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
@@ -36,15 +39,18 @@ __export(index_exports, {
   unregisterVault: () => import_vault_registry.unregisterVault
 });
 module.exports = __toCommonJS(index_exports);
+var import_asar_fallback_detection = require("./asar-fallback-detection.cjs");
 var import_connect_to_cdp = require("./connect-to-cdp.cjs");
 var import_context_id = require("./context-id.cjs");
 var import_context_provider = require("./context-provider.cjs");
+var import_electron_compatibility = require("./electron-compatibility.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
 var import_installer_compatibility = require("./installer-compatibility.cjs");
 var import_lib_registry = require("./lib-registry.cjs");
 var import_obsidian_metadata = require("./obsidian-metadata.cjs");
 var import_renderer_failed_to_initialize_error = require("./renderer-failed-to-initialize-error.cjs");
+var import_silent_asar_fallback_error = require("./silent-asar-fallback-error.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_appium = require("./transport-appium.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
@@ -57,7 +63,10 @@ var import_vault_registry = require("./vault-registry.cjs");
   DesktopCdpTransport,
   IncompatibleInstallerVersionError,
   RendererFailedToInitializeError,
+  SilentAsarFallbackError,
   TempVault,
+  checkAsarFallback,
+  checkElectronCompatibility,
   checkInstallerCompatibility,
   connectToCdp,
   createTransportFromOptions,
@@ -69,4 +78,4 @@ var import_vault_registry = require("./vault-registry.cjs");
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ29udGFpbnMgdGhlIGVudHJ5IHBvaW50IGZvciB0aGUgaW50ZWdyYXRpb24gdGVzdGluZyBtb2R1bGUuXG4gKi9cblxuZXhwb3J0IHR5cGUge1xuICBBc2FyRmFsbGJhY2ssXG4gIEFzYXJGYWxsYmFja1RpZXIsXG4gIENoZWNrQXNhckZhbGxiYWNrUGFyYW1zXG59IGZyb20gJy4vYXNhci1mYWxsYmFjay1kZXRlY3Rpb24uY2pzJztcbmV4cG9ydCB7IGNoZWNrQXNhckZhbGxiYWNrIH0gZnJvbSAnLi9hc2FyLWZhbGxiYWNrLWRldGVjdGlvbi5janMnO1xuZXhwb3J0IHR5cGUge1xuICBDZHBDb25uZWN0aW9uLFxuICBDb25uZWN0VG9DZHBPcHRpb25zXG59IGZyb20gJy4vY29ubmVjdC10by1jZHAuY2pzJztcbmV4cG9ydCB7IGNvbm5lY3RUb0NkcCB9IGZyb20gJy4vY29ubmVjdC10by1jZHAuY2pzJztcbmV4cG9ydCB7IENvbnRleHRJZCB9IGZyb20gJy4vY29udGV4dC1pZC5janMnO1xuZXhwb3J0IHR5cGUge1xuICBUcmFuc3BvcnRPcHRpb25zUmVzb2x2ZXIsXG4gIFZhdWx0UGF0aFJlc29sdmVyXG59IGZyb20gJy4vY29udGV4dC1wcm92aWRlci5janMnO1xuZXhwb3J0IHtcbiAgc2V0VHJhbnNwb3J0T3B0aW9uc1Jlc29sdmVyLFxuICBzZXRWYXVsdFBhdGhSZXNvbHZlclxufSBmcm9tICcuL2NvbnRleHQtcHJvdmlkZXIuY2pzJztcbmV4cG9ydCB0eXBlIHtcbiAgQ2hlY2tFbGVjdHJvbkNvbXBhdGliaWxpdHlQYXJhbXMsXG4gIEVsZWN0cm9uQ29tcGF0aWJpbGl0eSxcbiAgRWxlY3Ryb25Db21wYXRpYmlsaXR5VGllclxufSBmcm9tICcuL2VsZWN0cm9uLWNvbXBhdGliaWxpdHkuY2pzJztcbmV4cG9ydCB7IGNoZWNrRWxlY3Ryb25Db21wYXRpYmlsaXR5IH0gZnJvbSAnLi9lbGVjdHJvbi1jb21wYXRpYmlsaXR5LmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIEV2YWxJbk9ic2lkaWFuUGFyYW1zLFxuICBIb3ZlckVsZW1lbnRQYXJhbXMsXG4gIExpYixcbiAgTW92ZU1vdXNlUGFyYW1zLFxuICBQcmVzc0tleVBhcmFtcyxcbiAgVHlwZUludG9FZGl0b3JQYXJhbXMsXG4gIFVuaG92ZXJFbGVtZW50UGFyYW1zLFxuICBXYWl0VW50aWxQYXJhbXNcbn0gZnJvbSAnLi9ldmFsLWluLW9ic2lkaWFuLmNqcyc7XG5leHBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vZXZhbC1pbi1vYnNpZGlhbi5janMnO1xuZXhwb3J0IHR5cGUgeyBJbmNvbXBhdGlibGVJbnN0YWxsZXJWZXJzaW9uRXJyb3JDb25zdHJ1Y3RvclBhcmFtcyB9IGZyb20gJy4vaW5jb21wYXRpYmxlLWluc3RhbGxlci12ZXJzaW9uLWVycm9yLmNqcyc7XG5leHBvcnQgeyBJbmNvbXBhdGlibGVJbnN0YWxsZXJWZXJzaW9uRXJyb3IgfSBmcm9tICcuL2luY29tcGF0aWJsZS1pbnN0YWxsZXItdmVyc2lvbi1lcnJvci5janMnO1xuZXhwb3J0IHR5cGUge1xuICBDaGVja0luc3RhbGxlckNvbXBhdGliaWxpdHlQYXJhbXMsXG4gIEluc3RhbGxlckNvbXBhdGliaWxpdHksXG4gIEluc3RhbGxlckNvbXBhdGliaWxpdHlUaWVyXG59IGZyb20gJy4vaW5zdGFsbGVyLWNvbXBhdGliaWxpdHkuY2pzJztcbmV4cG9ydCB7IGNoZWNrSW5zdGFsbGVyQ29tcGF0aWJpbGl0eSB9IGZyb20gJy4vaW5zdGFsbGVyLWNvbXBhdGliaWxpdHkuY2pzJztcbmV4cG9ydCB0eXBlIHsgTGliUmVzb2x2ZXIgfSBmcm9tICcuL2xpYi1yZWdpc3RyeS5janMnO1xuZXhwb3J0IHsgcmVnaXN0ZXJMaWJSZXNvbHZlciB9IGZyb20gJy4vbGliLXJlZ2lzdHJ5LmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuUnVudGltZVZlcnNpb25zLFxuICBPYnNpZGlhblZlcnNpb25Eb3dubG9hZHMsXG4gIE9ic2lkaWFuVmVyc2lvbk1ldGFkYXRhXG59IGZyb20gJy4vb2JzaWRpYW4tbWV0YWRhdGEuY2pzJztcbmV4cG9ydCB7IGdldFZlcnNpb25NZXRhZGF0YSB9IGZyb20gJy4vb2JzaWRpYW4tbWV0YWRhdGEuY2pzJztcbmV4cG9ydCB7IFJlbmRlcmVyRmFpbGVkVG9Jbml0aWFsaXplRXJyb3IgfSBmcm9tICcuL3JlbmRlcmVyLWZhaWxlZC10by1pbml0aWFsaXplLWVycm9yLmNqcyc7XG5leHBvcnQgdHlwZSB7IFNpbGVudEFzYXJGYWxsYmFja0Vycm9yQ29uc3RydWN0b3JQYXJhbXMgfSBmcm9tICcuL3NpbGVudC1hc2FyLWZhbGxiYWNrLWVycm9yLmNqcyc7XG5leHBvcnQgeyBTaWxlbnRBc2FyRmFsbGJhY2tFcnJvciB9IGZyb20gJy4vc2lsZW50LWFzYXItZmFsbGJhY2stZXJyb3IuY2pzJztcbmV4cG9ydCB0eXBlIHtcbiAgUG9wdWxhdGVGaWxlQ29udGVudCxcbiAgUG9wdWxhdGVGaWxlc1BhcmFtc1xufSBmcm9tICcuL3RlbXAtdmF1bHQuY2pzJztcbmV4cG9ydCB7IFRlbXBWYXVsdCB9IGZyb20gJy4vdGVtcC12YXVsdC5janMnO1xuZXhwb3J0IHR5cGUge1xuICBBcHBpdW1TZXNzaW9uSW5mbyxcbiAgQXBwaXVtVHJhbnNwb3J0Q29uZmlnXG59IGZyb20gJy4vdHJhbnNwb3J0LWFwcGl1bS5janMnO1xuZXhwb3J0IHsgQXBwaXVtVHJhbnNwb3J0IH0gZnJvbSAnLi90cmFuc3BvcnQtYXBwaXVtLmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIERlc2t0b3BDZHBUcmFuc3BvcnRDb25maWcsXG4gIE93bmVkSW5zdGFuY2VBc2FyLFxuICBPd25lZEluc3RhbmNlQ29uZmlnXG59IGZyb20gJy4vdHJhbnNwb3J0LWRlc2t0b3AtY2RwLmNqcyc7XG5leHBvcnQgeyBEZXNrdG9wQ2RwVHJhbnNwb3J0IH0gZnJvbSAnLi90cmFuc3BvcnQtZGVza3RvcC1jZHAuY2pzJztcbmV4cG9ydCB7IGNyZWF0ZVRyYW5zcG9ydEZyb21PcHRpb25zIH0gZnJvbSAnLi90cmFuc3BvcnQtZmFjdG9yeS5janMnO1xuZXhwb3J0IHR5cGUge1xuICBPYnNpZGlhbkFuZHJvaWRBcHBpdW1UcmFuc3BvcnRPcHRpb25zLFxuICBPYnNpZGlhbkNkcFRyYW5zcG9ydE9wdGlvbnMsXG4gIE9ic2lkaWFuVHJhbnNwb3J0T3B0aW9uc1xufSBmcm9tICcuL3RyYW5zcG9ydC1vcHRpb25zLmNqcyc7XG5leHBvcnQgdHlwZSB7XG4gIE9ic2lkaWFuVHJhbnNwb3J0LFxuICBUcmFuc3BvcnRFdmFsT3B0aW9uc1xufSBmcm9tICcuL3RyYW5zcG9ydC5janMnO1xuZXhwb3J0IHtcbiAgcmVnaXN0ZXJWYXVsdCxcbiAgdW5yZWdpc3RlclZhdWx0XG59IGZyb20gJy4vdmF1bHQtcmVnaXN0cnkuY2pzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFXQSxxQ0FBa0M7QUFLbEMsNEJBQTZCO0FBQzdCLHdCQUEwQjtBQUsxQiw4QkFHTztBQU1QLG9DQUEyQztBQVczQyw4QkFBK0I7QUFFL0Isa0RBQWtEO0FBTWxELHFDQUE0QztBQUU1QywwQkFBb0M7QUFNcEMsK0JBQW1DO0FBQ25DLGlEQUFnRDtBQUVoRCx3Q0FBd0M7QUFLeEMsd0JBQTBCO0FBSzFCLDhCQUFnQztBQU1oQyxtQ0FBb0M7QUFDcEMsK0JBQTJDO0FBVTNDLDRCQUdPOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/index.d.cts

@@ -3,11 +3,15 @@
  *
  * Contains the entry point for the integration testing module.
  */
+export type { AsarFallback, AsarFallbackTier, CheckAsarFallbackParams } from './asar-fallback-detection.cjs';
+export { checkAsarFallback } from './asar-fallback-detection.cjs';
 export type { CdpConnection, ConnectToCdpOptions } from './connect-to-cdp.cjs';
 export { connectToCdp } from './connect-to-cdp.cjs';
 export { ContextId } from './context-id.cjs';
 export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
 export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
+export type { CheckElectronCompatibilityParams, ElectronCompatibility, ElectronCompatibilityTier } from './electron-compatibility.cjs';
+export { checkElectronCompatibility } from './electron-compatibility.cjs';
 export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';
@@ -16,9 +20,11 @@ export type { CheckInstallerCompatibilityParams, InstallerCompatibility, Install
 export { checkInstallerCompatibility } from './installer-compatibility.cjs';
 export type { LibResolver } from './lib-registry.cjs';
 export { registerLibResolver } from './lib-registry.cjs';
-export type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';
+export type { ObsidianRuntimeVersions, ObsidianVersionDownloads, ObsidianVersionMetadata } from './obsidian-metadata.cjs';
 export { getVersionMetadata } from './obsidian-metadata.cjs';
 export { RendererFailedToInitializeError } from './renderer-failed-to-initialize-error.cjs';
+export type { SilentAsarFallbackErrorConstructorParams } from './silent-asar-fallback-error.cjs';
+export { SilentAsarFallbackError } from './silent-asar-fallback-error.cjs';
 export type { PopulateFileContent, PopulateFilesParams } from './temp-vault.cjs';
 export { TempVault } from './temp-vault.cjs';
 export type { AppiumSessionInfo, AppiumTransportConfig } from './transport-appium.cjs';

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

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var installer_asset_exports = {};
 __export(installer_asset_exports, {
   buildInstallerAssetNameCandidates: () => buildInstallerAssetNameCandidates,
-  selectInstallerAssetName: () => selectInstallerAssetName
+  selectInstallerAssetName: () => selectInstallerAssetName,
+  selectInstallerDownloadUrl: () => selectInstallerDownloadUrl
 });
 module.exports = __toCommonJS(installer_asset_exports);
 const WINDOWS_ASSET_SHAPE = {
@@ -53,6 +54,19 @@ function selectInstallerAssetName(params) {
   const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);
   return params.assetNames.find((name) => pattern.test(name));
 }
+function selectInstallerDownloadUrl(params) {
+  const { downloads } = params;
+  if (!downloads) {
+    return void 0;
+  }
+  if (params.platform === "win32") {
+    return downloads.exe;
+  }
+  if (params.platform === "darwin") {
+    return downloads.dmg;
+  }
+  return downloads.tar;
+}
 function buildAssetNamePattern(shape, version) {
   const infixGroup = shape.optionalInfixes.length > 0 ? `(?:${shape.optionalInfixes.map(escapeRegExp).join("|")})?` : "";
   return new RegExp(
@@ -74,6 +88,7 @@ function getPlatformAssetShape(platform) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildInstallerAssetNameCandidates,
-  selectInstallerAssetName
+  selectInstallerAssetName,
+  selectInstallerDownloadUrl
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n */\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /** Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux). */\n  readonly baseName: string;\n\n  /** File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`. */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/** Separator forms tried, hyphen (newer) first, when falling back to templated names. */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /** The platform to build candidate names for. */\n  readonly platform: NodeJS.Platform;\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /** The release's asset names (e.g. from the GitHub release API). */\n  readonly assetNames: readonly string[];\n\n  /** The platform whose installer asset to select. */\n  readonly platform: NodeJS.Platform;\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map(escapeRegExp).join('|')})?`\n    : '';\n  return new RegExp(\n    `^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6CA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAGA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AAmChC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC,OACvD;AACJ,SAAO,IAAI;AAAA,IACT,IAAI,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,MAAM,aAAa,MAAM,SAAS,CAAC;AAAA,EAC9G;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,QAAQ,uBAAuB,MAAM;AACpD;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-asset.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for resolving which GitHub release asset is the desktop\n * **installer** for a given Obsidian version and platform.\n *\n * Obsidian changed its installer asset naming convention partway through its\n * history, so a version cannot be turned into an asset name by string\n * templating alone:\n *\n * - **Dot** separator on older releases: `Obsidian.<ver>.exe` (verified 0.14.5\n *   through 1.5.12), with a `-universal` infix on the macOS dmg\n *   (`Obsidian-<ver>-universal.dmg`).\n * - **Hyphen** separator on newer releases: `Obsidian-<ver>.exe`,\n *   `Obsidian-<ver>.dmg` (verified 1.6.7 onward; the transition is around 1.6.0).\n *\n * The integration-time downloader (`obsidian-installer.ts`) queries the\n * release's real asset list and picks the platform-correct one with\n * {@link selectInstallerAssetName}; if that network call is unavailable it\n * falls back to trying every {@link buildInstallerAssetNameCandidates} form.\n * Both helpers are pure so the separator/arch matrix stays unit-tested (the\n * downloader itself needs the network and is excluded from unit tests).\n *\n * Only the x64 installer is resolved \u2014 the extraction path is x64-only \u2014 so the\n * 32-bit / arm64 / all-users sibling assets are deliberately rejected.\n *\n * When the version is present in the baked `metadata.json` catalog (from\n * upstream `obsidian-versions.json`), its exact installer URL is already known;\n * {@link selectInstallerDownloadUrl} picks the platform-correct one and the\n * downloader uses it directly, skipping the release-API lookup and the\n * name-templating fallback entirely.\n */\n\nimport type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';\n\n/**\n * The platform-specific shape of an Obsidian installer asset name.\n */\ninterface PlatformInstallerAssetShape {\n  /** Leading token of the asset name: `Obsidian` (Windows/macOS) or `obsidian` (Linux). */\n  readonly baseName: string;\n\n  /** File extension without the leading dot, e.g. `exe`, `dmg`, `tar.gz`. */\n  readonly extension: string;\n\n  /**\n   * Infixes permitted between the version and the extension for the primary\n   * (non-arch) asset, e.g. `-universal` on the older macOS dmg. An empty array\n   * means the version is immediately followed by the extension.\n   */\n  readonly optionalInfixes: readonly string[];\n}\n\nconst WINDOWS_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'exe',\n  optionalInfixes: []\n};\n\nconst MAC_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'Obsidian',\n  extension: 'dmg',\n  optionalInfixes: ['-universal']\n};\n\nconst LINUX_ASSET_SHAPE: PlatformInstallerAssetShape = {\n  baseName: 'obsidian',\n  extension: 'tar.gz',\n  optionalInfixes: []\n};\n\n/** Separator forms tried, hyphen (newer) first, when falling back to templated names. */\nconst ASSET_NAME_SEPARATORS = ['-', '.'] as const;\n\n/**\n * Parameters for {@link buildInstallerAssetNameCandidates}.\n */\nexport interface BuildInstallerAssetNameCandidatesParams {\n  /** The platform to build candidate names for. */\n  readonly platform: NodeJS.Platform;\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerAssetName}.\n */\nexport interface SelectInstallerAssetNameParams {\n  /** The release's asset names (e.g. from the GitHub release API). */\n  readonly assetNames: readonly string[];\n\n  /** The platform whose installer asset to select. */\n  readonly platform: NodeJS.Platform;\n\n  /** The concrete `x.y.z` version. */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link selectInstallerDownloadUrl}.\n */\nexport interface SelectInstallerDownloadUrlParams {\n  /** The version's baked download URLs, or `undefined` when it is absent from the catalog. */\n  readonly downloads: ObsidianVersionDownloads | undefined;\n\n  /** The platform whose installer URL to select. */\n  readonly platform: NodeJS.Platform;\n}\n\n/**\n * Builds the fallback list of installer asset names to try when the release's\n * real asset list cannot be fetched, covering both separator forms (and, on\n * macOS, the `-universal` infix).\n *\n * @param params - The platform and version.\n * @returns Candidate asset names, hyphen-separated forms first.\n */\nexport function buildInstallerAssetNameCandidates(params: BuildInstallerAssetNameCandidatesParams): string[] {\n  const shape = getPlatformAssetShape(params.platform);\n  const infixes = shape.optionalInfixes.length > 0 ? ['', ...shape.optionalInfixes] : [''];\n  const candidates: string[] = [];\n  for (const separator of ASSET_NAME_SEPARATORS) {\n    for (const infix of infixes) {\n      candidates.push(`${shape.baseName}${separator}${params.version}${infix}.${shape.extension}`);\n    }\n  }\n  return candidates;\n}\n\n/**\n * Selects the platform-correct x64 installer asset name from a release's asset\n * list, tolerating both the dot- and hyphen-separated naming conventions and\n * rejecting the 32-bit / arm64 / all-users sibling assets.\n *\n * @param params - The asset list, platform, and version.\n * @returns The matching asset name, or `undefined` if none matches (e.g. a\n *   catalyst release that ships no installer).\n */\nexport function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined {\n  const pattern = buildAssetNamePattern(getPlatformAssetShape(params.platform), params.version);\n  return params.assetNames.find((name) => pattern.test(name));\n}\n\n/**\n * Selects the platform-correct x64 installer download URL from a version's\n * baked catalog entry.\n *\n * @param params - The baked download URLs and the platform.\n * @returns The installer URL for the platform, or `undefined` when the version\n *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst\n *   build, or a Linux `.tar.gz` that was never published).\n */\nexport function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined {\n  const { downloads } = params;\n  if (!downloads) {\n    return undefined;\n  }\n\n  if (params.platform === 'win32') {\n    return downloads.exe;\n  }\n\n  if (params.platform === 'darwin') {\n    return downloads.dmg;\n  }\n\n  return downloads.tar;\n}\n\n/**\n * Builds an anchored regular expression matching the primary installer asset\n * for a platform shape and version, across both separator conventions.\n *\n * @param shape - The platform asset shape.\n * @param version - The concrete `x.y.z` version.\n * @returns The matching pattern.\n */\nfunction buildAssetNamePattern(shape: PlatformInstallerAssetShape, version: string): RegExp {\n  const infixGroup = shape.optionalInfixes.length > 0\n    ? `(?:${shape.optionalInfixes.map(escapeRegExp).join('|')})?`\n    : '';\n  return new RegExp(\n    `^${escapeRegExp(shape.baseName)}[.-]${escapeRegExp(version)}${infixGroup}\\\\.${escapeRegExp(shape.extension)}$`\n  );\n}\n\n/**\n * Escapes a string for literal use inside a regular expression.\n *\n * @param value - The raw string.\n * @returns The escaped string.\n */\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Resolves the installer asset shape for a platform.\n *\n * @param platform - The Node.js platform identifier.\n * @returns The asset shape (Linux `.tar.gz` for any non-Windows/macOS platform).\n */\nfunction getPlatformAssetShape(platform: NodeJS.Platform): PlatformInstallerAssetShape {\n  if (platform === 'win32') {\n    return WINDOWS_ASSET_SHAPE;\n  }\n\n  if (platform === 'darwin') {\n    return MAC_ASSET_SHAPE;\n  }\n\n  return LINUX_ASSET_SHAPE;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqDA,MAAM,sBAAmD;AAAA,EACvD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAEA,MAAM,kBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC,YAAY;AAChC;AAEA,MAAM,oBAAiD;AAAA,EACrD,UAAU;AAAA,EACV,WAAW;AAAA,EACX,iBAAiB,CAAC;AACpB;AAGA,MAAM,wBAAwB,CAAC,KAAK,GAAG;AA8ChC,SAAS,kCAAkC,QAA2D;AAC3G,QAAM,QAAQ,sBAAsB,OAAO,QAAQ;AACnD,QAAM,UAAU,MAAM,gBAAgB,SAAS,IAAI,CAAC,IAAI,GAAG,MAAM,eAAe,IAAI,CAAC,EAAE;AACvF,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,uBAAuB;AAC7C,eAAW,SAAS,SAAS;AAC3B,iBAAW,KAAK,GAAG,MAAM,QAAQ,GAAG,SAAS,GAAG,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,SAAS,EAAE;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,yBAAyB,QAA4D;AACnG,QAAM,UAAU,sBAAsB,sBAAsB,OAAO,QAAQ,GAAG,OAAO,OAAO;AAC5F,SAAO,OAAO,WAAW,KAAK,CAAC,SAAS,QAAQ,KAAK,IAAI,CAAC;AAC5D;AAWO,SAAS,2BAA2B,QAA8D;AACvG,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,aAAa,SAAS;AAC/B,WAAO,UAAU;AAAA,EACnB;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,UAAU;AACnB;AAUA,SAAS,sBAAsB,OAAoC,SAAyB;AAC1F,QAAM,aAAa,MAAM,gBAAgB,SAAS,IAC9C,MAAM,MAAM,gBAAgB,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC,OACvD;AACJ,SAAO,IAAI;AAAA,IACT,IAAI,aAAa,MAAM,QAAQ,CAAC,OAAO,aAAa,OAAO,CAAC,GAAG,UAAU,MAAM,aAAa,MAAM,SAAS,CAAC;AAAA,EAC9G;AACF;AAQA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,QAAQ,uBAAuB,MAAM;AACpD;AAQA,SAAS,sBAAsB,UAAwD;AACrF,MAAI,aAAa,SAAS;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,aAAa,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/installer-asset.d.cts

@@ -23,7 +23,14 @@
  *
  * Only the x64 installer is resolved — the extraction path is x64-only — so the
  * 32-bit / arm64 / all-users sibling assets are deliberately rejected.
+ *
+ * When the version is present in the baked `metadata.json` catalog (from
+ * upstream `obsidian-versions.json`), its exact installer URL is already known;
+ * {@link selectInstallerDownloadUrl} picks the platform-correct one and the
+ * downloader uses it directly, skipping the release-API lookup and the
+ * name-templating fallback entirely.
  */
+import type { ObsidianVersionDownloads } from './obsidian-metadata.cjs';
 /**
  * Parameters for {@link buildInstallerAssetNameCandidates}.
  */
@@ -44,6 +51,15 @@ export interface SelectInstallerAssetNameParams {
     /** The concrete `x.y.z` version. */
     readonly version: string;
 }
+/**
+ * Parameters for {@link selectInstallerDownloadUrl}.
+ */
+export interface SelectInstallerDownloadUrlParams {
+    /** The version's baked download URLs, or `undefined` when it is absent from the catalog. */
+    readonly downloads: ObsidianVersionDownloads | undefined;
+    /** The platform whose installer URL to select. */
+    readonly platform: NodeJS.Platform;
+}
 /**
  * Builds the fallback list of installer asset names to try when the release's
  * real asset list cannot be fetched, covering both separator forms (and, on
@@ -63,3 +79,13 @@ export declare function buildInstallerAssetNameCandidates(params: BuildInstaller
  *   catalyst release that ships no installer).
  */
 export declare function selectInstallerAssetName(params: SelectInstallerAssetNameParams): string | undefined;
+/**
+ * Selects the platform-correct x64 installer download URL from a version's
+ * baked catalog entry.
+ *
+ * @param params - The baked download URLs and the platform.
+ * @returns The installer URL for the platform, or `undefined` when the version
+ *   has no catalog entry or ships no desktop installer for it (e.g. a catalyst
+ *   build, or a Linux `.tar.gz` that was never published).
+ */
+export declare function selectInstallerDownloadUrl(params: SelectInstallerDownloadUrlParams): string | undefined;

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

@@ -61,4 +61,4 @@ function checkInstallerCompatibility(params) {
 0 && (module.exports = {
   checkInstallerCompatibility
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';\n\nimport { compareVersions } from './obsidian-version.cjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,8BAAgC;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,UAAI,yCAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,cAAa,yCAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch \u2014 unless the\n *   caller has disabled the proactive throw (`shouldThrowOnIncompatibleInstaller`\n *   `false`), in which case the boot proceeds and the reactive dead-boot fast-fail\n *   catches it.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';\n\nimport { compareVersions } from './obsidian-version.cjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BA,8BAAgC;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,UAAI,yCAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,cAAa,yCAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}


package/dist/lib/cjs/installer-compatibility.d.cts

@@ -12,7 +12,10 @@
  *
  * - `minRunnableInstallerVersion` — the run floor. Below it the app cannot boot
  *   (`'unrunnable'`); the caller turns this into a proactive
- *   `IncompatibleInstallerVersionError` before any download/launch.
+ *   `IncompatibleInstallerVersionError` before any download/launch — unless the
+ *   caller has disabled the proactive throw (`shouldThrowOnIncompatibleInstaller`
+ *   `false`), in which case the boot proceeds and the reactive dead-boot fast-fail
+ *   catches it.
  * - `minRecommendedInstallerVersion` — the recommended floor (older versions
  *   only). At/above the run floor but below this, the app runs but is below
  *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "8.2.0";
+const LIBRARY_VERSION = false ? "dev" : "8.3.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION